C++修炼之路之继承＜二＞

一：子类的六大默认成员函数

二：继承与友元

三：继承与静态成员

四：复杂的继承关系+菱形继承+菱形虚拟继承

1.单继承

2.多继承

3.菱形继承；一种特殊的多继承

4.菱形虚拟继承

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

不使用虚拟继承前数据冗余的情况

使用虚拟继承数据的情况

经典例题

五：继承和组合

接下来的日子会顺顺利利，万事胜意，生活明朗-----------林辞忧

衔接上篇的内容继续介绍

一：子类的六大默认成员函数

1.默认的意思就是我们不写，编译器会自动生成一个，在子类中的默认成员函数要把父类单独看成一个独立的对象来完成对应操作

父类的默认函数

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
{
public:
	Student(const char* name,int id)
		:Person(name)//作为一个单独对象构造
		,_id(id)
	{
		cout << "Student(const char* name, int id)" << endl;
	}
	Student(Student& s)
		:Person(s)//父子类的赋值规则
		, _id(s._id)
	{
		cout << "Student(const Student& s)" << endl;
	}
	Student& operator=(Student& s)
	{
		if (this != &s)
		{
			_id = s._id;
			Person::operator = (s);//父子类的赋值规则
		}
		cout << "Student& operator=(const Student& s)" << endl;

		return *this;
	}
	~Student()
	{
		//Person::~Person();
		cout << "~Student()" << endl;
	}
protected:
	int _id;
};

特殊的对于子类此处的析构函数，不能显示调用父类的析构，原因为

1.由于多态的原因，析构函数统一会被处理成destructor

2.父子类的析构函数构成隐藏

3.为了保证析构安全，先子后父（如果先父后子的话，在父类析构后，在子类还可以访问父类的成员，此时就会导致访问已经释放的空间，导致越界访问），构造为先父后子

4.父类析构函数不需要显示调用，子类析构函数结束时会自动调用父类析构，保证先子后父

练习：如何实现一个不能被继承的类

方法为：可以将父类的成员函数或者整个成员访问方式设置为private,这样继承的时候无论继承方式为那种，都是不可见的

在c++11中新添加了final关键字，使用的话意味着该类不能被继承

二：继承与友元

友元关系不能继承，基类友元不能访问子类私有和保护成员

如要访问子类的私有和保护成员的话，在子类中也声明友元关系（就是基类的友元声明在派生类声明一下）

三：继承与静态成员

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

练习：计算创建多少个类对象--子类初始化时不管我们写不写都会走初始化列表，也一定会走父类的构造

class Person
{
public:
	Person() { ++_count; }
protected:
	string _name; // 姓名
public:
	static int _count; // 统计人的个数。
};

int Person::_count = 0;

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

Student func()
{
	Student st;
	return st;
}

int main()
{
	Person p;
	Student s;
	func();

	cout << Student::_count << endl;

	return 0;
}

四：复杂的继承关系+菱形继承+菱形虚拟继承

1.单继承

一个子类只有一个直接父类

2.多继承

一个子类有两个或以上直接父类

3.菱形继承；一种特殊的多继承

从这里就可以看出，在Assistant的对象中就有两份Person成员，这就导致数据冗余和二义性的问题，这样在访问数据的时候就不知道具体访问哪一个

4.菱形虚拟继承

于是提出了使用虚继承即添加关键字virtual来解决，这是就只有一份Person成员，只初始化一次

如：

class Person
{
public:
	string _name; // 姓名
	int _age;
	int _tel;
	// ...
};
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.Student::_name = "小张";
	a.Teacher::_name = "老张";
	a._name = "张三";
}

int main()
{
	Test();

	return 0;
}