NJUPT【面向对象程序设计及C++ 】

作者: Du1in9 | 来源:发表于2020-05-21 12:07 被阅读0次

Part 1/6 考试范围

第1章
面向对象的三大特征，类和对象，程序开发过程
第2章
cin、cout，:：，全局变量，定义函数时形参带有默认值，函数重载
引用，利用指针动态内存空间管理，try catch throw机制的异常处理方式
第3章
类的定义，对象的定义，this指针，构造函数，复制构造函数，析构函数，对象数组，对象指针、对象引用、对象参数
第4章
对象成员，常数据成员，常对象，常成员函数，友元函数、友元成员、友元类
第5章
类的继承与派生，private、protected、public，定义派生类对象时，构造函数的调用顺序，同名冲突，赋值兼容的四种情况
第6章
静态多态性、动态多态性，运算符重载，友元重载，成员函数重载，输入/输出流重载：ostream & 和 istream &，虚函数的定义，纯虚函数和抽象类
第7章
函数模板的定义及调用，函数模板的重载，类模板的定义及调用
第8章
文件的分类，open打开方文件，ios::in 读文件， ios::out 写文件，close关闭文件
运算符>>和<<对文件操作，get、put函数，read、write函数

Part 2/6 考试真题

第7题

Part 3/6 练习题库

第1章 C++语言概述

课后习题

①面向对象语言：C++，Java，Python
②类是类型，对象是类类型变量，类型不占有内存，变量占有内存
③面向对象特征：封装性，继承性，多态性
④对象是是类类型变量，不是结构体变量

第2章对C的改进及扩展

课后习题

①int y[n];中n必须为常量，int *py=new int[n];中n可以为常量和变量
②int add(int x,int y=4,int z=5);默认值的函数原型声明从右往左
③重载函数满足，形参的个数或类型或顺序不同
int a(int x);和int a(float x);
int b(int x,char *s);和int b(char *s,int x);
int c(int x);和int c(int x,int y);
而int d(int x); 和 char *d(int y); 不是重载
④int *p=new int;(一维数组）int *p=new int(10);（一维数组赋值）
int *p=new int[10];(10个元素）int *p=new int[10] (10);(错误语句）
⑤int x=1,y=2,&z=x;执行z=y后，x=z=y=2

平台习题

①全局变量 x 在main函数中可以访问，形如：“::x = 1;” 使其获得新的值1
②使用delete运算符释放所申请的动态内存空间
③为名空间ABC变量x赋值：
ABC::x = 10;
using namespace ABC; x = 10;
using ABC::x ; x = 10;
④运算符<<：
用于输出的插入符
左移位运算符
右边可以是表达式，变量
⑤关于try-catch：
语句块必须一起出现，缺一不可，且try块在先catch块在后
如果有try块，可以有多个，与try块对应的catch块可以有多个
⑥const char *;表示不能改指针，const name="abc";表示不能改name
⑦const char *ptr; 定义一个指向字符常量的指针
char const *ptr; 定义一个指向字符常量的指针
char * const; 定义一个指向字符的指针常数
⑧内联函数：
在编译时目标代码将插入每个调用该函数的地方
一般代码较短，而且调用较频繁
函数体内一般不能有开关语句及循环语句

第3章类与对象1

课后习题

①类定义结束以“ ; ”结束
②Time( int=0, int=0, int=0)有三个形参
③class类没有关键字public，private，protected时，访问属性为private
④类与对象的关系类似于数据类型与变量
任何一个对象只能属于一个具体的类
⑤一个类只能有一个析构函数
⑥拷贝构造函数的参数是某个对象的常引用名

平台习题

①私有成员变量不能赋初值
②p是一个指向类A公有数据成员m的公有指针成员，A1是类A的一个对象
可以用*A1.p=5给m赋值为5
③类的成员函数包括：构造函数，析构函数，拷贝构造函数
而友元函数不是类的成员函数
④一个类中可以有多个构造函数
构造函数在定义对象时自动执行
构造函数名必须和类名一致
构造函数无任何函数类型
⑤有参构造函数：A (int a);
无参构造函数：A ();
拷贝构造函数：A (const A& a);
赋值构造函数：A & operator = (const A& a);
⑥析构函数是在对象生存期结束时调用的
⑦成员函数不一定是内联函数
成员函数可以重载
成员函数可以是静态的

第4章类与对象2

课后习题

①静态数据成员在类外初始化
静态数据成员是同类所有对象共有的
静态数据成员为public，才能用类名::成员名访问
②静态成员函数没有this指针
③常数据成员通过类构造函数的初始化列表进行初始化
例如：A(int a,int b):a(a),b(b)
常数据成员必须初始化，不能被更新，作用域为本类
例如：const int a=10;
④普通函数可以改变数据成员的值，常成员函数不可以改变数据成员的值
⑤常对象只能调用常函数，常函数可以被任何对象调用
void fun() const //常函数fun()
Time const t1(12,34,36); //常对象t1

class Point
{
public:
    void a() //非静态成员函数
    { }
    static void b() //静态成员函数
    { }
};
void main()
{
    Point pt;
    pt.a(); //通过对象调用非静态成员函数
    pt.b(); //通过对象调用静态成员函数
    Point::a(); //报错 
    Point::b(); //通过类名调用静态成员函数 
}

平台习题

①常对象是各数据成员值不可改变的对象
常对象所属的类中也可以定义非常成员函数
②类中静态数据成员：static int count; 为其初始化：int Test::count=10;
③静态成员函数一般专门用来直接访问类的静态数据成员

第5章继承与派生

课后习题

①派生类可以继承多个基类，派生类对基类默认的继承方式为private
在多层的类继承中，中间类既是上层类的派生类又是下层类的基类
如果基类构造函数没有形参或带有默认值，
派生类构造函数初始化列表中就不必对基类构造函数进行调用
②多重继承构造函数的调用顺序一般可分为4个步骤：
Step 1：任何虚基类，按照它们被继承的顺序依次调用构造函数。
Step 2：任何非虚基类，按照它们被继承的顺序依次调用构造函数。
Step 3：任何派生类，按照它们声明的顺序依次调用所属类的构造函数。
Step 4：调用派生类自己的构造函数。
③派生类构造函数的成员初始化列表，不能包含基类的成员对象所属类的构造函数
④在定义最后派生类对象时，将引起虚基类构造函数的调用，该函数只能被调用一次

平台习题

①基类对象/引用=公有派生类对象/引用，反之不成立
基类对象的指针=公有派生类对象的指针，反之不成立
例如：B是基类A的派生类，并有A aa, *pa=&aa; B bb, *pb=&bb;
bb=aa; （错误语句）aa=bb; （正确语句）
*pb = *pa; （错误语句）pa=pb; （错误语句，不是指针）
②派生类是基类的特殊化，具体化，定义的延续，
③派生类对象d可以用d.x的形式访问基类的成员x，则x是：公有派生的公有成员
④派生类默认继承方式为private继承
基类公有成员在派生类中属性可变
对基类成员的访问必须无二义性
赋值兼容规则也适用于多重公有继承
⑤多重继承中，如果基类有非私有属性的同名成员，
在派生类引用该同名成员时可以在该同名成员前增加：“基类名:: ”来区分
⑥派生类新增加的成员函数，其父类中私有继承的私有成员是不可直接访问的
⑦对象成员的构造函数由所在类的构造函数来调用
对象成员的访问类型可以使用任何类型
对象成员如果是公有类型也可以被继承
对象成员中的成员可以被所在类的成员函数访问
⑧在最后派生类构造函数的调用中，
先调用虚基类的构造函数，再调用其它基类的构造函数时，不再调用虚基类的构造函数。

第6章多态性

课后习题

①C++语言中有5 个运算符不能重载：.、.*、::、?:、sizeof
②重载函数要求：参数个数不同或者参数类型不同
③运算符重载不可以改变运算符的个数，优先级，结合性，语法结构
④静态多态性可以使用函数重载和运算符重载获得
⑤抽象类是指含有纯虚函数的基类，其纯虚函数由派生类实现
纯虚函数是一种特殊的虚函数，它没有具体的实现代码
如果派生类不实现基类的纯虚函数，该派生类仍然为一个抽象类

平台习题

①抽象类的特性：不能说明其对象
②动态联编是用来在编译时确定操作函数的
③基类中说明了虚函数后，派生类中的函数可不必说明为虚函数

第7章模板

课后习题

①函数模板：
template <class T>
T max(T x, T y)
{
return(x > y)?x : y;
}
变量int i; char c;
错误语句：max(i, c); 正确语句：max(i, i); max(c, c); max((int)c, i);
②模板的使用是为了提高代码的可重用性
③函数模板：
template < class T1, class T2 >
void sum(T1 x, T2 y)
{
cout << sizeof( x+y );
}
sum('1', 99.0) 的输出结果是：8

因为99.0为double 类型，故 sizeof( x+y ) = sizeof( double ) = 8

平台习题

①函数模板：
template <class T>
class Array
{
...
};
模板类定义：Array<int> arr(100);
②函数模版：
template <class T1, class T2>
void sum(T1 x, T2 y)
{
cout<<(x+y);
}
变量：int a; double b; char c;
错误语句：sum("abc", "ABC"); 正确语句：sum(a,a); sum(a,b); sum(b,c);
③函数模版：
template <class T>
T func(T x, T y)
{
return x * x + y * y;
}
正确的调用语句是： func(3,4)
④模板参数可以作为：数据成员的类型，成员函数的返回类型，成员函数的参数类型
⑤模板声明的开始部分：template <class T1, class T2>
⑥模板的使用目的：提高代码的可重用性

第8章文件及输入输出

课后习题

①执行文件输入/输出的操作，需要在程序中包含头文件名字空间 std 的 fstream 文件
②打开文件时，文件的所有使用方式：
ios::app // 输出到尾部
ios::ate // 寻找文件尾
ios::in // 文件输入
ios::out // 文件输出
ios::trunc // 删除同名文件
ios::binary // 二进制方式打开
ios::nocreate // 若文件不存在，则open()函数失败
ios::noreplace // 若文件存在，则open()函数失败
对于 ifstream 流，缺省值为 ios::in
对于 ofstream 流，缺省值为 ios::out
③在ios 类中控制格式的标志位中：
dec、oct、hex 分别是10进制、8进制、16进制的标志位
showbase 表示输出数值前面带有基数符号
④getline()、read() 和 get() 是读操作的函数，put() 是写操作的函数
⑤istream & istream :: seekg(long, seek_dir); 表示在输入流中移动文件读指针。
long 参数规定偏移量，正数表示向后移，负数表示向前移。
seek_dir 参数规定起始位置：beg：开始位置。cur：当前位置。end：结束位置。
例：已知 a 为 ifstream 流类的对象，并打开了一个文件
将对象 a 的读指针移到当前位置后100个字节处的语句是：a.seekg(100, ios::cur);

平台习题

①float data，以二进制方式将 data 的数据写入输出文件流类对象 x 中去的语句是：x.write((char *)&data, sizeof(float));
②打开文件 D:\file.txt，写入数据的语句是：fstream infile(" D:\file.txt ", ios::in | ios::out);
③read 函数的功能是从输入流中读取：指定若干个字符

Part 4/6 实验报告

实验报告一：类和对象的定义及使用
实验题目1

#include <iostream>
#include <cstring>
using namespace std;

class BookCard
{
private:
    string id;      
    string stuName; 
    int number;     
public:
    BookCard(string i, string s, int n)
    {
        id=i;stuName=s;number=n;
    }
    BookCard()
    {
        id = "B19010250";stuName = "雪峰";number = 4;
    }
    void display()
    {
        cout << id <<' '<< stuName <<' '<< number << endl;
    } 
    bool borrow()
    {
        if (number==10)    {return false;}
        else   {number++;return true;}
    }
};
void f(BookCard &bk)
{
    if (!bk.borrow())
    {
        bk.display();
        cout << "you have borrowed 10 books,can not borrow any more!" << endl;
    }
    else
        bk.display();
}
int main()
{
    BookCard bk1("B20190620", "东平", 10), bk2;
    f(bk1);
    f(bk2);
    return 0;
}

实验题目2

#include <iostream>
#include <cstring>
using namespace std;

class Time
{
private:
    int Hour;int Minute;int Second;
public:
    Time(int H, int M, int S)//构造函数 
    {
        Hour = H;Minute = M;Second = S;
    }
    ~Time()//析构函数 
    {
    }
    void add( )//改变 
    {
        Second++; 
    }
    void set(int H, int M, int S)//设定 
    {
        Hour = H;Minute = M;Second = S;
    }
    void PrintTime()//输出 
    {
        cout << Hour << " : " << Minute << " : " << Second << endl;
    }
};

void f(Time *t)
{
    t-> PrintTime( );
}

int main()
{
    Time t0(9, 18, 46);
    t0.add();
    f(&t0);
    Time t1 = t0;//拷贝构造函数 
    t1.add();
    f(&t1);
    t0.set(1,2,34);
    f(&t0);
    return 0;
}

实验题目3

#include <iostream>
#include <cstring>
using namespace std;

class Girl;
class Boy
{
private:
    string name;int age;
public:
    Boy(string n, int a)//构造函数 
    {
        name = n;age = a;
    }
    ~Boy()//析构函数 
    {
    }
    friend void VisitBoyGirl(Boy &B, Girl &G);//友元 
};
class Girl
{
private:
    string name;int age;
public:
    Girl(string n, int a)//构造函数 
    {
        name = n;age = a;
    }
    ~Girl()//析构函数 
    {
    }
    friend void VisitBoyGirl(Boy &B, Girl &G);//友元 
};
void VisitBoyGirl(Boy &B, Girl &G)//顶层函数 
{
    cout << "Boy:" << B.name << " " << B.age << endl;
    cout << "Girl:" << G.name << " " << G.age << endl;
}
int main()
{
    Boy B("刘林峰",16);
    Girl G("张三",18);
    VisitBoyGirl(B,G);
    return 0;
}

实验报告二：继承与派生实验
实验题目1

#include <iostream>
#include <cstring>
using namespace std;

class Vehicle
{   
public:
    int number;
    Vehicle(int n):number(n)//构造
    {cout<<"构造Vehicle"<<endl;}
    ~Vehicle( ){cout << "析构Vehicle" << endl;}//析构 
};
class Bicycle: public virtual Vehicle
{
//private: 
//protected:
public:
    string brand1;
    Bicycle(int n,string b1):Vehicle(n),brand1(b1)//构造
    {cout<<"构造Bicycle"<<endl;}
    ~Bicycle( ){cout << "析构Bicycle" << endl;}//析构 
    void disp(){cout <<brand1<<endl;}
};
class Car: public virtual Vehicle
{
public:
    string brand2;
    Car(int n,string b2):Vehicle(n),brand2(b2)//构造
    {cout<<"构造Car"<<endl;}
    ~Car( ){cout << "析构Car" << endl;}//析构 
    void disp(){cout <<brand2<<endl;}
};
class MotorCycle: public Bicycle, public Car 
{
public:
    string brand3;
    MotorCycle(int n,string x,string y,string z): Bicycle(n,x), Car(n,y),Vehicle(n),brand3(z)//构造 
    {
        cout<<"构造MotorCycle"<<endl;
        cout<<number<<" "<<brand1<<" "<<brand2<<" "<<brand3<<endl;
    }
    ~MotorCycle( ){cout << "析构MotorCycle" << endl;}//析构 
    void disp(){cout <<brand3<<endl;}
};
int main()
{
    MotorCycle a(2,"Benz","Audi","BMW");
    return 0;
}

实验题目2

#include <iostream>
using namespace std;

class Base//基类 
{
public:
    int b;
    Base(int x): b(x){}//构造 
    void Show( ){cout<<b<<endl;}
};
class Derived: public Base//派生类 
{
public:
    int d;
    Derived(int x, int y): Base(x), d(y){}//构造 
    void Show( ){cout<<d<<endl;}
};
int  main( )
{
    Base B(11);//b=11
    Derived D(22, 33);//b=22, d=33
    
    B = D;//第一种赋值兼容
    B.Show();
    Base *B1 = &D;//第二种赋值兼容
    B1->Show(); 
    Derived *D1 = &D;//第三种赋值兼容
    Base *B2 = D1;
    B2->Show();
    Base &B3=D;//第四种赋值兼容
    B3.Show();
    return 0;
}

实验报告三：继承与派生实验
实验题目1

#include <iostream>
#include <stdlib.h>
using namespace std;

class Point    
{
private:
    double x,y;
public: 
    Point(double x=0.0,double y=0.0):x(x),y(y)//构造函数
    {  }
    Point & operator = (const Point &s)//赋值运算符 
    {
        x=s.x;
        y=s.y;
        return *this ;
    }
    Point operator + (const double b)//双目运算符"+" 
    {
        Point tempt;
        tempt.x=this->x+b;
        tempt.y=this->y+b;
        return tempt; 
    }
    Point operator + (const Point &b)//双目运算符"+" 
    {
        Point tempt;
        tempt.x=this->x+b.x;
        tempt.y=this->y+b.y;
        return tempt; 
    }
    Point operator ++ ( )//前置"++"运算符
    {
        ++x; ++y;
        return *this;       
    }
    friend Point operator - (const Point &a, const Point &b)//双目运算符"-"
    {
        Point tempt;
        tempt.x=a.x-b.x;
        tempt.y=a.y-b.y;
        return tempt;  
    }
    friend ostream & operator << ( ostream &out , const Point &s)//插入运算符 
    {
        out <<"("<< s.x<<","<<s.y<<")"<<endl;   
        return out;
    }
};

int main()
{
Point pt1(10.5,20.8),pt2(-5.3,18.4),pt3;
cout<<"original pt1,pt2,pt3 are:\n";
cout<<pt1<<pt2<<pt3;
pt3=pt1+100.8;
cout<<"after pt3=pt1+100.8, pt3 is:"<<pt3;
pt3=pt1+pt2;
cout<<"after pt3=pt1+pt2, pt3 is:"<<pt3;
pt3=++pt1;
++pt2;
cout<<"after ++ pt1,pt2,pt3 are:\n";
cout<<pt1<<pt2<<pt3;
pt3=pt1-pt2;
cout<<"after pt3=pt1-pt2, pt3 is:"<<pt3;
return 0 ;
}

实验题目2

#include <iostream>
#include <stdlib.h>
using namespace std;
const double PI = 3.1415 ;

class Container//容器 
{
public: 
    virtual double area ( ) const = 0 ;
    virtual double volume ( ) const = 0 ;
};

class Cube :public Container//正方体 
{
private:
    double a;
public:
    Cube(double a):a(a)
    { }
    double area() const
    {
        return a * a * 6;
    }
    double volume() const
    {
        return a * a * a;
    }
    void show()
    {
        cout << "正方体边长为：" << a << " 表面积为：" << this->area() << " 体积为：" << this->volume() << endl;
    }
};

class Sphere :public Container//球体 
{
private:
    double r;
public:
    Sphere(double r):r(r) 
    { }
    double area() const
    {
        return 4 * PI * r * r;
    }
    double volume() const
    {
        return 4.0 / 3 * PI * r * r * r;
    }
    void show()
    {
        cout << "球体半径为：" << r << " 表面积为：" << this->area() << " 体积为：" << this->volume() << endl;
    }
};

class Cylinder :public Container//圆柱体 
{
private:
    double r,h;
public:
    Cylinder(double r, double h):r(r),h(h)
    { }
    double area() const
    {
        return 2 * PI * r * h + 2 * PI * r * r;
    }
    double volume() const
    {
        return PI * r * r * h;
    }
    void show()
    {
        cout << "圆柱的底面半径为：" << r << " 高为：" << h << " 表面积为：" << this->area() << " 体积为：" << this->volume() << endl;
    }
};

int main()
{
    Cube cu(3);
    Sphere sp(2);
    Cylinder cy(2,3);
    cu.show();
    sp.show();
    cy.show();
    return 0;
}

实验报告四：流运算符的重载及文件的使用
实验题目1

#include <fstream>
#include <iostream>
using namespace std;

class Course
{
private:
    string name;
    int num;
public:
    friend istream & operator >> (istream &in , Course &a )//提取运算符“>>”
    {
        in>>a.name>>a.num;
        return in;
    }  
    friend ostream & operator << (ostream &out , Course &a )//插入运算符“<<”
    {
        out<<a.name<<" "<<a.num<<endl;
        return out ;
    }   
};

int main ( )
{ 
    int count;
    Course b;
    ifstream a ( "d:\course.txt" ) ;    
    if( !a )                    
    { 
        cout << "course.txt cannot be openned!" << endl ;
        return 0 ;
    }
    char ch;
    while( a.get( ch ) )            
    {               
        a>>b;
        cout<<b;
        count++;
    }
    cout<<"记录条数："<<count<<endl;
    a. close( );                                        
    return 0;
}

实验题目2

#include <fstream>
#include <iostream>
using namespace std;

void ReadFile(char *s)  
{  
    ifstream a ( s ) ;  
    if( !a )                    
    { 
        cout << s <<" cannot be openned!" << endl ;
    }
    char ch;
    while( a.get( ch ) )            
    {               
        cout<<ch;
    }
    cout<<endl;
    a. close( );  
}
void Change(char *s1,char *s2)  
{
    ifstream x (s1 ) ;  
    if( !x )                    
    { 
        cout << s1<<" cannot be openned!" << endl ;
    }
    ofstream y (s2 ) ;  
    if( !y )                        
    { 
        cout << s2<<" cannot be openned!" << endl ;
    }
    char ch;
    while( x .get( ch ) )           
    {   
        if(ch>='a'&&ch<='z')  
        {
           y.put( ch-32 ) ;     //ascii码中大小写相差32 
        }           
        else
        {
            y.put( ch ) ;  
        }
    }
    x. close( );                    
    y. close( );  
} 
int main ( )
{ 
    ReadFile("ff.txt");        //txt需放在当前目录 
    Change ("ff.txt" ,"ff2.txt");
    ReadFile("ff2.txt");
    return 0;
}

实验题目3

#include <fstream>
#include <iostream>
using namespace std;

class Student
{
private:
    char *nu;char *na;char *se;int s;//学号、姓名、性别、成绩
public:
    Student(char *nu="00",char *na="null",char *se="null",int s=0):nu(nu),na(na),se(se),s(s)//构造函数 
    { }  
    friend ostream & operator<<(ostream &out,const Student &s)//重载输出运算符<<
    {
        out<<s.nu<<" "<<s.na<<" "<<s.se<<" "<<s.s<<endl;
        return out;
    }
};

void CreateBiFile(char *filename) 
{
    ofstream out(filename);
    Student stu[3]={{"01","Tom","boy",80},{"02","Bill","boy",84},{"03","Bob","boy",90}}; //初始化信息
    out.write((char*)&stu,sizeof(stu));//二进制存储 
    out.close( );
}
void ReadBiFile(char *filename)//读取显示 
{ 
    Student stu[3];
    ifstream in(filename);
    while (!in.eof( ))
    {
        in.read((char*)&stu,sizeof(stu));//二进制存储
    } 
    for(int i=0;i<3;i++)
    {
        cout<<stu[i];
    }
    in.close( );
}

int main ( )
{ 
    CreateBiFile("stu.dat");
    ReadBiFile("stu.dat");
    return 0;
}

Part 5/6 平台练习

第二章
0x01 动态空间管理

#include<iostream> 
using namespace std;
int main()
{
    int num,i,positive,negative;
    positive=negative=0;
    cin>>num;
    int *p=new int[20];
    for(i=0;i<num;i++)
    {
        cin>>p[i];
    }
    for(i=0;i<num;i++)
    {
        if(p[i]>0)positive++;
        if(p[i]<0)negative++;
    }
    if(num>20||num<1)cout<<"number error.\n"; 
    else
    {
        cout<<"There are "<<num<<" figures,\n"; 
        cout<<positive<<" of them are positive numbers,\n"; 
        cout<<negative<<" of them are negatives.\n";
    }
    delete []p;
    return 0;
}

0x02 求圆的面积与周长

#include<iostream> 
using namespace std;
int main()
{
    double r,s,c;
    cin>>r;
    s=3.14159*r*r;
    c=3.14159*2*r;
    cout<<"s="<<s<<",c="<<c<<endl;
    return 0;
}

第三章
0x01 简单图书管理

图片.png

#include <iostream>
#include<cstring>
using namespace std;
class Book
{
private:
    string bookname;float price;int number;
public:
    Book(string name,float p,int n);
    void borrow()
    {
        number--;
    }
    void restore()
    {
        number++;
    }
    void display();
} ;
void Book::display()
{
    cout<<bookname<<" "<<price<<" "<<number<<endl;
}
Book::Book(string name,float p,int n)
{
    bookname=name;
    price=p;
    number=n;
}
int main()
{
    char name[20]="C++";
    Book book1(name,23.5,3);
    strcpy(name,"Data Structure");
    Book book2(name,28.8,7);
    book1.borrow();
    book1.display();
    book2.restore();
    book2.display();
    return 0;
}

0x02 友元函数的定义与使用

图片.png

#include <iostream>
#include<cstring>
using namespace std;
class Stu
{   
public:
    Stu(string name,int score);
    friend void print();
    string name;
    int score;
} ;
class Tea
{   
public:
    Tea(string name,string pro);
    friend void print();
    string name;
    string pro;
} ;
Stu::Stu(string n,int s){
    name=n;
    score=s;
}
Tea::Tea(string n,string p){
    name=n;
    pro=p;
}
void print(Stu S,Tea T)
{
    cout<<"student's name:"<<S.name<<"   "<<S.score<<endl;
    cout<<"Teacher's name:"<<T.name<<"   "<<T.pro<<endl;
}

int main()
{
    char stuname[20],teaname[20],teapro[20]; 
    cout<<"请输入学生姓名："<<endl; 
    cin>>stuname; 
    cout<<"请输入教师姓名："<<endl;
    cin>>teaname;
    cout<<"请输入教师职称："<<endl;  
    cin>>teapro;
    Stu student(stuname,88);
    Tea teacher(teaname,teapro);
    print(student,teacher);
    return 0;
}

0x03 立方体类的定义与使用

图片.png

#include <iostream>
#include<cstring>
using namespace std;
class Cube
{
public:
    int l,w,h;
    Cube(int L=3,int W=2,int H=1);
    int Compute()
    {
        return(l*w*h);
    }
};
Cube::Cube(int L,int W,int H)
{
    l=L;w=W;h=H;
}
int main()
{
    int l,w,h;
    cout<<"输入立方体的长宽高："<<endl;
    cin>>l>>w>>h;
    Cube A(l,w,h);
    Cube B;
    cout<<A.Compute()<<endl;
    cout<<B.Compute()<<endl;
}

0x04 设计汽车类

图片.png

#include <iostream>
#include<cstring>
using namespace std;
class Car
{
private:
        string brand;string type;int year;double price;
public:
        Car(string b,string t,int y,double p);
        Car()
        {
            brand="undefinition";
            type="undefinition";
            year=2000;
            price=0;
        }
        string GetBrand()
        {
            return brand;
        }
        string GetType()
        {
            return type;
        }
        int GetYear()
        {
            return year;
        }
        double GetPrice()
        {
            return price;
        }
};
Car::Car(string b,string t,int y,double p){
    brand=b;
    type=t;
    year=y;
    price=p;
}
int main() 
{ 
Car car1("FIAT","Palio",2007,6.5); 
cout<<car1.GetBrand (  ) <<"|"<<car1.GetType (  ) <<"|"<<car1.GetYear (  ) <<"|" <<car1.GetPrice (  ) <<endl; 
Car car2; 
cout<<car2.GetBrand (  )<<"|"<<car2.GetType (  )<<"|"<<car2.GetYear (  ) <<"|" <<car2.GetPrice (  )<<endl; 
return 0; 
}

0x05 设计学生类

图片.png

#include <iostream>
#include<cstring>
using namespace std;
class Student
{
private:
    int age;string name;
public:
    Student(int a, string m);
    Student()
    {
        age=0;name="unnamed";
    }
    void SetMember(int a, string m)
    {
        age=a;name=m;
    }
    int Getage()
    {
        return age;
    }
    string Getname()
    {
        return name;
    }
};
Student::Student(int a,string m)
{
    age=a;name=m;
}
int main( )
{
    Student stu[3]={Student(13,"wang")} ;   /*第一个元素用带参构造函数初始化；第二、三个元素由无参构造函数初始化，默认年龄为 0 ，姓名为 "unnamed"*/
    stu[2].SetMember(12,"zhang");           /*修改第三个元素的数据成员值*/
    cout<<stu[0].Getage( )<<","<<stu[0].Getname( )<<"\n";
    cout<<stu[1].Getage( )<<","<<stu[1].Getname( )<<"\n"; 
    cout<<stu[2].Getage( )<<","<<stu[2].Getname( )<<"\n"; /*这三句可改用一个循环*/
    return 0;
}

第四章
静态数据成员的使用

#include <iostream>
#include <cstring>
using namespace std;

class Student
{
private:
    int age;string name;
public:
    static int count;
    Student(int m,string n)
    {
        age=m;name=n;count++;
    }
    Student()
    {
        age=0;name="unnamed";count++;
    }
    ~Student()
    {
        count--;
    }
    void Print()const
    {
        cout<<"count="<<count<<endl;
        cout<<name<<"  "<<age<<endl;
    }
};
int Student::count=0;
int main()
{
    cout<<"count="<<Student::count<<endl;
    string stuname="ZhangHong";
    Student s1,*p=new Student(23,stuname);
    s1.Print();
    p->Print();
    delete p;
    s1.Print();
    Student Stu[4];
    cout<<"count="<<Student::count<<endl;
    return 0;   
}

第五章
0x01 简易工资管理

#include <iostream>
#include <cstring>
using namespace std;

class Employee
{   
public:
    string name;int working_years;
    Employee(string n,int y):name(n),working_years(y){}//构造函数 
    string Getname(){return name;}//名字 
    void SetWorkyears(int wy){working_years=wy;}//工作年龄 
};
class Worker:public  Employee
{ 
public:
    double pay_per_hour;int work_time;
    Worker(string n,int y,int x):Employee(n,y),work_time(x){}//构造函数 
    double count_pay(){return work_time*pay_per_hour+35*working_years;}//计算           
    void SetWorktime(int wt){work_time=wt;}//工作时长 
    void Setpay_per_hour(int x){pay_per_hour=x;}//时薪        
};
class SalesPerson:public  Employee
{       
public:
    double pay_per_hour;double saleroom;int work_time;
    SalesPerson(string n,int y,double sr,int x):Employee(n,y),saleroom(sr),work_time(x){}//构造函数 
    double count_pay(){return work_time*pay_per_hour+35*working_years+1.0*saleroom/100;}//计算
    void SetWorktime(int wt){work_time=wt;}//工作时长
    void Setpay_per_hour(int x){pay_per_hour=x;}//时薪
    void Setsalesroom(double sr){saleroom=sr;}//售出金额 
};
class Manager:public  Employee
{
public:
    Manager(string n,int y):Employee(n,y){}//构造函数
    double count_pay(){return 1000+35*working_years;}//计算
};
int main()
{
    Worker work("zhangqiang",3,200);
    work.Setpay_per_hour(50);
    cout<<"工资="<<work.count_pay()<<endl;
    work.SetWorktime(180);
    work.SetWorkyears(10);
    work.Setpay_per_hour(30);
    cout<<work.Getname()<<"  "<<work.count_pay()<<endl;
    
    SalesPerson sales("wangjun",5,300000,25);
    sales.SetWorktime(40);
    sales.Setpay_per_hour(80);
    sales.Setsalesroom(450000);
    cout<<sales.Getname()<<"  "<<sales.count_pay()<<endl;
    
    Manager mana("sunchao",20);
    cout<<mana.Getname()<<"  "<<mana.count_pay()<<endl;
    return 0;
}

0x02 长方体计算

#include <iostream>
#include <cstring>
using namespace std;

class S
{   
protected:
    float length;  float width; 
public:
    S(float l,  float w):length(l),width(w) {}//构造函数
    float area(){return length*width; }
    void disp(){cout<<area()<<" ";}
};
class V:public S
{ 
private:
    float height; 
public:
    V(float l,  float w,float h):S(l,w),height(h){}//构造函数 
    float calv(){return  length*width*height;} 
    void disp(){cout<<area()<<" ";cout<<calv()<<" ";}
};

int main()
{
    float l,w,h;
    cin>>l>>w>>h;
    V a(l,w,h);
    a.disp();
    return 0;
}

第六章
0x01 动态多态性

#include <iostream>
using namespace std;
const double PI = 3.1415 ;

class shape     
{
public: 
    virtual double volume ( ) = 0 ;//纯虚函数
};

class cylinder:public shape         
{
private:
    double h , r;
public:
    cylinder  (double r , double h ):h(h) , r(r)//重载 
    {   }
    double volume() 
    {
        return h*PI*r*r ;        //圆柱的体积
    }                   
};

class sphere:public shape            
{
private:
    double r ;
public:
    sphere(double r) : r( r )//重载 
    {   }
    double volume()  
    {
        return 4*PI*r*r*r/3;     //球的体积
    }                                
};

int main() 
{
   shape *p;
   double  r,h;
   cout<<"input r & h："<<endl;
   cin>>r>>h;
   cylinder cy(r,h);
   sphere sp(r);
   p=&cy;
   cout<<p-> volume()<<endl;            
   p=&sp;
   cout<<p-> volume()<<endl; 
   return 0;
}

0x02 矩阵类运算符重载

#include <iostream>
#include <stdlib.h>
using namespace std;

class Matrix    
{
private:
    int row,col,*m;
public: 
    Matrix(int r,int c):row(r),col(c)//重载 
    {
        cout<<"请输入该矩阵元素："<<endl;
        m = new int[row*col];
        for(int i=0;i<row*col;i++)
        {
            cin >> m[i];
        }
    }
    Matrix():row(3),col(3)//重载 
    {
        m = new int[9];
    }
    friend Matrix operator + (const Matrix &a, const Matrix &b)//加 
    {
        Matrix tempt;
        if(a.row!=b.row||a.col!=b.col)
        {
            cout<<"program terminated!"<<endl;
            system("pause");
        }
        else
        {
            for(int i=0;i<a.row*a.col;i++)
            {
                tempt.m[i]=a.m[i]+b.m[i];
            }
            return tempt;
        } 
    }
    Matrix & operator = (const Matrix &s)//赋值 
    {
        m = new int[s.row*s.col];
        for(int i=0;i<s.row*s.col;i++)
        {
            m[i]=s.m[i];
        }
        return *this ;
    }
    ~Matrix()//析构 
    {
        delete []m;
    }
    void disp();
};

void Matrix::disp()
{
    for(int i=0;i<row;i++)
    {
        cout<<'\t';
        for(int j=0;j<col;j++)
            cout<<*(m+i*col+j)<<'\t';
        cout<<endl;
    }
}

int main()
{
    int row_a,col_a,row_b,col_b;
    cout<<"请输入am矩阵的行数和列数:"<<endl;
    cin>>row_a>>col_a;
    Matrix am(row_a,col_a);
    cout<<"请输入bm矩阵的行数和列数:"<<endl;
    cin>>row_b>>col_b;
    Matrix bm(row_b,col_b),cm;
    cout<<"am:"<<endl;
    am.disp();
    cout<<"bm:"<<endl;
    bm.disp();
    cm=am+bm;
    cout<<"cm=am+bm:"<<endl;
    cm.disp();
    am=bm;
    cout<<"am=bm:"<<endl;
    am.disp();
    return 0;
}

Part 6/6 编程练习

第2章对C的改进及扩展
基本格式

#include <iostream>
using namespace std;

int main( )
{    
    return 0;
}

bool类型

bool Larger(int x , int y)    
{    
     if ( x > y )              
        return true;
     return false;               
}
int main( )
{    
    int x , y;   
    cin >> x >> y;                  
    bool t = Larger(x , y);  
    // false为 0，true为 1 
    cout << boolalpha << t << endl << noboolalpha << t << endl;
    return 0;
}

名字空间

namespace one               
{   
    int M = 200;      
    int f = -10;           
}                          
namespace two             
{             
    int f = -100 ;        
}                         
using namespace one ;   

int main( )
{    
    cout << M << endl; 
    cout << f << endl;   
    using two::f;   
    f = 123;    
    cout << f << endl; 
    return 0;
}

string类型应用，insert，replace，substr，find，erase函数

int main( )
{   
    string  s1, s2, s3;
    cin >> s1; // 读入不带空格的字符串，例如 "ABC" 
    cout << s1 << endl; 
    getline(cin,s1); // 读入带空格的字符串，例如 " A BC" 
    cout << s1 << endl; 
    s2 = "Student";     
    s3 = s2;  
    cout << s3 << endl;
    string s4 (8, 'A'); // "AAAAAAAA"  
    cout << s4 << endl;                     
    s2 = s3 + '&' + s4 ; // "Student&AAAAAAAA"
    cout << s2 << endl;
    
    s3.insert(7 , "&Teacher");  // "Student&Teacher"
    cout << s3 << endl;
    s3.replace(2 , 4 , "ar");  // "uden" 替换为 "ar"，"Start&Teacher" 
    cout << s3 << endl;
    s1 = s3.substr(6 , 7);  // 从 "Start&Teacher"中获取 "Teacher"
    cout << s1 << endl;
    int pos = s3.find(s1);  // s1在s3中第 6 位 
    cout << pos << endl;
    s3.erase(5 , 8);    // 从 "Start&Teacher"中删除 "&Teacher"
    cout << s3 << endl;
    bool f = s1 > s4;   // true 
    cout << boolalpha << f << endl;
    return 0;
}

全局变量与局部变量

int A = 20; 
int main( )
{   
    int a[3] = {10 , 20 , 30};        
    int A = 0; 
    // 局部变量 A=60           
    for (int i = 0 ; i < 3 ; i++){
        A+=a[i];
    }    
    ::A += A;    // 全局变量 ::A=80    
    cout << A << endl << ::A << endl;
    return 0;
}

形参带默认参数值的函数

void Fun( int i , int j  , int k=10 ){
    cout << i << " "<< j << " " << k << endl;
}
int main( )
{   
//  Fun ( 20 ); 报错
    Fun ( 20 , 30 ); // k默认为 10  
    Fun ( 20 , 30 , 40 ); // k替换为 40 
    return 0;
}

重载函数

int square ( int x ){                      
    cout << x * x << endl;  
}
float square ( float x ){                       
    cout << x * x << endl; 
}
double square ( double x ){                      
    cout << x * x << endl; 
}
int main( )
{   
    square ( 11 ); 
    square ( 1.1f );
    square ( 1.11 );
    return 0;
}

引用的声明及访问

int x = 5 , y = 10 ;
int &r = x ;   
     
void print( ){    
     cout << "x= " << x << " y= " << y << " r= " << r << endl ;
     cout << "Address of x " << &x << endl;         
     cout << "Address of y " << &y << endl;         
     cout << "Address of r " << &r << endl;         
}
int main( )
{   
    print (); // x=5 y=10 r=5
    y = 100;                      
    x = y - 10;                   
    print (); // x=90 y=100 r=90
    return 0;
}

引用作参，修改实际参数的值

void swap ( int &x , int &y ){                   
    int t = x ;   //t=3 
    x = y ;       //x=5              
    y = t ;       //y=3                     
}
int main( )
{   
    int a = 3 , b = 5 ;
    swap ( a , b ) ;                              
    cout << "a= " << a << " b= " << b << endl; 
    return 0;
}

三种参数的使用

int Fun (const int &x , int &y , int z){   
//  x++ ; 报错，x不可修改 
    y++ ;                           
    z++ ;           
    return y ;        
}
int main( )
{   
    int a = 1, b = 2, c = 3, d = 0;
    d = Fun ( a , b , c ) ;    // a不变，b=2+1，c不变，d=b
    cout << "a=" << a << " b=" << b << " c=" << c << " d=" << d << endl;
    return 0;
}

异常处理过程和方法

double divide(int x,int y){   
    // 如果分母为零，抛出异常 
    if ( y == 0 ){
        throw 2.333; 
    } 
    return x*1.0 / y;
}
int main( )
{   
    int a = 9, b = 5, c = 0;
    // 检查是否出现异常
    try{   
        cout << "a/b = " << divide (a , b) << endl;
        cout << "b/a = " << divide (b , a) << endl;
        cout << "a/c = " << divide (a , c) << endl;// 失败，不再try 
        cout << "c/b = " << divide (c , b) << endl;// 没有执行 
    }
    // catch到小数2.333 
    catch ( double ){   
        cout << "有分母为零的情况" << endl; 
    }
    return 0;
}

第3章类与对象1
类对象数据成员

class CDate{
public:
    int year;
    int month;
    int day;
};
int main( )
{   
    CDate date1;                      
    CDate date2;
    int age(0);// int age=0
    date1.year = 2019; date1.month = 3; date1.day = 9;
    date2.year = 1999; date2.month = 3; date2.day = 9;
    age = date1.year - date2.year;             
    cout << "He is " << age << " years old" << endl;
    cout << date2.year << " - "<< date2.month << " - " << date2.day << endl;
    cout << "date1 occupies " << sizeof(date1) << " bytes."; // 3 * 4 =12
    return 0;
}

this 指针

class CDate{
private:
    int Year, Month, Day;
public:
    void SetDate(int y,int m,int d){   
    Year = y;
    Month = m;
    Day = d; 
    }   
    void  Display( ){
    cout << "this 指针是: "<< this <<endl;                   
    cout << "Year地址: "  << &this -> Year << endl;    
    cout << "Month地址: "<< &this -> Month << endl;
    cout << "Day地址: "<< &this -> Day << endl;
    }
};
int main( )
{   
    CDate a ;
    a.SetDate (2019, 3, 9);    
    cout << "a地址: " << &a << endl;
    a.Display();
    return 0;
}

两种方式创建对象

class CDate{
    int Year, Month, Day;
public:
    CDate(int y=2000, int m=1, int d=22 ){ 
        Year = y; Month = m; Day = d; 
    }
    void  Display( ){
        cout << this->Year << " - "<< this->Month << " - " << this->Day << endl;                   
    }
};  
int main( )
{   
    CDate day1 (2019,3);// 初始化 day1
    CDate day2 = day1;  // 用day1初始化 day2
    day1.Display();
    day2.Display();
    return 0;
}

构造与析构顺序

class CDate
{   
    int year, month, day ;   
public:                  
    // 构造函数              
    CDate(int y=2000, int m=1, int d=1):year(y), month (m), day(d){
        cout << "构造成功" << endl;
    }      
    // 拷贝构造函数
    CDate(const CDate &x){
        year = x.year; month = x.month; day = x.day + 1;
        cout << "拷贝构造成功" << endl;
    }          
    void  Display ( ){
        cout<< year << "-" << month << "-" << day << endl;
    }  
    // 析构函数
    ~CDate(){
        cout << "析构成功" << endl; 
    }                  
};
CDate f (CDate day1){   
    CDate day2 (day1);   
    return day2;             
}                              
int main( )
{   
    CDate day1 (2019,3,9) ;      // 构造 day1 
    CDate day3;                  // 构造 day3 
    CDate day2 (day1) ;          // 拷贝构造 day2, 9+1=10
    CDate day4 = day2;           // 拷贝构造 day4, 10+1=11
    day3 = day2;                 // 拷贝构造 day3 
    day3 = f (day2);             // 拷贝构造 day3, 11+1=12
    // f 里的 day2，day1依次析构
    day3.Display( );            //2019-3-12
    // day4，day3，day2，day1依次析构 
    return 0;
}

类对象数组，初始化及访问

class CDate{   
    int year, month, day;    
public :                                
    CDate(int y=2000, int m=1, int d=1): year(y), month (m), day(d) 
    {  }     
    void  Display ( ){
        cout<< year << "-" << month << "-" << day << endl;
    } 
};                         
int main( )
{   
    CDate x[3]={ CDate(2019,3,8), CDate(2019,3,11) };
    for(int i=0; i< 3;  i++){
        x[i].Display( );
    } 
    return 0;
}

第4章类与对象2
包含类1

class A{
public:
    A( ){
        cout << "创建A" << endl; 
    }
    ~A( ){
        cout << "析构A" << endl; 
    }
};
class B{
public:
    B( ){
        cout << "创建B" << endl; 
    }
    ~B( ){
        cout << "析构B" << endl; 
    }
private:
    A a;// B类包含了A类
};
int main( )
{
    B  b;
    return 0;
}

包含类2

class CDate{   
    int year, month, day;   
public :                                
    CDate(int y, int m, int d):year(y),month (m),day(d) {       
        cout << "CDate 构造成功" << endl;
    }
    void  Display( ){   
        cout<< year << "-" << month << "-" << day << endl;
    }
    ~CDate(){
        cout << "CDate 析构成功" << endl;
    }
};

class Croster{
private:
    string name;
    CDate birthday;// Croster类包含了CDate类
public:
    Croster(string na, int y, int m, int d): birthday( y, m, d){
        cout << "Croster 构造成功" << endl;
        name = na;
    }
    void Display(){
        cout << name << " : ";
        birthday.Display();
    }
    ~Croster(){
        cout << "Croster 析构成功" << endl;
    }
};
int main()
{
    Croster stuA("赵焱", 2001, 1 ,29 );
    stuA.Display();
    return 0;
}

静态数据成员1

class Croster{
public:
    static int Count;
private:
    string name; int Math; int English;
public:
    Croster(string na="undefine", int m= 100, int e= 100): name(na), Math(m), English(e){ 
        cout << "欢迎新同学！" << endl ;
        Count -- ;
    }
};
int Croster :: Count = 100;// 初始化静态数据成员
int main()
{
    cout << "人数 ： " << Croster::Count << endl;
    Croster list[3];
    cout << "人数 ： " << list[1].Count << endl;
    Croster A;
    cout << "人数 ： " << A.Count << endl;
    return 0;
}

静态数据成员2

class Croster{
public:
    static int Count;
private:
    string name; int Math; static int Sum;
public:
    Croster(string na= "undefine", int m= 100): name(na), Math(m){ 
        cout << "欢迎新同学！" << endl ;
        Count -- ;
        Sum += Math;
    }
    static void Display(){
    //  cout << "name: " << name << endl; 报错 
        cout << "Sum = " << Sum << ", ";
        if ( Count == 100 ){
            cout << "Average = 0 " << endl;
        } 
        else{
            cout << "Average = " << Sum* 1.0/ (100-Count) << endl;
        } 
    }
};
int Croster :: Count = 100;  
int Croster :: Sum;// 默认初始值为0    
int main()
{
    Croster::Display();
    Croster list[3] ={ Croster("赵焱",95), Croster("钱朵", 90), Croster("孙力", 92) };
    list[2].Display();
    return 0;
}

静态数据成员3

class Croster{
private:
    string name; 
    double GPA, Math;  
    static const double Score  ;                   
public:
    Croster(string na= "undefine", double m= 100){   
        name = na; Math = m ;
    } 
    double GetGPA(){
        GPA = Math/10 - Score;
        return GPA;
    }
    void Display(){
        cout << name << "的成绩为：" << Math << ", " << "绩点为：" << GetGPA() << endl;
    }
};
const double Croster::Score = 5.00;  
int main()
{
    Croster A("赵焱", 93.5);
    A.Display();
    return 0;
}

第5章继承与派生
单继承

#include <iostream>
using namespace std;

class Base
{
private:
    int b1;
protected:
    int b2;
public:
    void set(int m, int n){
        b1 = m;
        b2 = n;
    }
    void show( ){
        cout << "b1 = " << b1 << endl;
        cout << "b2 = " << b2 << endl;
    }
};
class Derived: public Base// 公有派生类
{
private:
    int d;
public:
    void set2(int m, int n, int l){
        set(m,n);
        d = l;
    }
    void show2( ){
        show( );
        cout << "d = " << d << endl;
    }
};
int main( )
{
    Derived obj;
    obj.set2(30, 40, 50);
    obj.show( );
    obj.show2( );
    return 0;
}

多重继承

#include <iostream>
using namespace std;

class BaseA
{
private: int a1;
protected: int a2;
public: int a3;
    void setA(int x, int y, int z){
        a1 = x; a2 = y; a3 = z;
    }
    void showA( ){
        cout << " a1 = " << a1 << "， a2 = " << a2 << "， a3 = " << a3 << endl;
    }
};

class BaseB
{
private: int b1;
protected: int b2;
public: int b3;
    void setB(int x, int y, int z){
        b1 = x; b2 = y; b3 = z;
    }
    void showB( ){
        cout << " b1 = " << b1 << "， b2 = " << b2 << "， b3 = " << b3 << endl;
    }
};

class BaseC
{
private: int c1;
protected: int c2;
public: int c3;
    void setC(int x, int y, int z){
        c1 = x; c2 = y; c3 = z;
    }
    void showC( ){
        cout << " c1 = " << c1 << "， c2 = " << c2 << "， c3 = " << c3 << endl;
    }
};

class Derived: public BaseA, protected BaseB, private BaseC
{
private: int d1;
protected: int d2;
public: int d3;
    void setD(int x, int y, int z){
        d1 = x; d2 = y; d3 = z;
    }
    void showD( ){
        cout << " d1 = " << d1 << "， d2 = " << d2 << "， d3 = " << d3 << endl;
    }
    void setall(int x0, int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8, int x9, int x10, int x11 ){
        setA(x0, x1, x2);
        setB(x3, x4, x5);
        setC(x6, x7, x8);
        setD(x9, x10, x11);
    }
    void showall( ){
        showA( ); showB( ); showC( ); showD( );
    }
};
int main( )
{
    Derived obj;
    obj.setall(10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120);
    obj.showA( );//       showA( )为 public成员，可以通过 obj访问
//  obj.showB( );         showB( )为 protected成员，无法通过 obj访问
//  obj.showC( );         showC( )为 private成员，无法通过 obj访问
    obj.showD( );           
    obj.showall( );
    return 0;
}

构造，析构

#include <iostream>
using namespace std;

class Base//基类 
{
public:
    Base( ){cout << "构造A"<<endl;  }
    ~Base( ){cout << "析构A"<<endl; }
};
class Derived: public Base//派生类             
{                           
public:
    Derived( ){cout << "构造B"<<endl; }
    ~Derived( ){cout << "析构B"<<endl;  }
};
int main( )
{
    Derived obj;
    return 0;
}

多重继承下构造，析构

#include <iostream>
using namespace std;

class Grand
{
public:
    int a;
    Grand(int n): a(n)// a=1 
    {cout << "构造Grand, a = " << a << endl;}
    ~Grand( ){cout << "析构Grand" << endl;}// 析构 
};
class Father: public Grand
{
public:
    int b;
    Father(int n1,int n2): Grand(n1), b(n2)// Grand(1), b=2 
    {cout << "构造Father, b = " << b << endl;};
    ~Father( ){cout << "析构Father" << endl;}// 析构 
};
class Mother
{
public:
    int c;
    Mother(int n): c(n)// c=2
    {cout << "构造Mother, c = " << c << endl;}
    ~Mother( ){cout << "析构Mother" << endl;}// 析构 
};
class Son: public Father, public Mother
{
public:
    int d;
    Son(int n1, int n2, int n3, int n4): Father(n1, n2), Mother(n3), d(n4)// Father(1，2), Mother(3), d=4 
    {cout << "构造Son, d = " << d << endl;}
    ~Son( ){cout << "析构Son" << endl;}// 析构 
};
int main( )
{
    Son s(1,2,3,4);
    return 0;
}

派生类，基类有同名成员

#include <iostream>
using namespace std;

class Base
{
public:
    int a;
    Base(int x){
        a = x;
    }
    void Print1( ){
        cout << "Base::a = " << a << endl; 
    }
};
class Derived: public Base// 派生类 
{
public:
    int a;
    Derived(int x, int y): Base(x){
        a = y;              
        Base::a *= 2 ;      
    }
    void Print2( ){
        Base::Print1( );     
        cout << "Derived::a = " << a << endl;
    }
};

void f1(Base &obj)    {obj.Print1( );}
void f2(Derived &obj)    {obj.Print2( );}

int main( )
{
    Derived d(200,300) ;  
    d.Print2( );             // 输出1, 2行 
    d.a = 400;             
    d.Base::a = 500;        
    d.Base::Print1( ) ;      // 输出3行 
    Base *pb; 
    pb = &d;                
    pb -> Print1( );         // 输出4行 
    f1(d);                   // 输出5行 
    Derived *pd;
    pd = &d;                
    pd -> Print2( );         // 输出6，7行 
    f2(d);                   // 输出8，9行 
    return 0;
}

多重继承中，直接基类有同名成员

class Base1{
public:
    int a;
    Base1(int x):a(x){
        cout << "Base1 a = " << a << endl;
    }
};
class Base2{
public:
    int a;
    Base2(int x):a(x){
        cout << "Base2 a = " << a << endl;
    }
};
class Derived: public Base1, public Base2{
public:          
    Derived(int x,int y):Base1(x),Base2(y){
        Base1::a *= 2 ; 
        Base2::a *= 2 ;         
        cout << "Derived from Base1::a = "<<Base1::a << endl;               
        cout << "Derived from Base2::a = "<<Base2::a << endl;               
    }
};
int main( ){
    Derived obj(10, 20);
    return 0;
}

多层继承中，有共同的祖先基类

// 共同的祖先基类
class Base{
public:
    int a;
    Base(int x): a(x){ 
        cout << "基类 a = " << a << endl; 
    }
    ~Base( ){
        cout << "析构基类" << endl;
    }
};
// 派生一 
class Base1: public Base{
public:
    int b;
    // Base(20), c(10) 
    Base1(int x, int y): Base(y), b(x){
        cout << "派生一 a = " << a << endl;
        cout << "派生一 b = " << b << endl;
    }
    ~Base1( ){
        cout << "析构派生一" << endl; 
    }
};
// 派生二 
class Base2: public Base{ 
public:
    int c;
    // Base(40), c(20) 
    Base2(int x, int y): Base(y), c(x){ 
        cout << "派生二 a = " << a << endl;
        cout << "派生二 c = " << c << endl;
    }
    ~Base2( ){
        cout << "析构派生二" << endl; 
    }
};
class Derived: public Base1, public Base2{
public:
    // Base1(10, 20), Base2(20, 40)
    Derived(int x, int y): Base1(x, y), Base2(2*x, 2*y){
        cout << "Derived from Base1::a = "<< Base1::a << endl;                  
        cout << "Derived from Base2::a = "<< Base2::a << endl;                  
        cout << "Derived from Base1 b = "<< b << endl;                  
        cout << "Derived from Base2 c = "<< c << endl;                  
    }
    ~Derived( ){
        cout << "析构Derived" << endl;
    }
};
int main( ){   
    Derived obj(10, 20);
    return 0;
}

虚基类

class Base{
public:
    int a;
    Base(int x): a(x){ 
        cout << "Base a = " << a << endl; 
    }
};
// 虚基类一 
class Base1: public virtual Base{
public:
    int b;
    Base1(int x, int y): Base(y), b(x){
        cout << "虚基类一 a = " << a << endl;
        cout << "虚基类一 b = " << b << endl;
    }
};
// 虚基类二 
class Base2: public virtual Base{ 
public:
    int c;
    Base2(int x, int y): Base(y), c(x){ 
        cout << "虚基类二 a = " << a << endl;
        cout << "虚基类二 c = " << c << endl;
    }
};
class Derived: public Base1, public Base2{
public:
    // Base1(10, 20), Base2(20, 40), Base(30)
    Derived(int x, int y): Base1(x, y), Base2(2*x, 2*y), Base(3*x){
        cout << "a = " << a << endl << "b = " << b << endl << "c = " << c << endl;
        cout << "Base::a = " << Base::a << endl << "Base1::a = " << Base1::a << endl << "Base2::a = " << Base2::a << endl;
    }
};
int main( ){
    Derived obj(10, 20);
    return 0;
}

赋值兼容规则

class Base{
public:
    int b;
    Base(int x): b(x){  }
    int getb( ){ return b; }
};
class Derived: public Base{
public:
    int d;
    Derived(int x, int y): Base(x), d(y){  }
    int getd( ){ return d; }
};
int  main( ){
    Base B(11);
    Derived D(22, 33);
    // 第一种赋值兼容
    B = D;
    // 第二种赋值兼容
    Base *B1 = &D;  
    // 第三种赋值兼容
    Derived *D1 = &D;
    Base *B2 = D1;
    // 第四种赋值兼容
    Base &B3 = D;
    cout << "B.getb( ) = " << B.getb( ) << endl;
    cout << "B1->getb( ) = " << B1->getb( ) << endl;
    cout << "B2->getb( ) = " << B2->getb( ) << endl;
    cout << "B3.getb( ) = " << B3.getb( ) << endl;
    return 0;
}

第6章多态性
静态多态性

class Student{  
    string name;
    int no;
public:
    Student():name("同学"),no(0){  
    }                                  
    Student(string s, int n): name(s), no(n){  
    }
    void  print(){   
        cout << name << "  " << no << endl; 
    }                       
    void  print(int x){
        cout << name << "  B" << x << "  "<< no << endl;             
    }            
};
int  main( ){
    Student  s1;   
    s1.print ( );              
    Student  s2("学生", 18);                  
    s2.print ( );             
    s2.print (2019);  
    return 0;
}

重载运算符 "+"

class Complex{
private:
    float  real, imag; 
public:
    Complex (float r = 0, float i = 0):real(r),imag(i){ 
    } 
    void print ( ){ 
        cout << real << "+" << imag << "i" <<endl;                            
    } 
    Complex operator + (Complex &a){    
        Complex t;
        t.real = real + a.real ; 
        t.imag = imag + a.imag ;     
        return t;
    }
    Complex operator + (float x){
        return Complex (real+x, imag) ;
    }            
};

int  main( ){
    Complex c1 (1.5 , 2.5), c2(5 , 10), c3;
    cout << "c1 = " ;  c1.print( );
    cout << "c2 = " ;  c2.print( );
    c3 = c1 + c2 ; 
    cout << "c3 = c1+c2 = ";  c3.print( );
    c3 = c3 + 3.5 ; 
    cout << "c3 + 3.5 = ";  c3.print( ); 
    return 0;
}

重载运算符 "="

#include <iostream>
#include <cstring>
using namespace std;

class CMessage{
private:
    char* p;                              
public:
    CMessage(char* text = "ABC"){
        // 申请动态空间
        p = new char[strlen(text) + 1]; 
        strcpy(p, text);
    }
    void show(){
        cout << p <<endl;
    }
    // 赋值运算符 
    CMessage & operator = (CMessage &s){
        p = new char[strlen(s.p) + 1];
        strcpy(p, s.p);
        return *this ;
    }
};  
int  main( ){
    CMessage Mes1("爱我中华");
    CMessage Mes2;   
    Mes1.show(); Mes2.show();
    Mes2 = Mes1;
    Mes1.show(); Mes2.show();
    return 0;
}

重载运算符 “[ ]"

class Array{
    int  *m, num;                                   
public:
    Array(int n):num(n){      
        m = new int [num];
        for (int i = 0; i < num; i++){
            m[i] = (i+1)*10; 
        }
    }          
    // 调用运算符
    int & operator [] (int r){
        if(r>=0 && r<num){
            return *(m+r);
        }
        return *m;
    } 
    void show( ){
        for (int i = 0; i < num; i++){
            cout << "  " << m[i];
        }      
        cout << endl;
    }              
};   
int  main( ){
    Array  a(5); a.show( );  
    // *(a+2) = 800      
    a[2] = 800; a.show( ); 
    // *a = -100
    a[23] = -100; a.show( ); 
    return 0;
}

重载运算符 ">>"，"<<"

class Complex{
    float real, imag;
public:
    Complex (float r=0, float i=0): real(r),imag(i){   
    }
    friend istream & operator >> (istream &i, Complex &a){
        i >> a.real >> a.imag ; 
        return i;
    }
    friend ostream & operator << (ostream &o, Complex &a){
        o << a.real << "+" << a.imag << "i" << endl;   
        return o;
    }   
};
int  main( ){
    Complex c1, c2;
    cout << "input c1, c2:" << endl;
    cin >> c1 >> c2;
    cout << "c1 = " << c1 << "c2 = " << c2;  
    return 0;
}

重载运算符 “++”，“--”

class Complex{
    float real, imag;
public:
    Complex operator -- ( ){
        --real; --imag;                 
        return *this;
    }
    Complex operator ++ ( ){
        ++real; ++imag;                 
        return *this;
    }
    Complex operator -- (int){
        Complex t(*this);     
        real--; imag--;
        return t; 
    }
    Complex operator ++ (int){
        Complex t(*this);     
        real++; imag++;
        return t;       
    }
    friend istream & operator >> (istream &i, Complex &a){
        i >> a.real >> a.imag ; 
        return i;
    }
    friend ostream & operator << (ostream &o, Complex &a){
        o << a.real << "+" << a.imag << "i";   
        return o;
    }  
};
int  main( ){
    Complex c1, c2;
    cout << "input c1, c2:" << endl;
    cin >> c1 >> c2;
    cout << "c1 = " << c1 << "c2 = " << c2;  
    c1++; cout << "c1++ = " << c1 << endl;  
    ++c1; cout << "++c1 = " << c1 << endl;  
    c2++; cout << "c2++ = " << c2 << endl;  
    ++c2; cout << "++c2 = " << c2 << endl;  
    return 0;
}

虚函数的 Print()

class Base{
public:
    int a;
    Base(int x):a(x){
    }
    virtual void Print( ){
        cout << "Base::a = " << a << endl; 
    }
};
class Derived: public Base{
public:
    int a;
    Derived(int x, int y): Base(x),a(y){           
        Base::a *= 2 ;      
    }
    void Print( ){
        Base::Print( );     
        cout << "Derived::a = " << a << endl;
    }
};
void f1(Base &x){
    x.Print( );
}
void f2(Derived &x){
    x.Print( ); 
}
int  main( ){               
    Derived d(200,300) ;  // Base(200), d.a(300)
    d.Print( );         
    d.a = 400;            // d.a(400)
    d.Base::a = 500;      // Base(500)
    d.Base::Print( ) ;   
    Base b(8);            // b.a(8)
    Base *pb;               
    pb = &b;              // pb->a=8  
    pb -> Print( );       
    pb = &d;              // pb-> Base::a=500, pb-> a=400  
    pb -> Print( );     
    f1(b);             
    f1(d);              
    Derived *pd;
    pd = &d;              // pd-> Base::a=500, pd-> a=400
    pd -> Print( );     
    f2(d);              
    return 0;
}

虚函数的析构

class A{
public:
    virtual  ~A( ){
        cout << "析构A"<< endl;
    } 
};
class B: public A{
public:
    virtual ~B ( ){
        cout << "析构B" << endl;
    }              
};
int  main( ){
    A *a = new B();  
    delete a ;            
    return 0;
}

虚函数的同名覆盖

class base{
public: 
    // 虚函数
    virtual void f1( ){
        cout << "f1() of base "<< endl ;     
    } 
    // 虚函数 
    virtual void f2( ){
        cout << "f2() of base "<< endl ;     
    } 
}; 
class derive: public base{
 public:
    void f1( ){
        cout << "f1() of derive "<< endl;       
    } 
    void f2 (int x){ 
        cout << "f2() of derive "<< endl;       
    } 
    // 普通函数
    void f3(){ 
        cout << "f3() of derive "<< endl;       
    } 
};
int main(){
    derive x;
    x.f1 ( );     
    x.base::f2( );
    x.f2 (1);     
    x.f3 ( );   
    return 0;
}

纯虚函数

class Point{
public:
    // 纯虚函数
    virtual void Draw () = 0 ; 
};
class Line:public Point{
public:
    void Draw ( ){
        cout << "Line::Draw is called"<<endl ;
    }           
 };
class Circle:public Point{
public:
    void Draw ( ){
        cout << "Circle::Draw is called"<<endl ;
    }           
};
void Function(Point *p){ 
    p-> Draw( );      
}
int main(){
//  Point p; 报错 
    Line L; Function(&L);
    Circle C; Function(&C);     
    return 0;
}

纯虚函数的抽象类

class Shape{
public: 
    virtual double area( )= 0 ;
};
class Triangle: public Shape{
    double base, hight;
public:
    Triangle (double b, double h):base(b), hight(h){   
    }
    double area(){
        return 1/2*base*hight;     
    }               
};
class Rectangle:public Shape{
    double hight, width;
public:
    Rectangle(double h, double w):hight(h), width(w){   
    }
    double area(){
        return hight*width ;         
    }                   
};
class Circle:public Shape{
    double radius;
public:
    Circle(double r):radius(r){  
    }
    double area(){
        return 3.14*radius*radius;    
    }                                
};
int main(){
    Shape *p[3];                    
    p[0] = new Rectangle (2.5, 10.0); 
    p[1] = new Rectangle(15, 22);  
    p[2] = new Circle(3.0);         
    cout << "三角形面积: " << p[0]->area( ) << endl ;    
    cout << "长方形面积: " << p[1]->area( ) << endl ;
    cout << "圆形面积: " << p[2]->area( ) << endl;   
    return 0;
}

第7章模板
函数模板

// 函数模板
template <class T>                         
T Max(T x, T y){   
    return x>y ? x:y;
}                                         
int main(){
    cout << Max(2, 8) << endl;            
    cout << Max(2.5, 8.5) << endl;         
//  cout << Max(2, 8.5) << endl; 报错 
    cout << Max <int>(2, 8.5) << endl;      
    cout << Max <double>(2, 8.5) << endl;  
    return 0;
}

模板函数的重载

#include <iostream>
#include <cstring>
using namespace std;

template <class T>
T Max(T x, T y){   
    return x>y ? x:y;
}
char* Max(char* x, char* y){    
    return (strcmp(x,y)>0 ? x:y);
}                                      
int main(){
    cout << Max('2', '8') << endl;        
    cout << Max("gorilla", "star") << endl;  
    return 0;
}

类模板

template <class A, class B>
void sum(A a1, B a2){
    cout << (a1+a2);
}                                 
int main(){
    string a = "abc";
    string b = "cba";
    sum(a,b);
    return 0;
}

第8章文件及输入输出
cin，cin.get( )，cin.getline( )，getline( )

int main() { 
    char s1[80], s2[80], s3[80];
    string str1, str2;
    cout << "Enter sentence A: " << endl;       
    cin >> s1;                                                   
    cin.get (s2, 80);
    cout << "Enter sentence B: " << endl;         
    cin >> s1;                                                   
    cin.getline(s3, 80);   
    cout << "Enter sentence C: " << endl;                     
    cin >> str1;
    getline (cin, str2);
    cout << "cin: " << s1 << endl;         
    cout << "cin.get: " << s2 << endl;     
    cout << "cin: " << s1 << endl;                                                   
    cout << "cin.getline: " << s3 << endl; 
    cout << "cin: " << str1 << endl;              
    cout << "getline: " << str2 << endl;           
    return 0;
}

setf( )，unsetf( )

int main( ){ 
    cout.setf ( ios::showpos );  
    cout.setf ( ios::scientific ); //科学计数法
    cout << 123 << "　" << 123234.5 << endl;
    cout.unsetf ( ios::showpos );          
    cout << 123 << "　" << 123234.5 << endl;  
    return 0;
}

操纵函数 setw

#include<iostream>
#include<iomanip>
using namespace std;

int main(){ 
    int i = 6789, j = 1234, k = -10;
    cout << setw(6) << i << j << k << endl;
    cout << setw(6) << i << setw(8) << j << setw(10) << k << endl;
    return 0;
}

输出控制符函数 setup

#include <iostream>
#include <iomanip>
using namespace std;

ostream & setup (ostream &s){
    s.setf ( ios::left );  //左对齐
    s << setw(10) << setfill('$'); //域宽10，空白处用$填充
    return s;
}
int main(){ 
    cout << 10 << "Hello!" << endl;
    // 10 域宽2，"Hello!" 域宽6 
    cout << setup << 10 << "Hello!" << endl;
    cout << setup << 10 << setup  << "Hello!" << endl; 
    return 0;
}

“>>”，“<<” 文本操作

#include <fstream>
#include <iostream>
#include <cstring>
using namespace std;

void CreateFile(){   
    ofstream x ( "d:\\f1.txt" );              
    x << 10 << " " << 3.1415926;       
    x << "~ This is a short text file ~"; 
    x.close();                      
}
void ReadFile(){   
    int i; double d; string str;
    ifstream y ( "d:\\f1.txt" );           
    y >> i >> d ;                   
    cout << i << " " << d <<endl;            
    getline(y, str);                 
    cout << str << endl;                
    y.close();                        
} 
int main(  ){   
    CreateFile();           
    ReadFile();         
    return 0;
}

get()，put() 文本操作

int main ( ){ 
    //打开文本 
    ifstream x ( "d:\\abc.txt" );   
    ofstream y ( "d:\\xyz.txt" );  
    char c;
    //复制和输出
    while(x.get(c)){
        y.put(c);               
        cout.put(c);
    }
    x. close( );                    
    y. close( );                    
    return 0;
}

read()，write() 文本操作

void CreateBiFile( ){
    ofstream x ( "d:\\test.txt" );         
    double num = 3.1415926;          
    string str = "abcDEFlmn";
    char s[100];
    strcpy (s, str.c_str( ));  
    
    x.write ((const char *)&num, sizeof(double)); //写入数字 100 
    x.write (s, strlen(s)); //写入字符串 "abc" 
    x.close ( ) ;                   
}
void ReadBiFile(  ) 
{ 
    ifstream y( "d:\\test.txt" );         
    double num;
    char s[100] = "";    
                
    y.read(( char *)&num, sizeof(double)); //读取数字 
    y.read(s, 100 ); //读取字符串 
    cout << num << ' ' << s;                 
    y.close();                     
}
int main(){  
    CreateBiFile ( );
    ReadBiFile ( ); 
    return 0;
}

读写示例

int main(){   
    // 可读可写
    fstream x("d:\\test.txt", ios::in|ios::out); 
    long i, j;
    char c1, c2;
    // 将前5个字符顺序颠倒 
    for(i=0,j=4; i<j; i++,j--){               
    // seekg()是输入流的操作，g是get缩写                             
        x.seekg(i, ios::beg); x.get(c1);
        x.seekg(j, ios::beg); x.get(c2);
        x.seekg(j, ios::beg); x.put(c1);
        x.seekg(i, ios::beg); x.put(c2);
    }
    x.close();                     
    return 0;
}

NJUPT【面向对象程序设计及C++ 】

Part 1/6 考试范围

Part 2/6 考试真题

Part 3/6 练习题库

Part 4/6 实验报告

Part 5/6 平台练习

Part 6/6 编程练习

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

NJUPT 计软院复习资料

NJUPT【 面向对象程序设计及C++ 】

Part 1/6 考试范围

Part 2/6 考试真题

Part 3/6 练习题库

Part 4/6 实验报告

Part 5/6 平台练习

Part 6/6 编程练习

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

NJUPT 计软院 复习资料

NJUPT【面向对象程序设计及C++ 】

NJUPT 计软院复习资料