C++继承与派生(3)

1.私有继承以及私有继承和公有继承的区别

私有继承体现的是组合概念，比如：一个圆是由一个点和半径组合而成，但不能说一个圆就是一个点或者一个圆就是半径。组合有俩种方法：

class Point
{
private:
	float x;
	float y;
public:
	Point(float a=0.0f,float b=0.0f):x(a),y(b){}
	~Point(){}
};
class Circle
{
	Point p;
	float r;
public:
	Circle(float a=0.0f,float b=0.0f,float c=1.0f):p(a,b),r(c){}
	~Circle(){}
};

这是组合的方法，将一个类的成员设计为另一个类。

class Point
{
private:
	float x;
	float y;
public:
	Point(float a=0.0f,float b=0.0f):x(a),y(b){}
	~Point(){}
};
class Circle: private Point
{
	float r;
public:
	Circle(float a=0.0f,float b=0.0f,float c=1.0f):Point(a,b), r(c) {}
	~Circle(){}
};

这是私有继承，也表示组合。

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

只有一个部分时，可以使用私有继承，或成员数据方式实现组合如果有多个部分时，使用成员数据方式实现组合
私有继承:要表示类之间“用...来实现”的关系，可以选择是通过私有继承实现。现在这种情况下，这技术就比分层更有优势，因为通过它可以让你告诉别人:Point使用起来不安全，它只能用来实现其它的类。具体做法是将Point 的成员函数声明为保护类型

公有继承与组合的区别
继承与组合都是面向对象中代码复用的方式
公有继承:父类的内部细节对子类可见，其代码属于白盒式的复用
例: class Person ; class Student;
公有继承的优缺点
优点:
支持扩展，通过继承父类，可以设计较为复杂的系统，体现了由简单到复杂的认识过程.易于修改被复用的代码
缺点:
代码白盒复用，父类的实现细节暴露给子类，破坏了封装性当父类的实现代码修改时，可能使得子类也不得不修改，增加维护难度了类缺乏独立性，依赖于父类，耦合度较高不支持动态拓展，在编译期就决定了父类

组合和私有继承
组合:意味着“用...来实现"， 对象之间的内部细节不可见，其代码属于黑盒式复用。私有继承意味着“用...来实现”，是组合关系，父类的内部细节对子类不可见，其代码属于黑盒式复用
组合的优缺点
优点:
代码黑盒复用，被包括的对象内部实现细节对外不可见，封装性好整体类与局部类之间松耦合，相互独立，支持扩展
每个类只专注于一项任务
支持动态扩展，可在运行时根据具体对象选择不同类型的组合对象(扩展性比继承好)
缺点:
创建整体类对象时，需要创建所有局部类对象。导致系统对象很多。

公有继承与私有继承和组合如何选择?
在对象分析时明确具有是一个 (is - a) 的关系，使用公有继承。
在对象分析时明确具有“有一个”或“用...来实现"关系，使用组合和私有继承。
私有继承和组合如何选择?
答案很简单: 尽可能地使用组合，必须时才使用私有继承。什么时候必须呢?这往往是指有保护成员和或虚函数介入的时候考虑考虑使用私有继承。
私有继承在编码过程中就要指定具体的父类，其关系在编译期就确定，而组合的关系一般在运行时确定。

2.菱形继承

菱形继承是一种特殊的继承关系：

 

学生继承了人，工人也继承了人。暑假工继承了学生和工人。这样的话，暑假工就有俩个身份证号了。

两个身份证号显然是不合理的。可以把class Person这个共同基类设置为虚基类，这样从不同路径继承来的同名数据成员在内存中就只有一个拷贝，同名函数也只有一种映射。
虚基类 (virtual base class) 定义方式如下
class 派生类名:virtual 访问限定符 基类类名...}class 派生类名:访问限定符 virtual 基类类名...];
virtual 关键字只对紧随其后的基类名起作用:

class Person
{
	int _id;
public:
	Person(int id = 0) :_id(id) { cout << "Person()" << endl; }
	~Person() { cout << "~Person()" << endl; }
};

class Student : virtual public Person
{
private:
	int _snum;
public:
	Student(int id, int snum) :Person(id), _snum(snum) { cout << "Student()" << endl; }
	~Student() { cout << "~Student()" << endl; }
};

class Worker :virtual public Person
{
	int money;
public:
	Worker(int id, int mo) :Person(id), money(mo) { cout << "Empl()" << endl; }
	~Worker() { cout << "~Empl()" << endl; }
};

class EStudent :public Student, public Worker
{
	int level;
public:
	EStudent(int id, int snum, int money, int le) :Person(id), Student(id, snum),
		Worker(id, money), level(le) {
		cout << "EStudent()" << endl;
	}
	~EStudent() { cout << "~Estudent()" << endl; }
};

int main()
{
	EStudent est(9899, 2023, 5000, 2);
}

这样无论在哪个构造函数，都必须先构造人这个对象，然后在根据你的继承顺序继续构造对象。这在内存中的体现其实是偏移量，好几份内存中都保存着人，但是只有一个内存中保存的是人的身份证号，其他内存中为偏移量，可以理解为指针，指向人的身份证号。