复制构造函数

只有一个参数，即完成对同类对象的引用
形如X::X( X& )或X::X(const X &)，二者选一，后者能一常量对象作为参数
如果没有定义复制构造函数，那么编译器生成默认复制构造函数。默认的复制构造函数完成复制功能。

class Complex{
	private:
		double real, imag;
};
Complex c1;//调用缺省无参构造函数
Complex c2(c1);//调用缺省的复制构造函数，将c2初始化成hec1一样

如果定义的自己的复制构造函数，那么默认的复制构造函数不存在。

class Complex{
	public:
		double real, imag;
		Complex(){}
		Complex(const Complex & c){
			real = c.real;
			imag = c.imag;
			cout<<"copy constructor called";
		}
};
Complex c1;
Complex c2(c1);

不允许有形如X::X(X)的构造函数

class CSample{
	CSample(CSample c){
	}//错，不允许这样的构造函数
}

复制构造函数其作用的三种情况

1. 当用一个对象去初始化同类的另一个对象时。

Complex c2(c1);
Complex c2 = c1;//初始化语句，非赋值语句，和上面那一句完全等价

2. 如果某函数有一个参数是类A的对象，那么该函数被调用时，类A的复制构造函数将被调用。

class A
{
	public:
	A(){};
	A(A & a){
		cout<<"Copy constructor called"<<endl;
	}
};
void Func(A a1){}
//在这个函数中参数是A的对象，因为函数要生成一个形参。
//这个形参就是通过类A的复制构造函数生成的，而复制构造函数需要接受一个参数。
//这个参数就是下面的a2
int main(){
	A a2;
	Func(a2);
	return 0;
}
//一般情况下，实参会与传递到函数中的形参相等，但是在这种情况下就不一定相等了
//因为这里的a1是由我们自己编写的复制构造函数来生成的
//而复制构造函数并没有进行复制的工作，生成的a1只是打印出一句话；
//程序输出结果为："Copy constructor called"
//如果我们自己不写复制构造函数，用类默认的复制构造函数a1就会等于a2，因为默认的一定会进行复制工作

3. 如果函数的返回值是类A的对象，则函数返回时，A的复制构造函数将被调用

class A
{
	public:
	int v;
	A(int n){v = n;};
	A(A & a){
		v =  a.v;
		cout<<"Copy constructor called"<<endl;
	}
};
A Func(){
	A b(4);
	return b;
}
int main(){
	cout << Func().v << endl;
	return 0;
}
//输出结果：
//Copy constructor called
//4

类型转换构造函数

1. 实现类型的自动转换
2. 只有一个参数
3. 不是复制构造函数
4. 编译系统会自动调用->转换构造函数->建立一个临时对象/临时变量

class Complex{
	public:
		double real, imag;
		//1.类型转换构造函数
		Complex(int i){
			cout<<"IntConstructor called"<<endl;
			real  = i; imag = 0;
		}
		//2.
		Complex(double r, double i){
			real = r;
			imag = i;
		}
}
int main(){
	Complex c1(7, 8);//2
	
	//1：初始化的过程中调用类型转换构造函数的时候不会生成一个临时对象
	Complex c2 = 12;
	
	//赋值语句，会自动调用类型转换函数，会生成一个临时对象
	//9被自动转换成一个临时Complex对象，9被当成实参输入进Complex函数
	//然后再把生成的临时对象赋值给c1
	c1 = 9;
	cout<<c1.real<<","<<c1.imag<<endl;
	return 0;
}
//输出：
//IntConstructor called
//IntConstructor called
//9,0

析构函数（Destructor）

构造函数名字与类名相同，可以有参数不能有返回值，可以有多个构造函数，用来初始化对象。
析构函数名字与类名相同，在前面会加上“～”，没有参数和返回值，一个类最多只能有一个析构函数。
对象消亡时，自动被调用。在对象消亡前做善后工作，释放分配的空间。
定义类的时候没写析构函数，则编译器生成缺省析构函数，默认析构函数什么都不做，不涉及释放用户申请的内存释放等清理工作。
用户如果自己定义了析构函数，则编译器不生成缺省析构函数。

class String{
	private:
		char *p;
	public:
		String(){
			p = new char[10];
		}
		~String();
};
String::~String(){
	delete[] p;
}

对象数组生命期结束时，对象数组的每个元素的析构函数都会被调用

class Ctest{
	public:
		~Ctest(){ cout<<"destructor called"<<endl;}
};
int main(){
	Ctest array[2];
	cout<<"End Main"<<endl;
	return 0;
}
//程序结束，自动释放调用析构函数
//输出：
//End Main
//destructor called
//destructor called

delete运算导致析构函数调用

Ctest * pTest;
pTest = new Ctest;//构造函数调用
delete pTest;//析构函数调用

pTest = new Ctest[3];//构造函数调用3次
delete[] pTest;//析构函数调用3次

例子：

class Demo {
		int id;
	public:
		Demo( int i )
		{
			id = i;
			cout << “id=” << id << “ Constructed” << endl;
		}
		~Demo()
		{
			cout << “id=” << id << “ Destructed” << endl;
		}
};
Demo d1(1);
void Func(){
	static Demo d2(2);//d2是静态变量，所以func运行完还会存在，消亡会在整个程序结束后
	Demo d3(3);//d3的作用域只在这个函数里
	cout << “Func” << endl;
}
int main (){
	Demo d4(4);
	d4 = 6;//生成一个临时的对象，然后赋值完成后，把临时对象析构
	cout << “main” << endl;
	{ Demo d5(5);}//有一个自己的作用域，离变量最近的花括号就是作用域，作用域又可以表示这个变量的作用周期，所以结束后析构d5
	Func();
	cout << “main ends” << endl;
	return 0;
}
//还未消亡的对象：d1 d2 d4
//先让d4析构掉，再把d2这个静态对象析构掉，最后析构全局对象d1
//先被构造的对象会最后被析构掉，这也是c++语法的一个思想

输出:
id=1 Constructed
id=4 Constructed
id=6 Constructed
id=6 Destructed
main
id=5 Constructed
id=5 Destructed
id=2 Constructed
id=3 Constructed
Func
id=3 Destructed
main ends
id=6 Destructed
id=2 Destructed
id=1 Destructed

此外，析构函数和构造函数在不同编译器中的表现，个别调用情况不一致

构造函数：

是在对象已经具有空间以后做一些初始化的工作，不负责分配空间

是成员函数的一种，与类名相同，可带参，无返回值(void 也不行)，对对象做初始化

类默认有构造函数，无参无操作

有对象生成时一定调用构造函数

在对象已经分配空间后进行初始化工作

一个类可有多个构造函数

#include <iostream>
using namespace std;

class Complex {
    private:
        double real, imag;
    public:
        void set(double r, double i);
        //reload
        Complex(double r, double i);
        Complex(double r);
        Complex(Complex c1, Complex c2);
};

Complex::Complex(double r, double i){
    real = r;
    imag = i;
}
Complex::Complex(double r){
    real = r;
    imag = 0;
}
Complex::Complex(Complex c1, Complex c2){
    real = c1.real + c2.real;
    imag = c2.imag + c2.imag;
}

//在数组中的使用
class Sample{
    int x;
    public:
        Sample(){
            cout << "constr 1" << endl;
        }
        Sample(int n){
            cout << "constr 2" <<endl;
        }
};

int main(){
    //以下均报错，无参数
    //Complex c1;
    //Complex * p1 = new Complex;
    Complex c1(2), c2(1,0), c3(c1, c2);
    Complex * p2 = new Complex(2, 3);

    Sample array1[2];
    cout << "st1" << endl;

    Sample array2[2] = {4,5};
    cout << "st2" << endl;

    Sample array3[2] = {3};
    cout << "st3" << endl;

    Sample * array4 = new Sample[2];
    delete []array4;
    cout << "st4" << endl;

    return 0;
}

指针不会引发对象的生成

class Test{
    public:
        Test(int n){cout << "test1" << endl;}
        Test(int n, int m){cout << "test2" << endl;}
        Test(){cout << "test3" << endl;}
};

int main(){

    Test t1[3] = {1, Test(1,2)};
    Test t2[3] = {Test(2,3), Test(1,2), 1};
    Test * pt1[3];  //不导致对象生成，是一个指针数组
    Test * pt2[3] = {new Test(4), new Test(1,2)};

    return 0;

}

复制构造函数

形如  X::X( X& x) 或 X::X(const X& x) ，参数为同类对象的引用，无定义编译器默认生成，完成两个对象复制的功能

复制构造函数与无参构造函数区别：

      1. 无参构造函数也称默认构造函数，不一定存在（你不写任何构造函数编译器才会默认生成）

      2. 复制构造函数一定存在(要么你写要么编译器帮你写)，复制构造函数只有一个

class Complex:{
    private:
        double img,re;
};

int main(){
Complex c1;
Complex c2(c1);  //调用缺省的默认的复制构造函数，c2与c1一样
}

复制构造函数起作用的三种情况：

//1.
Complex c1;

//2.初始化同类的另一个对象
Complex c2(c1);   //或Complex c2=c1;

//某函数Func()的参数是类A的对象，则Func调用时，类A的复制构造函数将被调用
class A:
{    
    public:
        A(){};
        A(A & a){cout<<"copy construct"<<endl};
};

void Func(A a1){}

int main(){
    A a2;
    Func(a2);     //此时a1对象的初始化调用复制构造函数，但我们的复制构造函数不是拷贝，所以a1可
                  //能不是a2的拷贝  
    return 0;
}

//3.若函数Func的返回值为A的对象时，Func返回时A的复制构造函数被调用
class A:
{    
    public:
        int v;
        A(int n){v=n;};
        A(const A & a){
        v = a.v
        cout<<"copy construct"<<endl
        };
};
A Func(){
    A a1(3);
    return a1;
}
int main(){
    cout<<Func().v<<endl;  //3
    
    return 0;
}

对象间的赋值不等于复制构造函数被调用比如：

Complex c1;
c1=c2;

为了减少函数调用时，复制构造函数调用所产生的时间开销，可以用常量引用参数

void Func(const A & a ){}

引用的参数与实参是一回事，不会生成对象，若想让函数内部操作改变形参不改变实参，加上const

类型转换构造函数

为了实现类型转换

只有一个参数且不是复制构造函数

需要时编译器自动调用，生成一个无名临时对象

class Complex:
{
    public:
        double a,b;
        Complex(double i, double j){a=i;b=j;}
        Complex(int i){a=i; b=0;}  //double to int
};

int main(){
    Complex c1(7,8);  //7.0,8.0
    Complex c2=12;    //a=12,b=0
    c1=9;             //编译器将9自动转换为一个无名临时对象其a=9，b=0,再将这个临时对象赋给c1
    return 0;
}

析构函数（destructor）

在对象消亡时被调用（可为释放空间等），一个类最多一个

若不写编译器会自动生成（什么都不做）

函数名为：‘~’ + ‘className’

无参无返回值

在对象的空间被回收前的操作

class String:
{
       private:
            char *p;
       public:
            String(){
                p = new char[10];
            }
            ~ String();
};

String::~ String(){
    delete []p;
}

对象数组生命周期结束时，其中的每个元素的析构函数都会被调用

消亡的几种情况：

//1. main函数结束时
class A:
{
    public:
        int a;
    ~ A(){cout<< "destructor" <<endl;}        
};

int main(){
A a[2];
cout<< "end main" <<endl;

return 0;
}
//输出结果为：
//end main
//destructor
//destructor


//2.new出的对象，delete时消亡，不delete不消亡
A *a;
a = new A;
delete a;   //析构函数调用

A a1[3];
delete [] a;  //析构函数调用三次


//3. 对象作为函数返回值，返回后调用析构函数
class A:
{
    public:
        int a;
    ~ A(){cout<< "destructor" <<endl;}        
};

A func(A sa)              //调用默认复制构造函数初始化形参sa
{
    return sa;            //返回形参sa后析构函数被调用
}

int main(){
    A a;
    a = func(a);          //func(a)生成一个返回值对象(临时对象)，用复制构造函数初始化，其值赋
                          //值给a,执行完这条语句后，临时对象消亡，调用析构函数
    cout<< "end main" <<endl; 

    return 0;             //main结束后，全局对象a消亡，调用析构函数
}
//输出结果为：
//destructor
//destructor
//end main
//destructor

相关实例

析构函数和构造函数被调用实例：

class A:
{
    public:
        int a;
        A(int i){     //构造函数，也可算类型转换构造函数
            a=i;
            cout << "a" << a << " construct" << endl;
        };
        ~ A(){
            cout << "a"<< a << " destruct" << endl;
        }        
};

A a1(1);                               //step1:全局对象在main之前初始化,在整个程序结束后消亡

void func(){                           
    static A a2(2);                    //step8:静态局部变量初始化，在全部程序结束后消亡
    A a3(3);                           //step9:局部变量a3初始化，在func结束后消亡
    cout << "func end" << endl;
}

int main(){                   
    A a4(4);                           //step2:初始化a4,在main结束后消亡
    a4 = 6;                            //step3:类型转换构造函数生成值为6的临时对象
                                       //step4:临时对象赋值语句结束后消亡
    cout << "main" << endl;            //step5
    {A a5(5);}                         //step6:局部对象a5生成
                                       //step7:包含a5的最内层大括号结束后a5消亡
    func();
    cout << "end main" << endl;
}

//输出结果
// a1 construct
// a2 construct
// a4 construct
// a6 construct
// a6 destruct
// main
// a5 construct
// a5 destruct
// a2 construct
// a3 construct
// func end
// a3 destruct
// end main
// a6 destruct       //先消亡main内的
// a2 destruct       //因为a1比a2先初始化，后消亡
// a1 destruct

构造函数在不同编译器中表现

dev c++呼吁优化目的没有生成返回值临时对象，一般情况下没什么问题

类型转换函数基本概念：

1：定义转换构造函数的目的是实现类型的自动转换。
2：只有一个参数，而且不是复制构造函数的构造函数， 一般就可以看作是转换构造函数。
3：当需要的时候，编译系统会自动调用转换构造函数， 建立一个无名的临时对象(或临时变量)。

具体实例：

class Complex {
	 public: 
 		double real, imag;
 		Complex( int i) {//类型转换构造函数
			cout << "IntConstructor called" << endl;
			real = i; imag = 0; 
 		}
 		
		Complex(double r,double i) {real = r; imag = i; }
};
int main ()
{
	Complex c1(7,8);
	Complex c2 = 12;   //这里也调用了类型转换构造函数
	c1 = 9; // 9被自动转换成一个临时Complex对象
	
	cout << c1.real << "," << c1.imag << endl;
	
 	return 0;
}

结果输出：0,9

析构函数基本概念：

1：名字与类名相同，在前面加‘~’， 没有参数和返回值，
2：一个类最多只能有一个析构函数 。 析构函数对象消亡时即自动被调用 。可以定义析构函数来在对象消亡前做善后工作，比如释放分配的空间等。
3：如果定义类时没写析构函数，则编译器生成缺省析构函数。缺省析构函数什么也不做。
4：如果定义了析构函数，则编译器不生成缺省析构函数。

析构函数实例：

class String{
	private :
		char * p;
	public:
		String () {
			p = new char[10];
		}	
		~ String () ;
};

String ::~ String()//在这里定义了一个析构函数
{
delete [] p;
}

析构函数和数组：

对象数组生命期结束时，对象数组的每个元素的析构函数都会被调用。

若new一个对象数组，那么用delete释放时应该写 []。否则只delete一个对象(调用一次析构函数)

class Ctest {
	public:
		~Ctest() { cout<< "destructor called" << endl; }
};

int main () {
	Ctest array[2];
	cout << "End Main" << endl;
	return 0;
}

析构函数在对象作为函数返回值返回后被调用：

class CMyclass {
	public:
		~CMyclass() { cout << "destructor" << endl; }
};

CMyclass obj;
CMyclass fun(CMyclass sobj ) { //参数对象消亡也会导致析，构函数被调用

		return sobj; //函数调用返回时生成临时对象返回
		
}
int main(){
	obj = fun(obj); //函数调用的返回值（临时对象）被用过后，该临时对象析构函数被调用。
	return 0; 
}

总结：构造函数和析构函数什么时候被调用？

class Demo {
	int id;
	public:
		Demo(int i) {
			id = i;
			cout << "id=" << id << " constructed" << endl;
		}

		~Demo() {
			cout << "id=" << id << " destructed" << endl;
		}
};

Demo d1(1);          //全局对象在main函数还没有执行时就被创建
void Func() 
{
	static Demo d2(2);   //静态局部变量，整个程序结束时，这个被创建的对象才会消亡
	Demo d3(3);
	cout << "func" << endl;
}
int main () {
	Demo d4(4);
	d4 = 6;
	cout << "main" << endl;
	
	{ Demo d5(5);  }
	
	Func();
	cout << "main ends" << endl;
	return 0;
}

输出结果如下：

id=1 constructed 
id=4 constructed
id=6 constructed
id=6 destructed
main
id=5 constructed
id=5 destructed
id=2 constructed
id=3 constructed
func
id=3 destructed
main ends
id=6 destructed
id=2 destructed
id=1 destructed