【C++哲学】面向对象的三大特性之继承

举一个简单的例子来讲，如果将“人”作为一个类，包含姓名，年龄，性别等属性，以及吃饭，走路，说话等行为。如果再细分，对于“学生”类和“老师”类，除了上面“人”类的属性和行为之外，“学生”类还应该有学号和上课、考试等特有的属性和行为，“老师”类还应该有职称和备课，讲课等特有的属性和行为。所以，可以理解为是，“学生”类和“老师”类都是在自己特有属性和行为的基础上继承了“人”类所共有的属性和行为。

所以C++引入了继承(inheritance)，他也是面向对象程序设计使代码可以复用的最重要的手段，它允许我们在保持原有类特性的基础上进行扩展，增加方法(成员函数)和属性(成员变量)，这样产生新的类，称派生类。

下面我们看到没有继承之前我们设计了两个类Student和Teacher，Student和Teacher都有姓名/ 电话/年龄等成员变量，都有identity身份认证的成员函数，设计到两个类里面就是冗余的。当然他们也有一些不同的成员变量和函数，比如老师独有成员变量是职称，学生的独有成员变量是学号；学生的独有成员函数是学习，老师的独有成员函数是授课。

class Student { public: void identify()// 身份认证 { // ... } void study() { // ... } protected: string _name; // 姓名 size_t _age; // 年龄 string _tel; // 电话 string _stu; // 学号 }; class Teacher { void identify() { // ... } void teaching() { // ... } protected: string _name; // 姓名 size_t _age; // 年龄 string _tel; // 电话 string _tech; // 职称 };

所以，有了上面的思路，我就可以单独实现一个类，包含Student和Teacher的共有的成员，然后让Student和Teacher复用这个类，就不需要重复定义了，省去了很多麻烦。

class Person { public: void identfy() { // ... } protected: string _name; // 姓名 size_t _age; // 年龄 string _tel; // 电话 };

class Student:public Person { public: void study() { // ... } protected: string _stu; // 学号 }; class Teacher:public Person { public: void teaching() { // ... } protected: string _tech; //职称 };

2、继承的定义

2.1、定义格式

在上面我们看到Person就是基类，也称作父类。Student是派生类，也称作子类。

继承方式有三种：public继承，protected继承和private继承

而我们的访问限定符与继承方式也相似：public访问，protected访问和private访问。

2.2、继承基类成员访问方式的变化

1. 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。

2. 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就将基类成员定义为protected。可以看出保护成员限定符是因继承才出现的。

3. 基类的私有成员在派生类都是不可见。基类的其他成员在派生类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected > private。

4. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。

5.在实际使用的过程中其实最常用的就是public继承，因为protected和private继承的基类成员大多数都不能用，实际中扩展维护性不强。

3、继承类模板

下面我们演示一下用继承类模板vector<T>的方式实现一个简单的栈（stack）

template<class T> class stack : public vector<T> // public继承类模板vector<T> { public: void push(const T& x) { vector<int>::push_back(x); } void pop() { vector<int>::pop_back(); } bool empty() { return vector<int>::empty(); } };

需要注意：当基类是类模板时，需要指定一下类域，否则编译报错:error C3861: “push_back”: 找不到标识符
因为，在main函数中用stack<int>实例化对象时，虽然也实例化vector<int>了，但是，由于模板的按需实例化，在没有真正调用基类相关的接口函数之前，接口函数并没有实例化，这里如果直接调用：找不到push_back，就会报错。

// 错误示范： void push(const T& x) { push_back(x); // 报错 }

二、基类和派生类

1、基类与派生类间的类型转换⭐️

• public继承的派生类实例化的对象可以赋值给基类的指针 / 基类的引用。这里有个形象的说法叫切片或者切割。意思就是把派生类中基类那部分切出来，基类指针或引用指向的是派生类中切出来的基类那部分。

• 基类对象不能赋值给派生类对象。

int main() { Student sobj; // 派生类对象 // 1.派生类对象可以赋值给基类的指针/引用 Person1* pp = &sobj; Person1& rp = sobj; // 派生类对象可以赋值给基类的对象是通过调用后面会讲解的基类的拷贝构造完成的 Person pobj = sobj; //2.基类对象不能赋值给派生类对象，这里会编译报错 //sobj = pobj; return 0; }

2、继承中的作用域

2.1、隐藏规则

• 在继承体系中基类和派生类都有独立的作用域。

• 派生类和基类中有同名成员，派生类成员将屏蔽基类对同名成员的直接访问，这种情况叫隐藏。（在派生类成员函数中，可以使用基类对象.基类成员 显示访问）

// Student类中的func函数会隐藏掉Person类中的func class Person{ public: void func() { cout<<"Person:func()"<<endl; } }; class Student { public: void func() { cout<<"Student:func()"<<endl; } };

int main() { Student s; s.func(); // 显示调用 Person p; p.func(); return 0; }

• 对于成员函数，只要函数名相同就构成隐藏。

• 注意在实际中在继承体系里面最好不要定义同名的成员。

2.2、面试题实践⭐️

2.2.1、A和B类中的两个func构成什么关系？

（） A. 重载 B. 隐藏 C.没关系

2.2.2、下面程序的编译运行结果是什么？

（） A. 编译报错 B. 运行报错 C. 正常运行

class A { public: void fun() { cout << "func()" << endl; } }; class B : public A { public: void fun(int i) { cout << "func(int i)" << i << endl; } }; int main() { B b; b.fun(10); b.fun(); return 0; };

答案：B A

解析：虽然基类A与子类B中func函数参数不同，但只要函数名相同就构成隐藏。

由于子类B中的func函数隐藏了基类A中的func函数，所以子类对象b不能再调用基类的func函数。

三、派生类的默认成员函数

我们先实现一个基类，且包含四个默认成员函数：默认构造，拷贝构造，赋值重载和析构。同时，我，在每个默认成员函数中加上一些打印信息，用来作为标记，方便我们在实现子类的四个默认成员函数时观察子类与基类的关系。

class Person { public: //--------------------------默认构造------------------------------------------------ Person(const char* name = "xxx") :_name(name) { cout << "Person(const char* name = xxx)" << endl; } //-------------------------拷贝构造------------------------------------------------- Person(const Person& p) :_name(p._name) { cout << "Person(const Person& p)" << endl; } //-------------------------赋值重载------------------------------------------------- Person& operator=(const Person& p) { cout << "Person& operator=(const Person& p)" << endl; if(this!=&p) _name = p._name; return *this; } //-------------------------析构--------------------------------------------------- ~Person() { cout << "~Person()" << endl; } protected: string _name; // 成员变量 };

1、派生类4个常见的默认成员函数⭐️⭐️

class Student:public Person // 继承 { public: /*1、派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。 如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。 //--------------------------默认构造------------------------------------------------ Student(const char* name, int stuid, const char* address) :_stuid(stuid) ,_address(address) ,Person(name) // 显示调用 {} /*派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化*/ //--------------------------拷贝构造------------------------------------------------ Student(const Student& s) :_stuid(s._stuid) ,_address(s._address) ,Person(s) // 与构造函数相同子类也必须调用基类的拷贝构造函数，由于基类可以接收子类对象（即可以将子类对象赋值给基类对象） {} /*派生类的operator=必须要调用基类的operator=完成基类的复制。 需要注意的是派生类的operator=隐藏了基类的operator=， 所以显示调用基类的operator=，需要指定基类作用域*/ //--------------------------赋值重载------------------------------------------------ Student& operator=(const Student& s) { if (this != &s) { // ⭐️调用基类的赋值重载，同样的，子类对象可以赋值给基类对象 // ⭐️由于子类与基类的赋值重载函数名相同，构成隐藏，所以调用基类的赋值重载需要指定类域 Person::operator=(s); _stuid = s._stuid; _address = s._address; } return *this; } /*特殊的，子类的析构和父类析构函数也构成隐藏关系⭐️ 规定：不需要显示调用，子类析构函数之后，会自动调用父类析构 这样保证析构顺序，先子后父，显示调用取决于实现的人，不能保证 先子后父*/ //--------------------------析构-------------------------------------------------- ~Student() { //Person::~Person(); //delete _ptr; } protected: int _stuid; string _address; };

可视化测试：

int main() { Student s1("hds", 123456, "咸阳"); // 构造 Student s2("zm", 456789, "温州"); // 构造 Student s3(s2); // 拷贝构造 s1 = s3; // 赋值重载 return 0; }

2、实现一个不能被继承的类

方法1：基类的构造函数私有，派生类的构成必须调用基类的构造函数，但是基类的构成函数私有化以后，派生类看不见就不能调用了，那么派生类就无法实例化出对象。

class A { private: // 将基类的构造函数私有化 A() {} protected: int _a; }; class B :public A { public: // ... protected: int _b; };

方法2：C++11新增了一个final关键字，final修改基类，派生类就不能继承了。

class A final // final修饰A类 { public: void func() { } protected: int _a; }; class B :public A { public: // ... protected: int _b; };

四、继承与友元

友元关系不能继承，也就是说基类友元不能访问派生类私有和保护成员。

class Person { public: friend void Display(const Person& p, const Student& s); //友元声明 Person(const char* name="xxx") :_name(name) { } protected: string _name; // 姓名 }; class Student : public Person { public: Student(int stuNum = 123456) :_stuNum(stuNum) { } protected: int _stuNum; // 学号 }; void Display(const Person& p, const Student& s) { cout << p._name << endl; cout << s._stuNum << endl; }

由于仅声明Display为基类的友元函数，编译报错：error C2248: “Student::_stuNum”: 无法访问 protected 成员

解决方案：Display也变成Student 的友元即可

五、继承与静态成员

基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个派生类，都只有一个static成员实例。

class Person { public: string _name; static int _count; }; int Person::_count = 0; class Student : public Person { protected: int _stuNum; }; //--------------------------------------------------------------------------------------- int main() { Person p; Student s; // 这里的运行结果可以看到非静态成员_name的地址是不一样的 // 说明派生类继承下来了，父派生类对象各有一份 cout << &p._name << endl; cout << &s._name << endl; // 这里的运行结果可以看到静态成员_count的地址是一样的 // 说明派生类和基类共用同一份静态成员 cout << &p._count << endl; cout << &s._count << endl; // 公有的情况下，父派生类指定类域都可以访问静态成员 cout << Person::_count << endl; cout << Student::_count << endl; return 0; }

六、多继承及其菱形继承问题

1、继承模型

• 单继承：一个派生类只有一个直接基类时称这个继承关系为单继承

• 多继承：一个派生类有两个或以上直接基类时称这个继承关系为多继承，多继承对象在内存中的模型是，先继承的基类在前面，后面继承的基类在后面，派生类成员在放到最后面。

• 菱形继承：菱形继承是多继承的一种特殊情况。菱形继承的问题，从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题，在Student和Teacher的对象中都继承了Person的成员，所以，Assistant的对象中Person成员就会有两份。

支持多继承就一定会有菱形继承，像Java就直接不支持多继承，规避掉了这里的问题，所以实践中我们也是不建议设计出菱形继承这样的模型的。

class Person { public: string _name = "xxx"; // 姓名 }; //--------------------------------------------------------------------------- class Student :public Person { protected: int _stuid = 123456; // 学号 }; //--------------------------------------------------------------------------- class Teacher:public Person { protected: string _techid = "教授"; //职称 }; //--------------------------------------------------------------------------- class Assistant:public Student ,public Teacher { public: void Display() { cout << _name << endl; cout << _stuid << endl; cout << _techid << endl; cout << _majorCourse << endl; } protected: string _majorCourse = "xyz"; // 主修课程 }; //--------------------------------------------------------------------------- int main() { Assistant s; s.Display(); return 0; }

2、虚继承

为了解决上面因为菱形继承导致的数据冗余和二义性的问题，C++又引入了虚继承的概念，即保证上面的Assistant在继承Student和Teacher时，Assistant的对象中只要一份Person的成员。

class Person { public: string _name = "xxx"; // 姓名 }; //--------------------------------------------------------------------------- class Student : virtual public Person { protected: int _stuid = 123456; // 学号 }; //--------------------------------------------------------------------------- class Teacher : virtual public Person { protected: string _techid = "教授"; //职称 }; //--------------------------------------------------------------------------- class Assistant :public Student, public Teacher { public: void Display() { cout << _name << endl; cout << _stuid << endl; cout << _techid << endl; cout << _majorCourse << endl; } protected: string _majorCourse = "xyz"; // 主修课程 }; //--------------------------------------------------------------------------- int main() { Assistant s; s.Display(); return 0; }

3、多继承中的指针偏移问题

下面说法正确的是( )

A：p1 == p2 == p3 B：p1 < p2 < p3 C：p1 == p3 != p2 D：p1 != p2 != p3

class Base1 { public: int _b1; }; class Base2 { public: int _b2; }; class Derive : public Base1, public Base2 { public: int _d; }; int main() { Derive d; Base1* p1 = &d; Base2* p2 = &d; Derive* p3 = &d; return 0; }

答案：C

七、继承和组合

• public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。

• 组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。

• 继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用 (white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对派生类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。

• 对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。

• 优先使用组合，而不是继承。实际尽量多去用组合，组合的耦合度低，代码维护性好。不过也不太那么绝对，类之间的关系就适合继承(is-a)那就用继承，另外要实现多态，也必须要继承。类之间的关系既适合用继承(is-a)也适合组合(has-a)，就用组合。

举个例子，前面我们实现的容器适配器：stack，queue，priority_queue就是通过组合的方式实现的。