类和对象：构造函数与析构函数

构造函数详解

1. 什么是构造函数？

• 构造函数名和类名一致，没有返回值
• 在创建对象时自动执行，是一种特殊的成员函数

2. 构造函数的不同形式

（1） 默认构造函数 ：

• 由系统提供
• 不要用（）法调用默认构造函数，因为编辑器会将其当作函数函数声明对待，并不会将其当作实例化对象

（2）有参构造函数

（3）拷贝构造函数：

• 不能以值传递的形式进行（值传递的本质就是在调用拷贝构造函数这样会进入无限的递归），所以需要加 &
• 为防止copy对象被修改，需要加const

#include <iostream>

using namespace std;

class Person
{
private:

public:
    int m_age;

    //默认构造函数
    Person()
    {
        cout << "im default constructor " << endl;
    }

    //有参构造函数
    Person(int a)
    {
        m_age = a;
        cout << "im argument constructor" << endl;
    }

    //拷贝构造函数
    Person(const Person &p)
    {
        m_age = p.m_age;
        cout << "im copy constructor" << endl;
    }

    ~Person()
    {
        cout << "im destructor" << endl;
    }
    
    void show()
    {
        cout << m_age << endl;
    }
};




int main()
{
    Person p1;
    p1.m_age = 10;
    p1.show();

    Person p2(222);
    p2.show();

    Person p3(p2);
    p3.show();


    system("pause");
    return 0;
}

3. 初始化列表

Person(int a) : m_age(a){};

深浅拷贝问题

• 浅拷贝是简单的赋值操作，运行在栈上
• 深拷贝是在堆区重新申请空间，进行拷贝操作

#include <iostream>

using namespace std;

class TestCopy
{
private:
    
    
public:
    int x;
    TestCopy(int n)
    {
        this->x = n;
    }

    void show()
    {
        cout << x << endl;
    }
};



int main()
{
    //浅拷贝
    // TestCopy * p = new TestCopy(22);
    // TestCopy * p1 = p;     //浅拷贝直接将p1的指针指向p的地址，并没有重新为p1开辟一块新的内存，容易造成重复释放同一块内存的问题
    // p->x = 19;
    
    // p->show() ;
    // p1->show() ;
    
    // delete p;
    // delete p1;

    TestCopy * p = new TestCopy(33);
    TestCopy * p1 = p;
    p->x = 55;
    p->show();
    p1->show();

    //深拷贝              开辟了一块新的内存
    // TestCopy c(22);
    // TestCopy d = c; 
    // c.x = 334;
    // c.show();
    // d.show();


    

    return 0;
}


// #include <iostream>

// using namespace std;

// class TestCopy
// {
// private:
     
// public:
//     int *x;
//     TestCopy(int n)
//     {
//         x = new int(n);
//     }
//     TestCopy(const TestCopy &p)
//     {
//         x = new int (*p.x);          //在堆区开辟新的内存
//     }

//     ~TestCopy()
//     {
//         if(x != NULL)
//         {
//             delete(x);
//             x = NULL;
//         }
//     }

//     void show()
//     {
//         cout << *x << endl;
//     }
// };



// int main()
// {
    


//     //深拷贝              开辟了一块新的内存
//     TestCopy c(22);
//     TestCopy d = c; 
//     *(c.x) = 334;
//     c.show();
//     d.show();

//     return 0;
// }

析构函数详解

1. 是一种特殊的成员函数，没有返回值
2. 在销毁对象时自动执行，一般new的对象在析构函数里面销毁（delete）
3. 没有参数，不能被重载，一个类只有一个析构函数

~Person()
{
      cout << "im destructor" << endl;
}