【C++】继承

目录

一、概念与定义：

1、继承的概念：

2、继承的定义：

3、基类成员访问方式：

4、继承中的作用域：

二、基类和派生类对象的赋值转换：

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

示例： 

结论：

四、继承的友元与静态函数：

五、菱形继承及菱形虚拟继承

1、菱形继承：

菱形继承内数据冗余和二义性问题：

2、菱形虚拟继承：

六、继承与组合：

总结：

---

一、概念与定义：

1、继承的概念：

        继承是面向对象编程的三大基本特性之一（分别是：封装、继承和多态），它允许一个类（称为派生类或子类）继承另一个类（称为基类或父类）的属性和方法。通过继承，可以创建更加复杂和特定的类，同时重用已存在的类的代码。

2、继承的定义：

        举一个简单的例子：在一所学校中分别有着学生和教师两类的人，这就可以是看作为两个类，然后学生和教师都有着相同的属性，比如说名字和年龄，也有着不同的属性，比如学生自己的学号，教师自己的职工号，此时相同的属性就可以看作为一个基类(父类)，各自不同的属性就是派生类(子类)。

// 基类
class Person
{
protected:
	string _name = "zhangsan"; // 名字
	int _age = 18; // 年龄
};

// 派生类
class Student : public Person
{
protected:
	int _stid; // 学号
};
// 派生类
class Teacher : public Person
{
protected:
	int _teid; // 工号
};

3、基类成员访问方式：

以下是父类的成员通过对应的继承方式在子类中存在的方式：

1、对于上表其实可以发现的了，父类的私有成员在子类中都是无法直接访问的，但是可以间接的去访问，但是没什么大的必要，对于其他的成员通过不同的继承方式在子类的存在可以简单记为：（公有 < 保护 < 私有）取最小的权限。

2、在使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，可以补写出继承方式，但是最好是显式的写出继承方式。

3、在实际运用中一般都是使用的公有继承，很少使用保护、私有继承，也不提倡使用这俩继承方式，因为通过这样继承下来的成员都只能在派生类中使用。

4、继承中的作用域：

• 在继承体系中基类和派生类都有独立的作用域。
• 当子类和父类中有同名的成员时子类成员将屏蔽父类对同名成员的直接访问，这种情况就叫隐藏（或者重定义）。
• 可以通过（基类::基类成员）进行显式访问。
• 如果是函数成员的隐藏，只要函数名相同就构成隐藏（不看参数）。至于为什么不构成函数重载，因为函数重载要处于相同的作用域才会构成。
• 所以注意在实际使用时不要在继承体系中定义同名成员。

class A
{
public:
	void Print(){
		cout << "A.print()..." << endl;
	}

	int aa = 1;
};

class B : public A
{
public: 
	void Print(){ // 在B中定义与A相同名的成员变量以及函数，此时A中同名的就会被隐藏
		cout << "B.print()..." << endl;
	}

	int aa = 2;
};

int main()
{
	B b;
	b.Print();
	b.A::Print(); // 显式调用

	cout << "b.aa: " << b.aa << endl;
	cout << "b.A::aa: " << b.A::aa << endl; // 显式调用
	return 0;
}

二、基类和派生类对象的赋值转换：

        派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片
或者切割。寓意把派生类中父类那部分切来赋值过去。基类对象不能赋值给派生类对象。

class Person
{
public:
	string _name = "zhangsan"; // 名字
	int _age = 18; // 年龄
	int* a = new int[4] {0};
};

class Student : public Person
{
public:
	int _stid; // 学号
};

int main()
{

	// 切割/切片赋值兼容规则 -> 中间不会产生临时变量（编译器产生了特殊处理）
	Student s;
	Person p = s; // 子类对象赋值给父类对象,浅拷贝

	Person& ps = s; // 变成子类对象中父类那一部分的别名

	Person* pp = &s; // 指针指向子类对象切出来的那个父类对象

	ps._name += 'a';  // 通过改变父类对象也能去改变子类对象
	pp->_name += 'b'; // 指针也同理，并且因为赋值兼容还不会产生临时变量

	return 0;
}

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

示例： 

        关于派生类的默认成员函数我们需要注意的是其中的四个：构造函数、析构函数、拷贝构造、赋值重载。

class Person
{
public:
	Person(const char* name = "zhangsan")
		:_name(name)
	{
		cout << "Person()" << endl;
	}
	Person(const Person& p)
		:_name(p._name)
	{
		cout << "Person(const Person& p)" << endl;
	}
	Person& operator=(const Person& p)
	{
		if (this != &p)
			_name = p._name;
		cout << "Person& operator=(const Person& p)" << endl;
		return *this;
	}

	~Person()
	{
		cout << "~Person()" << endl;
	}
protected:
	string _name; // 名字
};

class Student : public Person
{
public:
	Student(const char* name, int stid)
		//:_name(name) 不能这样直接去初始化成员变量
		:Person(name) // 要这样显式调用
		,_stid(stid)
	{
		cout << "Student()" << endl;
	}

	Student(const Student& s)
		:Person(s) // 显式调用
		,_stid(s._stid)
	{
		cout << "Student(const Student& s)" << endl;
	}

	Student& operator=(const Student& s)
	{
		cout << "Student& operator=(const Student& s)" << endl;
		if (this != &s)
		{
			Person::operator=(s); // 显式调用父类的赋值重载
			_stid = s._stid;
			return *this;
		}
	}

	~Student()
	{
		cout << "~Student()" << endl;

		// 我们以为的析构函数: 先析构子类的，在调用父类的析构去析构父类数据

		// 析构子类数据

		Person::~Person();// 析构父类数据
		// 但是实际上我们并不需要自己去调用父类的析构函数
	}
protected:

	// 父类成员可以当成一个整体的一个自定义类型

	int _stid; // 学号
};

int main()
{
	cout << "构造函数: " << endl;
	Student s1("zhangsan", 20);
	
	cout << "拷贝构造: " << endl;
	Student s2(s1);
	
	cout << "赋值重载: " << endl;
	Student s3 = s2;

	cout << "析构函数: " << endl;
	return 0;
}

补充一点：由于多态的需要，析构函数名字会统一处理成destructor(),所以子类的析构函数跟父类的析构函数构成隐藏。

结论：

1. 子类的构造函数必须调用父类的构造函数初始化父类的那一部分成员。如果父类没有默认的构造函数，则必须在子类构造函数的初始化列表阶段显示调用。
2. 子类的拷贝构造函数必须调用父类的拷贝构造完成父类那一部分的拷贝初始化。
3. 子类的operator=必须要调用父类的operator=完成父类那一部分的复制。
4. 子类的析构函数会在被调用完成后自动调用父类的析构函数清理父类成员。因为这样才能保证子类对象先清理子类成员再清理父类成员的顺序。
5. 构造时：子类对象初始化先调用父类构造再调用子类构造，但是析构时：子类对象析构清理先调用子类析构再调父类的析构。

四、继承的友元与静态函数：

关于继承的友元：

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

关于继承的静态函数：

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

例如：

class A
{
public:
	A(){
		sum++;
	}

	static int sum;
};

int A::sum = 0;

class B : public A
{
};

int main()
{
	B b1;
	B b2;
	B b3;
	cout << B::sum << endl; // 创建了3个对象，所以sum的值为3
	cout << &A::sum << endl;
	cout << &B::sum << endl; // 用的都只能是同一个sum
}

五、菱形继承及菱形虚拟继承

1、菱形继承：

继承关系有：单继承、多继承、菱形继承。

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

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

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

菱形继承内数据冗余和二义性问题：

        如下代码，定义一个A类，然后通过公有继承给B类和C类，然后B类和C类中就分别有A类的保护成员（_a），然后定义一个派生类D，其基类分别是B和C，此时就会出现一个问题，因为B和C都继承的A，A类除私有数据外的都会分别给到B和C，然后这些数据又会一起给D，那么D中就会有两份A中的非私有数据（_a），这样就数据冗余了，而且访问时还会发生访问不明确的问题（二义性），就是访问的时候不知道你要访问的是B中的_a,还是C中的_a（虽然可以通过指定域访问解决二义性问题，但是数据冗余这个问题还是存在）。

class A
{
public:
	int _a;
};

class B : public A
{
public:
	int _b;
};

class C :public A
{
public:
	int _c;
};

class D : public B, public C
{
public:
	int _d;
};

2、菱形虚拟继承：

        为了解决在菱形继承中产生的数据冗余和二义性问题就引入了一个关键字 virtual ，出现了虚继承这个概念，virtual 就在B和C继承A的时候加在B和C身上，这时候就不会在发生数据冗余了（数据冗余解决了其实二义性也就跟着解决了）。

class B : virtual public A // virtual加在B、C上
{...}

class C : virtual public A
{...}

接着上面的代码设置如下变量，从内存的角度来看

 

六、继承与组合：

继承：

        继承是一种is - a 的关系，每一个派生类对象都是一个特殊的基类对象，比如说 梅花 是一种 植物，此时植物就是基类，而梅花就是一个派生类，这就是一种is - a 的关系。

组合：

        组合是一种 has - a 的关系，即一个B类中会有A类的对象，比如说一间 房子 有一个 门 ，此时房子就是B类，门就是A类，这就是一种 has - a 的关系。

继承与组合的区别：

        继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用，也就是说在继承这种方式里，基类内部的细节是对派生类可见的，在一定程度上破坏了基类的封装，在改变基类时，也会对派生类造成很大影响，派生类和基类的依赖关系很强，耦合度高。

        组合时类继承之外的另一种复用选择，这种复用被称为黑箱复用，对象的内部细节是不可见的，组合类之间并没有很强的依赖关系，能很好的保持基类的封装，耦合度低，但是组合也有缺点，例如如果过度使用组合，可能会导致对象结构变得复杂和难以维护。

总结：

        在实际当中，如果是类与类之间是 is - a 的关系就用继承，如果是 has - a 的关系就用组合，两者都有各自的优点和缺点，根据实际情况来使用，但是如果是 is - a 和 has - a 都可以的这种情况，就尽量多用组合。