c++中new操作符的具体使用

// 1. 分配一个 int，未初始化（值可能是随机的）
int* p1 = new int; 

// 2. 分配一个 int，并初始化为 10
int* p2 = new int(10); 

// 3. 分配一个类对象，自动调用构造函数
MyClass* obj = new MyClass(); 

// 使用完毕后，必须使用 delete 释放
delete p1;
delete p2;
delete obj;

/*使用new从堆中分配一个int大小内存，不同于malloc，new会返回一个具体类型的指针，而不是void* */
int* fun1()
{
    /*这里返回的虽然是一个局部变量指针，但因为是从堆中分配，退出函数后这块内存不会被销毁*/
    return new int;
}

/*使用new操作符分配一个int类型内存,并初始化为10 */
int* fun2()
{
    /*分配一个int类型内存，赋值为10*/
    return new int(10);
}

/*使用new分配一个类对象内存，在分配内存时会调用这个类的构造函数初始化这块内存*/
// my_class* fun3()
// {
//     return new my_clash();
// }

/*使用new分配一个数组*/
int* fun4()
{
    return new int[10];
}


int main()
{
    int *p1 = fun1();
    *p1 = 20;
    cout << "p1指向的值为:" << *p1 << endl;
    delete p1;

    int *p2 = fun2();
    cout << "p2指向的值为:" << *p2 << endl;
    delete p2;

    // my_clash *p3 = fun3();
    // delete p3;

    int *p4 = fun4();
    cout << "p4指向的数组为:";
    for (int i = 0; i < 10;i++)
    {
        p4[i] = i;
        cout << p4[i] << " ";
    }
    cout << endl;
    system("pause");
    return 0;
}

// 分配一个包含 10 个整数的数组
int* arr = new int[10];

// 访问数组元素
arr[0] = 5;

// 注意：释放数组时必须使用 delete[] (带方括号)
delete[] arr; 

try {
    int* bigArray = new int[1000000000000]; // 试图分配巨大的内存
} catch (const std::bad_alloc& e) {
    std::cout << "内存分配失败: " << e.what() << std::endl;
}

#include <new> // 必须包含

int* p = new(std::nothrow) int[1000000000000];
if (p == nullptr) {
    std::cout << "内存分配失败，指针为空" << std::endl;
} else {
    delete[] p;
}

#include <new>

char buffer[sizeof(MyClass)]; // 预先分配的栈内存或堆内存

// 在 buffer 的地址上调用 MyClass 的构造函数
MyClass* p = new (buffer) MyClass(123); 

// 注意：对于 Placement New，不能使用 delete p
// 必须显式调用析构函数
p->~MyClass();

// 如果 buffer 是堆内存，最后释放 buffer
// delete[] buffer; 

void badFunction() {
    int* ptr = new int(5);
    // ... 做一些操作
    // 函数结束，ptr 变量销毁了，但它指向的堆内存没有释放！
    // 这就是内存泄漏。
}

#include <memory>

// C++14 推荐写法：使用 make_unique
auto ptr = std::make_unique<MyClass>(10); 

// 不需要调用 delete，由 ptr 的析构函数自动处理
ptr->doSomething();

#include <memory>

auto ptr1 = std::make_shared<MyClass>(20);
auto ptr2 = ptr1; // 引用计数 +1

// 当 ptr1 和 ptr2 都销毁时，内存才会被释放