C++语法—类的继承

一、继承

继承方式有三种，public、private、protected

不管是什么继承方式，父类中的私有属性都无法直接访问，只能通过get、set访问

使用public继承，那么父类中的public、private、protected在子类中维持原来的修饰符；

使用protected继承，那么父类中的public、protected在子类中变为protected修饰，让子类的子类可以继续访问，无限向下传播；

使用private继承，那么父类中的public和protected在派生类中可以访问，父类中private数据成员不能访问。

1.1 子类显示调用父类构造函数

当父类只有带参数的构造函数时，子类才能以显示方法调用父类带参数的构造函数，否则编译将出现错误。

#include <iostream>
using namespace std;
class CEmployee                                        //定义CEmployee类
{public:int m_ID;                                            //定义数据成员char m_Name[128];                                    //定义数据成员char m_Depart[128];                                    //定义数据成员CEmployee(char name[])                                //带参数的构造函数{strcpy(m_Name,name);cout << m_Name<<"调用了CEmployee类带参数的构造函数"<< endl;    }CEmployee()                                        //无参构造函数{strcpy(m_Name,"MR");cout << m_Name<<"CEmployee类无参构造函数被调用"<< endl;        }~CEmployee()                                        //析构函数{cout << "CEmployee类析构函数被调用"<< endl;        //输出信息}
};
class COperator :public CEmployee                            //从CEmployee类派生一个子类
{public:char m_Password[128];                                //定义数据成员COperator(char name[ ]):CEmployee(name)                //显示调用父类带参数的构造函数{//设置数据成员cout << "COperator类构造函数被调用"<< endl;            //输出信息}COperator():CEmployee("JACK")                        //显示调用父类带参数的构造函数{//设置数据成员cout << "COperator类构造函数被调用"<< endl;            //输出信息}~COperator()                                        //析构函数{cout << "COperator类析构函数被调用"<< endl;            //输出信息}
};
int main(int argc, char* argv[])                                //主函数
{COperator optr1;                        //定义一个COperator对象，调用自身无参构造函数COperator optr2("LaoZhang");           //定义一个COperator对象，调用自身带参数构造函数return 0;
}

 

 

1.2 子类显示调用父类成员函数

如果子类中的成员函数与父类的名字一样，子类调用时会默认调用子类自己的成员函数，要想调用父类的该同名函数，则需要在调用时，方法前面添加父类作用域。

如果子类重载父类函数，既子类中有父类的同名函数，子类将屏蔽所有的父类同名函数不管父类重载了几次，父类中所有重名函数都被屏蔽，无法通过子类显示调用。

class Fu
{public:void test();
};
class Zi :public Fu
{public:void test();
};void main()
{Zi z1;z1.test();        //默认调用子类的成员函数z1.Fu::test();    //显示调用父类的成员函数
}

 

 

1.3 重载运算符

运算符实际上是一个函数，运算符的重载是函数的重载。

operator 类型名();

 

 

重载 + 号运算符

#include <iostream>
using namespace std;
class CBook
{public:CBook (int iPage){m_iPage=iPage;}CBook operator+( CBook b){return CBook (m_iPage+b.m_iPage);}void display(){cout << m_iPage << endl;}
protected:int m_iPage;
};void main()
{CBook bk1(10);CBook bk2(20);CBook tmp(0);tmp= bk1+bk2;tmp.display();
}

 

 

上面案例中的 + 号左右两边因为是相同的类型，所以可以交换左右的顺序。

operator + () 没有参数代表前置运算，要求前面的值，

operator + (int) 有参数代表后置运算，要求后面的值。

operator ++ () 没有参数代表前置运算，要求前面的值，

operator ++ (int) 有参数代表后置运算，要求后面的值。

下方的案例交换左右顺序是错误的：

#include <iostream>
using namespace std;
class CBook
{public:int m_Pages;void OutputPages(){cout<<m_Pages<<endl;}CBook(){m_Pages = 0;}CBook operator + (const int page){CBook bk;bk.m_Pages = m_Pages + page;return bk;}
};void main()
{CBook vbBook,vfBook;vfBook =  vbBook + 10;        //这里交换为 10 + vbBook 是错误的vfBook.OutputPages();
}

 

 

1.4 转换运算符

c++语言中普通的数据类型可以进行强制类型转换。

int i= 10;
double d;
d =(double) i;
//等同于下面的
d = double(i);

 

 

1.4.1 自定义类的强制转换重载

#include "stdafx.h"
#include <iostream>/*设计鸟类和动物类，创建一个鸟对象，将鸟对象强制转换为动物对象。
*/using namespace std;class CAnimal
{public:CAnimal(const char * name) {strcpy(this->name, name);}CAnimal(const CAnimal& other) {if(this != &other) {strcpy(this->name, other.name);}}char name[64];
};class CBird{public:CBird(const char * name){strcpy(this->name, name);}operator CAnimal() const{cout << this->name << "张张！" << endl;return CAnimal(this->name);}char name[64];
};int main(int argc, char* argv[])
{CBird bid("张伟");CAnimal ani = (CAnimal)bid;return 0;
}

 

 

1.5 多继承

#include <iostream>
using namespace std;
class CBicycle
{public:CBicycle(){cout << "Bicycle Construct" << endl;}CBicycle(int iWeight){m_iWeight=iWeight;}void Run(){cout << "Bicycle Run" << endl;}protected:int m_iWeight;
};class CAirplane
{public:CAirplane(){cout << "Airplane Construct " << endl;};CAirplane(int iWeight){m_iWeight=iWeight;}void Fly(){cout << "Airplane Fly " << endl;}protected:int m_iWeight;
};class CAirBicycle : public CBicycle, public CAirplane
{public:CAirBicycle(){cout << "CAirBicycle Construct" << endl;}void RunFly(){cout << "Run and Fly" << endl;}
};
void main()
{CAirBicycle ab;ab.RunFly();
}

 

 

1.6 多态

多态性是指具有不同功能的函数可以用同一个函数名。

多态性通过联编实现。

联编是指一个计算机程序自身彼此关联的过程。

按照进行的阶段不同，联编可以分为静态联编和动态联编。

在c++中，根据联编的时刻不同，存在两种类型的多态性，即函数重载和虚函数。

1.6.1 虚函数

重写虚函数时，函数原型必须保持一致。例如，基类为int类型，子类重写时也必须为int类型

虚函数有以下几方面的限制：

1.只有类的成员函数才能成为虚函数

2.静态成员函数不能是虚函数，因为静态成员函数不受限与某个对象

3.内联函数不能是虚函数，因为内联函数不能在运行中动态确定其位置

4.构造函数不能是虚函数，析构函数通常是虚函数

1.6.2 虚继承

虚继承解决菱形继承问题

1.7 抽象类

包含有纯虚函数的类称为抽象类，一个抽象类至少具有一个纯虚函数。

抽象类只能作为基类派生出新的子类，而不能在程序中被实例化，但是可以使用指向抽象类的指针。

一名软件构造师可以通过纯虚函数建立接口，让程序员填写代码实现接口，而自己主要负责建立抽象类。

1.7.1 纯虚函数

pure virtual function 纯虚函数是被标明为不具体实现的虚成员函数，它不具备函数的功能。

纯虚函数声明

virtual 类型 函数名(参数表列) = 0;

 

 

纯虚函数不能被继承，当基类是抽象类时，在派生类中必须给出基类中纯虚函数的定义，或在该类中再声明其为纯虚函数。只有在派生类中给出基类所有纯虚函数的实现时，该派生类才不再为抽象类。