C++智能指针原理与实战指南

1. C++智能指针深度解析与实践指南

在C++开发中，内存管理一直是开发者面临的核心挑战之一。传统的手动内存管理方式不仅容易导致内存泄漏，还会引发悬垂指针等问题。智能指针作为现代C++的重要特性，通过自动化的内存管理机制，极大地简化了内存管理的复杂度。

1.1 智能指针的核心价值

智能指针的本质是一个类模板，它封装了原始指针，并通过引用计数技术实现自动内存管理。当智能指针对象的生命周期结束时，其析构函数会自动释放所管理的堆内存。这种机制完美解决了以下常见问题：

• 内存泄漏：忘记调用delete释放堆内存
• 重复释放：同一块内存被多次释放
• 悬垂指针：访问已被释放的内存区域

智能指针家族主要包括三种类型：

1. shared_ptr：共享所有权指针
2. unique_ptr：独占所有权指针
3. weak_ptr：弱引用指针（解决循环引用）

1.2 shared_ptr的基本使用

shared_ptr采用引用计数机制，允许多个指针共享同一对象的所有权。当最后一个shared_ptr离开作用域时，对象才会被自动删除。

cpp复制#include <memory>
#include <iostream>

class Resource {
public:
    Resource() { std::cout << "Resource acquired\n"; }
    ~Resource() { std::cout << "Resource released\n"; }
};

int main() {
    // 创建shared_ptr
    std::shared_ptr<Resource> ptr1(new Resource());
    
    {
        // 共享所有权
        std::shared_ptr<Resource> ptr2 = ptr1;
        std::cout << "Inside block - use count: " << ptr1.use_count() << "\n";
    }
    
    std::cout << "Outside block - use count: " << ptr1.use_count() << "\n";
    return 0;
}

这段代码展示了shared_ptr的核心特性：

1. 构造时引用计数为1
2. 拷贝构造时引用计数增加
3. 析构时引用计数减少
4. 引用计数归零时自动释放资源

关键提示：虽然shared_ptr可以直接用new创建，但更推荐使用make_shared，它能将引用计数和对象内存分配在连续空间，提高性能。

1.3 循环引用问题与解决方案

shared_ptr虽然强大，但在某些场景下会导致内存无法释放，典型的就是循环引用问题。

cpp复制#include <memory>
#include <iostream>

class Node {
public:
    std::shared_ptr<Node> next;
    ~Node() { std::cout << "Node destroyed\n"; }
};

int main() {
    auto node1 = std::make_shared<Node>();
    auto node2 = std::make_shared<Node>();
    
    node1->next = node2;
    node2->next = node1;  // 循环引用
    
    return 0;
}

在这个例子中，即使离开作用域，两个Node对象也不会被销毁，因为它们的引用计数永远不会归零。这就是典型的循环引用问题。

解决方案是使用weak_ptr打破循环：

cpp复制class SafeNode {
public:
    std::weak_ptr<SafeNode> next;  // 使用weak_ptr替代
    ~SafeNode() { std::cout << "SafeNode destroyed\n"; }
};

weak_ptr不会增加引用计数，因此不会阻止对象的销毁。当需要访问对象时，可以通过lock()方法获取一个临时的shared_ptr。

2. 手写智能指针实现原理

理解智能指针的最佳方式就是自己实现一个简化版本。下面我们逐步构建一个自定义的SharedPtr模板类。

2.1 基础框架设计

首先定义模板类的基本结构：

cpp复制template<typename T>
class SharedPtr {
private:
    T* ptr;          // 原始指针
    int* count;      // 引用计数器
    
public:
    // 构造函数
    explicit SharedPtr(T* p = nullptr) : ptr(p), count(new int(1)) {}
    
    // 析构函数
    ~SharedPtr() {
        release();
    }
    
private:
    void release() {
        if (--(*count) == 0) {
            delete ptr;
            delete count;
            ptr = nullptr;
            count = nullptr;
        }
    }
};

这个基础版本已经能处理简单的内存管理：

• 构造时初始化引用计数为1
• 析构时减少引用计数，必要时释放资源

2.2 拷贝控制实现

智能指针的核心在于正确的拷贝语义：

cpp复制// 拷贝构造函数
SharedPtr(const SharedPtr<T>& other) 
    : ptr(other.ptr), count(other.count) {
    ++(*count);
}

// 拷贝赋值运算符
SharedPtr<T>& operator=(const SharedPtr<T>& other) {
    if (this != &other) {
        release();  // 释放当前资源
        
        ptr = other.ptr;
        count = other.count;
        ++(*count);
    }
    return *this;
}

拷贝控制的关键点：

1. 拷贝构造时增加引用计数
2. 赋值操作前先释放当前资源
3. 自赋值检查避免意外行为

2.3 移动语义支持

现代C++中，移动语义可以优化资源管理：

cpp复制// 移动构造函数
SharedPtr(SharedPtr<T>&& other) noexcept 
    : ptr(other.ptr), count(other.count) {
    other.ptr = nullptr;
    other.count = nullptr;
}

// 移动赋值运算符
SharedPtr<T>& operator=(SharedPtr<T>&& other) noexcept {
    if (this != &other) {
        release();
        
        ptr = other.ptr;
        count = other.count;
        
        other.ptr = nullptr;
        other.count = nullptr;
    }
    return *this;
}

移动操作的特点：

• 不增加引用计数
• 转移资源所有权
• 将源对象置为空状态

2.4 完整实现与测试

结合上述部分，我们得到完整的SharedPtr实现：

cpp复制template<typename T>
class SharedPtr {
private:
    T* ptr;
    int* count;
    
    void release() {
        if (count && --(*count) == 0) {
            delete ptr;
            delete count;
        }
    }
    
public:
    explicit SharedPtr(T* p = nullptr) : ptr(p), count(new int(1)) {}
    
    ~SharedPtr() { release(); }
    
    // 拷贝控制
    SharedPtr(const SharedPtr<T>& other) 
        : ptr(other.ptr), count(other.count) {
        ++(*count);
    }
    
    SharedPtr<T>& operator=(const SharedPtr<T>& other) {
        if (this != &other) {
            release();
            ptr = other.ptr;
            count = other.count;
            ++(*count);
        }
        return *this;
    }
    
    // 移动语义
    SharedPtr(SharedPtr<T>&& other) noexcept 
        : ptr(other.ptr), count(other.count) {
        other.ptr = nullptr;
        other.count = nullptr;
    }
    
    SharedPtr<T>& operator=(SharedPtr<T>&& other) noexcept {
        if (this != &other) {
            release();
            ptr = other.ptr;
            count = other.count;
            other.ptr = nullptr;
            other.count = nullptr;
        }
        return *this;
    }
    
    // 解引用操作符
    T& operator*() const { return *ptr; }
    T* operator->() const { return ptr; }
    
    // 使用计数查询
    int use_count() const { return count ? *count : 0; }
    
    // 显式bool转换
    explicit operator bool() const { return ptr != nullptr; }
};

测试用例：

cpp复制class TestObject {
public:
    TestObject() { std::cout << "TestObject created\n"; }
    ~TestObject() { std::cout << "TestObject destroyed\n"; }
    void greet() { std::cout << "Hello from TestObject\n"; }
};

void testSharedPtr() {
    SharedPtr<TestObject> ptr1(new TestObject());
    {
        SharedPtr<TestObject> ptr2 = ptr1;
        ptr2->greet();
        std::cout << "Use count inside block: " << ptr1.use_count() << "\n";
    }
    std::cout << "Use count outside block: " << ptr1.use_count() << "\n";
    
    SharedPtr<TestObject> ptr3;
    ptr3 = std::move(ptr1);
    if (!ptr1) {
        std::cout << "ptr1 is now empty after move\n";
    }
}

3. C++类型转换深度解析

C++提供了四种命名的强制类型转换操作符，比C风格的强制转换更安全、更明确。

3.1 const_cast：常量性转换

const_cast用于移除或添加const限定符，主要用于以下场景：

cpp复制void updateConfig(const Config* config) {
    // 需要修改配置，但参数是const的
    Config* writable = const_cast<Config*>(config);
    writable->setValue("timeout", 30);
}

const std::string& getReadOnlyName(const Employee& emp) {
    return emp.name;
}

void example() {
    Employee emp("John");
    // 需要临时修改只读引用
    std::string& name = const_cast<std::string&>(getReadOnlyName(emp));
    name = "Smith";
}

注意事项：const_cast不应用于修改原本就是常量的对象，这会导致未定义行为。

3.2 static_cast：静态类型转换

static_cast用于编译器已知的、相对安全的类型转换：

cpp复制// 基本类型转换
double d = 3.14;
int i = static_cast<int>(d);

// 类层次结构中的向上转换（安全）
class Base { virtual void foo() {} };
class Derived : public Base {};

Derived* derived = new Derived();
Base* base = static_cast<Base*>(derived);

// void*与具体指针类型的转换
void* voidPtr = derived;
Derived* derived2 = static_cast<Derived*>(voidPtr);

static_cast的特点：

• 编译时检查
• 不执行运行时类型检查
• 不能移除const/volatile限定符

3.3 dynamic_cast：动态类型转换

dynamic_cast用于在继承层次结构中进行安全的向下转换：

cpp复制class Animal {
public:
    virtual ~Animal() {}
};

class Dog : public Animal {
public:
    void bark() { std::cout << "Woof!\n"; }
};

class Cat : public Animal {
public:
    void meow() { std::cout << "Meow!\n"; }
};

void processAnimal(Animal* animal) {
    if (Dog* dog = dynamic_cast<Dog*>(animal)) {
        dog->bark();
    } 
    else if (Cat* cat = dynamic_cast<Cat*>(animal)) {
        cat->meow();
    }
}

dynamic_cast的关键点：

• 需要多态类型（至少有一个虚函数）
• 对指针转换失败返回nullptr
• 对引用转换失败抛出std::bad_cast
• 运行时开销较大

3.4 reinterpret_cast：重新解释转换

reinterpret_cast提供低级别的重新解释位模式的能力：

cpp复制// 指针与整数间的转换
int* ip = new int(42);
uintptr_t addr = reinterpret_cast<uintptr_t>(ip);
int* ip2 = reinterpret_cast<int*>(addr);

// 不同类型指针间的转换
struct Data {
    int x;
    double y;
};

Data* data = new Data{10, 3.14};
char* raw = reinterpret_cast<char*>(data);

reinterpret_cast的注意事项：

• 极度危险，应尽量避免使用
• 不进行任何类型检查
• 结果高度平台依赖
• 可能违反严格别名规则

4. nullptr的现代C++实践

nullptr是C++11引入的关键字，用于表示空指针常量，解决了NULL在重载解析中的歧义问题。

4.1 nullptr的优势

与传统NULL(通常是0)相比，nullptr具有以下优势：

1. 类型安全：nullptr的类型是std::nullptr_t，不是整数类型
2. 重载解析更精确
3. 模板代码中表现更好
4. 提高代码可读性

4.2 使用场景示例

cpp复制void func(int) { std::cout << "func(int)\n"; }
void func(char*) { std::cout << "func(char*)\n"; }

template<typename Func, typename Ptr>
void execute(Func f, Ptr p) {
    f(p);
}

int main() {
    func(0);          // 调用func(int)
    func(nullptr);    // 调用func(char*)
    
    // 模板场景
    execute(func, 0);      // 编译错误，歧义
    execute(func, nullptr); // 正确调用func(char*)
    
    // 容器中的空指针
    std::vector<int*> vec;
    vec.push_back(nullptr);
    vec.push_back(0);    // 也能工作，但不推荐
    
    // 智能指针
    std::shared_ptr<int> sp = nullptr;
    std::unique_ptr<double> up(nullptr);
}

4.3 最佳实践建议

1. 总是使用nullptr代替NULL或0表示空指针
2. 在模板元编程中优先使用nullptr
3. 使用auto接收nullptr时明确指定指针类型：

cpp复制auto ptr = nullptr;    // 类型是std::nullptr_t
auto p = (int*)nullptr; // 明确类型

4. 与类型推导结合时注意：

cpp复制template<typename T>
void foo(T t) {}

foo(nullptr);  // T推导为std::nullptr_t
foo((int*)nullptr); // T推导为int*

5. 智能指针实战经验与陷阱

在实际项目中使用智能指针时，有许多需要注意的细节和最佳实践。

5.1 常见陷阱与解决方案

陷阱1：原始指针与智能指针混用

cpp复制void process(shared_ptr<Resource> res);

Resource* raw = new Resource();
process(shared_ptr<Resource>(raw));  // 危险！
// 如果process函数保存了shared_ptr，而外部继续使用raw...

解决方案：始终使用智能指针管理对象生命周期，避免裸指针所有权传递。

陷阱2：循环引用

即使使用weak_ptr，复杂对象图中仍可能隐藏循环引用：

cpp复制class Controller {
    vector<shared_ptr<Listener>> listeners;
};

class Listener {
    shared_ptr<Controller> controller;  // 应该使用weak_ptr
};

解决方案：仔细设计对象关系，在可能形成循环的地方使用weak_ptr。

陷阱3：多线程安全性

shared_ptr的引用计数是原子操作，但管理的对象不是线程安全的：

cpp复制shared_ptr<Data> global_data;

void thread_func() {
    if (global_data) {
        global_data->modify();  // 需要额外的同步
    }
}

解决方案：对共享数据使用互斥锁等同步机制。

5.2 性能优化技巧

1. 优先使用make_shared/make_unique：

cpp复制auto ptr = make_shared<Resource>(args...);  // 单次内存分配

2. 减少shared_ptr的拷贝：

cpp复制void process(const shared_ptr<Resource>& ptr);  // 传const引用

3. 大对象考虑使用unique_ptr：

cpp复制auto largeObj = make_unique<LargeObject>();
process(std::move(largeObj));  // 转移所有权

4. 避免在热点路径上频繁创建/销毁shared_ptr。

5.3 自定义删除器

智能指针支持自定义删除器，适用于特殊资源管理：

cpp复制// 文件指针
shared_ptr<FILE> filePtr(fopen("data.txt", "r"), [](FILE* f) {
    if (f) fclose(f);
});

// 数组
shared_ptr<int[]> arr(new int[100], [](int* p) {
    delete[] p;
});

// 系统资源
struct SysResource {
    static void Release(ResourceHandle h);
};
shared_ptr<SysResource> res(acquireResource(), SysResource::Release);

6. 类型转换的最佳实践

正确使用类型转换对编写健壮的C++代码至关重要。

6.1 类型转换选择指南

6.2 安全向下转换模式

对于类层次结构的向下转换，推荐使用以下模式：

cpp复制class Base { public: virtual ~Base() {} };
class Derived : public Base { /*...*/ };

void process(Base* base) {
    if (auto derived = dynamic_cast<Derived*>(base)) {
        // 安全使用derived
    } else {
        // 处理错误或默认情况
    }
}

// 对于已知的安全转换（性能敏感场景）
void fastProcess(Base* base) {
    assert(dynamic_cast<Derived*>(base) != nullptr);
    auto derived = static_cast<Derived*>(base);
    // ...
}

6.3 避免类型转换的替代方案

在许多情况下，可以通过更好的设计避免类型转换：

1. 使用多态替代向下转换：

cpp复制class Shape {
public:
    virtual void draw() = 0;
};

// 而不是检查具体类型后转换

2. 使用模板避免void*转换：

cpp复制template<typename T>
void process(T* obj) { /*...*/ }

// 而不是
void process(void* data, int type);

3. 使用variant/any替代reinterpret_cast：

cpp复制std::variant<int, std::string> value;
// 比void*+类型标签更安全

7. 现代C++内存管理综合实践

结合智能指针、移动语义和RAII，可以实现高效安全的内存管理。

7.1 资源获取即初始化(RAII)模式

RAII是C++资源管理的核心理念：

cpp复制class FileHandle {
    FILE* file;
public:
    explicit FileHandle(const char* name) : file(fopen(name, "r")) {
        if (!file) throw std::runtime_error("File open failed");
    }
    
    ~FileHandle() { if (file) fclose(file); }
    
    // 禁止拷贝
    FileHandle(const FileHandle&) = delete;
    FileHandle& operator=(const FileHandle&) = delete;
    
    // 允许移动
    FileHandle(FileHandle&& other) noexcept : file(other.file) {
        other.file = nullptr;
    }
    
    FileHandle& operator=(FileHandle&& other) noexcept {
        if (this != &other) {
            if (file) fclose(file);
            file = other.file;
            other.file = nullptr;
        }
        return *this;
    }
    
    void read(/*...*/) { /*...*/ }
};

7.2 智能指针与RAII结合

将智能指针与自定义删除器结合，实现灵活的RAII：

cpp复制// 管理动态数组
auto arrayDeleter = [](int* p) { delete[] p; };
std::unique_ptr<int[], decltype(arrayDeleter)> 
    arr(new int[100], arrayDeleter);

// 管理第三方库资源
struct LibResource {
    static void Free(Resource* r) { lib_free(r); }
};
using ResourcePtr = std::unique_ptr<Resource, LibResource::Free>;

7.3 对象池模式实现

使用智能指针实现对象池可以避免频繁内存分配：

cpp复制class ObjectPool {
    std::vector<std::unique_ptr<Resource>> pool;
    
public:
    std::shared_ptr<Resource> acquire() {
        if (pool.empty()) {
            return std::shared_ptr<Resource>(
                new Resource(),
                [this](Resource* r) { pool.push_back(std::unique_ptr<Resource>(r)); }
            );
        } else {
            auto ptr = std::move(pool.back());
            pool.pop_back();
            return std::shared_ptr<Resource>(
                ptr.release(),
                [this](Resource* r) { pool.push_back(std::unique_ptr<Resource>(r)); }
            );
        }
    }
};

这种实现方式允许对象在使用后自动回收到池中，而不是被销毁。

8. 高级主题：智能指针与多线程

在多线程环境中使用智能指针需要特别注意线程安全问题。

8.1 shared_ptr的线程安全性

shared_ptr本身的引用计数操作是原子的，线程安全的，但需要注意：

1. 多个线程同时修改同一个shared_ptr实例需要同步
2. 管理的对象本身不保证线程安全
3. weak_ptr的lock()操作是原子的

cpp复制std::shared_ptr<Data> global_data;
std::mutex data_mutex;

void thread_func() {
    std::shared_ptr<Data> local_copy;
    {
        std::lock_guard<std::mutex> lock(data_mutex);
        local_copy = global_data;  // 安全的引用计数增加
    }
    
    if (local_copy) {
        // 使用local_copy不需要锁，因为是线程本地副本
        // 但访问Data成员可能需要额外的同步
    }
}

8.2 避免死锁的智能指针模式

当智能指针与互斥锁结合使用时，需要注意锁的获取顺序：

cpp复制class Account {
    std::mutex mtx;
    double balance;
public:
    void transfer(std::shared_ptr<Account> to, double amount) {
        std::lock(mtx, to->mtx);  // 同时获取两个锁，避免死锁
        std::lock_guard<std::mutex> lock1(mtx, std::adopt_lock);
        std::lock_guard<std::mutex> lock2(to->mtx, std::adopt_lock);
        
        balance -= amount;
        to->balance += amount;
    }
};

8.3 原子shared_ptr (C++20)

C++20引入了atomic<shared_ptr>，提供了更完善的多线程支持：

cpp复制#include <atomic>

std::atomic<std::shared_ptr<Data>> atomic_data;

void update_data() {
    auto new_data = std::make_shared<Data>(/*...*/);
    atomic_data.store(new_data, std::memory_order_release);
}

void use_data() {
    auto current_data = atomic_data.load(std::memory_order_acquire);
    if (current_data) {
        // 安全使用current_data
    }
}

原子shared_ptr操作比手动加锁效率更高，特别是在读多写少的场景。

9. 性能分析与优化

智能指针虽然方便，但也带来一定的性能开销，需要合理评估。

9.1 智能指针的性能开销

1. shared_ptr：

   • 引用计数的原子操作
   • 额外的内存分配（除非使用make_shared）
   • 更大的内存占用（通常为2倍原始指针）

2. unique_ptr：

   • 几乎零开销（与原始指针相当）
   • 编译时确定的所有权语义

3. weak_ptr：

   • 额外的控制块访问
   • lock()操作需要原子操作

9.2 性能优化策略

1. 热点路径避免shared_ptr拷贝：

cpp复制void process(const std::shared_ptr<Data>& data);  // 传引用

2. 使用make_shared合并内存分配：

cpp复制auto ptr = std::make_shared<Data>();  // 单次分配

3. 小对象使用unique_ptr：

cpp复制auto smallObj = std::make_unique<SmallObject>();

4. 对象池模式减少分配次数：

cpp复制ObjectPool<ExpensiveObject> pool;
auto obj = pool.acquire();  // 重用已分配对象

9.3 测量与分析方法

使用性能分析工具评估智能指针的影响：

1. 内存分析工具（Valgrind, Heaptrack）
2. CPU性能分析器（perf, VTune）
3. 微基准测试（Google Benchmark）

示例基准测试：

cpp复制#include <benchmark/benchmark.h>

static void RawPtrCreateDestroy(benchmark::State& state) {
    for (auto _ : state) {
        Data* data = new Data();
        delete data;
    }
}
BENCHMARK(RawPtrCreateDestroy);

static void SharedPtrCreateDestroy(benchmark::State& state) {
    for (auto _ : state) {
        auto data = std::make_shared<Data>();
    }
}
BENCHMARK(SharedPtrCreateDestroy);

BENCHMARK_MAIN();

10. 跨API边界使用智能指针

在与外部库或不同模块交互时，需要特别注意智能指针的使用。

10.1 与C API交互

当C API需要裸指针时，可以使用get()方法，但要确保生命周期：

cpp复制void c_api_function(Data* data);

void wrapper() {
    auto data = std::make_shared<Data>();
    
    // 确保data在调用期间保持活动
    c_api_function(data.get());
    
    // 如果API存储指针，需要特殊处理
}

对于回调API，可以使用shared_ptr延长生命周期：

cpp复制void register_callback(void (*cb)(void*), void* userdata);

void callback_wrapper(void* userdata) {
    auto data = static_cast<std::shared_ptr<Data>*>(userdata);
    // 使用(*data)->...
}

void register_data_callback(std::shared_ptr<Data> data) {
    auto holder = new std::shared_ptr<Data>(std::move(data));
    register_callback(callback_wrapper, holder);
    
    // 注意：需要在适当时候delete holder
}

10.2 跨模块边界传递

在不同DLL/SO模块间传递智能指针需要特别注意：

1. 确保所有模块使用相同标准库实现
2. 对象分配和释放应在同一模块中进行
3. 推荐使用原始指针或明确的生命周期协议

安全模式：

cpp复制// 模块A
std::unique_ptr<Data> create_data() {
    return std::make_unique<Data>();
}

// 模块B
void process_data(Data* data);  // 明确所有权语义

// 使用
auto data = create_data();
process_data(data.get());

10.3 自定义删除器跨边界

当资源需要在特定模块中释放时，使用自定义删除器：

cpp复制// 模块A
void free_resource(Resource* r);

// 模块B
void process() {
    Resource* raw = acquire_resource();
    std::shared_ptr<Resource> res(raw, [](Resource* r) {
        free_resource(r);  // 确保在模块A中释放
    });
    
    // 使用res...
}

11. 智能指针在容器中的使用

标准容器与智能指针结合能实现强大的内存管理功能。

11.1 vector与shared_ptr

cpp复制std::vector<std::shared_ptr<Employee>> team;

// 添加成员
team.push_back(std::make_shared<Employee>("Alice"));
team.emplace_back(new Employee("Bob"));

// 查找特定成员
auto it = std::find_if(team.begin(), team.end(), 
    [](const auto& emp) { return emp->name() == "Alice"; });

// 安全移除成员
if (it != team.end()) {
    team.erase(it);  // 如果这是最后一个引用，Employee会被自动删除
}

11.2 map与unique_ptr

cpp复制std::map<int, std::unique_ptr<Connection>> connections;

// 添加连接
connections[1] = std::make_unique<Connection>("db1");
connections.emplace(2, std::make_unique<Connection>("db2"));

// 转移所有权
auto conn = std::move(connections[1]);
connections.erase(1);

// 使用conn...

11.3 容器存储weak_ptr

weak_ptr可用于实现缓存机制：

cpp复制class Cache {
    std::unordered_map<std::string, std::weak_ptr<Resource>> cache;
    std::mutex mutex;
    
public:
    std::shared_ptr<Resource> get(const std::string& key) {
        std::lock_guard<std::mutex> lock(mutex);
        
        auto it = cache.find(key);
        if (it != cache.end()) {
            if (auto res = it->second.lock()) {
                return res;  // 缓存命中
            }
            cache.erase(it);  // 清理过期条目
        }
        
        // 缓存未命中，创建新资源
        auto res = std::make_shared<Resource>(key);
        cache[key] = res;
        return res;
    }
};

12. 智能指针与多态

智能指针与多态结合使用时需要注意一些特殊场景。

12.1 继承层次中的智能指针

cpp复制class Base {
public:
    virtual ~Base() = default;
    virtual void foo() = 0;
};

class Derived : public Base {
public:
    void foo() override { /*...*/ }
    void specific() { /*...*/ }
};

// 创建派生类但存储为基类指针
std::shared_ptr<Base> obj = std::make_shared<Derived>();

// 向下转换
if (auto derived = std::dynamic_pointer_cast<Derived>(obj)) {
    derived->specific();
}

12.2 enable_shared_from_this

当一个类的成员函数需要返回自身的shared_ptr时使用：

cpp复制class SelfAware : public std::enable_shared_from_this<SelfAware> {
public:
    std::shared_ptr<SelfAware> get_self() {
        return shared_from_this();
    }
};

void use_self_aware() {
    auto obj = std::make_shared<SelfAware>();
    auto another_ref = obj->get_self();
}

注意事项：

1. 必须由shared_ptr管理对象
2. 构造函数中不能调用shared_from_this()
3. 析构函数中不能调用shared_from_this()

12.3 多态析构

确保基类有虚析构函数：

cpp复制class Base {
public:
    virtual ~Base() = default;  // 必须的！
};

class Derived : public Base {
    std::vector<int> data;
public:
    ~Derived() override {
        // 会正确调用
    }
};

void test_poly_dtor() {
    std::shared_ptr<Base> ptr = std::make_shared<Derived>();
    // 当ptr销毁时，会正确调用Derived的析构函数
}

13. 智能指针与异常安全

智能指针极大地简化了异常安全代码的编写。

13.1 基本异常安全保证

cpp复制void unsafe_process() {
    Resource* res = new Resource();
    do_something();  // 可能抛出异常
    delete res;      // 如果上面抛出异常，这里不会执行
}

void safe_process() {
    auto res = std::make_shared<Resource>();
    do_something();  // 即使抛出异常，res也会被正确释放
}

13.2 强异常安全保证

使用智能指针实现事务性操作：

cpp复制struct Database {
    std::unique_ptr<Entry> current;
    
    void update(const Entry& new_entry) {
        auto new_copy = std::make_unique<Entry>(new_entry);
        validate(*new_copy);  // 可能抛出
        
        // 原子提交
        std::swap(current, new_copy);
        
        // 如果到这里，操作成功
        // 如果前面抛出，状态保持不变
    }
};

13.3 异常安全资源管理

结合智能指针与自定义删除器处理各种资源：

cpp复制void safe_file_operation() {
    auto file = std::shared_ptr<FILE>(
        fopen("data.txt", "r"), 
        [](FILE* f) { if (f) fclose(f); }
    );
    
    if (!file) throw std::runtime_error("Open failed");
    
    process_file(file.get());  // 可能抛出
    
    // 文件会被正确关闭
}

14. 调试智能指针问题

智能指针虽然减少了内存问题，但仍有需要调试的场景。

14.1 常见问题诊断

1. 循环引用：

   • 使用weak_ptr打破循环
   • 内存分析工具检测泄漏

2. 过早释放：

   • 检查shared_ptr的作用域
   • 验证引用计数

3. 多线程竞争：

   • 线程分析工具检测
   • 确保对管理对象的访问同步

14.2 调试技巧

1. 自定义删除器添加调试信息：

cpp复制auto debug_deleter = [](Resource* r) {
    std::cout << "Deleting resource at " << r << "\n";
    delete r;
};

std::shared_ptr<Resource> res(new Resource(), debug_deleter);

2. 跟踪引用计数变化：

cpp复制template<typename T>
class TracedSharedPtr {
    std::shared_ptr<T> ptr;
public:
    template<typename... Args>
    TracedSharedPtr(Args&&... args) : ptr(std::forward<Args>(args)...) {
        std::cout << "Created. Use count: " << ptr.use_count() << "\n";
    }
    
    // 代理所有shared_ptr操作并打印调试信息
};

3. 使用Valgrind检测内存问题：

bash复制valgrind --leak-check=full ./your_program

14.3 性能问题诊断

1. 分析shared_ptr拷贝热点：

cpp复制// 使用perf或VTune分析shared_ptr拷贝操作
void process(const std::shared_ptr<Data>& data) {  // 传引用减少拷贝
    // ...
}

2. 检测控制块分配：

cpp复制// 使用make_shared减少分配次数
auto data = std::make_shared<Data>();  // 单次分配

15. C++17/20智能指针增强

新标准为智能指针引入了更多有用特性。

15.1 C++17的shared_ptr数组支持

cpp复制// C++17之前
std::shared_ptr<int[]> arr(new int[10], std::default_delete<int[]>());

// C++17及以后
std::shared_ptr<int[]> arr(new int[10]);  // 正确调用delete[]

15.2 C++20的atomic<shared_ptr>

cpp复制#include <atomic>

std::atomic<std::shared_ptr<Data>> atomic_data;

void update() {
    auto new_data = std::make_shared<Data>(/*...*/);
    atomic_data.store(new_data);
}

void read() {
    auto current = atomic_data.load();
    if (current) {
        // 安全使用
    }
}

15.3 make_shared_for_overwrite (C++20)

避免初始化时的额外清零操作：

cpp复制// 传统make_shared会值初始化（清零）
auto zeroed = std::make_shared<int>();  // *zeroed == 0

// C++20 make_shared_for_overwrite不初始化
auto uninit = std::make_shared_for_overwrite<int>();  // *uninit 未初始化

16. 替代内存管理方案

智能指针并非适用于所有场景，有时需要其他方案。

16.1 自定义分配器

cpp复制template<typename T>
class PoolAllocator {
    static std::vector<std::unique_ptr<T[]>> pool;
    static constexpr size_t chunk_size = 1024;
    static size_t current_index;
    static T* current_chunk;
    
public:
    T* allocate(size_t n) {
        if (!current_chunk || current_index + n > chunk_size) {
            pool.emplace_back(new T[chunk_size]);
            current_chunk = pool.back().get();
            current_index = 0;
        }
        
        T* ptr = current_chunk + current_index;
        current_index += n;
        return ptr;
    }
    
    void deallocate(T*, size_t) noexcept {
        // 池