C++智能指针 STL内存管理方案-C++-PHP中文网

C++智能指针通过RAII机制自动管理内存，避免泄漏和悬空指针。std::unique_ptr独占所有权，高效安全；std::shared_ptr共享所有权，用引用计数管理生命周期；std::weak_ptr打破循环引用，实现非拥有式观察，三者结合STL容器可简化资源管理。

c++智能指针 stl内存管理方案

C++的智能指针，在我看来，是现代C++编程中处理内存管理的一剂良药，它极大地简化了资源管理，尤其是在与STL容器结合使用时，能有效避免内存泄漏和悬空指针等常见问题。它本质上就是一种RAII（Resource Acquisition Is Initialization）的实践，把资源的生命周期与对象的生命周期绑定起来，当对象超出作用域时，资源也自动释放。这比手动管理内存省心太多了，也更安全。

解决方案

在C++中，要妥善管理内存，特别是配合STL容器使用时，智能指针是不可或缺的工具。核心方案是根据所有权模型选择合适的智能指针类型：

std::unique_ptr

登录后复制

、

std::shared_ptr

登录后复制

和

std::weak_ptr

登录后复制

。它们分别对应独占所有权、共享所有权和非拥有观察者模式。通过将动态分配的对象封装在这些智能指针中，当智能指针本身被销毁时，它所管理的对象也会被自动删除，从而避免内存泄漏。对于STL容器，可以直接存储智能指针对象，例如

std::vector<std::unique_ptr<MyObject>>

登录后复制

，这使得容器在析构时能够自动清理其内部存储的所有动态分配的对象，极大地简化了资源管理逻辑。

std::unique_ptr

登录后复制

：独占所有权的内存管理利器

std::unique_ptr

登录后复制

，顾名思义，它代表的是一种独占所有权。也就是说，一个动态分配的对象只能被一个

unique_ptr

登录后复制

实例拥有。我个人非常喜欢用它，因为它几乎没有运行时开销，和裸指针一样高效，但却提供了自动内存管理的安全保障。它不支持拷贝构造和拷贝赋值，这强制你思考资源的所有权转移问题，只能通过移动语义来转移所有权。这在设计上就避免了许多潜在的陷阱，比如双重释放。

它特别适合用在以下场景：

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

当一个对象只由一个所有者管理，并在所有者销毁时被销毁。
作为函数的返回值，表示所有权的转移。
在工厂函数中创建对象并返回。
作为类成员，管理其内部的动态分配资源。

举个例子，如果你有一个

std::vector

登录后复制

，里面存放的元素是动态创建的，并且你希望每个元素都由

vector

登录后复制

独占管理，那么

std::vector<std::unique_ptr<MyClass>>

登录后复制

就是完美的解决方案。当

vector

登录后复制

被销毁时，它会负责调用每个

unique_ptr

登录后复制

的析构函数，进而释放所有

MyClass

登录后复制

对象占用的内存。这比你手动遍历

vector

登录后复制

然后

delete

登录后复制

每个元素要安全和简洁得多，也更容易维护。

#include <iostream>
#include <memory> // For std::unique_ptr
#include <vector>

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

// 示例：unique_ptr 作为函数返回值，转移所有权
std::unique_ptr<MyResource> createResource(int id) {
    return std::make_unique<MyResource>(id);
}

int main() {
    // 独占所有权示例
    std::unique_ptr<MyResource> res1 = std::make_unique<MyResource>(1);
    res1->doSomething();

    // 所有权转移
    std::unique_ptr<MyResource> res2 = std::move(res1); // res1 变为空
    if (res1) {
        std::cout << "res1 still holds resource." << std::endl;
    } else {
        std::cout << "res1 no longer holds resource." << std::endl;
    }
    res2->doSomething();

    // unique_ptr 和 STL 容器
    std::vector<std::unique_ptr<MyResource>> resources;
    resources.push_back(std::make_unique<MyResource>(3));
    resources.push_back(createResource(4)); // 函数返回 unique_ptr

    for (const auto& r_ptr : resources) {
        r_ptr->doSomething();
    }

    // main 函数结束时，res2 和 resources 中的 MyResource 对象都会被自动销毁
    std::cout << "End of main function." << std::endl;
    return 0;
}

登录后复制

std::shared_ptr

登录后复制

：处理共享所有权的理想选择

当多个对象需要共享同一个资源的生命周期时，

std::shared_ptr

登录后复制

就派上用场了。它通过引用计数（reference counting）机制来管理内存：每当有一个

shared_ptr

登录后复制

指向同一个资源时，引用计数就增加；当一个

shared_ptr

登录后复制

被销毁或重新指向其他资源时，引用计数就减少。当引用计数归零时，表示没有

shared_ptr

登录后复制

再引用该资源，资源就会被自动释放。这解决了多方协同管理资源生命周期的难题。

shared_ptr

登录后复制

的优势在于其灵活性，但随之而来的也有一些需要注意的地方。引用计数会带来一定的运行时开销，而且如果设计不当，可能会导致循环引用（circular reference），进而造成内存泄漏。这是使用

shared_ptr

登录后复制

时最常见也最需要警惕的问题。

乾坤圈新媒体矩阵管家

新媒体账号、门店矩阵智能管理系统

查看详情

它适用于：

多个对象需要共同拥有并管理一个资源的生命周期。
在复杂对象图中，资源需要在不同部分之间共享。

比如，你有一个缓存系统，多个客户端可能会访问同一个数据对象。每个客户端都持有一个

shared_ptr

登录后复制

，当所有客户端都不再需要这个数据时，它就会被自动清理。这比手动追踪哪个客户端是最后一个使用者要方便得多。

#include <iostream>
#include <memory> // For std::shared_ptr
#include <vector>

class SharedResource {
public:
    SharedResource(int id) : id_(id) {
        std::cout << "SharedResource " << id_ << " constructed." << std::endl;
    }
    ~SharedResource() {
        std::cout << "SharedResource " << id_ << " destructed." << std::endl;
    }
    void use() {
        std::cout << "SharedResource " << id_ << " is being used. Current ref count: "
                  << shared_from_this().use_count() << std::endl;
    }
private:
    int id_;
};

int main() {
    std::shared_ptr<SharedResource> s_res1 = std::make_shared<SharedResource>(100);
    std::cout << "s_res1 ref count: " << s_res1.use_count() << std::endl;

    std::shared_ptr<SharedResource> s_res2 = s_res1; // 拷贝，引用计数增加
    std::cout << "s_res1 ref count: " << s_res1.use_count() << std::endl;
    std::cout << "s_res2 ref count: " << s_res2.use_count() << std::endl;

    {
        std::shared_ptr<SharedResource> s_res3 = s_res1; // 再次拷贝
        std::cout << "s_res1 ref count: " << s_res1.use_count() << std::endl;
        s_res3->use();
    } // s_res3 离开作用域，引用计数减少

    std::cout << "s_res1 ref count after s_res3 out of scope: " << s_res1.use_count() << std::endl;

    // shared_ptr 和 STL 容器
    std::vector<std::shared_ptr<SharedResource>> shared_resources_vec;
    shared_resources_vec.push_back(s_res1); // s_res1 再次被拷贝
    shared_resources_vec.push_back(std::make_shared<SharedResource>(200));

    std::cout << "s_res1 ref count after vector push_back: " << s_res1.use_count() << std::endl;

    // main 函数结束时，所有 SharedResource 对象都会在引用计数归零时被销毁
    std::cout << "End of main function." << std::endl;
    return 0;
}

登录后复制

std::weak_ptr

登录后复制

：打破循环引用的关键与非拥有观察

std::weak_ptr

登录后复制

是

std::shared_ptr

登录后复制

的辅助工具，它不拥有所指向的对象，因此不会增加对象的引用计数。它的主要作用是观察

shared_ptr

登录后复制

管理的对象，而不会阻止该对象被销毁。这在处理

shared_ptr

登录后复制

可能导致的循环引用问题时显得尤为重要。

当两个或多个对象通过

shared_ptr

登录后复制

相互引用时，它们的引用计数永远不会归零，导致它们永远不会被销毁，这就是循环引用。

weak_ptr

登录后复制

通过提供一种非拥有式的引用，打破了这种循环。一个对象可以通过

shared_ptr

登录后复制

拥有另一个对象，而另一个对象则通过

weak_ptr

登录后复制

观察第一个对象。当第一个对象被销毁时，

weak_ptr

登录后复制

会自动失效，因为它观察的对象已经不存在了。

要访问

weak_ptr

登录后复制

指向的对象，你需要先调用它的

lock()

登录后复制

方法，该方法会返回一个

std::shared_ptr

登录后复制

。如果对象仍然存在，

lock()

登录后复制

会返回一个有效的

shared_ptr

登录后复制

；否则，它会返回一个空的

shared_ptr

登录后复制

。这提供了一种安全的方式来检查对象是否仍然存活。

使用场景：

打破
```
shared_ptr
```
登录后复制
造成的循环引用。
实现缓存机制，其中缓存项可以在不被引用时自动过期。
在父子关系中，子节点持有父节点的
```
shared_ptr
```
登录后复制
，而父节点持有子节点的
```
weak_ptr
```
登录后复制
。

说实话，刚接触

weak_ptr

登录后复制

时，觉得它有点绕，不如

unique_ptr

登录后复制

和

shared_ptr

登录后复制

那么直观。但一旦你遇到循环引用，或者需要设计一个观察者模式，但又不希望观察者“拥有”被观察者，

weak_ptr

登录后复制

的价值就凸显出来了。它是构建健壮、复杂对象关系图的关键一环。

#include <iostream>
#include <memory> // For std::shared_ptr, std::weak_ptr

class B; // 前向声明

class A {
public:
    std::shared_ptr<B> b_ptr;
    A() { std::cout << "A constructed." << std::endl; }
    ~A() { std::cout << "A destructed." << std::endl; }
    void link(std::shared_ptr<B> b) {
        b_ptr = b;
    }
};

class B {
public:
    std::weak_ptr<A> a_ptr; // 使用 weak_ptr 打破循环
    B() { std::cout << "B constructed." << std::endl; }
    ~B() { std::cout << "B destructed." << std::endl; }
    void link(std::shared_ptr<A> a) {
        a_ptr = a;
    }
    void accessA() {
        if (auto sp = a_ptr.lock()) { // 尝试获取 shared_ptr
            std::cout << "B can access A." << std::endl;
        } else {
            std::cout << "A no longer exists." << std::endl;
        }
    }
};

int main() {
    std::cout << "--- 循环引用问题（使用 weak_ptr 解决） ---" << std::endl;
    {
        std::shared_ptr<A> my_a = std::make_shared<A>();
        std::shared_ptr<B> my_b = std::make_shared<B>();

        // 相互引用
        my_a->link(my_b);
        my_b->link(my_a);

        std::cout << "my_a ref count: " << my_a.use_count() << std::endl; // 应该是 1 (my_a自己)
        std::cout << "my_b ref count: " << my_b.use_count() << std::endl; // 应该是 2 (my_b自己 + my_a->b_ptr)

        my_b->accessA(); // 此时 A 仍然存在
    } // my_a 和 my_b 离开作用域

    std::cout << "--- 离开作用域后，对象是否被销毁？ ---" << std::endl;
    // 由于 B 中使用了 weak_ptr，A 的引用计数会归零，A 会被销毁。
    // A 销毁后，其持有的 B 的 shared_ptr 也会失效，B 的引用计数归零，B 也会被销毁。
    // 如果 B 中也用 shared_ptr，则 A 和 B 都不会被销毁。

    // 再次尝试访问已销毁的 A
    std::shared_ptr<A> expired_a;
    std::shared_ptr<B> observer_b = std::make_shared<B>();
    observer_b->link(expired_a); // link to a null shared_ptr
    observer_b->accessA(); // 应该输出 "A no longer exists."

    std::cout << "End of main function." << std::endl;
    return 0;
}

登录后复制

以上就是C++智能指针 STL内存管理方案的详细内容，更多请关注php中文网其它相关文章！