1、继承类之间的赋值

继承类之间的赋值，是指基类的对象赋值给子类的对象，或者子类赋值给基类的操作。一般情况下，只能是子类的对象赋值给基类对象 

class Father
{
public:
	Father(){a = 100;}
	~Father(){}

	const Father &operator=(const Father &m)//m是=号右边的对象  
	{  
		//自己给自己赋值的情况  
		if (this == &m)  
		{  
			return *this;  
		}  
		else  
		{  
			//把=号右边对象成员的值赋给左边对象成员  
			a = m.a;  
			return *this;  
		}  
	} 

private:
	int a;
};

class Son:public Father
{
public:
	Son(){b = 200;}
	~Son(){}
private:
	int b;
};
int main()
{
	Father father;
	Son son;

	//子类对象可以赋值给基类对象
	father = son;//father.operator=(son);

	//基类对象不能赋值给子类对象
	/*赋值操作会调用operator=()函数，把father作为参数传递并给子类数据成员赋值，但是
	通常子类成员包含从基类继承过来的和自己额外定义的成员，那么用基类对象给子类对象赋值
	的时候就会出现问题，因为基类对象中并不包含子类额外定义数据成员*/
	//son = father;

	//基类对象指针可以指向子类对象
	Father *pF = &son;

	//子类对象指针不能指向父类
	/*这样会使得把一部分不属于基类对象的内存也包括进来，在使用该指针的时候，常常会修改
	基类对象之外的数据，造成严重错误*/
	//Son *pS = &father;

	//基类对象的引用可以作为子类对象的别名
	Father &fat = son;

	//子类对象的引用不能作为基类对象的别名，原因和指针相同
	//Son &s = father;
	return 0;
}

2、继承的构造和析构顺序

在构造一个子类的时候，会首先调用基类的构造函数(毕竟有父才有子嘛)对子类中基类那部分成员进行初始化，然后才会执行子类的构造函数，对子类其他成员进行初始化，如果这个基类仍是一个派生类，那么会一直往上执行，直到完成为止；析构的顺序和构造相反。 

class Grandfather
{
public:
	Grandfather(){x = 300; cout<<"Grandfather构造函数"<<endl;}
	~Grandfather(){cout<<"Grandfather析构函数"<<endl;}

private:
	int x;
};

class Father:public Grandfather
{
public:
	Father(){a = 100;cout<<"Father构造函数"<<endl;}
	~Father(){cout<<"Father析构函数"<<endl;}
private:
	int a;
};

class Son:public Father
{
public:
	Son(){b = 200;cout<<"Son构造函数"<<endl;}
	~Son(){cout<<"Son析构函数"<<endl;}
private:
	int b;
};
int main()
{
	Son s;//先构造Grandfather，再构造Father，最后构造Son
	//结束时，析构的顺序正好相反
	return 0;
}

3、多重继承的构造和析构顺序

多重继承的构造是按照继承时的顺序进行的，析构的顺序和构造时的顺序相反 

class a
{
public:
	a(){cout<<"a构造函数"<<endl;}
	~a(){cout<<"a析构函数"<<endl;}
};

class b
{
public:
	b(){cout<<"b构造函数"<<endl;}
	~b(){cout<<"b析构函数"<<endl;}
};

class c
{
public:
	c(){cout<<"c构造函数"<<endl;}
	~c(){cout<<"c析构函数"<<endl;}
};

class d:public b, public a, public c
{
public:
	d(){cout<<"d构造函数"<<endl;}
	~d(){cout<<"d析构函数"<<endl;}
};

int main()
{
	//构造顺序：b、a、c、d
	d s;
	//析构顺序：d、c、a、b
	return 0;
}

4、多重继承的二义性

如果派生类中有相同的函数定义，那么就会出现二义性问题，解决这个问题的方法就是在调用方法前面加上类型限定符。

如果子类里面有和基类里相同的函数，那么不会导致二义性，因为在调用函数的时候，编译器会先搜索子类中的函数，一旦

找到，调用即被确认下来。所以不会产生二义性。

class a
{
public:
	void print(){cout<<"a的函数"<<endl;}
};

class b
{
public:
	void print(){cout<<"b的函数"<<endl;}
};

class c
{
public:
	void print(){cout<<"c的函数"<<endl;}
};

class d:public b, public a, public c
{
public:
	//继承关系最下面一个子类中有和父类相同函数的时候，不会产生二义性
	//因为在调用的时候，编译器会优先在子类中搜索
	void print(){cout<<"d的函数"<<endl;}
};

int main()
{
	d cd;
	cd.b::print();//作用域标识符明确指定调用b的print()函数
	cd.print();
	return 0;
}

5、使用虚基类避免多重继承时的二义性 

class Human
{
public:
	void Speak(){cout<<"会讲汉语"<<endl;}
};

class Mother:virtual public Human
{

};

class Father:virtual public Human
{

};

//Mother和Father将公共基类说明为虚基类(virtual)
//因此，公共基类将只为条多继承路径的汇合处生成基类的一个实例
//也就是说，只为Son(Son是Father和Mother的汇合)类生成一个Speak函数，从而避免二义性
class Son:public Mother, public Father
{
};

int main()
{
	Son son;
	son.Speak();
	return 0;
}

6、继承中的重载

当子类没有与基类拥有同名函数的时候，这时基类中的函数及其重载版本将会被子类全部继承过来。

当在子类中定义一个与基类同名的函数时，那么等于是告知编译器，用子类的函数覆盖掉基类的同名函数，同时将基类这个函数的重载版本隐藏起来。

class Father
{
public:
	void print(){cout<<"Father::print()"<<endl;}
	void print(int i){cout<<"Father::print(int)"<<endl;}
};

class Son:public Father
{
public:
	//覆盖掉基类同名函数，并且隐藏基类同名函数的重载版本
	void print(){cout<<"Son::print()"<<endl;}
	//const重载函数，会根据调用对象的版本选择
	//非const对象，调用print()函数
	//const对象，调用print()const函数
	void print()const{cout<<"Son::print()const"<<endl;}
};

int main()
{
	Son so;
	const Son s;
	s.print();
	so.print();
	return 0;
}