---

前言

菱形继承的类对父类的初始化、组合、多态、多态的原理等的介绍

---

一、菱形继承的类对父类的初始化

#include<iostream>
#include <string>
using namespace std;

class A
{
public:
	A(const char* A)
		:_a(A)
	{
		cout << "class A" << endl;
	}
	string _a;
};

class B : virtual public A
{
public:
	B(const char* A, const  char* B)
		:A(A)
		,_b(B)
	{
		cout << "class B" << endl;
	}
	string _b;
};

class C : virtual public A
{
public:
	C(const char* A, const char* C)
		:A(A)
		,_c(C)
	{
		cout << "class C" << endl;
	}
	string _c;
};

class D : public B, public C
{
public:
	D(const char* A, const char* B, const char* C, const char* D)
		: A(A)
		, B(A, B)
		, C(A, C)
		, _d(D)
	{
		cout << "class D" << endl;
	}
	string _d;
};


int main()
{

	D d("class A", "class B", "class C", "class D");
	
	return 0;
}

结构为：

• 因为D类有如上的结构，所以A类会在D类中调用构造函数初始化，并且只调用一次，在D类中初始化B类和C类时，传入的A类不调用A类的构造函数初始化。

二、组合

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

优先使用对象组合，而不是类继承。

#include <iostream>
using namespace std;

class A
{
protected:
	int _a;
};

class B : public A
{
protected:
	A _bb;
};

int main()
{

	return 0;
}

三、 多态

1. 构成多态

构成多态需要两个条件：

1. 必须通过基类的指针或者引用调用虚函数
2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

// 构成多态
#include<iostream>
using namespace std;

class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "购票---全价" << endl;
	}
};

class Student : public Person
{
public:
	virtual void BuyTicket()
	{
		cout << "购票---半价" << endl;
	}
};

//void fun(Person& p)
//{
//	p.BuyTicket();
//}

void fun(Person* p)
{
	p->BuyTicket();
}

int main()
{
	Person p;
	fun(&p);

	Student s;
	fun(&s);

	return 0;
}

2. 虚函数

虚函数：即被virtual修饰的类成员函数称为虚函数。

class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "购票---全价" << endl;
	}
};

3. 虚函数的重写

虚函数的重写(覆盖)：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数。

在重写基类的虚函数的时候，虽然派生类的虚函数不写virtual也可以构成重写， 但是不建议这样使用

#include<iostream>
using namespace std;

class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "购票---全价" << endl;
	}
};

class Student : public Person
{
public:
	virtual void BuyTicket()
	{
		cout << "购票---半价" << endl;
	}
};

4. 虚函数重写的两个例外

1. 协变

基类与派生类虚函数返回值类型不同。

简单来讲就是 基类与派生类的虚函数的返回值构成父子类指针或引用关系。

#include <iostream>
using namespace std;

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

class Person
{
public:
	virtual A* BuyTicket()
	{
		cout << "购票---全价" << endl;
		return new A;
	}
};

class Student : public Person
{
public:
	virtual B* BuyTicket()
	{
		cout << "购票---半价" << endl;
		return new B;
	}
};

void fun(Person& p)
{
	p.BuyTicket();
}


int main()
{
	Person p;
	fun(p);
	Student s;
	fun(s);
	return 0;
}

• 基类和派生类构成父子类指针的关系

2. 析构函数的重写

虽然基类和派生类的析构函数的函数名不同，但是编译器会将析构函数的函数名，都处理成destructor,因此可以构成重写。

一般情况下，应该将派生类的析构函数与基类析构函数构成函数重写，使下面的情况delete可以实现多态，保证指向的对象正确调用析构函数。

析构函数可以构成虚函数重写吗， 为什么要构成虚函数重写？

1. 析构函数加virtual会构成析构函数，因为编译器会将析构函数的名字统一命名为destructor
2. 构成虚函数重写是因为，我们new一个派生类对象的空间，但是用基类的类型指针接收
3. 在析构这个对象时，只会进行普通调用，普通调用会按照当前类型， 则只会调用基类的析构函数
4. 这种情况，我们希望是一个多态调用，按照指向的类型调用析构函数，就需要构成虚函数的重写。

#include <iostream>
using namespace std;


class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "购票---全价" << endl;
	}

	 virtual ~Person()
	{
		cout << " ~Person() " << endl;
	}
};

class Student : public Person
{
public:
	virtual void BuyTicket()
	{
		cout << "购票---半价" << endl;
	}

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

int main()
{
	Person* p1 = new Person;
	Person* p2 = new Student;

	delete p1;
	delete p2; // p2->destuctor() + operator delete(p)

	// 这里我们期望是一个多态调用，而不是普通调用

	p1 = nullptr;
	p2 = nullptr;

	return 0;
}

5. C++11 final 和 override

1. final

final 修饰的虚函数不能被重写

final修饰的类，不能被当做基类， 不能被继承

2. override

检查派生类中的虚函数与基类中虚函数是否构成重写，若不构成重写则报错。

#include <iostream>
using namespace std;


class Person
{
public:
	virtual void BuyTicket()
	{}

};

class Student : public Person
{
public:
	// 检查派生类中的虚函数与基类中的虚函数是否构成重写
	virtual void BuyTicket()override
	{
		cout << "购票---半价" << endl;
	}
};


int main()
{
	Person p;

	return 0;
}

6. 设计不想被继承的类

将构造函数私有或者将析构函数私有

将构造函数私有

#include <iostream>
using namespace std;

class A
{
public:
	static A CreateObj()
	{
		return A();
	}
private:
	A() {}

};

int main()
{
	A::CreateObj();
	return 0;
}

7. 重载、覆盖（重写）、 隐藏（重定义）的对比

四、多态的原理

普通调用在编译时地址就确定了
多态调用在程序运行时，到指向对象的虚函数表中找函数的地址

#include <iostream>
using namespace std;

class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "购票---全价" << endl;
	}

	int _a = 0;

};

class Student: public Person
{
public:
	virtual void BuyTicket()
	{
		cout << "购票---半价" << endl;
	}

	int _b = 1;
};

// 普通调用
//void fun(Person p)
//{
//	p.BuyTicket();
//}

// 多态调用
void fun(Person& p)
{
	p.BuyTicket();
}

int main()
{
	Person p;

	Student s;


	return 0;
}

---

总结

菱形继承的类对父类的初始化、组合、多态、多态的原理等的介绍