C++-Record34—继承中的构造和析构

目录

类型兼容性原则

 继承中的对象内存模型

继承中的构造析构调用原则

继承中的构造析构调用顺序原则

总体代码

---

类型兼容性原则

类型兼容规则是指在需要基类对象的任何地方，都可以使用公有派生类的对象来替代。通过公有继承，派生类得到了基类中除构造函数、析构函数之外的所有成员。这样，公有派生类实际就具备了基类的所有功能，凡是基类能解决的问题，公有派生类都可以解决。类型兼容规则中所指的替代包括以下情况：

子类对象可以当作父类对象使用

子类对象可以直接赋值给父类对象

子类对象可以直接初始化父类对象

父类指针可以直接指向子类对象

父类引用可以直接引用子类对象

在替代之后，派生类对象就可以作为基类的对象使用，但是只能使用从基类继承的成员。

以上过程不可逆！

类型兼容规则是多态性的重要基础之一。

上例子，先定义一个父类和子类：

class Parent
{
public:
	void printP()
	{
		cout<<"我是爹..."<<endl;
	}

	Parent()
	{
		cout<<"parent构造函数"<<endl;
	}

	Parent(const Parent &obj)
	{
		cout<<"copy构造函数"<<endl;
	}

private:
	int a;
};

class child : public Parent
{
public:
	void printC()
	{
		cout<<"我是儿子"<<endl;
	}
protected:
private:
	int c;
};

设定主函进行调用：
 

void main()
{
	Parent p1;
	p1.printP();

	child c1;
	c1.printC();
	c1.printP();

	cout<<"hello..."<<endl;
	system("pause");
	return ;
}

代码运行完美，说明父类创建的对象和子类创建的对象都是可以正常运行的。那么引出了赋值兼容性原则的第一层含义：通过基类指针（引用）可以指向子类对象。

	//赋值兼容性原则 
	//1-1 基类指针 (引用) 指向 子类对象
	Parent *p = NULL;
	p = &c1;
	p->printP();

 再进行探究，指针作函数参数，定义一个全局函数：

void howToPrint(Parent *base)
{
	base->printP(); //父类的 成员函数 

}

然后，把一个子类对象的地址扔给父类对象的指针， 编译器是不会报错的：

	howToPrint(&p1);
	howToPrint(&c1); 

再再继续探究，引用做函数参数，还是定义一个全局函数：

void howToPrint2(Parent &base)
{
	base.printP(); //父类的 成员函数 
}

然后把子类的引用也可以传给父类对象，编译器也不会报错，

	//1-3引用做函数参数
	howToPrint2(p1);
	howToPrint2(c1); 

如果我把这个过程给逆过来，就会报错：

void howToPrint3(child &base)
{
	base.printP(); //子类的 成员函数 
}

	howToPrint3(p1); //报错了！
	howToPrint3(c1);

所以，如果是把父类的引用传给子类的话，就会出现报错了！ 

 

 接下来，就是赋值兼容性原则的第二层含义：可以直接定义一个父类对象p3，可以用子类对象来初始化它。

	//可以让子类对象   初始化   父类对象
	//子类就是一种特殊的父类
	Parent p3 = c1;

 继承中的对象内存模型

子类拥有了父类所有的成员变量及方法，如果子类再创建新的成员变量及方法，类会再分配内存的。

 在学习继承概念之前，成员通过构造函数的方式来进行初始化，那加入了继承概念之后，如何进行初始化的呢？就比如子类如何初始化继承而来的属性和自己新添加的属性呢？这就引导了下一个话题。

继承中的构造析构调用原则

问题：如何初始化父类成员？父类与子类的构造函数有什么关系

        在子类对象构造时，需要调用父类构造函数对其继承得来的成员进行初始化

        在子类对象析构时，需要调用父类析构函数对其继承得来的成员进行清理

继承中的构造析构调用顺序原则

1、子类对象在创建时会首先调用父类的构造函数

2、父类构造函数执行结束后，执行子类的构造函数

3、当父类的构造函数有参数时，需要在子类的初始化列表中显式调用

4、析构函数调用的先后顺序与构造函数相反

举例说明，先定义一个父类和一个子类：

父类中写有参构造函数，

class Parent
{
public:
	Parent(int a, int b)
	{
		this->a = a;
		this->b = b;
		cout<<"父类构造函数..."<<endl;
	}
	~Parent()
	{
		cout<<"析构函数..."<<endl;
	}

	void printP(int a, int b)
	{
		this->a = a;
		this->b = b;
		cout<<"我是爹..."<<endl;
	}
private:
	int a;
	int b;
};

下面是子类的编写，其中，子类的有参构造函数，有初始化列表，调用了父类的构造函数，完成初始化。

class child : public Parent
{
public:
	child(int a, int b, int c) : Parent(a, b)
	{
		this->c = c;
		cout<<"子类的构造函数"<<endl;
	}
	~child()
	{
		cout<<"子类的析构"<<endl;
	}
	void printC()
	{
		cout<<"我是儿子"<<endl;
	}
protected:
private:
	int c;
};

 进行调用：

void playObj()
{
	child c1(1, 2, 3);
}
void main()
{
	//Parent p(1, 2);
	playObj();

	cout<<"hello..."<<endl;
	system("pause");
	return ;
}

顺序的话，先调用父类的构造函数，再是子类的构造函数，再是子类的析构函数，再是父类的析构函数。

总体代码

dm04_类型兼容性原则.cpp

#include <iostream>
using namespace std;

class Parent
{
public:
	void printP()
	{
		cout<<"我是爹..."<<endl;
	}

	Parent()
	{
		cout<<"parent构造函数"<<endl;
	}

	Parent(const Parent &obj)
	{
		cout<<"copy构造函数"<<endl;
	}

private:
	int a;
};

class child : public Parent
{
public:
	void printC()
	{
		cout<<"我是儿子"<<endl;
	}
protected:
private:
	int c;
};



/*
兼容规则中所指的替代包括以下情况：
	子类对象可以当作父类对象使用
	子类对象可以直接赋值给父类对象
	子类对象可以直接初始化父类对象
	父类指针可以直接指向子类对象
	父类引用可以直接引用子类对象
	*/



//C++编译器 是不会报错的 .....
void howToPrint(Parent *base)
{
	base->printP(); //父类的 成员函数 

}

void howToPrint2(Parent &base)
{
	base.printP(); //父类的 成员函数 
}
void main()
{
	//

	Parent p1;
	p1.printP();

	child c1;
	c1.printC();
	c1.printP();


	//赋值兼容性原则 
	//1-1 基类指针 (引用) 指向 子类对象
	Parent *p = NULL;
	p = &c1;
	p->printP();  

	//1-2 指针做函数参数

	howToPrint(&p1);
	howToPrint(&c1); 

	//1-3引用做函数参数
	howToPrint2(p1);
	howToPrint2(c1); 


	//第二层含义

	//可以让子类对象   初始化   父类对象
	//子类就是一种特殊的父类
	Parent p3 = c1;


	cout<<"hello..."<<endl;
	system("pause");
	return ;
}

dm05_继承中构造和析构.cpp

#include <iostream>
using namespace std;

//结论
//先 调用父类构造函数 在调用 子类构造函数
//析构的顺序  和构造相反

/*
1、子类对象在创建时会首先调用父类的构造函数
	2、父类构造函数执行结束后，执行子类的构造函数
	3、当父类的构造函数有参数时，需要在子类的初始化列表中显示调用
	4、析构函数调用的先后顺序与构造函数相反
*/

class Parent
{
public:
	Parent(int a, int b)
	{
		this->a = a;
		this->b = b;
		cout<<"父类构造函数..."<<endl;
	}
	~Parent()
	{
		cout<<"析构函数..."<<endl;
	}

	void printP(int a, int b)
	{
		this->a = a;
		this->b = b;
		cout<<"我是爹..."<<endl;
	}
private:
	int a;
	int b;
};


class child : public Parent
{
public:
	child(int a, int b, int c) : Parent(a, b)
	{
		this->c = c;
		cout<<"子类的构造函数"<<endl;
	}
	~child()
	{
		cout<<"子类的析构"<<endl;
	}
	void printC()
	{
		cout<<"我是儿子"<<endl;
	}
protected:
private:
	int c;
};


void playObj()
{
	child c1(1, 2, 3);
}
void main()
{
	//Parent p(1, 2);
	playObj();


	cout<<"hello..."<<endl;
	system("pause");
	return ;
}