构造/析构函数

注意

1.构造/析构函数名要跟类同名

2.构造函数无返回值，也不能写成void

3.构造函数常常设置为公有成员（public），保证外部也可以使用

4.构造函数可以没有参数，可重载

5.在调用对象时候会自动调用构造函数，无需手动修改，只会调用一次

6.如果不写构造函数，系统会默认提供一个无参数构造函数

7.如果写了构造函数，且类中无无无参构造函数，则在需要实例化这个对象的时候，需要进行有参数实例化

8.无参数或有参数构造函数都别写在私有或者保护成员写下，否则可能在类外无法调用

初始化

1.成员变量与构造函数实参从重名

2.成员变量中const

3.成员变量中有&

4.有成员子类并且需要调用成员子类的有参构造函数

#include <iostream>
#include <string>
using namespace std;
/******************构造_析构***************/
class MyClass
{
public:
    // 默认构造函数
    MyClass()
    {
        cout << "无参构造函数" << endl;
        cout << "默认构造函数" << endl;
    }
    MyClass(int a)
    {
        cout << "有参构造函数" << endl;
        cout << "自定义构造函数" << endl;
        cout << "参数为 = " << a << endl;
    }
    ~MyClass()
    {
        cout << "析构函数" << endl;
    }

private:
};
/******************构造_析构_调用***************/
class Myclass1
{
private:
    int a;

public:
    Myclass1()
    {
        a = 10;
        cout << "参数为 = " << a;
        cout << "我是无参构造函数" << endl;
    }
    Myclass1(int a_1)
    {
        a = a_1;
        cout << "参数为 = " << a;
        cout << "我是有参构造函数" << endl;
    }
    ~Myclass1()
    {
        cout << "我是析构函数" << endl;
    }
};
/******************构造_析构_初始化***************/
class Myclass2
{
private:
    int a;

public:
    Myclass2() : a(10)
    {
        cout << "参数为 = " << a;
        cout << "我是无参构造函数" << endl;
    }
    Myclass2(int a_1) : a(a_1)
    {
        cout << "参数为 = " << a;
        cout << "我是有参构造函数" << endl;
    }
    ~Myclass2()
    {
        cout << "我是析构函数" << endl;
    }
};
/******************构造_析构_初始化_调用***************/
class Myclass3
{
private:
    int a;

public:
    void print()
    {
        cout << "参数为 = " << a;
        cout << "我是print函数" << endl;
    }
    Myclass3() : a(10)
    {
        cout << "参数为 = " << a;
        cout << "我是无参构造函数" << endl;
    }
    Myclass3(int a_1) : a(a_1)
    {
        cout << "参数为 = " << a;
        cout << "我是有参构造函数" << endl;
    }
    ~Myclass3()
    {
        cout << "我是析构函数" << endl;
    }
    /******************构造_析构_浅拷贝**************/
    Myclass3(const Myclass3 &obj)
    {
        a = obj.a;
        cout << "浅拷贝" << endl;
    }
    Myclass3 &operator=(const Myclass3 &obj)
    {
        a = obj.a;
        cout << "浅拷贝" << endl;
        return *this;
    }
    /******************构造_析构_深拷贝**************/
    Myclass3(Myclass3 &obj, int b)
    {
        a = obj.a;
        cout << "深拷贝" << endl;
    }
    Myclass3 &operator=(Myclass3 &obj)
    {
        a = obj.a;
        cout << "深拷贝" << endl;
        return *this;
    }
};

int main()
{
    /******************构造_析构***************/
    cout << endl;
    cout << "构造_析构" << endl;
    MyClass A;
    A.~MyClass();
    cout << endl;
    /******************构造_析构_调用***************/
    cout << endl;
    cout << "构造_析构_调用" << endl;
    Myclass1 *p1 = new Myclass1;
    Myclass1 *p2 = new Myclass1;
    Myclass1 *p3 = new Myclass1;
    Myclass1 *p4 = new Myclass1;
    delete p1;
    delete p2;
    delete p3;
    delete p4;
    /******************构造_析构_初始化***************/
    cout << endl;
    cout << "构造_析构_初始化" << endl;
    Myclass2 B;
    Myclass2 C(20);
    cout << endl;
    /******************构造_析构_初始化_调用***************/
    cout << endl;
    cout << "构造_析构_初始化_调用" << endl;
    Myclass3 D;
    D.print();
    Myclass3 E(30);
    E.print();
    /******************构造_析构_浅拷贝**************/
    cout << endl;
    cout << "构造_析构_浅拷贝" << endl;
    Myclass3 F(D);
    F.print();
    Myclass3 G;
    G = F;
    G.print();
    /******************构造_析构_深拷贝**************/
    cout << endl;
    cout << "构造_析构_深拷贝" << endl;
    Myclass3 H(E, 40);
    H.print();
    Myclass3 I(H, 50);
    I.print();
    return 0;
}