在C++编程中，内存泄漏是困扰开发者的核心难题之一。手动管理动态内存时，忘记delete、异常导致delete跳过等情况，极易造成内存浪费、程序崩溃，尤其在大型项目中，内存管理的复杂度会呈指数级上升，排查内存泄漏问题往往需要耗费大量时间和精力。

为从根本上解决这一问题，C++11标准正式引入智能指针，它本质是封装了裸指针的类模板，通过RAII（资源获取即初始化）机制，将动态内存的管理与智能指针的生命周期绑定，实现内存的自动分配与释放，让开发者无需手动调用delete，从根源上减少内存泄漏风险，提升代码的安全性和可维护性。

智能指针的核心作用是接管动态内存的生命周期，当智能指针生命周期结束（出作用域、被销毁或被重置）时，其析构函数会自动调用delete，释放所指向的动态内存，避免了手动管理内存的繁琐与失误。同时，智能指针支持像裸指针一样的解引用（*）、箭头（->）操作，兼顾了安全性与易用性，开发者无需改变原有的编程习惯，就能轻松实现内存的安全管理。

C++标准库中提供4种智能指针：auto_ptr、unique_ptr、shared_ptr、weak_ptr，其中auto_ptr因设计缺陷已被C++11弃用，C++17更是彻底移除了该类型，下面重点介绍后三种智能指针及auto_ptr的基本情况，帮助开发者清晰区分各类智能指针的适用场景。

一、四种智能指针详解

1. auto_ptr（已弃用）

auto_ptr是C++98标准引入的第一代智能指针，其核心功能是实现动态内存的自动释放，初衷是解决手动delete遗漏导致的内存泄漏问题。但auto_ptr存在严重的设计缺陷——拷贝赋值时会强制转移指针的所有权，导致原智能指针变为悬空指针（指向无效内存），后续若对原指针进行解引用操作，会引发未定义行为，甚至导致程序崩溃。正是这一致命缺陷，使得auto_ptr在C++11中被标记为弃用，C++17中彻底移除，目前仅作为C++智能指针发展的历史知识点，实际开发中严禁使用。

#include <iostream>
using namespace std;

int main() {
    auto_ptr<int> ptr1(new int(10)); // 初始化auto_ptr，指向动态内存10
    auto_ptr<int> ptr2 = ptr1; // 拷贝赋值，所有权从ptr1转移到ptr2，ptr1悬空
    cout << *ptr2 << endl; // 正常输出10，ptr2拥有内存所有权
    // cout << *ptr1 << endl; // 未定义行为，ptr1已无所有权，大概率崩溃
    return 0;
}

2. unique_ptr（独占式智能指针）

unique_ptr是C++11推出的、用于替代auto_ptr的独占式智能指针，其核心设计理念是“独占所有权”，即一块动态内存只能被一个unique_ptr对象管理，禁止拷贝和赋值操作，从根本上避免了auto_ptr的悬空指针问题。unique_ptr的效率与裸指针几乎一致，无需额外的性能开销，同时支持通过std::move()函数转移所有权，转移后原unique_ptr对象变为空指针，无法再访问原内存资源，有效保证了内存管理的安全性。unique_ptr适合管理单个对象的动态内存，尤其适用于局部作用域、函数返回值等场景，是日常开发中使用频率较高的智能指针之一。

#include <iostream>
#include <memory> // 所有智能指针均需包含该头文件
using namespace std;

int main() {
    unique_ptr<int> ptr1(new int(20)); // 初始化unique_ptr，独占内存所有权
    cout << *ptr1 << endl; // 正常解引用，输出20
    // unique_ptr<int> ptr2 = ptr1; // 编译报错，禁止直接拷贝
    unique_ptr<int> ptr2 = move(ptr1); // 通过move转移所有权，ptr1变为空
    if (!ptr1) cout << "ptr1已无所有权，变为空指针" << endl; // 输出该提示
    cout << *ptr2 << endl; // ptr2拥有所有权，输出20
    return 0;
}

3. shared_ptr（共享式智能指针）

shared_ptr是C++11中最常用、最灵活的智能指针，其核心特性是“共享所有权”，即多個shared_ptr对象可以指向同一块动态内存，通过引用计数（reference count）机制实现内存的协同管理。引用计数的工作原理的是：当第一个shared_ptr对象初始化时，引用计数设为1；每新增一个shared_ptr对象指向该内存，引用计数加1；每一个shared_ptr对象销毁（出作用域、被重置）时，引用计数减1；当引用计数降至0时，说明没有任何智能指针管理该内存，此时自动调用delete释放内存，确保内存不泄漏。

使用场景：shared_ptr的灵活性使其适用于多种场景，例如多线程环境下共享资源（需配合线程安全机制）、容器中存储动态对象（vector<shared_ptr<T>>）、多个对象需要共同管理同一资源（如父子对象共享数据）等。优点：使用灵活，支持拷贝、赋值操作，无需手动管理内存，大幅降低内存泄漏风险，同时提供use_count()方法获取引用计数，方便开发者调试。

存在问题：shared_ptr的核心缺陷是循环引用，当两个或多个shared_ptr对象互相指向对方时，会形成引用计数的闭环，导致引用计数永远无法降至0，进而造成内存泄漏；另外，若直接使用裸指针初始化多个shared_ptr对象，会导致多个智能指针各自维护引用计数，最终引发内存重复释放的未定义行为；此外，shared_ptr的引用计数机制会带来轻微的性能开销，在高频访问场景下需谨慎使用。

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

int main() {
    // 基本使用示例：多个shared_ptr共享同一内存
    shared_ptr<int> ptr1(new int(30)); // 引用计数=1
    shared_ptr<int> ptr2 = ptr1; // 拷贝，引用计数=2
    shared_ptr<int> ptr3(ptr1); // 拷贝构造，引用计数=3
    cout << "引用计数：" << ptr1.use_count() << endl; // 输出3
    cout << *ptr1 << " " << *ptr2 << " " << *ptr3 << endl; // 输出30 30 30
    
    // 循环引用示例（内存泄漏）
    struct Node {
        shared_ptr<Node> next; // 节点的next指针为shared_ptr
    };
    shared_ptr<Node> node1(new Node()); // node1引用计数=1
    shared_ptr<Node> node2(new Node()); // node2引用计数=1
    node1->next = node2; // node2引用计数=2
    node2->next = node1; // node1引用计数=2
    // 程序结束时，node1和node2销毁，引用计数均变为1，无法释放内存，造成泄漏
    return 0;
}

4. weak_ptr（弱引用智能指针）

weak_ptr是C++11为解决shared_ptr循环引用问题而专门设计的弱引用智能指针，它不拥有内存的所有权，仅对shared_ptr指向的内存进行弱引用，不会增加引用计数。weak_ptr无法直接解引用访问内存资源，需通过lock()方法获取一个shared_ptr对象，若此时内存未被释放，lock()返回有效shared_ptr；若内存已释放，lock()返回空shared_ptr，有效避免了悬空指针问题。weak_ptr通常作为观察者，用于辅助shared_ptr管理内存，除了解决循环引用，还可用于观察内存是否有效，适合在不影响内存生命周期的场景下使用。

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

struct Node {
    weak_ptr<Node> next; // 用weak_ptr替代shared_ptr，避免循环引用
};

int main() {
    shared_ptr<Node> node1(new Node()); // node1引用计数=1
    shared_ptr<Node> node2(new Node()); // node2引用计数=1
    node1->next = node2; // weak_ptr不增加引用计数，node2计数仍为1
    node2->next = node1; // weak_ptr不增加引用计数，node1计数仍为1
    
    // 通过lock()方法获取shared_ptr，访问内存
    shared_ptr<Node> temp = node1->next.lock();
    if (temp) {
        cout << "内存有效" << endl;
    } else {
        cout << "内存已释放" << endl;
    }
    
    cout << "node1引用计数：" << node1.use_count() << endl; // 输出1
    cout << "node2引用计数：" << node2.use_count() << endl; // 输出1
    // 程序结束时，node1和node2销毁，引用计数变为0，内存正常释放
    return 0;
}

二、手撕shared_ptr核心实现

shared_ptr的核心是引用计数和资源管理，其底层通过两个指针实现：一个指向动态内存的裸指针（管理资源），一个指向引用计数的指针（管理引用次数）。下面实现一个简化版shared_ptr，包含构造、拷贝、赋值、析构及解引用等核心功能，忽略线程安全（标准库中shared_ptr的引用计数是线程安全的）、定制删除器、动态数组管理等复杂细节。

#include <iostream>
using namespace std;

template<typename T>
class MySharedPtr {
private:
    T* ptr;          // 指向动态内存的裸指针，负责访问资源
    int* refCount;   // 指向引用计数的指针，多个对象共享同一计数

public:
    // 构造函数：初始化资源和引用计数
    MySharedPtr(T* p = nullptr) : ptr(p), refCount(new int(1)) {
        if (!p) *refCount = 0; // 若传入空指针，引用计数设为0
    }

    // 拷贝构造函数：共享资源，引用计数加1
    MySharedPtr(const MySharedPtr& other) {
        ptr = other.ptr;         // 共享裸指针，指向同一内存
        refCount = other.refCount; // 共享引用计数指针
        if (ptr) (*refCount)++;  // 若资源有效，计数加1
    }

    // 赋值运算符重载：释放当前资源，共享新资源
    MySharedPtr& operator=(const MySharedPtr& other) {
        if (this == &other) return *this; // 自赋值判断，避免重复操作
        
        // 释放当前资源：计数减1，若为0则彻底释放内存和计数
        if (ptr && --(*refCount) == 0) {
            delete ptr;         // 释放动态内存
            delete refCount;    // 释放引用计数内存
        }
        
        // 共享新资源，更新指针和计数
        ptr = other.ptr;
        refCount = other.refCount;
        if (ptr) (*refCount)++;
        
        return *this;
    }

    // 解引用运算符：访问资源
    T& operator*() const { return *ptr; }
    // 箭头运算符：访问资源的成员（如对象的成员函数、成员变量）
    T* operator->() const { return ptr; }

    // 获取当前引用计数
    int use_count() const { return *refCount; }

    // 析构函数：释放资源（生命周期结束时调用）
    ~MySharedPtr() {
        // 计数减1，若为0则释放资源
        if (ptr && --(*refCount) == 0) {
            delete ptr;
            delete refCount;
            cout << "内存已释放" << endl; // 提示内存释放成功
        }
    }
};

// 测试简化版shared_ptr的功能
int main() {
    MySharedPtr<int> ptr1(new int(100)); // 初始化，计数=1
    cout << "ptr1引用计数：" << ptr1.use_count() << endl; // 输出1
    cout << "ptr1指向的值：" << *ptr1 << endl; // 输出100
    
    MySharedPtr<int> ptr2 = ptr1; // 拷贝，计数=2
    cout << "拷贝后引用计数：" << ptr1.use_count() << endl; // 输出2
    cout << "ptr2指向的值：" << *ptr2 << endl; // 输出100
    
    MySharedPtr<int> ptr3(new int(200)); // 新初始化，计数=1
    ptr3 = ptr1; // 赋值，释放ptr3原有资源，共享ptr1的资源，计数=3
    cout << "赋值后引用计数：" << ptr1.use_count() << endl; // 输出3
    
    return 0; // 程序结束，三个对象销毁，计数降至0，输出"内存已释放"
}

三、总结

智能指针是C++内存管理的核心工具，其本质是通过RAII机制封装裸指针，实现动态内存的自动管理，从根源上减少内存泄漏、重复释放等问题。

本文介绍的四种智能指针中，auto_ptr因设计缺陷已被弃用，实际开发中应坚决避免使用；unique_ptr实现独占式所有权，效率高、安全性强，适合管理单个对象的动态内存；shared_ptr实现共享式所有权，灵活性高，是日常开发中最常用的智能指针，但需注意规避循环引用问题；weak_ptr作为辅助工具，用于解决shared_ptr的循环引用，不拥有资源所有权，仅提供弱引用功能。