构造函数复制构造函数经典问题

◆由于构造函数不能被继承，因此，派生类的构造函数中除了对派生类中数据成员进行初始化外，还必须通过调用直接基类的构造函数来对基类中数据成员初 始化，一般地将，对派生类中数据成员初始化放在该派生类构造函数的函数体内，而调用基类构造函数的基类中数据成员初始化放在该构造函数的成员初始化表中。 派生类构造函数的格式如下表示：
<派生类构造函数名>(<参数表>) : <成员初始化表>
{
  <派生类构造函数的函数体>
}
其中，<派生类构造函数名>同该派生类的类名。<成员初始化表>中包含如下的初始化项：
①基类的构造函数，用来给基类中数据成员初始化；
②子对象的类的构造函数，用来给派生类中子对象的数据成员初始化；
③派生类中常成员的初始化。
<派生类构造函数的函数体>用来给派生类中的数据成员初始化。
派生类构造函数的调用顺序如下：
①基类构造函数；
②子对象的构造函数；
③成员初始化表中其他初始化项；
④派生类构造函数的函数体。

派生类中析构函数
由于析构函数也不能继承，因此派生类的析构函数中将调用直接基类的析构函数。执行派生类析构函数的顺序正好与指向派生类的构造函数的顺序相反。先调用派生类的析构函数，再调用子对象类的析构函数，最后调用直接基类的析构函数。

#include<iostream>
using namespace std;
class A
{
public:
	A(int x=0)
	{
		a=x;
		cout<<"A Constructor"<<endl;
	}
	A(A&t)
	{
		cout<<"A COPY"<<endl;
	}
	~A()
	{
		cout<<"A Destructor"<<endl;
	}
	void display()
	{
		cout<<a<<endl;
	}
private:
	int a;
};
class B:public A
{
public:
	B(int i):A(i)//B(A i):aa(i)
	{
	    cout<<"B Constructor"<<endl;
	}
	~B()
	{
        cout<<"B Destructor"<<endl;
	}
private:
	A aa;
};
int main()
{

	
	B b(33);
	b.display();
   return 0;
}

结果：

A Constructor

A Constructor

B Constructor

33

B Destructor

A Destructor

A Destructor

#include<iostream>
using namespace std;
class A
{
public:
	A(int x=0)
	{
		a=x;
		cout<<"A Constructor"<<endl;
	}
	A(A&t)
	{
		cout<<"A COPY"<<endl;
	}
	~A()
	{
		cout<<"A Destructor"<<endl;
	}
	void display()
	{
		cout<<a<<endl;
	}
private:
	int a;
};
class B:public A
{
public:
	B(int i):aa(i)
	{
	    cout<<"B Constructor"<<endl;
	}
	~B()
	{
        cout<<"B Destructor"<<endl;
	}
private:
	A aa;
};
int main()
{

	
	B b(33);
   
   return 0;
}

结果：

A Constructor

A Constructor

B Constructor

B Destructor

A Destructor

A Destructor

#include<iostream>
using namespace std;
class A
{
public:
	A(int x=0)
	{
		a=x;
		cout<<"A Constructor"<<endl;
	}
	A(A&t)
	{
		cout<<"A COPY"<<endl;
	}
	~A()
	{
		cout<<"A Destructor"<<endl;
	}
	void display()
	{
		cout<<a<<endl;
	}
private:
	int a;
};
class B:public A
{
public:
	B(A i):aa(i)
	{
	    cout<<"B Constructor"<<endl;
	}
	~B()
	{
        cout<<"B Destructor"<<endl;
	}
private:
	A aa;
};
int main()
{
	
	
	B b(33);
	
   
   return 0;
}

结果：

A Constructor

A Constructor

A COPY

B Constructor

A Destructor

B Destructor

A Destructor

A Destructor

#include<iostream>
using namespace std;
class A
{
public:
	A(int x=0)
	{
		a=x;
		cout<<"A Constructor"<<endl;
	}
	A(A&t)
	{
		cout<<"A COPY"<<endl;
	}
	~A()
	{
		cout<<"A Destructor"<<endl;
	}
	void display()
	{
		cout<<a<<endl;
	}
private:
	int a;
};
class B:public A
{
public:
	B(A &i):aa(i)//B(A i):aa(i)
	{
	    cout<<"B Constructor"<<endl;
	}
	~B()
	{
        cout<<"B Destructor"<<endl;
	}
private:
	A aa;
};
int main()
{
	
	A a(3);
	
	B b(a);
	b.display();
   
   return 0;
}

结果：

A Constructor

A Constructor

A COPY

B Constructor

0

B Destructor

A Destructor

A Destructor

A Destructor

#include<iostream>
using namespace std;
class A
{
public:
	A(int x=0)
	{
		a=x;
		cout<<"A Constructor"<<endl;
	}
	A(A&t)
	{
		cout<<"A COPY"<<endl;
	}
	~A()
	{
		cout<<"A Destructor"<<endl;
	}
	void display()
	{
		cout<<a<<endl;
	}
private:
	int a;
};
class B:public A
{
public:
	B(A i):aa(i)//B(A i):aa(i)
	{
	    cout<<"B Constructor"<<endl;
	}
	~B()
	{
        cout<<"B Destructor"<<endl;
	}
private:
	A aa;
};
int main()
{
	
	A a(3);
	
	B b(a);
	b.display();
   
   return 0;
}

结果：

A Constructor

A COPY

A Constructor

A COPY

B Constructor

A Destructor

0

B Destructor

A Destructor

A Destructor

A Destructor

#include<iostream>
using namespace std;
class A
{
public:
	A(int x=0)
	{
		a=x;
		cout<<"A Constructor"<<endl;
	}
	A(A&t)
	{
		cout<<"A COPY"<<endl;
	}
	~A()
	{
		cout<<"A Destructor"<<endl;
	}
	void display()
	{
		cout<<a<<endl;
	}
private:
	int a;
};
class B:public A
{
public:
	B(){cout<<"B Constructor"<<endl;}
	~B()
	{
        cout<<"B Destructor"<<endl;
	}
	
private:
	A aa;
};
int main()
{	
	B b; 
   return 0;
}

结果：

A Constructor

A Constructor

B Constructor

B Destructor

A Destructor

A Destructor