继承（C++）

继承（C++）

继承

什么是继承？

继承的概念继承如何定义 基类（父类）和派生类（子类）对象赋值转换继承中的作用域派生类的默认成员函数继承与友元继承与静态成员复杂的菱形继承及菱形虚拟继承（面试常问）

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

什么是继承？ 继承的概念

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

一、比如动物 Aniaml 具有的共性：吃饭、睡觉。狗会叫，但是狗也会吃饭、睡觉，我们先来看不继承父类（基类）是个什么样的情况？

class Animal
{
public:
	void eat()
	{
		cout << "eating" << endl;
	}
	void sleep()
	{
		cout << "sleeping" << endl;
	}	
};
class Dog
{
public:
	void bark()
	{
		eat();
		cout << "barking" << endl;
	}
};

会显示未定义。

二、当我们继承之后，就可以使用父类（基类）的方法

class Animal
{
public:
	void eat()
	{
		cout << "eating" << endl;
	}
	void sleep()
	{
		cout << "sleeping" << endl;
	}	
};
class Dog : public Animal
{
public:
	void bark()
	{
		eat();
		cout << "barking" << endl;
	}
};

这就是继承的一个作用，提高了代码的复用性

继承如何定义

继承关系跟访问限定符一样，都要public、protected、private

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

一、我们先来看public继承

class Animal
{
public:
	void eat()
	{
		cout << "eating" << endl;
	}
	void sleep()
	{
		cout << "sleeping" << endl;
	}	
protected:
	int age;
private:
	string description;//动物的样子 私有
};
class Dog : public Animal
{
public:
	void bark()
	{
		//description = "长得很好看";//在子类中不可见
		age = 10;
		eat();
		cout << "barking" << endl;
	}
};

父类的 public 成员 和 protected 成员在子类中是可见可访问的 父类的 public 成员在子类中访问权限就是 public， protected成员在子类中访问权限就是protectedprivate在子类中是不可访问的，但是他的对象物理空间是存在的，这里只是看不到，无法去访问

二、我们在来看 protected 方式基础基类

class Dog : protected Animal
{
public:
	void bark()
	{
		//description = "长得很好看";//在子类中不可见
		age = 10;
		eat();//类中依然可以访问
		cout << "barking" << endl;
	}
};

但类外就无法访问了，因为此时父类的成员按照protected权限继承给了子类，protected、public的权限限定符全部变成了protected

三、private继承父类

private 继承虽然在对象物理空间存在，但是子类也无法访问

四、继承方式的总结

public、protected、private继承父类

public、protected继承在子类中是可访问的，但protected在类外不可访问private 虽然对象物理空间存在，但不管是子类还是类外都不可访问父类的其他成员在子类中的访问方式：public > protected > private

基类（父类）和派生类（子类）对象赋值转换

基类对象不能赋值给派生类对象派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。俗称切片
基类的指针可以通过强制类型转换赋值给派生类的指针。但是必须是基类的指针是指向派生类对象时才是安全的。
继承中的作用域

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

class Animal
{
public:
	void fun()
	{
		cout << "Animal" << endl;
	}
public:
	int age = 10;
};
class Dog : public Animal
{
public:
	void fun()
	{
		fun();
		cout << "Dog is " << age << " years！！！" << endl;
	}
public:
	int age = 10;
};

子类fun函数中调用的还是子类的fun函数，会直接导致栈溢出，这里就体现了继承下重名的问题，造成对父类同名成员的隐藏这里子类和父类的成员函数不构成重载，因为没有在同一作用域下。避

解决隐藏的问题，可以显示调用父类中的成员函数

派生类的默认成员函数

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

class Animal
{
public:
	Animal(const char* name = "peter")
		: _name(name)
	{
		cout << "Animal()" << endl;
	}
	Animal(const Animal& p)
		: _name(p._name)
	{
		cout << "Animal(const Person& p)" << endl;
	}
	Animal& operator=(const Animal& p)
	{
		cout << "Animal operator=(const Animal& p)" << endl;
		if (this != &p)
			_name = p._name;
		return *this;
	}
	~Animal()
	{
		cout << "~Animal()" << endl;
	}
protected:
	string _name; // 姓名
};
class Dog : public Animal
{
public:
	Dog(const char* name, int age)
		: Animal(name)
		, _age(age)
	{
		cout << "Dog()" << endl;
	}
private:
	int _age;
};

子类的构造函数会调用父类的构造函数去初始化父类的那一部分成员

如果父类没有默认的构造函数去初始化，就会报错

接着第2条，那么我们只能在子类的构造函数的初始化列表阶段显示调用

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

Dog(const Dog& d)
		: Animal(d) //上面转换 子类对象可以赋给父类对象
		,_age(d._age)
	{
		cout << "Dog(const Person& p)" << endl;
	}

不能直接利用子类对象的成员变量拷贝给父类的

必须显示调用父类的拷贝构造完成父类的拷贝初始化

三、派生类的operator=必须要调用基类的operator=完成基类的复制

Dog& operator=(const Dog& d)
	{
		cout << "Dog operator=(const Dog& p)" << endl;
		if (this != &d)
		{
			Animal::operator=(d);
			_age = d._age;
		}
		return *this;
	}

如果不显示调用，隐藏的this指针，会一直调用自己的拷贝赋值，导致栈溢出

正确的做法，指明作用域

四、派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序
五、派生类对象初始化先调用基类构造再调派生类构造。
六、 派生类对象析构清理先调用派生类析构再调基类的析构

上面的图更直观，下面的图供参考

继承与友元

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

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

要是想访问该友元方法，在子类中添加友元声明即可

继承与静态成员

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

class Animal
{
public:
	static int _count;//只存在一份
protected:
	string _name; // 姓名
	
};
int Animal::_count = 0;
class Dog : public Animal
{
protected:
	int _stuNum; // 学号
};

复杂的菱形继承及菱形虚拟继承（面试常问）

单继承：一个子类只有一个直接父类时称这个继承关系为单继承

多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承

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

菱形继承的问题：会有数据冗余和二义性

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

如果要访问，需要显示指定访问谁的

解决办法：使用虚继承可以解决数据冗余和二义性的问题

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";
	// 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
	a.Student::_name = "xxx";
	a.Teacher::_name = "yyy";
}

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

但如何解决的？我们先来看看不是虚继承的情况下，a对象的一个字节数。

class A
{
public:
	int _a;
};
// class B : public A
class B : public A
{
public:
	int _b;
};
// class C : public A
class C : public A
{
public:
	int _c;
};
class D : public B, public C
{
public:
	int _d;
};

下图是菱形继承的内存对象成员模型：这里可以看到数据冗余

在虚继承中，我们在来看看字节数

原因：有两个虚基表指针，各占4个字节，其他成员变量占16个字节，所以总24个字节，具体原理，继续往下看

下图是菱形虚拟继承的内存对象成员模型

我们也可以通过汇编来观察一下内存对象

这里可以分析出D对象中将A放到的了对象组成的最下面，这个A同时属于B和C，那么B和C如何去找到公共的A呢？这里是通过了B和C的两个指针，指向的一张表。这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的A

下面的图也可以参考！！！

继承总结

首先，继承中的多继承的语法是比较复杂，又存在菱形继承，在到菱形虚拟继承，就有设计虚基表指针去解决数据冗余和二义性的问题，所以一般不建议设计出多继承，更不要设计出菱形继承，别自己给自己挖坑。（C++自己给自己挖的坑，一系列的语法难度是比较大的，自己挖的坑要自己填）

public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。优先使用对象组合，而不是类继承

class A
{
public:
	int a;
protected:
	int b;
};
class B : public A
{};
class C
{
public:
	int c;
protected:
	int d;
};
class D
{
public:
	C c;
};

但在实际开发中，虽然组合比继承好，但并不是不用继承，这要看类与类之间的关系。
实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承，可以用组合，就用组合

// Car和BMW Car和Benz构成is-a的关系
class Car{
protected:
	string _colour = "白色"; // 颜色
	string _num = "陕ABIT00"; // 车牌号
};
class BMW : public Car{
public:
	void Drive() {cout << "好开-操控" << endl;}
};
class Benz : public Car{
public:
	void Drive() {cout << "好坐-舒适" << endl;}
};
// Tire和Car构成has-a的关系
class Tire{
protected:
	string _brand = "Michelin"; // 品牌
	size_t _size = 17; // 尺寸
};
class Car{
protected:
	string _colour = "白色"; // 颜色
	string _num = "陕ABIT00"; // 车牌号
	Tire _t; // 轮胎
};

所以什么时候用继承，什么时候用组合，要看实际的情况，千万不要不看关系就直接用组合！！！
更新不易，记得三连！！！