C++在构造函数中使用new时，需要注意这些事！

1. 使用new时需要注意的事项

在C++程序中，使用new关键字动态地为对象分配内存空间，往往会涉及到构造函数的调用。在构造函数中使用new时，需要注意以下几个问题：

1.1 内存泄漏的问题

如果在构造函数中使用new动态地分配内存空间，并且在析构函数中没有手动释放该内存空间，就会造成内存泄漏的问题。

class MyClass {
public:
    MyClass() {
        pData = new int[10];
    }
    ~MyClass() {
        // 必须手动释放分配的内存，否则会导致内存泄漏
        delete[] pData;
    }
private:
    int* pData;
};

在上述代码中，MyClass类的构造函数中使用new动态地分配了10个int类型的内存空间，这里必须在析构函数中手动释放该内存。

1.2 对象初始化的问题

使用new时，需要注意对象的初始化问题。如果在构造函数中使用new动态地分配内存空间，并且在该内存空间中存在成员变量，则需要手动调用该成员变量的构造函数。

class MyClass {
public:
    MyClass() {
        pData = new int[10];
        for (int i = 0; i < 10; i++)
            pData[i] = i;
    }
    ~MyClass() {
        delete[] pData;
    }
private:
    int* pData;
};
class Test {
public:
    Test() {
        pMyClass = new MyClass();
    }
    ~Test() {
        delete pMyClass;
    }
private:
    MyClass* pMyClass;
};

在上述代码中，Test类的构造函数中使用new动态地分配了一个MyClass对象，并且在该对象的构造函数中使用new动态地分配了10个int类型的内存空间，同时对内存空间进行了初始化。这里需要手动调用MyClass类的构造函数来完成对象的初始化。

1.3 拷贝构造函数的问题

在使用new动态分配内存空间时，还需要注意拷贝构造函数的问题。如果对象中存在动态分配的内存空间，并且没有手动地定义拷贝构造函数，则使用默认的浅拷贝构造函数时就会造成内存泄漏的问题。

class MyClass {
public:
    MyClass() {
        pData = new int[10];
        for (int i = 0; i < 10; i++)
            pData[i] = i;
    }
    MyClass(const MyClass& obj) {
        pData = new int[10];
        for (int i = 0; i < 10; i++)
            pData[i] = obj.pData[i];
    }
    ~MyClass() {
        delete[] pData;
    }
private:
    int* pData;
};
class Test {
public:
    Test() {
        pMyClass = new MyClass();
    }
    Test(const Test& obj) {
        pMyClass = new MyClass(*(obj.pMyClass));
    }
    ~Test() {
        delete pMyClass;
    }
private:
    MyClass* pMyClass;
};

在上述代码中，MyClass类中存在动态分配的内存空间，需要手动定义拷贝构造函数来避免浅拷贝所带来的问题，Test类中也需要定义拷贝构造函数来完成对象的拷贝。

2. 示例程序

下面是一个使用new时需要注意的示例程序。

#include <iostream>
using namespace std;
class MyClass {
public:
    MyClass() {
        pData = new int[10];
        for (int i = 0; i < 10; i++)
            pData[i] = i;
    }
    MyClass(const MyClass& obj) {
        pData = new int[10];
        for (int i = 0; i < 10; i++)
            pData[i] = obj.pData[i];
    }
    ~MyClass() {
        delete[] pData;
    }
private:
    int* pData;
};
class Test {
public:
    Test() {
        pMyClass = new MyClass();
    }
    Test(const Test& obj) {
        pMyClass = new MyClass(*(obj.pMyClass));
    }
    ~Test() {
        delete pMyClass;
    }
private:
    MyClass* pMyClass;
};
int main() {
    Test t1;
    Test t2(t1);
    return 0;
}

在上述代码中，MyClass类的构造函数中使用new动态地分配了10个int类型的内存空间，同时对内存空间进行了初始化，Test类中包含了一个MyClass类型的指针，并且在构造函数和拷贝构造函数中使用new动态地为其分配内存空间。在主函数中，先创建了t1对象，然后使用t1对象拷贝构造了t2对象。

3. 总结

在使用new时，需要注意内存泄漏、对象初始化、拷贝构造函数等问题。程序员应该养成良好的代码编写习惯，及时手动释放不再使用的内存空间，并使用合适的构造函数来保证对象的初始化和拷贝。