C++动态内存分配的核心机制与最佳实践(从对象生命周期到智能管理)

#include <iostream>
using namespace std;
class Student {
private:
    string name;  // 成员变量：需要初始化的字符串
    int age;
public:
    // 构造函数：初始化资源（必须被调用，否则name可能为乱码）
    Student(string n, int a) : name(n), age(a) {
        cout << "构造函数：" << name << "(" << age << ")" << endl;
    }
    // 析构函数：清理资源（若有动态内存，需在此释放）
    ~Student() {
        cout << "析构函数：" << name << "已销毁" << endl;
    }
};
int main() {
    // new：分配内存 + 调用构造函数（传递参数"Alice", 18）
    Student* s = new Student("Alice", 18);  // 输出：构造函数：Alice(18)
    // 使用对象（此处省略具体操作）
    return 0;
}

// 非抛出版new：失败时返回nullptr
Student* s = new (nothrow) Student("Bob", 20);  
if (s == nullptr) {  // 需手动检查
    cerr << "内存分配失败" << endl;
}

int main() {
    Student* s = new Student("Alice", 18);  // 构造函数执行
    // ... 使用对象 ...
    delete s;  // 1. 调用析构函数（输出：析构函数：Alice已销毁）；2. 释放内存
    s = nullptr;  // 置空，避免野指针
    return 0;
}

int main() {
    // new[]：分配数组内存 + 为每个元素调用构造函数
    // 注：C++11起支持初始化列表（早期标准需默认构造函数）
    Student* arr = new Student[3]{
        Student("Alice", 18),
        Student("Bob", 19),
        Student("Charlie", 20)
    };  // 输出3行构造函数信息
    // ... 使用数组 ...
    // delete[]：为每个元素调用析构函数 + 释放数组内存
    delete[] arr;  // 输出3行析构函数信息（与构造顺序相反）
    arr = nullptr;
    return 0;
}

// 错误示例：new[] 与 delete 混用
delete arr;  // 仅第一个元素析构，后两个元素资源泄漏，堆结构被破坏

#include <memory>  // 必须包含智能指针头文件
int main() {
    // 方式1：通过构造函数传入new的对象（C++11）
    unique_ptr<Student> uptr1(new Student("Alice", 18));  
    // 方式2：通过make_unique创建（C++14推荐，更安全，避免内存泄漏风险）
    auto uptr2 = make_unique<Student>("Bob", 19);  // 自动推导类型
    // 访问对象：用->或*（与裸指针一致）
    // uptr1->getName();  // 假设Student有getName方法
    // 所有权转移（只能移动，不能复制）
    unique_ptr<Student> uptr3 = move(uptr2);  // uptr2失去所有权，变为nullptr
    // uptr1、uptr3出作用域时，自动调用delete，释放对象（无需手动操作）
    return 0;
}

int main() {
    // 方式1：构造函数传入new的对象
    shared_ptr<Student> sptr1(new Student("Alice", 18));  
    // 方式2：make_shared创建（推荐，更高效）
    auto sptr2 = make_shared<Student>("Bob", 19);  
    // 复制：引用计数+1
    shared_ptr<Student> sptr3 = sptr2;  // sptr2和sptr3共享对象，引用计数=2
    // 访问对象：与裸指针一致
    // cout << sptr3->age << endl;
    // sptr1销毁时，引用计数=0，释放Alice；
    // sptr2和sptr3都销毁时，引用计数=0，释放Bob（自动执行）
    return 0;
}

class A;
class B {
public:
    shared_ptr<A> a_ptr;  // B持有A的shared_ptr
};
class A {
public:
    shared_ptr<B> b_ptr;  // A持有B的shared_ptr
};
int main() {
    auto a = make_shared<A>();
    auto b = make_shared<B>();
    a->b_ptr = b;  // 互相引用
    b->a_ptr = a;  
    // 退出时，a和b的引用计数仍为1（互相持有），内存泄漏！
    return 0;
}

class A;
class B {
public:
    weak_ptr<A> a_ptr;  // 弱引用，不增加计数
};
class A {
public:
    weak_ptr<B> b_ptr;  // 弱引用，不增加计数
};
// 循环被打破，引用计数可正常归零，内存释放

class Student {
public:
    // 类级重载operator new：仅用于Student对象的分配
    void* operator new(size_t size) {
        cout << "自定义分配" << size << "字节" << endl;
        return malloc(size);  // 内部可调用malloc或自定义内存池
    }
    // 类级重载operator delete：对应释放
    void operator delete(void* ptr) {
        cout << "自定义释放内存" << endl;
        free(ptr);
    }
};

#include <new>  // placement new需包含此头文件
int main() {
    // 1. 先分配原始内存（如通过malloc）
    void* raw_mem = malloc(sizeof(Student));  
    // 2. placement new：在原始内存上构造对象
    Student* s = new(raw_mem) Student("Alice", 18);  // 仅调用构造函数
    // 3. 使用对象...
    // 4. 手动调用析构函数（placement new无对应的delete）
    s->~Student();  
    // 5. 释放原始内存
    free(raw_mem);
    return 0;
}