C++ 智能指针完全指南：原理、用法与避坑实战 | 极客日志

C++算法

C++ 智能指针完全指南：原理、用法与避坑实战

本文详解 C++ 智能指针核心原理及实战应用。基于 RAII 机制解决异常下的资源泄漏问题。对比 auto_ptr、unique_ptr、shared_ptr 和 weak_ptr 的特性与场景，重点讲解 shared_ptr 引用计数实现及循环引用解决方案。涵盖定制删除器、线程安全注意事项及内存泄漏预防策略，帮助开发者安全高效地管理动态内存。

樱花落尽发布于 2026/3/29更新于 2026/4/141 浏览

一、智能指针的核心：RAII 设计思想

1.1 为什么需要智能指针？

手动管理内存的致命问题：异常导致资源泄漏。例如下面的代码，Divide抛出异常后，array1和array2的delete语句无法执行，造成内存泄漏：

double  { 
{
    
    
    
    
    * array1 =  [];
    * array2 =  [];
    
     {
         len, time;
        cin >> len >> time;
        cout << (len, time) << endl;
    }  (...) {
        cout <<  << array1 << endl;
        cout <<  << array2 << endl;
        [] array1;
        [] array2;
        ; 
    }
    
    cout <<  << array1 << endl;
    [] array1;
    cout <<  << array2 << endl;
    [] array2;
}
{
     {
        ();
    }  ( * errmsg) {
        cout << errmsg << endl;
    }  ( exception& e) {
        cout << e.() << endl;
    }  (...) {
        cout <<  << endl;
    }
     ;
}

template<class T>
class SmartPtr {
public:
    // 构造时获取资源（RAII）
    SmartPtr(T* ptr) :_ptr(ptr) {}
    // 析构时自动释放资源
    ~SmartPtr() {
        cout << "delete []:" << _ptr << endl;
        delete[] _ptr;
    }
    T& operator*() { return *_ptr; }
    T* operator->() { return _ptr; }
    T& operator[](size_t i) { return _ptr[i]; }
private:
    T* _ptr;
};
// int main() {
//     SmartPtr<int> sp1 = new int[5] {1, 2, 3, 4, 5};
//     *sp1 += 1;
//     sp1[2] += 1;
// 
//     SmartPtr<pair<int, int>> sp2 = new pair<int, int>[2];
//     sp2->first = 1;
//     sp2->second = 1;
// 
//     return 0;
// }

double Divide(int a, int b) { // 当 b == 0 时抛异常 if (b == 0) { throw "Divide by zero condition!"; } else { return (double)a / (double)b; } }
void Func() {
    SmartPtr<int> sp1 = new int[10];
    SmartPtr<int> sp2 = new int[10];
    int len, time;
    cin >> len >> time;
    cout << Divide(len, time) << endl;
}
int main() {
    try {
        Func();
    } catch (const char* errmsg) {
        cout << errmsg << endl;
    } catch (const exception& e) {
        cout << e.what() << endl;
    } catch (...) {
        cout << "未知异常" << endl;
    }
    return 0;
}

template <class T, class... Args>
shared_ptr<T> make_shared(Args&&... args);

智能指针	核心特性	适用场景	效率	注意事项
`unique_ptr`	独占资源，不支持拷贝	局部变量、函数返回值、容器元素	最高	移动后原对象悬空
`shared_ptr`	共享资源，支持拷贝	多对象共享资源、多线程共享数据	中等	避免循环引用（用 weak_ptr 解决）
`weak_ptr`	弱引用，不管理资源	解决 shared_ptr 循环引用、观察资源	高	需 lock() 获取 shared_ptr 才能访问资源

#include<memory>
class A {
public:
    A(int a1 = 1, int a2 = 1) :_a1(a1), _a2(a2) { cout << "A()" << endl; }
    ~A() { cout << "~A()" << endl; }
    int _a1 = 1;
    int _a2 = 1;
};
int main() {
    // 拷贝对象存在问题
    SmartPtr<int> sp1 = new int[10];
    SmartPtr<int> sp2(sp1);
    auto_ptr<A> ap1(new A);
    ap1->_a1++; // 管理全转移，ap1 悬空
    auto_ptr<A> ap2(ap1); // ap1->_a1++; // 这个时候就报错了
    ap2->_a1++;
    unique_ptr<A> up1(new A);
    // 不允许拷贝
    // unique_ptr<A> up2(up1);
    // unique_ptr<A> up2(move(up1)); // 可以移动
    up1->_a1++;
    up1.release();
    // if(up1)
    if (up1.operator bool()) {
        cout << "up1 不为空" << endl;
    } else {
        cout << "up1 为空" << endl;
    }
    shared_ptr<A> sp3(new A);
    // 支持拷贝
    shared_ptr<A> sp4(sp3);
    sp3->_a1++;
    return 0;
}

#include <memory>
struct Date {
    int _year, _month, _day;
    Date(int y=1, int m=1, int d=1) : _year(y), _month(m), _day(d) {}
    ~Date() { cout << "~Date()" << endl; }
};
int main() {
    // 构造：托管资源
    unique_ptr<Date> up1(new Date(2024, 10, 1));
    // 支持指针操作
    up1->_year = 2025;
    cout << up1->_year << endl;
    // 不支持拷贝（编译报错）
    // unique_ptr<Date> up2(up1);
    // 支持移动（资源所有权转移，up1 悬空）
    unique_ptr<Date> up3(move(up1));
    if (!up1) cout << "up1 已悬空" << endl;
    // 管理数组（特化版本，析构时用 delete[]）
    unique_ptr<Date[]> up4(new Date[5]);
    return 0;
}

namespace Scy {
template<class T>
class auto_ptr {
public:
    auto_ptr(T* ptr) :_ptr(ptr) { }
    auto_ptr(auto_ptr<T>& sp) :_ptr(sp._ptr) { // 管理权转移 sp._ptr = nullptr; }
    auto_ptr<T>& operator=(auto_ptr<T>& ap) {// 检测是否为自己给自己赋值
        if (this != &ap) {
            // 释放当前对象中资源
            if (_ptr) delete _ptr;
            // 转移 ap 中资源到当前对象中
            _ptr = ap._ptr;
            ap._ptr = NULL;
        }
        return *this;
    }
    ~auto_ptr() {
        if (_ptr) {
            cout << "delete:" << _ptr << endl;
            delete _ptr;
        }
    }
    // 像指针一样使用
    T& operator*() { return *_ptr; }
    T* operator->() { return _ptr; }
private:
    T* _ptr;
};
template<class T>
class unique_ptr {
public:
    explicit unique_ptr(T* ptr) :_ptr(ptr) { }
    ~unique_ptr() {
        if (_ptr) {
            cout << "delete:" << _ptr << endl;
            delete _ptr;
        }
    }
    // 像指针一样使用
    T& operator*() { return *_ptr; }
    T* operator->() { return _ptr; }
    unique_ptr(const unique_ptr<T>&sp) = delete;
    unique_ptr<T>& operator=(const unique_ptr<T>&sp) = delete;
    unique_ptr(unique_ptr<T> && sp) :_ptr(sp._ptr) { sp._ptr = nullptr; }
    unique_ptr<T>& operator=(unique_ptr<T> && sp) {
        delete _ptr;
        _ptr = sp._ptr;
        sp._ptr = nullptr;
    }
private:
    T* _ptr;
};
}

int main() {
    // 构造：托管资源，计数器初始为 1
    shared_ptr<Date> sp1(new Date(2024, 10, 1));
    cout << "sp1 引用计数：" << sp1.use_count() << endl; // 输出 1
    // 拷贝：计数器 +1
    shared_ptr<Date> sp2(sp1);
    shared_ptr<Date> sp3 = sp2;
    cout << "sp1 引用计数：" << sp1.use_count() << endl; // 输出 3
    // 移动：所有权转移，原对象悬空，计数器不变
    shared_ptr<Date> sp4(move(sp1));
    cout << "sp1 是否为空：" << (sp1 ? false : true) << endl; // 输出 true
    cout << "sp4 引用计数：" << sp4.use_count() << endl; // 输出 3
    // 管理数组（特化版本）
    shared_ptr<Date[]> sp5(new Date[5]);
    // 推荐：用 make_shared 构造（更高效，避免内存泄漏风险）
    auto sp6 = make_shared<Date>(2024, 10, 2);
    return 0;
}

#include<functional>
#include<atomic>
namespace Scy {
template<class T>
class shared_ptr {
public:
    explicit shared_ptr(T* ptr = nullptr) :_ptr(ptr), _pcount(new int(1)) // ,_pcount(new atomic<int>(1)) {}
    // RAII
    template<class D>
    explicit shared_ptr(T* ptr, D del) :_ptr(ptr), _pcount(new int(1)), _del(del) {}
    ~shared_ptr() {
        // 引用计数减到 0 ,说明最后一个管理智能指针对象，要释放资源
        release();
    }
    shared_ptr(const shared_ptr& sp) :_ptr(sp._ptr), _pcount(sp._pcount) {
        // 加加计数
        ++(*_pcount);
    }
    void release() {
        if (--(*_pcount) == 0) {
            // cout << "delete []:" << _ptr << endl;
            // delete _ptr;
            _del(_ptr);
            delete _pcount;
        }
    }
    // sp1 = sp3
    shared_ptr& operator=(const shared_ptr& sp) {
        // if (this != &sp)
        if (_ptr != sp._ptr) {
            release();
            _ptr = sp._ptr;
            _pcount = sp._pcount;
            ++(*_pcount);
        }
        return *this;
    }
    T* get() const { return _ptr; }
    int use_count() { return *_pcount; }
    T& operator*() { return *_ptr; }
    T* operator->() { return _ptr; }
    T& operator[](size_t i) { return _ptr[i]; }
private:
    T* _ptr;
    int* _pcount; // atomic<int>* _pcount;
    function<void(T*)> _del = [](T* ptr) {delete ptr; };
};
template<class T>
class weak_ptr {
public:
    weak_ptr() { }
    weak_ptr(const shared_ptr<T>& sp) :_ptr(sp.get()) { }
    // 不参与资源的管理
private:
    T* _ptr = nullptr; // int* _pcount;
};
}
// int main() {
//     Scy::shared_ptr<A> sp1(new A);
//     Scy::shared_ptr<A> sp2(sp1);
//     sp1 = sp1;
//     sp1 = sp2;
// 
//     Scy::shared_ptr<A> sp3(new A);
// 
//     sp1 = sp3;
// }

struct ListNode {
    int _data;
    shared_ptr<ListNode> _next; // 互相引用
    shared_ptr<ListNode> _prev;
    ~ListNode() { cout << "~ListNode()" << endl; }
};
int main() {
    shared_ptr<ListNode> n1(new ListNode);
    shared_ptr<ListNode> n2(new ListNode);
    cout << n1.use_count() << "," << n2.use_count() << endl; // 输出 1,1
    n1->_next = n2; // n2 计数 +1 → 2
    n2->_prev = n1; // n1 计数 +1 → 2
    // 析构 n1 和 n2：计数各减 1 → 1，无法释放资源（循环引用）
    cout << n1.use_count() << endl;
    cout << n2.use_count() << endl;
    return 0;
}

struct ListNode {
    int _data;
    weak_ptr<ListNode> _next; // 弱引用，不增加计数
    weak_ptr<ListNode> _prev;
    ~ListNode() { cout << "~ListNode()" << endl; }
};
int main() {
    shared_ptr<ListNode> n1(new ListNode);
    shared_ptr<ListNode> n2(new ListNode);
    n1->_next = n2; // weak_ptr 绑定 shared_ptr，n2 计数仍为 1
    n2->_prev = n1; // weak_ptr 绑定 shared_ptr，n1 计数仍为 1
    // 析构 n1 和 n2：计数各减 1 → 0，资源释放（输出~ListNode()两次）
    cout << n1.use_count() << endl;
    cout << n2.use_count() << endl;
    return 0;
}

int main() {
    std::shared_ptr<string> sp1(new string("111111"));
    std::shared_ptr<string> sp2(sp1);
    std::weak_ptr<string> wp = sp1;
    cout << wp.expired() << endl;
    cout << wp.use_count() << endl << endl;
    // sp1 和 sp2 都指向了其他资源，则 weak_ptr 就过期了
    sp1 = make_shared<string>("222222");
    cout << wp.expired() << endl;
    cout << wp.use_count() << endl << endl;
    // 没有过期，通过 lock 拷贝一个 shared_ptr 对象来访问资源
    if(!wp.expired()) {
        auto sp = wp.lock();
        cout << wp.expired() << endl;
        cout << wp.use_count() << endl << endl;
        *sp += "xxxxxxxx";
    }
    sp2 = make_shared<string>("333333");
    cout << wp.expired() << endl;
    cout << wp.use_count() << endl << endl;
    return 0;
}

template<class T>
void DeleteArrayFunc(T* ptr) { delete[] ptr; }
template<class T>
class DeleteArray {
public:
    void operator()(T* ptr) { delete[] ptr; }
};
int main() {
    // 定制删除器
    Scy::shared_ptr<A> sp1(new A[10], DeleteArray<A>());// 仿函数
    Scy::shared_ptr<A> sp2(new A[10], DeleteArrayFunc<A>);// 函数指针
    // 推荐
    Scy::shared_ptr<A> sp3(new A[10], [](A* ptr) {delete[] ptr; });// lambda
    Scy::shared_ptr<FILE> sp4(fopen("Test.cpp", "r"), [](FILE* ptr) {fclose(ptr); });
    Scy::shared_ptr<A> sp5(new A);
    // 删除器的位置是一致的，shared_ptr 在构造函数参数，unique_ptr 类模版的参数
    // 这里没有使用相同的方式还是挺坑的
    // 使用仿函数 unique_ptr 可以不在构造函数传递，因为仿函数类型构造的对象直接就可以调用
    // 但是下面的函数指针和 lambda 的类型不可以
    std::unique_ptr<A, DeleteArray<A>> up1(new A[10]); // 仿函数
    std::unique_ptr<A, void(*)(A*)> up2(new A[10], DeleteArrayFunc<A>);// 函数指针
    auto del = [](A* ptr) {delete[] ptr; };
    std::unique_ptr<A, decltype(del)> up3(new A[10], del); // lambda
    // 更简洁的方式
    // 因为 new[]经常使用，所以 unique_ptr 和 shared_ptr
    // 实现了⼀个特化版本，这个特化版本析构时用的 delete[]
    std::shared_ptr<A[]> sp10(new A[10]);
    std::unique_ptr<A[]> up10(new A[10]);
    auto sp11 = make_shared<A>(1, 1);
    return 0;
}

struct AA {
    int _a1 = 0;
    int _a2 = 0;
    ~AA() { cout << "~AA()" << endl; }
};
int main() {
    Scy::shared_ptr<AA> p(new AA);
    const size_t n = 100000;
    mutex mtx;
    auto func = [&]() {
        for (size_t i = 0; i < n; ++i) {
            // 这里智能指针拷贝会++计数
            Scy::shared_ptr<AA> copy(p);
            {
                unique_lock<mutex> lk(mtx);
                copy->_a1++;
                copy->_a2++;
            }
        }
    };
    thread t1(func);
    thread t2(func);
    t1.join();
    t2.join();
    cout << p->_a1 << endl;
    cout << p->_a2 << endl;
    cout << p.use_count() << endl;
    return 0;
}

int main() {
    // 申请一个 1G 未释放，这个程序多次运行也没啥危害
    // 因为程序马上就结束，进程结束各种资源也就回收了
    char* ptr = new char[1024 * 1024 * 1024];
    cout << (void*)ptr << endl;
    return 0;
}

C++ 智能指针完全指南：原理、用法与避坑实战

一、智能指针的核心：RAII 设计思想

1.1 为什么需要智能指针？

1.2 RAII：智能指针的设计灵魂

二、C++ 标准库智能指针：用法与场景

核心智能指针简介

补充知识点

2.1 unique_ptr：独占式智能指针（推荐优先使用）

2.2 shared_ptr：共享式智能指针（支持拷贝，重点了解）

核心原理

核心用法

2.3 weak_ptr：弱引用智能指针（解决循环引用）

2.3.1 循环引用问题（`shared_ptr`的致命缺陷）

2.3.2 用 weak_ptr 解决循环引用

2.3.3 weak_ptr 访问资源

2.4 使用示例演示

三、shared_ptr 的线程安全问题

四、C++11 和 boost 中智能指针的关系

五、内存泄漏：大型项目设计必备

5.1 什么是内存泄漏，内存泄漏的危害

5.2 如何避免内存泄漏

更多推荐文章

相关免费在线工具

C++ 智能指针完全指南：原理、用法与避坑实战

一、智能指针的核心：RAII 设计思想

1.1 为什么需要智能指针？

1.2 RAII：智能指针的设计灵魂

二、C++ 标准库智能指针：用法与场景

核心智能指针简介

补充知识点

2.1 unique_ptr：独占式智能指针（推荐优先使用）

2.2 shared_ptr：共享式智能指针（支持拷贝，重点了解）

核心原理

核心用法

2.3 weak_ptr：弱引用智能指针（解决循环引用）

2.3.1 循环引用问题（shared_ptr的致命缺陷）

2.3.2 用 weak_ptr 解决循环引用

2.3.3 weak_ptr 访问资源

2.4 使用示例演示

三、shared_ptr 的线程安全问题

四、C++11 和 boost 中智能指针的关系

五、内存泄漏：大型项目设计必备

5.1 什么是内存泄漏，内存泄漏的危害

5.2 如何避免内存泄漏

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具

2.3.1 循环引用问题（`shared_ptr`的致命缺陷）