C++智能指针在内存管理中的应用

P粉602998670

发布时间：2025-09-13 10:55:01

379人浏览过

来源于php中文网

原创

C++智能指针通过RAII机制自动化内存管理，避免内存泄漏和野指针。std::unique_ptr以独占所有权和移动语义确保资源唯一归属；std::shared_ptr通过引用计数实现共享所有权，但需警惕循环引用，可用std::weak_ptr打破；智能指针还可管理文件句柄、互斥锁等非内存资源；手动内存管理仅在底层编程、性能极致要求等少数场景下必要。

c++智能指针在内存管理中的应用

C++智能指针在内存管理中的核心作用，在于将资源（主要是堆内存）的生命周期管理自动化，通过RAII（Resource Acquisition Is Initialization）原则，有效避免了传统C++中常见的内存泄漏、野指针和二次释放等问题，极大地提升了代码的安全性、健壮性和开发效率。它让我们从繁琐的手动

new

和

delete

中解脱出来，能够更专注于业务逻辑的实现。

解决方案

智能指针通过封装原始指针，并利用对象生命周期来管理其所指向的资源。当智能指针对象被销毁时（例如，超出作用域或被删除），它会自动释放所管理的资源。C++标准库提供了几种主要的智能指针类型，每种都有其特定的所有权语义和应用场景：

std::unique_ptr

、

std::shared_ptr

和

std::weak_ptr

。

std::unique_ptr

实现了独占所有权。这意味着一个资源只能由一个

unique_ptr

管理。当

unique_ptr

被销毁时，它所拥有的资源也会被释放。它不能被复制，但可以通过移动语义转移所有权。这种特性使其非常适合用于局部变量、工厂函数返回对象，或任何需要明确资源归属权的场景。

std::shared_ptr

实现了共享所有权。多个

shared_ptr

可以共同拥有同一个资源。它内部维护一个引用计数，每当一个新的

shared_ptr

指向该资源时，引用计数加一；每当一个

shared_ptr

被销毁或不再指向该资源时，引用计数减一。当引用计数归零时，资源才会被释放。这对于需要在多个地方共享同一资源但又不确定何时可以安全释放的场景非常有用。

立即学习“C++免费学习笔记（深入）”；

std::weak_ptr

是一种不拥有资源的智能指针。它被设计用来解决

shared_ptr

可能导致的循环引用问题。

weak_ptr

可以观察

shared_ptr

所管理的资源，但不会增加引用计数。它提供了一种检查资源是否仍然存在的方式，如果资源已被释放，

weak_ptr

会变为空。要访问

weak_ptr

所指向的资源，需要先将其转换为

shared_ptr

。

std::unique_ptr

究竟如何确保资源独占性？

我个人觉得，

unique_ptr

的设计哲学非常直观，就是“我的就是我的，你拿走就不是我的了”。它通过几个核心机制来强制执行这种独占性：

首先，

unique_ptr

的拷贝构造函数和拷贝赋值运算符被显式地标记为

delete

。这意味着你不能像复制普通对象那样复制一个

unique_ptr

。比如，

std::unique_ptr p1(new int(10)); std::unique_ptr p2 = p1;

这样的代码在编译时就会报错，因为它试图复制一个不可复制的对象。这种限制从根本上杜绝了多个

unique_ptr

同时拥有同一块内存的可能性，也就避免了双重释放（double-free）的风险。

其次，它拥抱了C++11引入的移动语义。虽然不能复制，但

unique_ptr

可以被“移动”。这意味着所有权可以从一个

unique_ptr

转移到另一个

unique_ptr

。当一个

unique_ptr

被移动后，原有的

unique_ptr

会变为空（不再拥有资源），而新的

unique_ptr

则获得了对资源的独占所有权。这通过

std::move

函数实现，比如

std::unique_ptr p2 = std::move(p1);

。这种机制确保了在任何时刻，资源都只有一个明确的拥有者。

举个例子：

#include 
#include 
#include 

class MyObject {
public:
    MyObject(int id) : id_(id) {
        std::cout << "MyObject " << id_ << " constructed." << std::endl;
    }
    ~MyObject() {
        std::cout << "MyObject " << id_ << " destroyed." << std::endl;
    }
    void doSomething() {
        std::cout << "MyObject " << id_ << " doing something." << std::endl;
    }
private:
    int id_;
};

// 工厂函数返回一个独占所有权的MyObject
std::unique_ptr createObject(int id) {
    return std::make_unique(id); // 使用make_unique更安全高效
}

void processObject(std::unique_ptr obj) {
    if (obj) { // 检查是否为空
        obj->doSomething();
    }
    // obj 在这里超出作用域，它所拥有的MyObject会被自动销毁
}

int main() {
    std::cout << "--- unique_ptr example start ---" << std::endl;
    std::unique_ptr obj1 = createObject(1);
    obj1->doSomething();

    // 尝试复制会编译错误：
    // std::unique_ptr obj_copy = obj1; 

    // 移动所有权
    std::unique_ptr obj2 = std::move(obj1); 
    if (obj1) { // obj1 此时已经为空
        obj1->doSomething(); // 不会执行
    } else {
        std::cout << "obj1 is now empty after move." << std::endl;
    }
    obj2->doSomething();

    // 将所有权传递给函数
    processObject(std::move(obj2));
    if (!obj2) {
        std::cout << "obj2 is now empty after passing to function." << std::endl;
    }

    // 在vector中存储unique_ptr
    std::vector> objects;
    objects.push_back(std::make_unique(3));
    objects.push_back(std::make_unique(4));
    // 当objects超出作用域时，其中的MyObject也会被自动销毁

    std::cout << "--- unique_ptr example end ---" << std::endl;
    return 0;
}

输出会清晰地展示对象的构造和销毁时机，以及所有权转移后的状态。

unique_ptr

保证了资源在任何时候都只有一个明确的“主人”，一旦这个主人消失，资源也随之释放，这正是其独占性的魅力所在。

std::shared_ptr

的引用计数机制有哪些潜在陷阱和最佳实践？

初次接触

shared_ptr

时，我曾天真地以为它能解决所有问题，直到我遇到了循环引用这个“甜蜜的陷阱”。

shared_ptr

的核心是引用计数，它很方便，但如果使用不当，反而会造成内存泄漏。

潜在陷阱：循环引用

当两个或多个

shared_ptr

相互持有对方的

shared_ptr

时，就会形成循环引用。在这种情况下，即使外部已经没有

shared_ptr

指向它们，它们的引用计数也永远不会降到零，因为它们自己互相引用着。这会导致它们所管理的资源永远不会被释放，从而造成内存泄漏。

考虑一个简单的双向链表节点：

#include 
#include 

class Node {
public:
    int value;
    std::shared_ptr next;
    std::shared_ptr prev; // 这里的prev是问题所在

    Node(int val) : value(val) {
        std::cout << "Node " << value << " constructed." << std::endl;
    }
    ~Node() {
        std::cout << "Node " << value << " destroyed." << std::endl;
    }
};

void createCircularReference() {
    std::shared_ptr node1 = std::make_shared(1);
    std::shared_ptr node2 = std::make_shared(2);

    node1->next = node2; // node2的引用计数变为2
    node2->prev = node1; // node1的引用计数变为2

    // 此时，即使node1和node2超出作用域
    // node1的引用计数仍为1（被node2->prev引用）
    // node2的引用计数仍为1（被node1->next引用）
    // 它们都不会被销毁，内存泄漏
} // node1, node2超出作用域，但Node 1和Node 2的析构函数不会被调用

int main() {
    std::cout << "--- Shared_ptr circular reference example start ---" << std::endl;
    createCircularReference();
    std::cout << "--- Shared_ptr circular reference example end ---" << std::endl;
    // 你会发现，程序结束时，Node 1和Node 2的析构函数并没有被调用
    return 0;
}

最佳实践：使用

std::weak_ptr

打破循环引用

std::weak_ptr

就是为了解决循环引用而生的。它是一种非拥有型智能指针，它观察

shared_ptr

管理的资源，但不会增加引用计数。当需要访问资源时，

weak_ptr

可以被转换为

shared_ptr

。如果资源已经被释放，转换会失败，返回一个空的

shared_ptr

。

修改上面的链表节点，将

prev

改为

weak_ptr

：

云网OA

采用JSP开发的办公自动化产品、基于B/S结构，运行环境：JDK v1.5、Tomcat v5.5、MySQL v4.1，三者均为以上版本其他相关内容：可视化流程设计：流程支持串签、会签和分支流程，可以设置流程节点的修改、删除权限，并可指定流程中各个用户在表单中可以填写的域。智能表单所见即所得设计：智能设计，自动在数据库中生成表格，方便优化程序公共交流：集论坛、博客、聊天室于一体文件柜：C

下载

#include 
#include 

class NodeFixed {
public:
    int value;
    std::shared_ptr next;
    std::weak_ptr prev; // 使用weak_ptr

    NodeFixed(int val) : value(val) {
        std::cout << "NodeFixed " << value << " constructed." << std::endl;
    }
    ~NodeFixed() {
        std::cout << "NodeFixed " << value << " destroyed." << std::endl;
    }
};

void createNoCircularReference() {
    std::shared_ptr node1 = std::make_shared(1);
    std::shared_ptr node2 = std::make_shared(2);

    node1->next = node2; // node2的引用计数变为2
    node2->prev = node1; // node1的引用计数不变，因为是weak_ptr

    // 此时，当node1和node2超出作用域时
    // node1的引用计数降为0，NodeFixed 1被销毁
    // NodeFixed 1销毁后，node1->next（即node2）的引用计数降为1
    // 接着node2的引用计数降为0，NodeFixed 2被销毁
} // node1, node2超出作用域，NodeFixed 1和NodeFixed 2的析构函数会被调用

int main() {
    std::cout << "--- Shared_ptr with weak_ptr example start ---" << std::endl;
    createNoCircularReference();
    std::cout << "--- Shared_ptr with weak_ptr example end ---" << std::endl;
    // 此时，程序结束时，你会看到NodeFixed 1和NodeFixed 2的析构函数都被调用了
    return 0;
}

其他最佳实践：

避免从原始指针创建多个
shared_ptr
：永远不要这样做
```
std::shared_ptr p1(raw_ptr); std::shared_ptr p2(raw_ptr);
```
。这会导致两个独立的引用计数，最终对同一块内存进行两次释放。正确的做法是，一旦资源由
```
shared_ptr
```
管理，就始终通过
```
shared_ptr
```
来传递和访问它，或者使用
```
std::enable_shared_from_this
```
。
优先使用
std::make_shared
：它不仅更简洁，而且在性能上通常优于
```
new
```
和
```
shared_ptr
```
构造函数的组合。
```
make_shared
```
只进行一次内存分配，同时为对象和控制块（包含引用计数等信息）分配内存，而分开创建则需要两次分配。
理解线程安全：
```
shared_ptr
```
的引用计数操作是原子性的，因此在多线程环境下增加或减少引用计数是安全的。然而，
```
shared_ptr
```
所指向的对象本身的访问和修改并不是自动线程安全的。如果多个线程会修改同一个
```
shared_ptr
```
指向的对象，你仍然需要使用互斥锁（
```
std::mutex
```
）或其他同步机制来保护对该对象的访问。

除了内存，智能指针还能管理哪些类型的资源？

别以为智能指针只管内存那点事，它的“野心”可大着呢。智能指针，尤其是

std::unique_ptr

，其本质是一个遵循 RAII 原则的通用资源管理工具。只要是任何需要配对操作（获取-释放、打开-关闭、锁定-解锁）的资源，它都能胜任。这得益于

unique_ptr

允许你提供自定义的删除器（deleter）。

一些常见的非内存资源管理场景包括：

文件句柄： 在C语言风格的API中，文件通常通过

FILE*

句柄操作，需要

fclose()

来关闭。

#include 
#include 
#include  // For FILE, fopen, fclose

// 自定义删除器，用于关闭文件
struct FileCloser {
    void operator()(FILE* file) const {
        if (file) {
            std::cout << "Closing file..." << std::endl;
            fclose(file);
        }
    }
};

int main() {
    // 使用unique_ptr管理FILE*，并指定自定义删除器
    std::unique_ptr filePtr(fopen("example.txt", "w"));

    if (filePtr) {
        fprintf(filePtr.get(), "Hello from unique_ptr!\n");
        std::cout << "File written successfully." << std::endl;
    } else {
        std::cerr << "Failed to open file." << std::endl;
    }
    // filePtr超出作用域时，FileCloser会被调用，自动关闭文件
    return 0;
}

互斥锁（Mutex）： 在多线程编程中，

std::lock_guard

和

std::unique_lock

已经是RAII的典范，但如果你需要更灵活的自定义锁管理，或者处理一些非标准库的锁，

unique_ptr

也可以派上用场。

#include 
#include 
#include  // For std::mutex

std::mutex myMutex;

// 自定义删除器，用于解锁互斥量
struct MutexUnlocker {
    void operator()(std::mutex* mtx) const {
        if (mtx && mtx->try_lock()) { // 避免解锁未锁定的互斥量
             mtx->unlock();
             std::cout << "Mutex unlocked." << std::endl;
        } else if (mtx) {
            std::cout << "Mutex was already unlocked or could not be locked for unlock." << std::endl;
        }
    }
};

void accessProtectedResource() {
    // 尝试锁定互斥量，并用unique_ptr管理其生命周期
    std::unique_ptr lockGuard(&myMutex);
    myMutex.lock(); // 实际锁定
    std::cout << "Resource accessed, mutex is locked." << std::endl;
    // lockGuard超出作用域时，myMutex会被自动解锁
} // 离开作用域时，MutexUnlocker被调用，解锁myMutex

当然，对于标准库的

std::mutex

，我们通常会直接使用

std::lock_guard

或

std::unique_lock

，它们是专门为锁管理设计的更安全、更惯用的RAII封装。这里只是为了演示

unique_ptr

的通用性。

网络套接字、数据库连接、图形API资源（如OpenGL纹理、DirectX缓冲区）： 这些资源通常需要显式的创建和销毁函数。通过自定义删除器，
```
unique_ptr
```
可以很好地管理它们。例如，一个管理Winsock套接字的
```
unique_ptr
```
可以在其删除器中调用
```
closesocket()
```
。
动态链接库句柄： 在Windows上是
```
HMODULE
```
，需要
```
FreeLibrary()
```
；在Linux上是
```
void*
```
，需要
```
dlclose()
```
。这些都可以用
```
unique_ptr
```
加自定义删除器来管理。

关键在于，

unique_ptr

的第二个模板参数

Deleter

可以是任何可调用对象（函数指针、函数对象、lambda表达式），只要它能接受原始指针作为参数并执行清理操作即可。这种灵活性使得

unique_ptr

成为了一个强大的、通用的资源管理工具，远不止局限于内存管理。

在现代C++项目中，何时仍然需要手动管理内存？

虽然智能指针大大简化了开发，但我有时还是会遇到那些不得不亲自动手“搬砖”的场景。在现代C++中，手动管理内存（即直接使用

new

和

delete

）应该是非常罕见且经过深思熟虑的选择，但以下几种情况，它可能仍然是必要的：

底层系统编程和嵌入式开发： 在资源极其有限的嵌入式系统、操作系统内核或设备驱动程序中，对内存的精确控制至关重要。智能指针的额外开销（即使很小，如
```
shared_ptr
```
的控制块）可能无法接受。此外，在这些环境中，内存分配器可能不是标准的
```
new
```
/
```
delete
```
，而是定制的、更直接的内存操作。
自定义内存分配器： 当你需要实现自己的内存池、竞技场分配器（arena allocator）或其他高性能、特定用途的内存管理策略时，你通常会直接操作原始内存块，而不是通过智能指针。智能指针可以用来管理这些自定义分配器分配出来的对象，但分配器本身的操作往往是手动的。
与C语言API交互： 很多C库返回的是原始指针，并且要求你手动调用特定的
```
free
```
函数（例如
```
malloc
```
/
```
free
```
，或者
```
SDL_malloc
```
/
```
SDL_free
```
）。虽然你可以通过
```
unique_ptr
```
的自定义删除器来封装这些C API，但有时候，为了避免引入额外的抽象层或在性能敏感的循环中，直接使用C风格的内存管理可能更直接。
性能极度敏感的代码： 在某些对性能有极致要求的场景下，即使是
```
unique_ptr
```
的微小开销（例如，在某些极端情况下，编译器可能无法完全优化掉其内部的指针检查）也可能被认为过高。此时，程序员可能会选择手动管理内存以获得最细粒度的控制，尽管这通常意味着更高的风险和维护成本。
实现智能指针本身： 显然，当你自己在实现一个智能指针类时，你需要在其内部直接使用
```
new
```
和
```
delete
```
来管理原始内存。
某些数据结构和算法： 在实现一些复杂的数据结构（例如，某些形式的图、树或自定义容器）时，为了优化内存布局、减少碎片或实现特殊的内存管理策略，可能需要直接控制对象的创建和销毁。