c++进阶：继承

本节目标

1.继承的概念及定义

2.基类和派生类对象赋值转换

3.继承中的作用域

4.派生类的默认成员函数

5.继承与友元

6.继承与静态成员

7.复杂的菱形继承及菱形虚拟继承

8.继承的总结和反思

9.笔试面试题

一，继承的概念和定义

继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保 持原有类特性的基础上进行扩展，增加功能，

这样产生新的类，称派生类。

继承呈现了面向对象 程序设计的层次结构，体现了由简单到复杂的认知过程。

以前我们接触的复用都是函数复用，继承是类设计层次的复用。

1，san应用场景

当对不同几个事务但是他们又有共同点时，可以用基类把他们共同点放在一起，这样可以提高运行效率，简称继承。

比如老师和学生都是人，他们具有人的公共特点，但是又有不同，把相同部分叫做父类/基类，

把不同部分叫做子类/派生类，就是类设计参差的复用。

代码实现：
继承会继承基类的函数，成员等。

class Person
{
public:
 void Print()
 {
 cout << "name:" << _name << endl;
 cout << "age:" << _age << endl;
 }
protected:
 string _name = "peter"; // 姓名
 int _age = 18;  // 年龄
};
// 继承后父类的Person的成员（成员函数+成员变量）都会变成子类的一部分。这里体现出了
Student和Teacher复用了Person的成员。下面我们使用监视窗口查看Student和Teacher对象，可
以看到变量的复用。调用Print可以看到成员函数的复用。
class Student : public Person
{
protected:
 int _stuid; // 学号
};
class Teacher : public Person
{
protected:
 int _jobid; // 工号
};
int main()
{
 Student s;
 Teacher t;
 s.Print();
 t.Print();
 return 0;
}

2，继承的定义

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

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

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

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

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

实例演示：
 

// 实例演示三种继承关系下基类成员的各类型成员访问关系的变化  
class Person
{
public :
 void Print ()
 {
 cout<<_name <<endl;
 }
protected :
 string _name ; // 姓名
private :
 int _age ; // 年龄
};
//class Student : protected Person
//class Student : private Person
class Student : public Person
{
protected :
 int _stunum ; // 学号
};

二，基类和派生类对象赋值转换

存在的问题：

平时在赋值时会产生一个中间的临时变量，而中间变量具有常属性，因此被赋值对象必须要是const类型。

但是在继承里：
公有继承下，它赋值时不产生临时对象，这是一个特殊处理，认为父类和子类是天然的，是一种赋值兼容处理，叫做切割或者切片

class person
{
public:
	void print()
	{
		cout << "my name is pig " << _name << endl;
		cout << "my age is " << _age << endl;
	}
protected:
	string _name = "peter";
	int _age = 18;
};

class student : public person
{
protected:
	int _stuid;
};
class teacher :public person
{
protected:
	int _jobid;
};

int main()
{
	student s;
	person t = s;
	person& rp = s;
	return 0;
}

三，继承中的作用域

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

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

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

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

1，成员变量隐藏

类似以下这种，父类和子类有相同的成员变量num，他们构成隐藏，子类的会隐藏父类的成员（就近原则）。

class Person
{
protected :
 string _name = "小李子"; // 姓名
 int _num = 111;   // 身份证号
};
class Student : public Person
{
public:
 void Print()
 {
 cout<<" 姓名:"<<_name<< endl;
 cout<<" 身份证号:"<<Person::_num<< endl;
 cout<<" 学号:"<<_num<<endl;
 }
protected:
 int _num = 999; // 学号
};

但是有办法一定选择父类的num吗？

指定作用域：

直接指定使用父类域里的成员，只是默认情况下是子类的。

2，成员函数重载

这里父类和子类拥有相同的函数名，他们构成隐藏同上。

class A
{
public:
 void fun()
 {
 cout << "func()" << endl;
 }
};
class B : public A
{
public:
 void fun(int i)
 {
 A::fun();
 cout << "func(int i)->" <<i<<endl;
 }
};

四，派生类的默认构造函数‘

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

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

3. 派生类的operator=必须要调用基类的operator=完成基类的复制。

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

5. 派生类对象初始化先调用基类构造再调派生类构造。

6. 派生类对象析构清理先调用派生类析构再调基类的析构。

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

1，误区

子类成员显示调用拷贝构造时，不能像普通类那样调，如下面这个会报错：

而是类似调用匿名对象一样：

运算符重载：

父子类的析构函数：

若是采用以下调用方法会报错，原因是父子类的析构会构成隐藏，由于多态，析构统一被处理成destructor

故得指定对象：

2，整体代码实现

class Person
{
public :
 Person(const char* name = "peter")
 : _name(name )
 {
 cout<<"Person()" <<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 ; // 姓名
};
class Student : public Person
{
public :
 Student(const char* name, int num)
 : Person(name )
 , _num(num )
 {
 cout<<"Student()" <<endl;
 }

 Student(const Student& s)
 : Person(s)
 , _num(s ._num)
 {
 cout<<"Student(const Student& s)" <<endl ;
 }

 Student& operator = (const Student& s )
 {
 cout<<"Student& operator= (const Student& s)"<< endl;
 if (this != &s)
 {
 Person::operator =(s);
 _num = s ._num;
 }
 return *this ;
 }

 ~Student()
 {
 cout<<"~Student()" <<endl;
 }
protected :
 int _num ; //学号
};
void Test ()
{
 Student s1 ("jack", 18);
Student s2 (s1);
 Student s3 ("rose", 17);
 s1 = s3 ;
}

tip：

c++11新增了一个关键字，final，它定义的父类无法被继承

五，继承和友元

父类的成员不能被继承，类似于爸爸的盆友不是你的盆友，除非他成为你的盆友（成为你的成员）。

class Student;
class Person
{
public:
 friend void Display(const Person& p, const Student& s);
protected:
 string _name; // 姓名
};
class Student : public Person
{
protected:
 int _stuNum; // 学号
};
void Display(const Person& p, const Student& s)
{
 cout << p._name << endl;
 cout << s._stuNum << endl;
}
void main()
{
 Person p;
 Student s;
 Display(p, s);
}

六，继承与静态成员

但是静态成员可以被子类继承下来

七，复杂的菱形继承及菱形虚拟继承

单继承：

多继承：

菱形继承：继承的一种特殊情况

1，菱形继承的问题及解决方式

问题：

当最底下的类继承两个类，会产生两个身份，不知道要访问谁，存在二义性。

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 _majorCourse ; // 主修课程
};
void Test ()
{
 // 这样会有二义性无法明确知道访问的是哪一个
 Assistant a ;
a._name = "peter";
// 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
 a.Student::_name = "xxx";
 a.Teacher::_name = "yyy";
}

解决方法：虚拟继承，虚拟继承可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系，在Student和 Teacher的继承Person时使用虚拟继承，即可解决问题。需要注意的是，虚拟继承不要在其他地 方去使用。

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 _majorCourse ; // 主修课程
};
void Test ()
{
 Assistant a ;
 a._name = "peter";
}

虚继承要加在直接继承基类的位置

2，虚拟继承解决数据冗余和二义性的原理

为了研究虚拟继承原理，我们给出了一个简化的菱形继承继承体系，再借助内存窗口观察对象成 员的模型。

class A
{
public:
 int _a;
};
// class B : public A
class B : virtual public A
{
public:
 int _b;
};
// class C : public A
class C : virtual public A
{
public:
 int _c;
};
class D : public B, public C
{
public:
 int _d;
};
int main()
{
 D d;
 d.B::_a = 1;
 d.C::_a = 2;
 d._b = 3;
 d._c = 4;
 d._d = 5;
 return 0;
}

加上虚继承后，a的成员既不能放在b中也不能放在c中，所以得找个位置存起来

所以virtual实现用另外一个地址储存距离父类（a类）的偏移量实现，这样就能找到a了

3，菱形继承在实际中的应用

在流插入流提取时使用的是这种方式：

八，总结和反思

1. 很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱 形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设 计出菱形继承。否则在复杂度及性能上都有问题。

2. 多继承可以认为是C++的缺陷之一，很多后来的OO语言都没有多继承，如Java。

3. 继承和组合：

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

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

（3）优先使用对象组合，而不是类继承 。

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

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

（6）实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有 些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用 继承，可以用组合，就用组合。

组合：

// 组合
class C
{
public:
	void func()
	{}
protected:
	int _c;
};

class D
{
public:
	void f()
	{
		_c.func();
		//_c._a++;
	}
protected:
	C _c;
	int _d;
};

继承：
 

class A
{
public:
	void func()
	{}
protected:
	int _a;
};

class B : public A
{
public:
	void f()
	{
		func();
		_a++;
	}
protected:
	int _b;
};

1，考察题目

（1）下列哪个选项是正确的

答案：

C

解析：

p3指向derive整体，也就是起点位置，，而p1的base1刚好也指向结构体开始的位置，所以p1和p3指向位置一样，p2指向base2的起点，故和p1和p3不同。

（2）

答案：
A

解析：

初始化顺序是按照声明顺序来的，a最先被继承，产生虚继承，故a先被初始化，再执行main函数里的顺序b，c，d，故答案选A。

注意：
单独继承A时，每运行一次就调用一次a。

初始化顺序是按照d列表的初始化顺序

本节就到这里啦！