类的构造和析构函数

构造和析构语法

构造函数语法：
构造函数函数名和类名相同，没有返回类型，连void都不可以，但可以有参数，可以重载
析构函数语法：
析构函数函数名是在类名前面加”~”组成,没有返回类型，连void都不可以,不能有参数，不能重载

class Data
{
public:
    int num;
public:
    //构造函数(无参的构造)
    Data()
    {
        num = 0;
        cout<<"无参的构造函数"<<endl;
    }
    //构造函数（有参的构造）
    Data(int n)
    {
        num = n;
        cout<<"有参的构造函数"<<endl;
    }

    //析构函数
    ~Data()
    {
        cout<<"析构函数"<<endl;
    }

};
void test01()
{
    //类实例化对象 系统自定调用构造函数
    Data ob;
    
    //函数结束的时候 局部对象ob 被释放 系统自动调用析构函数
}
int main(int argc, char *argv[])
{
    cout<<"-----001-----"<<endl;
    test01();
    cout<<"------002-------"<<endl;
    return 0;
}

构造函数分类

1、构造函数分类：
按参数类型：分为无参构造函数和有参构造函数
按类型分类：普通构造函数和拷贝构造函数(复制构造函数)
2、构造函数的调用

class Data
{
public:
    int num;
public:
    //构造函数(无参的构造)
    Data()
    {
        num = 0;
        cout<<"无参的构造函数 num = "<<num<<endl;
    }
    //构造函数（有参的构造）
    Data(int n)
    {
        num = n;
        cout<<"有参的构造函数 num = "<<num<<endl;
    }

    //析构函数（没有返回值类型 没有参数 不能重载）
    ~Data()
    {
        cout<<"析构函数 num = "<<num<<endl;
    }

};
void test02()
{
    //调用无参 或 默认构造 (隐式调用)
    Data ob1;
    //调用无参构造 （显示调用）
    Data ob2 = Data();

    //调用有参构造（隐式调用）
    Data ob3(10);
    //调用有参构造（显示调用）
    Data ob4 = Data(20);

    //隐式转换的方式 调用有参构造（针对于 只有一个数据成员）（尽量别用)
    Data ob5 = 30;//转化成Data ob5(30)

    //匿名对象(当前语句结束 匿名对象立即释放)
    Data(40);
    cout<<"------"<<endl;
    
    //千万不要 用一下方式调用 无参构造
    
}

## 拷贝构造函数

```cpp
//拷贝构造函数
Data(const Data &ob)//const Data &ob = ob1
{
    //拷贝构造函数 是ob2调用 num就是ob2的num
    //ob2.num = ob1.num
    num = ob.num;
    cout<<"拷贝构造"<<endl;
}

void test03()
{
    Data ob1(10);
    cout<<"ob1.num = "<<ob1.num<<endl;

    //调用拷贝构造函数（如果用户  不实现拷贝构造 系统将调用默认的拷贝构造）
    //默认的拷贝构造:单纯的整体赋值（浅拷贝）
    //如果用户实现了 拷贝构造 系统将调用用户实现的拷贝构造

    Data ob2(ob1);//隐式调用拷贝构造函数
    cout<<"ob2.num = "<<ob2.num<<endl;

    Data ob3 = Data(ob1);//显示调用拷贝构造函数
    cout<<"ob3.num = "<<ob3.num<<endl;

    Data ob4 = ob1;//=隐式转换调用
    cout<<"ob4.num = "<<ob4.num<<endl;
}

记住一句话：旧对象 初始化 新对象 才会调用拷贝构造函数。
Data ob1(10);

Data ob2(ob1);//拷贝构造
Data ob3 = Data(ob1);//拷贝构造
Data ob4 = ob1;//拷贝构造函数
注意：下方的就不会调用拷贝构造
Data ob1(10);
Data ob2;
ob2 = ob1;//不会调用拷贝构造 单纯对象 赋值操作
案例：
void test04()
{
Data ob1(10);//调用有参构造
Data ob2;//调用无参构造

ob2 = ob1;//对象的赋值

cout<<"ob1.num = "<<ob1.num<<endl;
cout<<"ob2.num = "<<ob2.num<<endl;

}

构造函数规则

系统会对任何一个类提供3个函数成员函数：
默认构造函数（空） 默认析构函数（空） 默认拷贝构造函数（浅拷贝）
1、如果用户提供了有参构造 将屏蔽 系统的默认构造函数。
Data ob1;//err
2、如果用户提供了有参构造 不会屏蔽 系统的默认拷贝构造函数。
Data ob1(10);
Data ob2 = ob1;
ob2.num == 10
3、如果用户提供了拷贝构造函数 将屏蔽 系统的默认构造函数、默认拷贝构造函数。
Data ob1;//err

总结：
对于构造函数：用户一般要实现：无参构造、有参构造、拷贝构造、析构。