多重继承与派生类成员标识

单一继承

一个派生类只有一个直接基类的情况称为单一继承

多重继承或多继承

由多个基类共同派生出新的派生类，这样的继承结构称为多重继承

class Chair
{
protected:
	float money;
public:
	Chair(float ft=122):money(ft){}
	float Money() { return money; }
};

class Bed
{
protected:
	float money;
public:
	Bed(float ft=1200):money(ft){}
	float Money() { return money; }
};

//躺椅
class DeckChair :public Bed, public Chair
{
public:
	DeckChair(){}
	DeckChair(float bf, float cf) :Chair(cf), Bed(bf)
	{
		Bed::money = 3000;
	}
	void total()
	{
		float total = Bed::money + Chair::money;
		cout << total << endl;
	}
};
int main()
{
	DeckChair dc(1000, 10);//初始化顺序和继承顺序有关，和初始化列表无关
	dc.total();
	//dc.Money();
	dc.Bed::Money();
	dc.Chair::Money();
	return 0;
}

菱形继承

菱形继承是多重继承一种特殊情况

class person
{
private:
	int _idPerson;
public:
	person(int id) :_idPerson(id) { cout << "create Person" << endl; }
};
class Student :public person
{
private:
	int _snum;
public:
	Student(int s,int id):person(id),_snum(s){}
};
class Gstudent :public Student //研究生
{
private:
	int _gsnum;
public:
	Gstudent(int g,int s,int id):Student(s,id),_gsnum(g){}
};

class Employee :public person  //职工
{
private:
	int _enum;
public:
	Employee(int e,int id):person(id),_enum(e){}
};

class EGStudent :public Gstudent, public Employee //在职研究生
{
private:
	int _egsnum;
public:
	EGStudent(int es, int g, int s, int sid, int e, int eid)
		:Gstudent(g, s, sid), Employee(e, eid), _egsnum(es)
	{

	}
};

int main()
{
	EGStudent egs(1, 2, 3, 4, 5, 6);
	person per(1);
	per = (Gstudent)egs;
	per = (Employee)egs;
	return 0;
}

虚基类

class person
{
protected:
	int _idPerson;
public:
	person(int id) :_idPerson(id) { cout << "create Person" << endl; }
};
class Student :virtual public person  //虚继承人
{
private:
	int _snum;
public:
	Student(int s, int id) :person(id), _snum(s) { cout << "create student" << endl; }
};
class Gstudent :public Student //研究生
{
private:
	int _gsnum;
public:
	Gstudent(int g, int s, int id) :Student(s, id), _gsnum(g), person(id) { cout << "cteate Gstudent" << endl; }
};

class Employee :virtual public person  //虚继承人
{
private:
	int _enum;
public:
	Employee(int e, int id) :person(id), _enum(e) { cout << "create Employee" << endl; }
};

class EGStudent :public Gstudent, public Employee
{
private:
	int _egsnum;
public:
	EGStudent(int es, int g, int s, int sid, int e, int eid)
		:Gstudent(g, s, sid),
		Employee(e, eid),
		_egsnum(es),
		person(eid)
	{
		cout << "create EDGtudent" << endl;
	}
	void fun()
	{
		Gstudent::_idPerson = 100;
		Employee::_idPerson = 200;
		person::_idPerson = 300;
	}
};

int main()
{
	EGStudent egs(1, 2, 3, 4, 5, 6);
	person per(1);
	per=egs;
	person *p=nullptr;
	p=&egs;
	return 0;
}

运行结果：

菱形继承的大小

class A
{};
class B :public A 
{};
class C : public A
{};
class D :public B, public C
{};
int main()
{
	D d;
	cout << sizeof(d) << endl;
}

class A
{};
class B :virtual public A 
{};
class C : public A
{};
class D :virtual public B, public C
{};
int main()
{
	D d;
	cout << sizeof(d) << endl;
}