C++继承 - 技术栈

继承

[1. 继承的概念及定义](#1. 继承的概念及定义)
- [1.1 继承的概念](#1.1 继承的概念)
- [1.2 继承定义](#1.2 继承定义)
- - [1.2.1 定义格式](#1.2.1 定义格式)
  - [1.2.2 继承基类成员访问方式的变化](#1.2.2 继承基类成员访问方式的变化)
- [1.3 继承类模板](#1.3 继承类模板)
[2. 基类和派生类间的转换](#2. 基类和派生类间的转换)
[3. 继承中的作用域](#3. 继承中的作用域)
- [3.1 隐藏规则](#3.1 隐藏规则)
- [3.2 考察继承作用域相关选择题](#3.2 考察继承作用域相关选择题)
[4. 派生类的默认成员函数](#4. 派生类的默认成员函数)
- [4.1 四个常见的默认成员函数](#4.1 四个常见的默认成员函数)
- [4.2 实现一个不能被继承的类](#4.2 实现一个不能被继承的类)
[5. 继承与友元](#5. 继承与友元)
[6. 继承与静态成员](#6. 继承与静态成员)
- [6.1 继承与静态成员](#6.1 继承与静态成员)
- [6.2 统计父类和子类实例化对象的个数](#6.2 统计父类和子类实例化对象的个数)
[7. 多继承及其菱形继承问题](#7. 多继承及其菱形继承问题)
- [7.1 继承模型](#7.1 继承模型)
- [7.2 虚继承](#7.2 虚继承)
- [7.3 多继承中指针偏移问题](#7.3 多继承中指针偏移问题)
- [7.4 IO库中的菱形虚拟继承](#7.4 IO库中的菱形虚拟继承)
[8. 扩展：菱形虚拟继承原理剖析](#8. 扩展：菱形虚拟继承原理剖析)
[9. 继承和组合](#9. 继承和组合)
[10. 继承的几个选择题](#10. 继承的几个选择题)

1. 继承的概念及定义

1.1 继承的概念

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

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

cpp 复制代码

class Student
{
public:
	// 进入校园/图书馆/实验室刷二维码等身份认证
	void identity()
	{
		// ...
	}

	// 学习
	void study()
	{
		// ...
	}
protected:
	string _name = "peter"; // 姓名
	string _address;		// 地址
	string _tel;            // 电话
	int _age = 18;          // 年龄

	int _stuid;             // 学号
};

class Teacher
{
public:
	// 进入校园/图书馆/实验室刷二维码等身份认证
	void identity()
	{
		// ...
	}

	// 授课
	void teaching()
	{
		// ...
	}
protected:
	string _name = "peter"; // 姓名
	string _address;		// 地址
	string _tel;            // 电话
	int _age = 18;          // 年龄

	int _title;             // 职称
};

int main()
{
	return 0;
}

下⾯我们公共的成员都放到Person类中，Student和Teacher都继承Person，就可以复⽤这些成员，就不需要重复定义了，省去了很多麻烦。

cpp 复制代码

class Person
{
public:
	// 进入校园/图书馆/实验室刷二维码等身份认证
	void identity()
	{
		cout << "void identity()" << _name << endl;
	}
protected:
	string _name = "peter"; // 姓名
	string _address;		// 地址
	string _tel;            // 电话
	int _age = 18;          // 年龄
};

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

class Teacher : public Person
{
public:
	// 授课
	void teaching()
	{
		//...
	}
protected:
	int _title;             // 职称
};

int main()
{
	Student s;
	Teacher t;
	
	s.identity();
	t.identity();

	return 0;
}

1.2 继承定义

1.2.1 定义格式

下⾯我们看到Person是基类，也称作⽗类。Student是派⽣类，也称作⼦类。(因为翻译的原因，所以既叫基类/派⽣类，也叫⽗类/⼦类)

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

基类private成员在派⽣类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派⽣类对象中，但是语法上限制派⽣类对象不管在类里面还是类外面都不能去访问它。
基类private成员在派⽣类中不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
实际上面的表格我们进行一下总结会发现，基类的私有成员在派⽣类都是不可见的。基类的其他成员在派⽣类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected > private。
使用关键字class时默认的继承方式是private，使⽤struct时默认的继承方式是public，不过最好显式的写出继承⽅式。
在实际运⽤中⼀般使⽤都是public继承，⼏乎很少使用protetced/private继承，也不提倡使⽤protetced/private继承，因为protetced/private继承下来的成员都只能在派⽣类的类⾥⾯使⽤，实
际中扩展维护性不强。

下面演示一下不可见的情形

cpp 复制代码

class Person
{
private: // 不可见
	string _name = "peter"; // 姓名
};

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


int main()
{
	Student s;
	s._name;

	return 0;
}

1.3 继承类模板

cpp 复制代码

namespace bit
{
    //template<class T>
    //class vector
    //{};
    
    // stack和vector的关系，既符合is - a，也符合has - a
    // is - a 就是 继承关系，has - a 就是 组合关系
	template<class T>
	     // 派生类         // 基类
    class stack : public std::vector<T>
    {
    public:
	    void push(const T& x)
	    {
		    // 基类是类模板时，需要指定⼀下类域，
            // 否则编译报错: error C3861 : "push_back":找不到标识符
            // 因为stack<int>实例化时，也实例化vector<int>了
            // 但是模版是按需实例化,push_back等成员函数未实例化，所以找不到
            //push_back(x); // error

			// 所以也要把vector<int>中的该成员函数实例化了
            vector<T>::push_back(x);
            
        }
        void pop()
        {
            vector<T>::pop_back();
        }
        const T& top()
        {
            return vector<T>::back();
        }
        bool empty()
        {
            return vector<T>::empty();
        }
    };
}

int main()
{
    bit::stack<int> st;
    st.push(1);
    st.push(2);
    st.push(3);
    while (!st.empty())
    {
        cout << st.top() << " ";
        st.pop();
    }
    return 0;
}

2. 基类和派生类间的转换

通常情况下我们把⼀个类型的对象赋值给另⼀个类型的指针或者引用时，存在类型转换，中间会产生临时对象，所以需要加const，如： int a = 1; const double& d = a; public继承中，就是⼀个特殊处理的例外，派⽣类对象 可以赋值给 基类的指针 / 基类的引⽤，⽽不需要加const，这⾥的指针和引⽤绑定是派⽣类对象中的基类部分，如下图所示。也就意味着⼀个基类的指针或者引⽤，可能指向基类对象，也可能指向派⽣类对象。

派⽣类对象赋值给基类对象是通过基类的拷⻉构造函数或者赋值重载函数完成的(这两个函数的细节后面会讲)，这个过程就像派⽣类⾃⼰定义部分成员切掉了⼀样，所以也被叫做切割或者切片，如下图所示。

基类对象不能赋值给派⽣类对象。

基类的指针或者引⽤可以通过强制类型转换赋值给派⽣类的指针或者引⽤。但是必须是基类的指针是指向派⽣类对象时才是安全的。这⾥基类如果是多态类型，可以使⽤RTTI(Run-Time Type Information)的dynamic_cast 来进⾏识别后进⾏安全转换。（ps：这个我们后⾯类型转换章节再单独专⻔讲解，这⾥先提⼀下）

cpp 复制代码

class Person
{
protected:
	string _name; // 姓名
	string _sex;  // 性别
	int _age;	  // 年龄
};

class Student : public Person
{
public:
	int _No; // 学号
};
int main()
{
	// 会产生临时对象，所以要加const
	int a = 1;
	const double& d = a;

	string s1 = "1111";
	const string& s2 = "1111";

	Student sobj;
	// 1.派⽣类对象可以赋值给基类的指针/引⽤
	Person * pp = &sobj;
	Person& rp = sobj;
	
	// 派生类对象可以赋值给基类的对象是通过调⽤后⾯会讲解的基类的拷⻉构造完成的
	Person pobj = sobj;
	
	//2.基类对象不能赋值给派⽣类对象，这⾥会编译报错
	//sobj = pobj;
	
	return 0;
}

3. 继承中的作用域

3.1 隐藏规则

在继承体系中基类和派⽣类都有独⽴的作⽤域。
派⽣类和基类中有同名成员，派⽣类成员将屏蔽基类对同名成员的直接访问，这种情况叫隐藏。（在派⽣类成员函数中，可以使⽤基类::基类成员显式访问）
需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
注意在实际中在继承体系⾥⾯最好不要定义同名的成员。

cpp 复制代码

// Student的_num和Person的_num构成隐藏关系，可以看出这样代码虽然能跑，但是非常容易混淆
class Person
{
protected:
	string _name = "张三"; // 姓名
	int _num = 111;// 身份证号
};
class Student : public Person
{
public:
	void Print()
	{
		cout << " 姓名:"<<_name<< endl;
		// Person中的_num 和 Student中的_num构成隐藏
		cout << " 身份证号: "<<Person::_num<< endl;
		cout << " 学号: "<<_num<<endl;
	}
protected:
	int _num = 999; // 学号
};
int main()
{
	Student s1;
	s1.Print();

	return 0;
};

3.2 考察继承作用域相关选择题

A和B类中的两个fun构成什么关系（）
A. 重载 B. 隐藏 C.没关系
下⾯程序的编译运⾏结果是什么（）
A. 编译报错 B. 运⾏报错 C. 正常运⾏

cpp 复制代码

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类中的两个fun构成隐藏关系，不理解的话可以看看3.1隐藏规则的定义。

对于第二问：两个函数调用都没有指定类域，因为是B类实例化的对象默认调用B中的fun函数，第二个函数没有传参数，这是语法错误，编译过不去，可以传参或者b.A::fun()解决。

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

4.1 四个常见的默认成员函数

6个默认成员函数，默认的意思就是指我们不写，编译器会给我们⾃动⽣成⼀个，那么在派⽣类中，这⼏个成员函数是如何⽣成的呢？

当基类存在默认构造函数（无参构造函数）时，派生类构造函数的初始化列表中不需要显式调用基类构造函数，编译器会自动隐式调用基类的默认构造函数来完成基类成员的初始化。只有当基类没有默认构造函数（例如仅定义了带参构造函数）时，派生类才必须在构造函数的初始化列表中显式调用基类的构造函数。
派生类拷贝构造函数必须在的初始化列表中显式调用基类的拷贝构造函数初始化。
派⽣类的operator=必须要调⽤基类的operator=完成派生类的复制。需要注意的是派⽣类的operator=隐藏了基类的operator=，所以显式调⽤基类的operator=，需要指定基类作⽤域。
派⽣类的析构函数会在被调⽤完成后⾃动调⽤基类的析构函数清理基类成员。因为这样才能保证派⽣类对象先清理派⽣类成员再清理基类成员的顺序。
派⽣类对象初始化先调⽤基类构造再调派⽣类构造。
派⽣类对象析构清理先调⽤派⽣类析构再调基类的析构。
因为多态中⼀些场景析构函数需要构成重写，重写的条件之⼀是函数名相同(这个我们多态章节会讲解)。所以编译器对析构函数名进⾏了特殊处理，处理成destructor()，所以基类析构函数不加virtual的情况下，派⽣类析构函数和基类析构函数构成隐藏关系。

cpp 复制代码

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
{
    // 默认成员函数 - 跟类和对象规则高度类似
    // 两个部分分开处理：
    // 1. 基类成员（整体，调用基类构造）
    // 2. 派生类成员（跟类和对象一样）
public:
    Student(const char* name, int num, const char* addr)
        //:_name(name) // 必须调用基类构造，不能通过直接访问基类的成员构造
        :Person(name) // 调用基类的构造
        , _num(num)
        ,_addr(addr)
    {
        // 一般都要自己写
    }

    Student(const Student& s)
        :Person(s) // 必须调用基类的拷贝构造
        ,_num(s._num)
        ,_addr(s._addr)
    {
        // 编译器默认生成的就够用了
        // 存在深拷贝时，才自己写
    }

    Student& operator=(const Student& s)
    {
        // 编译器默认生成的就够用了
        // 存在深拷贝时，才自己写
        if (this != &s)
        {
        	// 成员函数名相同，构成隐藏，需要指定类域
            Person::operator=(s);
            _num = s._num;
            _addr = s._addr;
        }
        return *this;
    }

    // 析构函数名字因为后续多态章节中"重写"的原因，会被处理成destructor
    // 所以派生类和基类析构构成隐藏关系
    ~Student()
    {
        //Person::~Person();
        // 派生类析构调用后，会自动调用基类析构，所以自己实现析构时不需要显式调用
    }
    // 构造初始化，先父后子。析构清理资源，先子后父
    // 可以理解为：先定义的先初始化后析构，后定义的后初始化先析构
    // 深层次原因是：假如先析构父，因为子是可以访问父中的对象的，但父已经析构了，那就可能会出现问题
protected:
    int _num; // 学号
    string _addr;
};
int main()
{
    Student s1("张三", 111, "北京");
    Student s2(s1);
    Student s3("李四", 222, "武汉");
    s1 = s3;

    return 0;
}

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

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

cpp 复制代码

class Base
{
public:
	void func5() { cout << "Base::func5" << endl; }
protected:
	int a = 1;
private: // C++98的方法 - 将构造写成私有的
	Base()
		{}
};

class Derive :public Base
{
	void func4() { cout << "Derive::func4" << endl; }
protected:
	int b = 2;
};

int main()
{
	Base b;
	Derive d;

	return 0;
}

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

cpp 复制代码

// C++11的方法 - 新增一个final关键字，final修改基类，派生类就不能继承了
class Base final
{
public:
	void func5() { cout << "Base::func5" << endl; }
protected:
	int a = 1;
public: 
	Base()
	{}
};

// error C3246: "Derive": 无法从 "Base" 继承，因为它已声明为 "final"
class Derive :public Base
{
	void func4() { cout << "Derive::func4" << endl; }
protected:
	int b = 2;
};

int main()
{
	Base b;
	Derive d;

	return 0;
}

5. 继承与友元

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

cpp 复制代码

class Student; // 前置声明

class Person
{
public:
	// 友元函数的声明找不到Student，所以要前置声明
	friend void Display(const Person& p, const Student& s);
protected:
	string _name; // 姓名

};
class Student : public Person
{
	// 解决方案：把Display也变成Student的友元
	//friend void Display(const Person& p, const Student& s);
protected:
	int _stuNum; // 学号

};
void Display(const Person& p, const Student& s)
{
	cout << p._name << endl;
	// 编译报错：error C2248 :"Student::_stuNum" :无法访问protected成员
	cout << s._stuNum << endl; // 不能访问
}
int main()
{
	Person p;
	Student s;
	
	Display(p, s);

	return 0;
}

6. 继承与静态成员

6.1 继承与静态成员

基类定义了static静态成员，则整个继承体系⾥⾯只有⼀个这样的成员。⽆论实例化出多少个派⽣类，都只有⼀个static成员实例。

cpp 复制代码

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

6.2 统计父类和子类实例化对象的个数

cpp 复制代码

class Person
{
public:
	// 只需要在父类的构造中写++_count即可，
	// 因为子类的构造函数也要调用父类的构造
	Person() { ++_count; } 
	string _name;
	static int _count;
};

int Person::_count = 0;

class Student : public Person
{
protected:
	int _stuNum;
};

int main()
{
	Person p1;
	Person p2;
	Student s1;
	Student s2;
	Student s3;

	// 输出结果：5
	cout << Person::_count << endl;
	
	return 0;
}

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

7.1 继承模型

单继承：⼀个派⽣类只有⼀个直接基类时称这个继承关系为单继承

多继承 ：⼀个派⽣类有两个或以上直接基类时称这个继承关系为多继承，多继承对象在内存中的模型

是，先继承的基类在前⾯，后⾯继承的基类在后⾯，派⽣类成员在放到最后⾯。

菱形继承 ：菱形继承是多继承的⼀种特殊情况。菱形继承的问题，从下⾯的对象成员模型构造，可以

看出菱形继承有数据冗余和⼆义性 的问题，在Assistant的对象中Person成员会有两份。⽀持多继承就⼀定会有菱形继承，像Java就直接不⽀持多继承，规避掉了这⾥的问题，所以实践中我们也是不建议

设计出菱形继承这样的模型的。

菱形继承

cpp 复制代码

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; // 主修课程

};
int main()
{
	Assistant a;
	// 编译不知道要访问哪个_name
	a._name = "peter"; // 编译报错：error C2385 :对"_name"的访问不明确
	// 需要显式指定访问哪个基类的成员可以解决二义性问题，但是数据冗余问题无法解决
	a.Student::_name = "xxx";
	a.Teacher::_name = "yyy";

	return 0;
}

7.2 虚继承

很多⼈说C++语法复杂，其实多继承就是⼀个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂，性能也会有⼀些损失，所以最好不要设计出菱形继承。多继承可以认为是C++的缺陷之⼀，后来的⼀些编程语⾔都没有多继承，如Java。

虚拟菱形继承就是在菱形继承的基础上，在腰部位置加上virtual关键字

cpp 复制代码

class Person
{
public:
	string _name; // 姓名
	/*int _tel;
	int _age;
	string _gender;
	string _address;*/
	// ...
};

// 使用虚继承Person类
class Student : virtual public Person
{
protected:
	int _num; // 学号
};

// 使用虚继承Person类
class Teacher : virtual public Person
{
protected:
	int _id; // 职工编号
};

// 教授助理
class Assistant : public Student, public Teacher
{
protected:
	string _majorCourse; // 主修课程
};
int main()
{
	// 使用虚继承可以解决数据冗余和二义性
	Assistant a;
	a._name = "peter";
	return 0;
}

我们可以设计出多继承，但是不建议设计出菱形继承，因为菱形虚拟继承以后，⽆论是使⽤还是底层都会复杂很多。当然有多继承语法⽀持，就⼀定存在会设计出菱形继承，像Java是不⽀持多继承的，就避开了菱形继承。

思考一下下面代码 a 对象中 _name 是 "张三"、"李四"、"王五"中的哪一个？

cpp 复制代码

class Person
{
public:
	Person(const char* name)
		:_name(name)
	{}
	string _name; // 姓名
};

class Student : virtual public Person
{
public:
	Student(const char* name, int num)
		:Person(name)
		, _num(num)
	{}
protected:
	int _num; //学号
};

class Teacher : virtual public Person
{
public:
	Teacher(const char* name, int id)
		:Person(name)
		, _id(id)
	{}
protected:
	int _id; // 职工编号
};

// 不要去玩菱形继承 
class Assistant : public Student, public Teacher
{
public:
	Assistant(const char* name1, const char* name2, const char* name3)
		:Person(name3) // 编译器会在这里调用Person的构造
		// Student 和 Teacher 中 Person的构造不会调用，可以通过调试观察
		, Student(name1, 1) 
		, Teacher(name2, 2) 
	{}
protected:
	string _majorCourse; // 主修课程
};
int main()
{
	Assistant a("张三", "李四", "王五");

	return 0;
}

7.3 多继承中指针偏移问题

下面说法正确的是（）

A：p1 == p2 == p3

B：p1 < p2 < p3

C：p1 == p3 != p2

D：p1 != p2 != p3

cpp 复制代码

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

不理解可以参考多继承的概念和下面的内存分布图

7.4 IO库中的菱形虚拟继承

cpp 复制代码

template<class CharT, class Traits = std::char_traits<CharT>>
class basic_ostream : virtual public std::basic_ios<CharT, Traits>
{};
template<class CharT, class Traits = std::char_traits<CharT>>
class basic_istream : virtual public std::basic_ios<CharT, Traits>
{};

8. 扩展：菱形虚拟继承原理剖析

菱形虚拟继承如何解决数据冗余和二义性问题？

对于该图中的菱形虚拟继承而言

先抛出结论：对于一个Assistant的对象，在底层编译器会把Person中的_name对象放在类的头部或结尾，VS是放在结尾，分别在Student和Teacher中的头部放一个指向虚基表的地址，该虚基表中存放着其距离Person中_name的偏移量，编译器就是通过偏移量找到Person中的_name的。如下图所示。

为了研究虚拟继承原理，我们给出了⼀个简化的菱形虚拟继承体系，再借助内存窗⼝观察对象成员的模型。要注意的是这⾥必须借助内存窗⼝才能看到真实的底层对象内存模型，vs编译器的监视窗⼝是经过特殊处理的，以它的⻆度给出了⼀个⽅便看的样⼦，但并不是本来的样⼦。有时想看清真实的内存模型，往往需要借助内存窗⼝。

通过下⾯的简化菱形虚拟继承模型，我们可以看到，D对象中的B和C部分中分别包含⼀个地址指向虚基表，B指向的虚基表中存储了B对象部分距离公共的A的相对偏移量距离，C指向的虚基表中存储了C对象部分距离公共的A的相对偏移量距离。这样公共的虚基类A部分在D对象中就只有⼀份了，这样就解决了数据冗余和⼆义性的问题。

通过B的对象模型，我们发现菱形虚拟继承中B和C的对象模型跟D保持的⼀致的⽅式去存储管理A，这样当B的指针访问A时，⽆论B指针指向D对象，还是B指针直接指向B对象，访问A成员都是通过虚基表指针的⽅式查找到A成员再访问。

cpp 复制代码

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._a = 3;
	d._b = 4;
	d._c = 5;
	d._d = 6;

	return 0;
}

cpp 复制代码

int main()
{
	// 接上面的代码
	
	B b;
	b._a = 7;
	b._b = 8;
	// B的指针指向B对象
	B* p2 = &b;

	// B的指针指向D对象
	B* p1 = &d;

	// p1和p2分别对指向的a成员访问修改
	// 分析内存模型，我们发现B对象也使⽤了虚基表指向A成员的模型
	// 所以打开汇编我们看到下⾯的访问_a的⽅式是⼀样的
	p1->_a++;
	p2->_a++;

	return 0;
}

9. 继承和组合

public继承是⼀种is -a的关系。也就是说每个派⽣类对象都是⼀个基类对象。
组合是⼀种has-a的关系。假设B组合了A，每个B对象中都有⼀个A对象。
继承允许你根据基类的实现来定义派⽣类的实现。这种通过⽣成派⽣类的复⽤通常被称为⽩箱复⽤(white-box reuse)。术语"⽩箱"是相对可视性⽽⾔：在继承⽅式中，基类的内部细节对派⽣类可⻅。继承⼀定程度破坏了基类的封装，基类的改变，对派⽣类有很⼤的影响。派⽣类和基类间的依赖关系很强，耦合度⾼。
对象组合是类继承之外的另⼀种复⽤选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接⼝。这种复⽤⻛格被称为⿊箱复⽤(black-box reuse)，因为对象的内部细节是不可见的。对象只以"⿊箱"的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使⽤对象组合有助于你保持每个类被封装。
优先使⽤组合，⽽不是继承。实际尽量多去⽤组合，组合的耦合度低，代码维护性好。不过也不太绝对，类之间的关系只适合继承(is -a)那就⽤继承，另外要实现多态，也必须要继承。类之间的关系既适合⽤继承(is-a)也适合组合(has-a)，就⽤组合。

cpp 复制代码

// 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; // 轮胎
};

// Car和BMW/Benz更符合is-a的关系
class BMW : public Car 
{
public:
	void Drive() { cout << "好开-操控" << endl; }
};

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

记忆 is -a 和 has -a 的方法：

想一下前面的继承Student继承了Person，学生是一个人。所以继承就是 is -a ，组合就是 has -a

10. 继承的几个选择题

下面关于继承说法不正确的是（）

A. 继承可以使用现有类的所有功能，并在无需重新编写原来类的情况下对这些功能进行扩展

B. 继承体系中子类必须要体现出与基类的不同

C. 子类对象一定比基类对象大

D. 继承呈现了面相对象程序设计的层次结构，体现了有简单到复杂的认知过程

关于继承说法正确的是（）

A. 所有的类都可以被继承

B. Car(汽车)类和Tire(轮胎)类可以使用继承方式体现

C. 继承是实现代码复用的唯一手段

D. 狗是一种动物，可以体现出继承的思想

关于同名隐藏的说法正确的是（）

A. 同一个类中，不能存在相同名称的成员函数

B. 在基类和子类中，可以存在相同名称但参数列表不同的函数，他们形成重载

C. 在基类和子类中，不能存在函数原型完全相同的函数，因为编译时会报错

D. 成员函数可以同名，只要参数类型不同即可，成员变量不能同名，即使类型不同

下面说法正确的是（）

A. 派生类构造函数初始化列表的位置必须显式调用基类的构造函数，已完成基类部分成员的初始化

B. 派生类构造函数先初始化子类成员，再初始化基类成员

C. 派生类析构函数不会自动析构基类部分成员

D. 子类构造函数的定义有时需要参考基类构造函数

下列代码中f函数执行结束后输出（）

cpp 复制代码

class A
{
public:
  A() { cout<<"A::A()"<<endl; }
  ~A() { cout<<"A::~A()"<<endl; }
  int a;
};

class B : public A
{
public:
  B() { cout<<"B::B()"<<endl; }
  ~B() {cout<<"B::~B()"<<endl; }
  int b;
};

void f()
{
  B b;
}

A. B::B() B::~B()

B. B::B() A::A() A::~A() B::B()

C. A::A() B::B() B::~B() A::~A()

D. 以上都不对

复制代码

答案：

第一题：C

A.这是继承的功能，也是代码复用的体现

B.继承除了吸收基类成员之外，一般还需要扩充自己的数据成员，跟基类有所不一样

C.不一定，有可能子类只是改写父类的方法而已，并没有增加其自身的数据成员，则大小一样，故错误

D.继承体现了一定的层次结构和认知过程

第二题：D

A.final说明的类不能被继承

B.应该使用组合，因为Tire类跟Car类属于Has-a的关系

C.模板也是代码复用的重要手段

D.狗是动物的一种，属于is-a关系，是继承的体现

第三题：D

A.可以存在，如函数重载

B.基类与子类函数名字相同，参数不同，形成的是隐藏

C.可以共存

D.成员函数在同一个类里面同名，此时构成了重载，但变量一定不能同名，故正确

第四题：D

A.如果父类有默认构造函数，此时就不需要

B.顺序相反，先初始化父类，再是子类

C.会调用，并且按照构造的相反顺序进行调用

D.是的，需要看父类构造函数是否需要参数子类的，从而你决定子类构造函数的定义

第五题：C

分析: 子类实例化对象，由于继承的有父类。所以会先构造父类，然后在构造子类，析构顺序完全按照构造的相反顺序进行析构，故答案为 C