中国大学MOOC程序设计与算法（三）：C++ 面向对象程序设计 第五周 继承 笔记 之 公有(public)继承的赋值兼容原则

第五周 继承
1.继承和派生的基本概念
2.继承关系和复合关系
3.覆盖和保护成员
4.派生类的构造函数
5.公有(public)继承的赋值兼容原则

5.公有(public)继承的赋值兼容原则

最常见的公有(public)继承

class base { };
class derived : public base { };
base b;
derived d;

公有(public)继承的赋值兼容原则

1） 派生类的对象可以赋值给基类对象，因为派生类的对象就是一个基类对象。
b = d;//反过来不行
2） 派生类对象可以初始化基类引用
base & br = d;
3） 派生类对象的地址可以赋值给基类指针
base * pb = & d;
如果派生方式是 private或protected，则上述三条不可行。

protected继承和private继承（不是经常用到）的继承规则

class base {
};
class derived : protected base {
};
base b;
derived d;

protected继承时，基类的public成员和protected成员成为派生类的protected成员。
private继承时，基类的public成员成为派生类的private成员，基类的protected成员成为派生类的不可访问成员。
protected和private继承不是“是”的关系。

基类与派生类的指针强制转换

1）公有派生的情况下,派生类对象的指针可以直接赋值给基类指针
Base * ptrBase = &objDerived;
ptrBase指向的是一个Derived类的对象；
*ptrBase可以看作一个Base类的对象，访问它的public成员直接通过ptrBase即可，但不能通过ptrBase访问objDerived对象中属于Derived类而不属于Base类的成员
2）即便基类指针指向的是一个派生类的对象，也不能通过基类指针访问基类没有，而派生类中有的成员。
3）通过强制指针类型转换，可以把ptrBase转换成Derived类的指针，但要保证ptrBase指向的是一个Derived类的对象，否则很容易会出错。

Base * ptrBase = &objDerived;
Derived *ptrDerived = (Derived * ) ptrBase;

例子：

#include <iostream>
using namespace std;
class Base {
	protected:
		int n;
	public:
		Base(int i):n(i){
			cout << "Base " << n <<" constructed" << endl; 
		}
		~Base() {
			cout << "Base " << n <<" destructed" << endl;
		}
		void Print() { cout << "Base:n=" << n << endl;}
};
class Derived:public Base {
	public:
		int v;
		Derived(int i):Base(i),v(2 * i) {
			cout << "Derived constructed" << endl;
		}
		~Derived()  {
			cout << "Derived destructed" << endl;
		}
		void Func() { } ;
		void Print() {
			cout << "Derived:v=" << v << endl;
			cout << "Derived:n=" << n << endl;
		}
};
int main() {
	Base objBase(5);
	Derived objDerived(3);
	Base * pBase = & objDerived ;//派生类对象的指针可以直接赋值给基类指针
	//pBase->Func(); //error,编译不通过，Base 类没有Func() 成员函数
	//pBase->v = 5; //error,编译不通过; Base 类没有v 成员变量
	pBase->Print();
	//Derived * pDerived = & objBase; //error，不能将基类对象指针赋值给派生类
	Derived * pDerived = (Derived *)(& objBase);//基类强制转换成派生类，前提是基类指向一个派生类
	pDerived->Print(); // 慎用，可能出现不可预期的错误
	pDerived->v = 128; // 往别人的空间里写入数据，会有问题
	objDerived.Print();
	return 0;
}
输出结果：
Base 5 constructed  //Base objBase(5);
Base 3 constructed // Derived objDerived(3);
Derived constructed // Derived objDerived(3);
Base:n=3 // pBase->Print();
Derived:v=1245104 //pDerived->Print(); 内存访问出错，pDerived指向一个基类对象，没有v成员，pDerived->v 位于别人的空间里
Derived:n=5 //pDerived->Print(); 
Derived:v=6 //objDerived.Print();
Derived:n=3 //objDerived.Print();
Derived destructed //程序结束，先析构派生类对象objDerived
Base 3 destructed //析构pBase 
Base 5 destructed  //析构objBase

Derived * pDerived = (Derived *)(& objBase);的效果

直接基类与间接基类

类A派生类B，类B派生类C，类C派生类D，……
– 类A是类B的直接基类
– 类B是类C的直接基类，类A是类C的间接基类
– 类C是类D的直接基类，类A、B是类D的间接基类
构造函数的顺序是从最基最底层的类开始构造，析构的顺序是反过来的。

在声明派生类时，只需要列出它的直接基类
– 派生类沿着类的层次自动向上继承它的间接基类
– 派生类的成员包括:派生类自己定义的成员,直接基类中的所有成员,所有间接基类的全部成员

例子：

#include <iostream>
using namespace std;
class Base {
	public:
		int n;
		Base(int i):n(i) {
			cout << "Base " << n << " constructed"<< endl;
		}
		~Base() {
		cout << "Base " << n << " destructed"<< endl;
		}
};
class Derived:public Base
{
	public:
		Derived(int i):Base(i) {
			cout << "Derived constructed" << endl;
		}
		~Derived() {
			cout << "Derived destructed" << endl;
		}
};
class MoreDerived:public Derived {
	public:
		MoreDerived():Derived(4) {
			cout << "More Derived constructed" << endl;
		}
		~MoreDerived() {
			cout << "More Derived destructed" << endl;
		}
};
int main()
{
	MoreDerived Obj;
	return 0;
}
输出结果：
Base 4 constructed
Derived constructed
More Derived constructed
More Derived destructed
Derived destructed
Base 4 destructed