动态内存管理¶

void function() {
    int x = 10;        // 栈上分配
    double arr[100];   // 栈上分配
    // x 和 arr 在函数返回时自动释放
}

int n;
cout << "请输入学生人数: ";
cin >> n;
// int scores[n];   // 错误！C++中数组大小必须是编译时常量

// 需要在函数返回后对象仍然存在
Point* createPoint() {
    Point p(3, 4);   // 局部对象，函数返回后被销毁
    return &p;       // 危险！返回的是已销毁对象的地址
}

#include <iostream>
using namespace std;

int main() {
    // 1. 分配单个 int
    int* p1 = new int;          // 分配未初始化的 int
    int* p2 = new int(10);      // 分配并初始化为 10
    int* p3 = new int();        // 分配并初始化为 0

    cout << "*p1 = " << *p1 << endl;   // 未初始化，值不确定
    cout << "*p2 = " << *p2 << endl;   // 10
    cout << "*p3 = " << *p3 << endl;   // 0

    // 释放单个对象
    delete p1;
    delete p2;
    delete p3;

    // 2. 分配数组
    int* arr = new int[5];      // 分配 5 个 int（未初始化）
    int* arr2 = new int[5]();   // 分配 5 个 int（全部初始化为 0）

    for (int i = 0; i < 5; i++) {
        arr[i] = i * 10;
    }

    // 释放数组（注意 delete[]）
    delete[] arr;
    delete[] arr2;

    return 0;
}

#include <iostream>
using namespace std;

class Point {
public:
    Point(int x = 0, int y = 0) : x(x), y(y) {
        cout << "Constructor called: Point(" << x << ", " << y << ")" << endl;
    }

    ~Point() {
        cout << "Destructor called" << endl;
    }

    void show() const {
        cout << "Point(" << x << ", " << y << ")" << endl;
    }

private:
    int x, y;
};

int main() {
    cout << "--- 动态创建单个对象 ---" << endl;
    Point* p1 = new Point(3, 4);    // 分配内存 + 调用构造函数
    p1->show();
    delete p1;                       // 调用析构函数 + 释放内存

    cout << "--- 动态创建对象数组 ---" << endl;
    Point* arr = new Point[3];       // 每个元素调用默认构造函数
    arr[0].show();
    arr[1].show();
    arr[2].show();
    delete[] arr;                    // 每个元素调用析构函数

    return 0;
}

#include <iostream>
#include <cstdlib>
using namespace std;

class Student {
private:
    string name;
    int age;
public:
    Student(const string& n, int a) : name(n), age(a) {
        cout << "Student constructed: " << name << endl;
    }
    ~Student() {
        cout << "Student destroyed: " << name << endl;
    }
};

int main() {
    // C风格：不会调用构造/析构
    cout << "=== C style (malloc/free) ===" << endl;
    Student* s1 = (Student*)malloc(sizeof(Student));
    // 内存未初始化，不能使用
    free(s1);   // 不会调用析构函数

    // C++风格：调用构造/析构
    cout << "\n=== C++ style (new/delete) ===" << endl;
    Student* s2 = new Student("Alice", 20);
    delete s2;   // 调用析构函数

    // 数组分配对比
    cout << "\n=== Array allocation ===" << endl;
    // C风格：分配并释放
    int* arr1 = (int*)malloc(sizeof(int) * 10);
    free(arr1);

    // C++风格
    int* arr2 = new int[10];
    delete[] arr2;

    return 0;
}

#include <iostream>
#include <new>
using namespace std;

int main() {
    try {
        // 尝试分配大量内存
        int* p = new int[1000000000];
        // 使用 p...
        delete[] p;
    } catch (const bad_alloc& e) {
        cout << "Memory allocation failed: " << e.what() << endl;
    }

    return 0;
}

#include <iostream>
#include <new>
using namespace std;

int main() {
    // nothrow 版本：失败返回 nullptr
    int* p = new (nothrow) int[1000000000];

    if (p == nullptr) {
        cout << "Memory allocation failed" << endl;
    } else {
        delete[] p;
    }

    return 0;
}

#include <iostream>
using namespace std;

class Point {
public:
    Point() : x(0), y(0) {
        cout << "Default Constructor called." << endl;
    }
    Point(int x, int y) : x(x), y(y) {
        cout << "Constructor called: Point(" << x << ", " << y << ")" << endl;
    }
    ~Point() {
        cout << "Destructor called." << endl;
    }

    void move(int dx, int dy) {
        x += dx;
        y += dy;
    }

    void show() const {
        cout << "Point(" << x << ", " << y << ")" << endl;
    }

private:
    int x, y;
};

int main() {
    int count;
    cout << "Please enter the count of points: ";
    cin >> count;

    // 动态创建对象数组
    Point* points = new Point[count];

    // 通过指针访问数组元素
    for (int i = 0; i < count; i++) {
        points[i].move(i * 5, i * 10);
    }

    for (int i = 0; i < count; i++) {
        cout << "Point " << i << ": ";
        points[i].show();
    }

    // 释放对象数组
    delete[] points;

    return 0;
}

#include <iostream>
using namespace std;

int main() {
    int rows, cols;
    cout << "Enter rows and cols: ";
    cin >> rows >> cols;

    // 方法一：使用 new 创建二维数组（只有第一维可以是变量）
    int (*matrix)[4] = new int[rows][4];   // 第二维必须是常量

    // 方法二：使用指针数组（两维都可以是变量）
    int** matrix2 = new int*[rows];
    for (int i = 0; i < rows; i++) {
        matrix2[i] = new int[cols];
    }

    // 使用矩阵
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            matrix2[i][j] = i * cols + j;
        }
    }

    // 释放矩阵（二维释放需要循环）
    for (int i = 0; i < rows; i++) {
        delete[] matrix2[i];
    }
    delete[] matrix2;

    delete[] matrix;

    return 0;
}

#include <iostream>
#include <memory>   // 智能指针头文件
using namespace std;

class Point {
public:
    Point(int x = 0, int y = 0) : x(x), y(y) {
        cout << "Point constructed" << endl;
    }
    ~Point() {
        cout << "Point destroyed" << endl;
    }
    void show() const {
        cout << "Point(" << x << ", " << y << ")" << endl;
    }
    void move(int dx, int dy) {
        x += dx;
        y += dy;
    }
private:
    int x, y;
};

int main() {
    // 创建 unique_ptr
    unique_ptr<Point> p1(new Point(3, 4));
    p1->show();

    // 也可以使用 make_unique（C++14）
    auto p2 = make_unique<Point>(5, 6);
    p2->show();

    // p1 不能复制，但可以转移所有权
    // unique_ptr<Point> p3 = p1;   // 错误！不能复制

    unique_ptr<Point> p3 = move(p1);   // 所有权转移
    if (p1 == nullptr) {
        cout << "p1 is now empty" << endl;
    }
    p3->show();

    // 离开作用域时自动释放
    return 0;
}

#include <iostream>
#include <memory>
using namespace std;

class Point {
public:
    Point(int x = 0, int y = 0) : x(x), y(y) {
        cout << "Point constructed" << endl;
    }
    ~Point() {
        cout << "Point destroyed" << endl;
    }
    void show() const {
        cout << "Point(" << x << ", " << y << ")" << endl;
    }
private:
    int x, y;
};

int main() {
    // 创建 shared_ptr
    shared_ptr<Point> sp1 = make_shared<Point>(3, 4);
    cout << "Reference count: " << sp1.use_count() << endl;   // 1

    {
        shared_ptr<Point> sp2 = sp1;   // 共享所有权，引用计数增加
        cout << "Reference count: " << sp1.use_count() << endl;   // 2
        sp2->show();
    }   // sp2 离开作用域，引用计数减少

    cout << "Reference count: " << sp1.use_count() << endl;   // 1

    // sp1 离开作用域，引用计数变为 0，对象被销毁
    return 0;
}

#include <iostream>
#include <memory>
using namespace std;

int main() {
    shared_ptr<int> sp = make_shared<int>(10);
    weak_ptr<int> wp = sp;   // 弱引用，不增加引用计数

    cout << "Reference count: " << sp.use_count() << endl;   // 1

    // 使用 weak_ptr 前需要 lock() 获取 shared_ptr
    if (auto temp = wp.lock()) {
        cout << "Value: " << *temp << endl;   // 10
    }

    sp.reset();   // 释放 shared_ptr

    if (wp.expired()) {
        cout << "Weak pointer expired" << endl;   // 对象已被释放
    }

    return 0;
}

#include <iostream>
#include <string>
using namespace std;

class Person {
private:
    string name;
    int age;
public:
    Person(const string& n = "", int a = 0) : name(n), age(a) {
        cout << "Person constructed: " << name << endl;
    }
    ~Person() {
        cout << "Person destroyed: " << name << endl;
    }

    void introduce() const {
        cout << "I'm " << name << ", " << age << " years old." << endl;
    }
};

int main() {
    cout << "=== 1. 单个对象的分配和释放 ===" << endl;
    Person* p1 = new Person("Alice", 25);
    p1->introduce();
    delete p1;
    p1 = nullptr;

    cout << "\n=== 2. 对象数组的分配和释放 ===" << endl;
    Person* arr = new Person[3] {
        Person("Bob", 20),
        Person("Charlie", 22),
        Person("David", 24)
    };

    for (int i = 0; i < 3; i++) {
        arr[i].introduce();
    }
    delete[] arr;

    cout << "\n=== 3. 基本类型的分配 ===" << endl;
    // 基本类型初始化
    int* n1 = new int;        // 未初始化
    int* n2 = new int(100);   // 初始化为 100
    int* n3 = new int();      // 初始化为 0

    cout << "*n1 = " << *n1 << " (未初始化)" << endl;
    cout << "*n2 = " << *n2 << endl;
    cout << "*n3 = " << *n3 << endl;

    delete n1;
    delete n2;
    delete n3;

    cout << "\n=== 4. 内存分配失败处理 ===" << endl;
    try {
        // 尝试分配大量内存
        int* huge = new int[1000000000];
        cout << "Memory allocated successfully" << endl;
        delete[] huge;
    } catch (const bad_alloc& e) {
        cout << "Allocation failed: " << e.what() << endl;
    }

    cout << "\n=== 5. 容器自动管理内存（推荐） ===" << endl;
    // 使用 vector 自动管理内存，无需手动 delete
    vector<Person> people;
    people.push_back(Person("Eve", 30));
    people.push_back(Person("Frank", 28));
    for (const auto& p : people) {
        p.introduce();
    }
    // vector 在析构时自动释放内存

    return 0;
}