1
// new/delete用法
2
int* p1 = new int;            // 分配单个int
3
delete p1;                   // 释放单个int
4
// malloc/free用法
5
int* p2 = (int*)malloc(sizeof(int));  // 需要显式指定大小和类型转换
6
free(p2);                           // 释放内存

1
// new[]/delete[]用法
2
int* arr1 = new int[10];      // 分配包含10个int的数组
3
delete[] arr1;                 // 释放数组内存
4

5
// malloc/free数组用法
6
int* arr2 = (int*)malloc(10 * sizeof(int));  // 需要手动计算数组大小
7
free(arr2);                                 // 释放数组内存

1
// new支持直接初始化
2
int* p1 = new int(10);            // 分配并初始化为10
3
int* arr1 = new int[3]{1, 2, 3};  // 分配数组并初始化（C++11及以上）
4

5
// malloc需要手动初始化
6
int* p2 = (int*)malloc(sizeof(int));
7
*p2 = 10;  // 手动初始化

1
#include <iostream>
2
#include <cstdlib>  // 包含malloc/free
3
#include <new>      // 包含bad_alloc异常
4

5
class MyClass {
6
public:
7
    MyClass() {
8
        std::cout << "MyClass构造函数被调用" << std::endl;
9
    }
10

11
    ~MyClass() {
12
        std::cout << "MyClass析构函数被调用" << std::endl;
13
    }
14

15
    void setValue(int v) {
16
        value = v;
17
    }
18

19
    int getValue() const {
20
        return value;
21
    }
22

23
private:
24
    int value;
25
};
26

27
int main() {
28
    std::cout << "=== 使用new/delete ===" << std::endl;
29
    try {
30
        // 使用new分配并构造对象
31
        MyClass* obj1 = new MyClass();
32
        obj1->setValue(42);
33
        std::cout << "obj1的值: " << obj1->getValue() << std::endl;
34

35
        // 使用delete销毁并释放对象
36
        delete obj1;
37
    } catch (const std::bad_alloc& e) {
38
        std::cerr << "new分配失败: " << e.what() << std::endl;
39
    }
40

41
    std::cout << "\n=== 使用malloc/free ===" << std::endl;
42
    // 使用malloc分配内存
43
    MyClass* obj2 = (MyClass*)malloc(sizeof(MyClass));
44
    if (obj2 == NULL) {
45
        std::cerr << "malloc分配失败" << std::endl;
46
        return 1;
47
    }
48

49
    // 手动调用构造函数
50
    new (obj2) MyClass();  // placement new，仅调用构造函数
51
    obj2->setValue(99);
52
    std::cout << "obj2的值: " << obj2->getValue() << std::endl;
53

54
    // 手动调用析构函数
55
    obj2->~MyClass();
56

57
    // 使用free释放内存
58
    free(obj2);
59

60
    return 0;
61
}

1
#include <iostream>
2
#include <cstdlib>
3

4
int main() {
5
    const int SIZE = 5;
6

7
    std::cout << "=== 使用new[]/delete[]创建数组 ===" << std::endl;
8
    int* arr1 = new int[SIZE]{1, 2, 3, 4, 5};  // C++11及以上支持初始化列表
9
    for (int i = 0; i < SIZE; i++) {
10
        std::cout << "arr1[" << i << "] = " << arr1[i] << std::endl;
11
    }
12
    delete[] arr1;
13

14
    std::cout << "\n=== 使用malloc/free创建数组 ===" << std::endl;
15
    int* arr2 = (int*)malloc(SIZE * sizeof(int));
16
    if (arr2 == NULL) {
17
        std::cerr << "malloc分配失败" << std::endl;
18
        return 1;
19
    }
20

21
    // 手动初始化数组
22
    for (int i = 0; i < SIZE; i++) {
23
        arr2[i] = i * 10;
24
        std::cout << "arr2[" << i << "] = " << arr2[i] << std::endl;
25
    }
26

27
    free(arr2);
28

29
    return 0;
30
}

1
#include <iostream>
2
#include <new>
3
#include <cstdlib>
4

5
int main() {
6
    std::cout << "=== new的异常处理 ===" << std::endl;
7
    try {
8
        // 尝试分配大量内存，可能抛出异常
9
        int* largeArray = new int[1000000000];  // 10亿个int，约4GB
10
        delete[] largeArray;
11
        std::cout << "new分配成功" << std::endl;
12
    } catch (const std::bad_alloc& e) {
13
        std::cerr << "new分配失败: " << e.what() << std::endl;
14
    }
15

16
    std::cout << "\n=== malloc的错误处理 ===" << std::endl;
17
    // 尝试分配大量内存
18
    int* largeArray = (int*)malloc(1000000000 * sizeof(int));  // 约4GB
19
    if (largeArray == NULL) {
20
        std::cerr << "malloc分配失败" << std::endl;
21
    } else {
22
        std::cout << "malloc分配成功" << std::endl;
23
        free(largeArray);
24
    }
25

26
    return 0;
27
}