（二十一）构造与析构

构造函数

• 函数名与类名相同，没有返回值。相当于将对象初始化

class Circle
{
public:
    Circle()
    {
        x = y = 0;
        radius = 1;
    }
public:
    int x,y;
    int radius;
};

构造函数可以重载，只要参数列表不同就行

class Circle
{
public:
    Circle()
    {
        x = y = 0;
        radius = 1;
    }
    Circle(int x,int y,int r)
    {
        this->x = x;
        this->y = y;
        this->radius = r;
    }
public:
    int x,y;
    int radius;
};

int main()
{
    Circle a;
    Circle b(1,1,4);
    return 0;
}

int a(10);//就是int a = 10；

构造函数保证了对象一被创建就是被初始化的，可以避免忘记初始化产生错误

析构函数

析构是构造的反过程，表示对象的销毁过程。析构函数只能有一个，不允许重载

class Object
{
public:
    ~Object()
    {
        printf("...销毁...\n")
    }
}

自动生成的构造/析构函数

如果程序没有构造函数/析构函数，那么编译器会隐含地添加一个，相当于写了一个空的构造/析构函数

class Object
{
public:
    Object()
    {
    }
    ~Object()
    {
    }
}

构造函数的初始化列表

class Circle
{
public:
    Circle():x(0),y(0),radius(1)
    { 
        //x = y = 0; radius = 1; 
    }
private:
    int x,y;
    int radius;
};

必须使用初始化列表的情况：当成员为引用类型

#include<stdio.h>
class Object
{
public:
    Object(int& a):ref(a)
    {
    }
private:
    int& ref;
}
int main()
{
    int value = 1;
    Object obj(value);
    return 0;
}

构造和析构的顺序

#include<stdio.h>

class ChildA
{
public:
    ChildA()
    {
        printf("创建A...\n");
    }
    ~ChildA()
    {
        printf("销毁A...\n");
    }
};

class ChildB
{
public:
    ChildB()
    {
        printf("创建B...\n");
    }
    ~ChildB()
    {
        printf("销毁B...\n");
    }
};

class Object
{
public:
    Object()
    {
        printf("创建Object...\n");
    }
    ~Object()
    {
        printf("销毁Object...\n");
    }
private:
    ChildA a;
    ChildB b;
};

int main()
{
    Object obj;
    return 0;
}

上述运行结果为

//只有A和B创建之后，Object才能创建
创建A...
创建B...
创建Object...
销毁Object...
销毁B...
销毁A...