继承(全)

目录

一. 继承的概念及定义

1.1 继承的概念

1.2 继承的机制

1.3 继承的定义

1.3.1 定义格式​编辑

1.3.2 继承父类成员访问方式的变化

1.4 继承类模板

二. 父类和子类对象赋值兼容转换

2.2 类型转换的特殊处理规则

2.3 应用实例

三. 继承中的作用域

3.1 隐藏规则

3.2 继承作用域选择题精解

运行结果:

四. 子类的默认成员函数

4.1 4个常见默认成员函数

4.2 构造函数和析构函数

4.3 实现一个不能被继承的类

五. 友元与继承

5.1 解决方案

六. 继承与静态成员

6.1 运行实例：

七. 多继承及其菱形继承问题

7.1 继承模型：单继承和多继承

7.2 继承模型：菱形继承

7.3 虚继承

7.3.1 virtual 关键字

7.4 多继承中的指针偏移问题

7.4.1 答案解析

八. 继承和组合

8.1 继承和组合的基本概念

8.2 应用实例：

一. 继承的概念及定义

1.1 继承的概念

继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许我们在保持原有类特性的基础上进行扩展，增加方法(成员函数)和属性(成员变量)，这样产生新的类，称子类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的函数层次的复用，继承是类设计层次的复用。

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

class Student { public: void identity() { //... } void study() { //... } protected: string _name = "peter";//姓名 string _adderss; //地址 string _tel; //电话 int _age = 18; //年龄 int _stuid; //学号 };

class Teacher { public: void identity() { //... } void teaching() { //... } protected: string _name = "张三";//姓名 string _adderss; //地址 string _tel; //电话 int _age = 18; //年龄 string _title; //学号 };

1.2 继承的机制

可以看到我们设计了两个类Student和Teacher，Student和Teacher都有姓名/地址电话/年龄等成员变量，都有identity身份认证的成员函数，设计到两个类里面就是冗余的。当然他们也有一些不同的成员变量和函数。那么我们就可P以把公共的部分统一放在一个类Person中，然后Student、Teacher都继承这个类。

class Person { public: void identity() { cout << " void identity()" << _name << endl; } protected: string _name = "张三"; //姓名 string _adderss; //地址 string _tel; //电话 int _age = 18; //年龄 };

class Student: public Person { public: void study() { //... } protected: int _stuid; //学号 };

class Teacher:public Person { public: void teaching() { //... } protected: string _title; //学号 };

1.3 继承的定义

1.3.1 定义格式

下面我们看到Person是基类，也称作父类；Student是派生类，也称作子类。（这主要是因为因为翻译的原因，所以既叫基类 / 派生类，也叫父类 / 子类）

1.3.2 继承父类成员访问方式的变化

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

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

3. 实际上面的表格我们进行一下总结会发现，父类的私有成员在子类都是不可见。父类的其他成员在子类的访问方式 == Min(成员在父类的访问限定符，继承方式)，public > protected > private。

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

5. 在实际运用中一般使用都是public继承，几乎很少使用protected/private继承，也不提倡使用protected/private继承，因为protected/private继承下来的成员都只能在子类的类里面使用，实际中扩展维护性不强。

1.4 继承类模板

#define CONTAINER vector<T> template<class T> class Stack:public CONTAINER { public: void push(const T& val) { this->CONTAINER::push_back(val); } void pop() { this->CONTAINER::pop_back(); } const T& top() { return this->CONTAINER::back(); } size_t size() { return this->CONTAINER::size(); } bool empty() { return this->CONTAINER::empty(); } }; int main() { Stack<int> st; st.push(1); st.push(2); st.push(3); st.push(4); while (!st.empty()) { cout << st.top() << ' '; st.pop(); } cout << endl; return 0; }

模版是按需实例化的，调用了哪个成员函数，就实例化哪个。

像这里，构造/析构/push_back会实例化，其他成员函数就不会实例化。

二. 父类和子类对象赋值兼容转换

•public继承的子类对象可以赋值给父类的对象 / 父类的指针 / 父类的引用。这里有个形象的说法叫切片或者切割。寓意把子类中父类那部分切掉赋值过去。

• 父类对象不能赋值给子类对象。

• 父类的指针或者引用可以通过强制类型转换赋值给子类的指针或者引用。但是必须是父类的指针是指向子类对象时才是安全的。这里父类如果是多态类型，可以使用RTTI（Run-Time Type Information）的dynamic_cast来进行识别后进行安全转换。（ps：这个我们后面类型转换章节再单独专门讲解，这里先提一下）

2.2 类型转换的特殊处理规则

2.3 应用实例

class Person { protected: string _name; // 姓名 string _sex; // 性别 int _age; // 年龄 }; class Student : public Person { public: int _Nu; // 学号 }; int main() { Student sobj; //1.子类对象可以赋值给父类对象/指针/引用 Person pobj = sobj; Person* pp = &sobj; Person& rzp = sobj; //2.父类对象不能赋值给子类对象 sobj = (Student)pobj; return 0; }

三. 继承中的作用域

3.1隐藏规则

1. 在继承体系中父类和子类都有独立的作用域。

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

3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。

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

class Person { protected: string _name="小李子"; // 姓名 int _num = 10;; }; class Student : public Person { public: void Print() { cout << this->_num << endl; cout << this->Person::_num << endl; } protected: int _num = 999;// 学号 }; int main() { Student s1; s1.Print(); return 0; }

3.2 继承作用域选择题精解

1、A和B类中的两个func构成什么关系（）

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

2、下面程序的编译运行结果是什么（）

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

运行结果:

// 选择题 class A { public: void fun() { cout << "func()" << endl; } }; class B : public A { public: void fun(int i) { cout << "void func(int i)" << i << endl; } }; int main() { //// 同名函数，只看函数名，不看参数，参数是否相同不重要 B b; b.fun(10); //b.fun(); // 报错 b.A::fun(); // 解决方式 // 实践中不建议定义同名函数，完全是坑自个儿 return 0; }

四. 子类的默认成员函数

4.1 4个常见默认成员函数

6个默认成员函数，默认的意思就是指我们不写，编译器会变我们自动生成一个，那么在子类中，这几个成员函数是如何生成的呢？

1. 子类的构造函数必须调用父类的构造函数初始化父类的那一部分成员。如果父类没有默认的构造函数，则必须在子类构造函数的初始化列表阶段显式调用。

2. 子类的拷贝构造函数必须调用父类的拷贝构造完成父类的拷贝初始化。

3. 子类的 operator= 必须要调用父类的 operator= 完成父类的复制。需要注意的是子类的 operator= 隐藏了父类的 operator=，所以显示调用父类的 operator=，需要指定父类作用域。

4. 子类的析构函数会在被调用完成后自动调用父类的析构函数清理父类成员。因为这样才能保证子对象先清理子类成员再清理父类成员的顺序。

5. 子对象初始化先调用父类构造再调用子类构造。

6. 子对象析构清理先调用子类析构再调用父类的析构。

7. 因为多态中一些场景析构函数需要构成重写，重写的条件之一是函数名相同（这个我们多态章节会讲解）。那么编译器会对析构函数名进行特殊处理，处理成 destructor()，所以父类析构函数不加 virtual 的情况下，子类析构函数和父类析构函数构成隐藏关系。

4.2 构造函数和析构函数

父类：

class Person { public: Person(const char* name) :_name(name) { cout << "Person()" << endl; } Person() = default; 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="lzx"; // 姓名 };

子类：

class Student :public Person { public: Student(const char* name,int num,const char*addrss) :Person(name) ,_num(num) ,_addrss(addrss) {} Student(const Student& s,int a) :_num(s._num) , _addrss(s._addrss) ,Person(s) {} Student& operator=(const Student& s) { if (this != &s) { this->Person::operator=(s); _num = s._num; _addrss = s._addrss; } return *this; } ~Student() { //// 不用显示调用基类析构，编译器会在派生类析构结束之后自动调用析构 //Person::~Person(); //// ... // 隐式原因：为了安全性 cout << "~Student()" << endl; } protected: int _num=1; string _addrss = "西安市高新区"; };

继承的基类成员变量（整体对象）+ 自己的成员变量（遵循普通的规则，跟类和对象部分一样）默认生成的构造，派生类自己的成员，内置类型不确定，自定义类型调用默认构造，基类部分调用默认构造本质上可以把派生类当做多了自定义类型成员变量（基类）的普通类总，跟普通类原则一样。派生类一般要自己的实现构造，不显示写析构、拷贝析构、赋值重载，除非派生类有深拷贝的资源。

4.3 实现一个不能被继承的类

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

class Base { private: Base() { } }; class Derive :public Base { public: void func4() { cout << "void func4()" << endl; } }; int main() { Derive d; return 0; }

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

class Base final { private: Base() { } }; class Derive :public Base { public: void func4() { cout << "void func4()" << endl; } }; int main() { Derive d; return 0; }

五. 友元与继承

友元关系不能继承，也就是说父类友元不能访问子类私有和保护成员

5.1 解决方案

把派生类也变成基类的友元的友元即可。

//前置声明 class Student; class Person { public: friend void Display(const Person& p, const Student& s); protected: string _name; }; class Student :public Person { public: friend void Display(const Person& p, const Student& s); protected: int _stuNum; }; void Display(const Person& p, const Student& s) { cout << p._name << endl; cout << s._stuNum << endl; } int main() { Student s; Person p; Display(p, s); return 0; }

六. 继承与静态成员

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

6.1 运行实例：

class Student; class Person { public: string _name; static int _count; }; int Person::_count = 1; 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; }

七. 多继承及其菱形继承问题

7.1 继承模型：单继承和多继承

7.2 继承模型：菱形继承

class Person { public: string _name; }; class Student :public Person { protected: int _num;//学号 }; class Teacher :public Person { protected: int _id;//职工编号 }; class Assistant :public Student, public Teacher { protected: string _majorCource;//主修课程 }; int main() { //编译报错： error C2385: 对“_name”的访问不明确 Assistant a; a._name = "peter"; //需要显示指定访问哪个父类的成员可以解决二义性问题。但是数据冗余问题无法解决 a.Student::_name = "xxx"; a.Teacher::_name = "yyy"; return 0; }

7.3 虚继承

要注意 virtual 要加在腰部位置。使用虚继承后，直接调用或者指定类域都是可行的。

class Person { public: string _name; }; class Student : virtual public Person { protected: int _num;//学号 }; class Teacher : virtual public Person { protected: int _id;//职工编号 }; class Assistant :public Student, public Teacher { protected: string _majorCource;//主修课程 }; int main() { //编译报错： error C2385: 对“_name”的访问不明确 Assistant a; a._name = "peter"; //需要显示指定访问哪个父类的成员可以解决二义性问题。但是数据冗余问题无法解决 a.Student::_name = "xxx"; a.Teacher::_name = "yyy"; return 0; }

7.3.1 virtual 关键字

哪个类有二义性、数据冗余，那么继承这个父类的子类才要加上 virtual。

7.4 多继承中的指针偏移问题

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; }

7.4.1 答案解析

正确答案：C（先继承的先声明）

八. 继承和组合

8.1 继承和组合的基本概念

1. public继承是一种is-a的关系。也就是说每个子类对象都是一个父类对象。
2. 组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。
3. 继承允许你根据父类的实现来定义子类的实现。这种通过生成子类的复用通常被称为白箱复用（white-box reuse）。术语“白箱”是相对可视性而言的：在继承方式中，父类的内部细节对子类可见。
4. 继承一定程度破坏了父类的封装，父类的改变，对子类有很大的影响。子类和父类之间的依赖关系很强，耦合度高。
5. 对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格称为黑箱复用（black-box reuse），因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。
6. 优先使用组合，而不是继承。实际尽量多用组合，组合的耦合度低，代码维护性好。不过也不太那么绝对，类之间的关系就适合继承(is-a)那就用继承，另外要实现多态，也必须要继承。类之间的关系既适合用继承(is-a)也适合组合(has-a)，就用组合。
7. 很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂，性能也会有一些损失，所以最好不要设计出菱形继承。多继承可以认为是C++的缺陷之一，后来的的一些编程语言都没有多继承，如Java。

8.2 应用实例：

is-a用继承，has-a用组合。

// 继承和组合 // Tire(轮胎)和Car(⻋)更符合has-a的关系 class Tire { protected: string _brand = "Michelin"; // 品牌 size_t _size = 17; // 尺寸 }; class Car { protected: string _colour = "白色"; // 颜色 string _num = "陕ABIT00"; // 车牌号 Tire _t1; // 轮胎 Tire _t2; // 轮胎 Tire _t3; // 轮胎 Tire _t4; // 轮胎 }; class BMW : public Car { public: void Drive() { cout << "好开-操控" << endl; } }; // Car和BMW/Benz更符合is-a的关系 class Benz : public Car { public: void Drive() { cout << "好坐-舒适" << endl; } }; template<class T> class vector {}; // stack和vector的关系，既符合is-a，也符合has-a template<class T> class stack : public vector<T> {}; template<class T> class stack { public: vector<T> _v; }; int main() { return 0; }