C++子类的构造、析构和拷贝函数

子类的构造

子类的构造在执行它的构造函数前会根据继承表的顺序执行父类的构造函数
1、默认执行父类的无参构造。
2、显式调用有参构造，在子类的构造函数后，初始化列表中显示调用父类对的有参构造函数

class Base
{
public:
	char* str;
	Base(void)
	{
		cout << "无参构造" << endl;
	}
	Base(const char* str)
	{
		this->str = new char[strlen(str)+1];
		strcpy(this->str,str);
		cout << "父类的有参构造：" << str << endl;
	}
};
class A: public Base
{
public:
	A(void)
	{
		cout << "类A的构造函数" << endl;
	}
	A(const char* str):Base(str) // 调用父类的有参构造函数
	{
		cout << "类A的有参构造：" << str << endl;
	}
};
int main()
{
	A a;	// 调用父类的无参构造
	A a1("hehe");	// 调用父类的有参构造
}

子类的析构

子类在它的析构函数执行完后，会根据继承表的顺序逆序执行父类的析构函数。
注意：父类的指针可以指向子类对象，当通过父类指针释放对象时，只会调用父类的析构函数，而这种析构方式有可能造成内存泄漏。

class Base
{
public:
	char* str;
	Base(Void)
	{
		cout << "无参构造" << endl;
	}
	Base(const char* str)
	{
		this->str = new char[strlen(str)+1];
		strcpy(this->str,str);
		cout << "父类有参构造：" << str << endl;
	}
	~Base(void)
	{
		cout << "父类析构函数" << endl;
	}
};
class A:public Base
{
public:
	A(void)
	{
		cout << "类A的构造函数" << endl;
	}
	A(const char* str):Base(str)
	{
		cout << "类A的有参构造：" << str << endl;
	}
	~A(void)
	{
		cout << "子类的析构函数" << endl;
	}
};
int main()
{
	Base* p = new A("我是子类");	// 父类指针指向子类对象是安全的
	delete p;	// 只会调用父类的析构函数
}

子类的拷贝构造函数

1、当使用子类对象来初始化新的子类对象时，会自动调用子类缺省的拷贝构造函数，并且会先调用父类缺省的拷贝构造函数
2、如果子类中实现了拷贝构造，需要显式调用父类的拷贝构造，否则就会调用无参构造。

class Base
{
public:
	char* str;
	Base(void)
	{
		cout << "无参构造" << endl;
	}
	Base(const char* str)
	{
		this->str = new char[strlen(str)+1];
		strcpy(this->str,str);
		cout << "父类的拷贝构造" << endl;
	}
	~Base（void）
	{
		cout << "父类的析构函数" << endl;
	}
};
class A:public Base
{
public:
	A(void)
	{
		cout << "类A的构造函数" << endl;
	}
	A(const char* str):Base(str)
	{
		cout << "类A的有参构造：" << str << endl;
	}
	~A(void)
	{
		cout << "子类析构函数" << endl;
	}
	A(A& that):Base(that)	// 显式调用父类的拷贝构造
	{
		cout << "子类拷贝构造" << endl;
	}
	/*
	A(A& that)	// 只会调用无参构造
	{
		cout << "子类拷贝构造" << endl;
	}
	*/
};
int main()
{
	A* p = new A("我是子类");
	cout << "----------------" << endl;
	A a = *p;	// 拷贝构造函数
}