构造、解析函数

构造函数

构造函数是成员函数的一种，名字与类名相同，不能有返回值（void也不行）
左用是对对象初始化，比如给成员变量赋初值
类可以有多个构造函数

---

没有初始化对象

class Complex{
public:
    void set(double r,double i);
protected:
private:
    double real,imag;
};
Complex c1;
Complex * pc=new Complex;

---

自定义构造函数

class Complex{
public:
    void Complex(double r,double i=0);
protected:
private:
    double real,imag;
};
void Complex::Complex(double r,double i=0){
    real=r;imag=i;
}

Complex c1;//error 缺少必要的构造函数
Complex *pc=new Complex(3,4);
Complex c2(4);
Complex c3(5,6),c4(6,7);

---

多个构造函数

class Complex{
public:
    void Complex(double r,double i=0);
    void Complex(double r);
    void Complex(double c1,double c2);
protected:
private:
    double real,imag;
};
void Complex::Complex(double r,double i=0){
    real=r;imag=i;
}
void Complex::Complex(double r){
    real=r;imag=0;
}
void Complex::Complex(Complex c1,Complex c2){
    real=c1.real+c2.real;
    imag=c1.imag+c2.imag;
}
Complex c1(3),c2(1,0),c3(c1,c2);

---

构造函数在数组中的使用

class CSample{
public:
    CSample(){
        cout<<"construct 1 called!"<<endl;
    }
    CSample(int n){
        x=n;
        cout<<"construct 2 called!"<<endl;
    }
protected:

    int x;
};

int main(){

    cout<<"step1:"<<endl;CSample array1[2];
    cout<<"step2:"<<endl;CSample array2[2]={4,5};
    cout<<"step3:"<<endl;CSample array3[2]={4};
    cout<<"step4:"<<endl;CSample *array4=new CSample[2] ;delete array4;
    return 0;
}

输出结果

---

构造函数在对象数组与数组指针之间的区别

class Test{
public:
    Test(int n){}
    Test(int n,int m){}
    Test(){}
protected:
private:
};

Test array[2]={1,Test(1,2)};
Test array2[3]={Test(1,2),Test(5,2),4};
Test *pc[3]={new Test(1,2),new Test(3,4)}

初始化对象数组，每个元素都会调用构造函数
初始化指针数组，只有调用才会生成。不调用指针就为NULL

class CSample{
private:

public:
    int x;
    CSample(){ cout << "construct 1 called!" << endl; }
    CSample(int n) {
        x = n; cout << "construct 2 called!" << endl;
    }
};

int main() {
    cout << "step1" << endl;  CSample array[2];
    cout << "step2" << endl;  CSample array2[2] = { 1,2 };
    cout << array2[1].x << endl;
    cout << "-----------------" << endl;
    cout << "step3" << endl; CSample array3[2] = { 3 };
    cout << "step4" << endl; CSample *array4[3] = {  (new CSample(3)) };
    cout << (*array4[0]).x << endl;
    return 0;
}

复制构造函数

只有一个参数，即对同类对象的引用
形如X::X(X &),X::X(const X &)，二者选一后能以常量对象作为参数
没有定义复制构造函数，系统默认的复制构造函数完成复制功能。

类型转换构造函数

只有一个参数，即对同类对象的引用
形如X::X(const X &) , X::X(X &)
如果没有定义复制构造函数，编译器生成默认复制构造函数

//默认构造函数
class Complex{
public:
protected:
private:
    double real,imag;
};
Complex c1;
Complex c2(c1);

class CSample{
private:
    int x;
public:
    CSample() { cout << "111" << endl; }
    CSample(const CSample & c) {
        x = c.x; cout << "222" << endl;
    }
};

int main() {
    CSample a1;
    CSample a2 (a1);//CSample a2=a1; 结果一样
    return 0;
}

输出：

• 当用一个对象去初始化同类的一个对象

    Complex c2(c1); 
    Complex c2=c1;//初始化语句，非赋值语句

class CSample{
private:
public:
    int x;
    CSample() {
        cout << "con 1 called!" << endl;
    }
    CSample(int n) {
        this->x = n;
        cout << "con 2 called!" << endl;
    }
    CSample(const CSample &s) {
        x = s.x; cout << "con 3 called!" << endl;
    }
};

int main() {
    CSample a11; a11 = 22;
    CSample a2(a11);
    cout << a2.x << endl;
    return 0;
}

- 如果某函数的参数为同类A的对象，调用该函数，他的复制构造函数将会被调用

class CSample{
private:
    int x;
public:
    CSample() { cout << "111" << endl; }
    CSample(const CSample & c) {
        x = c.x; cout << "222" << endl;
    }
};

void fun1(CSample a){}

void fun2(CSample b) {
    cout << "333" << endl;
}

int main() {
    CSample a1;
    fun1(a1);
    cout << endl;
    fun2(a1);
    return 0;
}

• 如果函数的返回值是A的对象，返回时候，A的复制构造函数将会被调用
• 复制构造函数在什么时候被调用？

class  feng{
public:
    int v;
    feng(int c){
        v=c;
    }
    feng(const feng & c){
        v=c.v;
        cout<<"feng"<<endl;
    }
protected:
private:
};

feng func1(){
    cout << "inside" << endl;
    //是想看看执行顺序的
    feng qq(33);
    return qq;
}
int main(){
    cout <<func1().v<<endl;
    return 0;
}

首先执行func的函数，函数内打印inside，再就是返回是一个对象，此时调用复制构造函数，再次返回，最终返回了一个对象之后，开始打印本对象的数值。

类型转换构造函数

目的：实现类型的自动转换
特点：只有一个参数，不是复制构造函数

class abc{
public:
    double real,imag;
    abc(int i){
        real=i;imag=0;
        cout<<"int constructor called!"<<endl;
    }
    abc(double a,double b){
        real=a;imag=b;
    }
protected:
private:
};

int main(){
    abc c1(7,8);
    abc c2=99;//不是赋值，而是初始化
    cout <<c1.real<<","<<c1.imag<<endl;
    c1=22;//9被临时转换成一个abc对象
    cout <<c1.real<<","<<c1.imag<<endl;
    cout <<c2.real<<","<<c2.imag<<endl;
    return 0;

}

析构函数

总结：

---

-构造函数：
成员函数一种、名字与类名相同
可以有参数、但不能有返回值
可以有多个构造函数、用来初始化对象

---

-析构函数：
成员函数一种、名字与类名相同
在前面加“~”
没有参数和返回值
一个类最多一个析构函数

---

对象消亡时，自动被调用
定义类没有析构函数，编译器生成缺省析构函数
定义析构函数，编译器不生成缺省析构函数

---

• 析构函数和数组

class abc{
public:
    ~abc();
protected:
private:
};

abc::~abc(){
    cout<<"123"<<endl;
}

int main(){
    abc aa[3];
    cout<<"end"<<endl;
    return 0;
}

输出：

• 析构函数和运算符delete

delete运算会导致析构函数调用

abc *p;
p=new abc;//构造函数调用
delete abc;//析构函数调用

p=new abc[2];//构造函数调用2次
delete [] p;//析构函数调用2次

---

综合例子

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

Demo d1(1);

void func(){
    static Demo d2(2);
    Demo d3(3);
    cout<<"func end"<<endl;
}

int main(){
    Demo d4(4);
    d4=6;//将右边常量转换成临时demo 对象
    cout <<"main"<<endl;
    {
        Demo d5(5);
    }
    func();
    cout<<"main end"<<endl;
    return 0;
}