C++ 不同继承之间的的关系

公有继承：“是一个” 的关系

派生类与基类：

赋值兼容规则
C++面向对象编程中一条重要的规则是：公有继承意味着 “是一个” 。一定要牢牢记住这条规则。
在任何需要基类对象的地方都可以用公有派生类的对象来代替，这条规则称赋值兼容规则。它包括
以下情况：

1. 派生类的对象可以赋值给基类的对象，这时是把派生类对象中从对应基类中继承来的隐藏对象赋值给基类对象。反过来不行，因为派生类的新成员无值可赋。
2. 可以将一个派生类的对象的地址赋给其基类的指针变量，但只能通过这个指针访问派生类中由基类继承来的隐藏对象，不能访问派生类中的新成员。同样也不能反过来做。
3. 派生类对象可以初始化基类的引用。引用是别名，但这个别名只能包含派生类对象中的由基类继承来的隐藏对象。

如下代码示例：

class Object
{
public:
int value;
public:
Object(int x = 0) :value(x) {}
~Object() {}
void print(int x)
{
value = x;
cout << value << endl;
}
};
class Base : public Object
{
public:
int num;
public:
Base(int x = 0):Object(x),num(x+10) {}
};
int main()
{
Base base(10);
Object obja(0);
Object *op = &base;
Object &ob = base;
obja = base;
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

继承关系中的构造函数与析构函数

class Person
{
	int _id;
public:
	Person(int id) :_id(id)
	{
		cout << "Create Person " << this << endl;
	}
	~Person()
	{
		cout << "Destroy Person " << this << endl;
	}
};
 
class Student : public Person
{
	int _s_id;
 
public:
	Student(int id, int s, int n) :_s_id(s),  Person(id)
	{
		cout << "Create Student: " << this << endl;
	}
	~Student()
	{
		cout << "Destroy Student" << this << endl;
	}
};
int main()
{
	Student stud(90010, 202201, 23);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

定义基类person，派生类student，当在主函数中创建一个派生类对象时，首先创建person对象，再创建student对象，析构时，先析构派生类对象，再析构基类对象

继承关系中拷贝构造函数

1. 程序设计者在基类和派生类中都没有定义拷贝构造函数;C++编译器将自动产生按位拷贝的拷贝构造函数；在派生类的拷贝构造函数的初始化表中，加入基类拷贝构造函数的调用，是C++编译器合成的代码；

2. 程序设计者在基类中定义拷贝构造函数；而在派生类中没有定义拷贝构造函数；C++编译器将会在派生类中自动产生按位拷贝的拷贝构造函数。并合成代码，调用(关联）基类的拷贝构造函数。

3. 程序设计者在基类和派生类中都定义了拷贝构造函数；程序设计者在派生类中,没有指定调用基类的拷贝构造函数时。C++编译器合成的代码调用基类的缺省构造函数，如果基类中没有缺省构造函数。合成代码失败。

4. 程序设计者在基类中没有定义拷贝构造函数（C++编译器将自动产生按位拷贝的拷贝构造函数）。而在派生类中定义了拷贝构造函数。程序设计者在派生类中,没有指定调用基类的拷贝构造函数时。C++编译器合成的代码调用基类的缺省构造函数，如果基类中没有缺省构造函数。

继承关系中赋值运算符的重载

1. 程序设计者在基类和派生类中都没有重载operator=函数; C++编译器将在基类和派生类中自动产生按位赋值的,重载operator=函数；C++编译器会在派生类的重载赋值函数中，加入基类重载赋值函数的调用，是C++编译器合成的代码；（完成行为的统一）；
2. 程序设计者在基类中定义重载赋值函数；而在派生类中没有定义重载赋值函数；C++编译器将会在派生类中自动产生按位赋值的重载赋值函数。并合成代码，调用(关联）基类的重载赋值函数。
3. 程序设计者在基类和派生类中都定义了重载赋值函数；程序设计者在派生类中,没有指定调用基类的重载赋值函数时。C++编译器不会合成调用基类的重载赋值函数的代码。要在派生类的重载赋值函数调用基类的重载赋值函数，程序设计者必须自己加入调用代码。
4. 程序设计者在基类中没有定义重载赋值函数（C++编译器将自动产生按位赋值的重载赋值函数。而在派生类中定义了重载赋值函数。程序设计者在派生类中,没有指定调用基类的重载赋值函数。C++编译器不会合成调用基类的重载赋值函数的代码。

通过组合体现 “有一个” 或 “用…来实现”

  使某个类的对象成为另一个类的数据成员，从而实现将一个类构筑在另一个类之上，这一过程称为
1

"组合“，分层；

组合

通过组合来体现 “有一个” 或 “用…来实现”。
例如，“汽车有一个发动机 或 汽车用发动机来实现 ” (has-a) 关系可以用单一组合表示为：

class Engine // 发动机
{
private:
int cylinderNum; // 气缸数
public:
Engine(int n = 4) :cylinderNum(n) {}
void Start(); // 启动
};
class Car
{
private:
Engine eg;
public:
Car():eg(8) {}
void StartCar();
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

**组合关系：**通过组合体现 “有一个” 或 “用…来实现”。组合是一种耦合度更强的关联关系。存在组合关系的类表示“整体-部分”的关联关系，“整体”负责“部分”的生命周期，他们之间是共生共死的；并且“部分”单独存在时没有任何意义。

同样的“有一个”关系也能用私有继承表示：

class Engine // 发动机
{
private:
int cylinderNum; // 气缸数
public:
Engine(int n = 4) :cylinderNum(n) {}
void EnStart(); // 启动
};
class Door
{
private:
int doorNum;
public:
Door(int n = 5) :doorNum(n) {}
}
class Car : private Engine
{
public:
Car() :Engine(8) {}
void StartCar(); //通过发动引擎来发动这辆汽车
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

私有继承： 要表示类之间 “用…来实现” 的关系，可以选择是通过私有继承实现。现在这种情况下，这一技术就比分层更有优势，因为通过它可以让你告诉别人：Engine使用起来不安全，它只能用来实现其它的类

**聚合关系：**通过聚合体现 “有一个” 或 “用…来实现”。 整体类与局部类之间松耦合，相互独立。

class Engine // 发动机
{
private:
int cylinderNum; // 气缸数
public:
Engine(int n = 4) :cylinderNum(n) {}
void Start(); // 启动
};
class Car
{
private:
Engine *peg;
public:
Car():peg(nullptr) {}
void SetEngine(Engine *p) { peg = p;}
void StartCar();
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

总结

公有继承与组合的区别
继承与组合都是面向对象中代码复用的方式。

公有继承： 父类的内部细节对子类可见，其代码属于白盒式的复用；
例如： class Person ; class Student;

公有继承的优缺点

优点：

支持扩展，通过继承父类，可以设计较为复杂的系统，体现了由简单到复杂的认识过程。
易于修改被复用的代码。

缺点：

代码白盒复用，父类的实现细节暴露给子类，破坏了封装性。
当父类的实现代码修改时，可能使得子类也不得不修改，增加维护难度。
子类缺乏独立性，依赖于父类，耦合度较高。
不支持动态拓展，在编译期就决定了父类。

组合和私有继承

**组合：**意味着 “用…来实现”; 对象之间的内部细节不可见，其代码属于黑盒式复用。
私有继承意味着 “用…来实现”; 是组合关系，父类的内部细节对子类不可见，其代码属于黑盒式复用。

优点：

代码黑盒复用，被包括的对象内部实现细节对外不可见，封装性好。
整体类与局部类之间松耦合，相互独立。
支持扩展每个类只专注于一项任务
支持动态扩展，可在运行时根据具体对象选择不同类型的组合对象(扩展性比继承好)。

缺点：

创建整体类对象时，需要创建所有局部类对象。导致系统对象很多。

公有继承与私有继承和组合如何选择？

在对象分析时明确具有是一个（is - a) 的关系，使用公有继承。
在对象分析时明确具有 “有一个” 或 "用…来实现"关系，使用组合和私有继承。

私有继承和组合如何选择？

答案很简单：尽可能地使用组合，必须时才使用私有继承。什么时候必须呢？这往往是指有保护成员
和/或虚函数介入的时候考虑考虑使用私有继承。
//私有继承在编码过程中就要指定具体的父类，其关系在编译期就确定，而组合的关系一般在运行时确
定。