C++类的继承

C++继承

下面是我定义类：

class father
{
public:
	father()
	{
		cout << "father"<<endl;
	}

	void fun_father()
	{
		cout << "father fun"<<endl;
	}

	~father()
	{
		cout << "delete father"<<endl;
	}

};

class father1:public father
{
public:
	father1()
	{
		cout << "father1"<<endl;
	}

	void fun_father1()
	{
		cout << "father1 fun"<<endl;
	}

	~father1()
	{
		cout << "delete father1"<<endl;
	}

};

class son:public father1
{
public:
	son()
	{
		cout << "son"<<endl;
	}
	
	void fun_son()
	{
		cout << "son fun"<<endl;
	}

	~son()
	{
		cout << "delete son"<<endl;
	}
};

这个是他们三者之间的关系：

下面进行测试：

一.测试构造函数的调用顺序

（一）father *a创建三种对象看看构造函数调用的顺序

1.创建father对象

//1.创建father类的对象
father *a=new father();

结果为：（只调用了father类的构造函数）

2.创建father1对象

//2.创建father1类的对象
father *a=new father1();

结果为：（先调用father类的构造函数，再调用father1类的构造函数）

3.创建son对象

//3.创建son类的对象
father *a=new son();

结果为：（先调用father类的构造函数，再调用father1类的构造函数，最后再调用son的构造函数）

（二）father1 *a创建3种对象看看构造函数调用的顺序

1.创建father对象

//1.创建father类的对象
father1 *a=new father();

结果：报错，派生类指针无法创建基类对象

2.创建father1对象

//2.创建father1类的对象
father1 *a=new father1();

结果：先调用father类的构造函数，再调用father1类的构造函数

3.创建son对象

//3.创建son类的对象
father1 *a=new son();

结果：先调用father类的构造函数，再调用father1类的构造函数，最后再调用son的构造函数

（三）son *a创建son对象构造函数调用的顺序必然为：先调用father类的构造函数，再调用father1类的构造函数，最后再调用son的构造函数

总结：
用指针实例化一个对象的时候，构造函数调用的循序和指针的类型无关，只与要创建的对象有关，并且会从最上层的基类的构造函数开始一层一层往下调用，直到调用了你要创建的那个对象的构造函数。
基类的指针可以创建出派生类的对象，但是派生类的指针无法创建出基类的对象

二.测试析构函数的调用顺序：delete 三种指针

（一）.delete father指针

1.delete 创建father对象的father指针

father *a=new father();
delete a;

结果：调用了father类的析构函数

2.delete 创建father1对象的father指针

father *a=new father1();
delete a;

结果：还是调用了father类的析构函数

3.delete 创建son对象的father指针

father *a=new son();
delete a;

结果：还是调用了father类的析构函数

（二）.delete father1指针

1.delete 创建father1对象的father1指针

father1 *a=new father1();
delete a;

结果：先调用了father1的析构函数，再调用了father的析构函数

2.delete 创建son对象的father1指针

father1 *a=new son();
delete a;

结果：先调用了father1类的析构函数，在调用了father的析构函数

（三）.delete son指针

1.delete 创建son对象的son指针

son *a=new son();
delete a;

结果：先调用了son的析构函数，再调用了father1的析构函数，最后调用了father的析构函数

总结：
析构函数的调用只与指针的类型有关，与new出来的对象无关，并且是由派生类一层一层往上析构的，直到最开始的基类被析构掉。

三.测试访问权限

（一）测试father指针创建的对象

只能访问到father类里面的方法

（二）测试father1指针创建的对象

能访问到father1和father的方法

（三）测试son指针创建的对象

能访问到father，father1和son三个的方法

总结：
访问权限也是只和指针类型有关的，与创建的对象无关，并且派生类可以访问到整条继承链条之前的全部方法