C++ 内存管理进阶：从裸指针到智能指针实战

1.3 野指针

指向已释放或非法地址的指针访问会导致崩溃。

// 反面示例：裸指针导致的野指针问题
int* func() {
    int x = 10;
    return &x; // 返回栈内存地址，形成野指针
}

int main() {
    int* p = func();
    cout << *p << endl; // 访问野指针，行为未定义
    return 0;
}

1.4 异常安全

异常发生时，正常流程中断，可能导致裸指针未被释放。

// 反面示例：异常导致的内存泄漏
void func() {
    int* p = new int(30);
    try {
        throw runtime_error("something wrong");
    } catch (...) {
        throw; // 重新抛出异常
    }
    delete p; // 永远不会执行
}

1.5 智能指针的核心使命

智能指针将指针生命周期与对象生命周期绑定，通过 RAII 机制实现自动释放。它封装了裸指针，在析构时自动调用 delete，从根本上避免了上述问题。

二、智能指针的核心组件

C++11 标准库提供了三种核心智能指针：unique_ptr、shared_ptr 和 weak_ptr。

2.1 unique_ptr：独占所有权的'独行侠'

unique_ptr 是最简单高效的智能指针，核心是独占所有权。同一时间只能有一个 unique_ptr 指向一块内存，销毁时自动释放。

2.1.1 核心原理

底层封装裸指针，禁用拷贝构造和赋值，支持移动语义，析构时调用 delete。

// 简化版 unique_ptr 实现（仅演示核心逻辑）
template <typename T>
class MyUniquePtr {
private:
    T* ptr;
public:
    explicit MyUniquePtr(T* p = nullptr) : ptr(p) {}
    ~MyUniquePtr() { delete ptr; ptr = nullptr; }
    
    // 禁用拷贝
    MyUniquePtr(const MyUniquePtr& other) = delete;
    MyUniquePtr& operator=(const MyUniquePtr& other) = delete;
    
    // 支持移动
    MyUniquePtr(MyUniquePtr&& other) noexcept : ptr(other.ptr) {
        other.ptr = nullptr;
    }
    
    T* get() const { return ptr; }
};

2.1.2 基本使用

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

class Test {
public:
    Test(int id) : id_(id) { cout << "Test(" << id_ << ") 构造" << endl; }
    ~Test() { cout << "Test(" << id_ << ") 析构" << endl; }
    void show() { cout << "Test id: " << id_ << endl; }
private:
    int id_;
};

void test_unique_ptr_basic() {
    // 方式 1：通过 make_unique 创建（推荐）
    unique_ptr<Test> up1 = make_unique<Test>(1);
    up1->show();
    
    // 方式 2：通过 new 创建（不推荐）
    unique_ptr<Test> up2(new Test(2));
    
    // 错误：不允许拷贝
    // unique_ptr<Test> up3 = up1;
    
    // 正确：移动构造
    unique_ptr<Test> up5 = move(up1);
    up5->show();
    
    // 重置指针
    up5.reset(new Test(5));
    up5->show();
}

int main() {
    test_unique_ptr_basic();
    return 0;
}

运行结果确认对象离开作用域时自动析构，移动后原指针置空。

2.1.3 使用场景与最佳实践

• 独占资源：优先使用 unique_ptr。
• 函数返回值：传递临时对象所有权。
• 容器元素：vector<unique_ptr<T>> 避免拷贝开销。
• 最佳实践：优先使用 make_unique，避免手动 get()/release()。

2.2 shared_ptr：共享所有权的'社交达人'

当多个指针需共享同一块内存时，使用 shared_ptr。它通过引用计数管理，最后一个销毁时释放内存。

2.2.1 核心原理：引用计数

每个 shared_ptr 封装数据指针和控制块指针。控制块存储引用计数，增删操作同步更新，计数归零时释放对象和控制块。

2.2.2 基本使用

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

class Test {
public:
    Test(int id) : id_(id) { cout << "Test(" << id_ << ") 构造" << endl; }
    ~Test() { cout << "Test(" << id_ << ") 析构" << endl; }
    void show() { cout << "Test id: " << id_ << endl; }
private:
    int id_;
};

void test_shared_ptr_basic() {
    shared_ptr<Test> sp1 = make_shared<Test>(1);
    cout << "sp1 use_count: " << sp1.use_count() << endl; // 1
    
    shared_ptr<Test> sp2 = sp1; // 引用计数加 1
    cout << "sp1 use_count after copy: " << sp1.use_count() << endl; // 2
    
    shared_ptr<Test> sp3 = move(sp1); // 引用计数不变，sp1 置空
    cout << "sp1 use_count after move: " << sp1.use_count() << endl; // 0
}

2.2.3 循环引用问题

两个 shared_ptr 互相持有对方会导致引用计数永不为 0，造成泄漏。

void test_shared_ptr_cycle() {
    shared_ptr<Test> sp1 = make_shared<Test>(100);
    shared_ptr<Test> sp2 = make_shared<Test>(200);
    sp1->sp_self = sp2; // 假设成员变量为 shared_ptr
    sp2->sp_self = sp1;
    // 离开作用域后，引用计数为 1，无法析构
}

2.3 weak_ptr：打破循环的'旁观者'

weak_ptr 是弱引用，不增加引用计数，用于观察 shared_ptr 管理的对象。

2.3.1 核心原理

仅存储控制块指针，通过 lock() 获取 shared_ptr 访问对象。对象析构后控制块保留直到弱引用计数也为 0。

2.3.2 解决循环引用

将循环引用中的一方改为 weak_ptr。

class Test {
public:
    weak_ptr<Test> wp_self; // 弱引用
};

void test_weak_ptr_solve_cycle() {
    shared_ptr<Test> sp1 = make_shared<Test>();
    shared_ptr<Test> sp2 = make_shared<Test>();
    sp1->wp_self = sp2; // 不增加 sp2 引用计数
    sp2->wp_self = sp1;
    // 离开作用域后，引用计数归 0，正常析构
}

2.3.3 使用场景

• 解决循环引用：核心用途。
• 观察者模式：避免主题被观察者绑架。
• 缓存场景：对象销毁后缓存自动失效。

三、进阶技巧：定制删除器、类型转换与性能优化

3.1 定制删除器

默认使用 delete，特殊资源（如文件句柄）需自定义释放逻辑。

#include <memory>
#include <fstream>

void close_file(FILE* fp) {
    if (fp) fclose(fp);
}

void test_custom_deleter() {
    FILE* fp = fopen("test.txt", "w");
    unique_ptr<FILE, decltype(&close_file)> up2(fp, close_file);
}

3.2 类型转换

智能指针需使用专用转换函数：

• static_pointer_cast：静态转换。
• dynamic_pointer_cast：动态转换（多态）。
• const_pointer_cast：去除 const。

shared_ptr<Base> sp_base = make_shared<Derived>();
if (auto sp_derived = dynamic_pointer_cast<Derived>(sp_base)) {
    sp_derived->derived_func();
}

注意：unique_ptr 不支持类型转换，因所有权独占。

3.3 性能优化

• 优先使用 unique_ptr：无额外开销。
• 使用 make_shared：一次性分配对象和控制块，减少内存分配次数。
• 避免不必要的拷贝：传递 const shared_ptr&。
• 合理使用 lock()：短暂持有返回的 shared_ptr。

四、常见问题与最佳实践总结

4.1 常见错误

1. 循环引用：导致泄漏，用 weak_ptr 解决。
2. 过期访问：weak_ptr 未检查 expired() 或 lock() 返回值。
3. 数组管理：使用 unique_ptr<T[]> 而非 unique_ptr<T>。
4. 混合管理：裸指针交给多个智能指针管理导致二次释放。

4.2 最佳实践

1. 优先智能指针：替代裸指针。
2. 工厂函数：使用 make_shared/make_unique。
3. 避免滥用 get/release：仅在必要时暴露裸指针。
4. 选择合适类型：独占用 unique_ptr，共享用 shared_ptr + weak_ptr。

结语

从裸指针到智能指针，C++ 内存管理经历了革命性进化。RAII 机制将责任转移给编译器，解决了泄漏、野指针等经典问题。遵循'能用智能指针就不用裸指针'的原则，合理选择类型并掌握进阶技巧，能让代码更安全高效。智能指针虽非银弹，却是 C++ 内存管理最强大的武器。