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

4. 智能指针的核心使命

智能指针是一个包装器类，封装了裸指针，并在析构函数中自动执行 delete。利用 C++ 对象'出作用域即析构'的规则，当智能指针对象离开作用域时，内存被自动释放，从根本上避免了上述问题。

二、智能指针的三驾马车：unique_ptr、shared_ptr、weak_ptr

C++11 提供了三种核心智能指针，它们各有设计理念和适用场景。

1. unique_ptr：独占所有权的独行侠

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

原理与实现

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

#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_;
};

int main() {
    // 推荐方式：make_unique
    unique_ptr<Test> up1 = make_unique<Test>(1);
    up1->show();

    // 移动所有权
    unique_ptr<Test> up2 = move(up1);
    // up1 变为 nullptr
    
    return 0;
}

使用场景

• 独占资源：一块内存只需一个指针管理。
• 函数返回值：传递临时对象所有权。
• 容器元素：vector<unique_ptr<T>> 避免拷贝开销。

最佳实践：优先使用 make_unique 创建；避免滥用 get() 和 release()；管理数组时使用 unique_ptr<T[]>。

2. shared_ptr：共享所有权的社交达人

当多个指针需要引用同一资源时，shared_ptr 应运而生。它支持共享所有权，引用计数减为 0 时才释放内存。

引用计数原理

每个 shared_ptr 封装数据指针和控制块指针。控制块存储引用计数、弱引用计数及析构器。拷贝 shared_ptr 时引用计数加 1，析构时减 1。

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

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

void test_cycle() {
    shared_ptr<Test> sp1 = make_shared<Test>(100);
    shared_ptr<Test> sp2 = make_shared<Test>(200);
    
    // 循环引用：sp1 持有 sp2，sp2 持有 sp1
    sp1->sp_self = sp2;
    sp2->sp_self = sp1;
    
    // 此时引用计数均为 2，离开作用域后无法减为 0
    // 导致内存泄漏
}

循环引用问题

两个或多个 shared_ptr 互相持有对方引用，导致引用计数永远不为 0，造成内存泄漏。这是 shared_ptr 的致命缺陷。

3. weak_ptr：打破循环的旁观者

weak_ptr 是一种弱引用智能指针，不拥有对象所有权，仅观察 shared_ptr 管理的对象。它不会增加引用计数，因此不会导致循环引用。

核心原理

weak_ptr 仅存储控制块指针。创建时弱引用计数加 1。无法直接访问对象，需通过 lock() 获取 shared_ptr。

解决方案与使用

将循环引用中的一方改为 weak_ptr 即可解决。

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

class Test {
public:
    Test(int id) : id_(id) { cout << "Test(" << id_ << ") 构造" << endl; }
    ~Test() { cout << "Test(" << id_ << ") 析构" << endl; }
    weak_ptr<Test> wp_self; // 使用 weak_ptr 打破循环
private:
    int id_;
};

void test_solve_cycle() {
    shared_ptr<Test> sp1 = make_shared<Test>(100);
    shared_ptr<Test> sp2 = make_shared<Test>(200);
    
    sp1->wp_self = sp2; // 不增加 sp2 的引用计数
    sp2->wp_self = sp1;
    
    // 离开作用域后，引用计数减为 0，对象正常析构
}

使用场景：解决 shared_ptr 循环引用、观察者模式、缓存失效检测。

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

1. 定制删除器

默认使用 delete 释放内存。特殊资源（如文件句柄、动态数组）需自定义释放逻辑。

#include <memory>
#include <cstdio>

// lambda 表达式作为删除器
auto close_file_deleter = [](FILE* fp) {
    if (fp) fclose(fp);
};

void test_custom_deleter() {
    FILE* fp = fopen("test.txt", "w");
    unique_ptr<FILE, decltype(close_file_deleter)> up(fp, close_file_deleter);
    // 离开作用域自动调用 fclose
}

2. 类型转换

智能指针不能直接使用 static_cast 等，需使用专用函数：

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

注意：dynamic_pointer_cast 仅适用于 shared_ptr，unique_ptr 不支持。

3. 性能优化

• 优先使用 unique_ptr：无额外开销，接近裸指针性能。
• 使用 make_shared：一次性分配对象和控制块内存，减少分配次数。
• 避免不必要的拷贝：传递 shared_ptr 时尽量用 const&。

四、避坑指南与最佳实践总结

虽然智能指针强大，但使用不当仍可能导致问题。

常见错误

1. 循环引用：shared_ptr 互相持有，需用 weak_ptr 解决。
2. 过期访问：weak_ptr 访问前检查 expired() 或判断 lock() 返回值。
3. 数组管理：unique_ptr<int> 管理数组会调用 delete 而非 delete[]，应使用 unique_ptr<int[]>。
4. 裸指针混用：不要将裸指针交给多个智能指针管理，会导致二次释放。

最佳实践

1. 能用智能指针就不用裸指针：除非与 C 语言兼容。
2. 优先使用 make_shared / make_unique：更安全且性能更好。
3. 避免滥用 get() / release()：仅在必要时暴露裸指针。
4. 选择合适的智能指针：独占用 unique_ptr，共享用 shared_ptr + weak_ptr。

结语

从裸指针的'步步惊心'到智能指针的自动化管理，C++ 内存管理经历了一次革命性进化。掌握智能指针及其原理，能让代码更安全、高效。在实际开发中，遵循'能⽤智能指针就不用裸指针'的原则，合理选择类型，让内存管理不再是痛点，而是底气。