C++如何使用智能指针替代裸指针提高安全性-C++-PHP中文网

智能指针通过RAII机制提升C++内存安全，unique_ptr实现独占所有权避免内存泄漏，shared_ptr通过引用计数支持共享所有权，weak_ptr打破循环引用。

c++如何使用智能指针替代裸指针提高安全性

在C++中，使用智能指针替代裸指针是提升代码安全性和健壮性的关键一步。它们通过自动化内存管理，有效杜绝了内存泄漏、悬空指针、重复释放等一系列长期困扰C++开发者的顽疾，让资源管理变得更加可靠和直观。

智能指针的核心在于它们遵循RAII（Resource Acquisition Is Initialization）原则，将资源的生命周期与对象的生命周期绑定。当智能指针对象超出作用域时，它所管理的资源（通常是堆内存）会自动被释放。这极大地简化了错误处理和异常安全代码的编写，让开发者能将更多精力放在业务逻辑而非繁琐的内存管理上。

为什么裸指针在C++中如此危险且难以驾驭？

回想一下，我们有多少次因为忘记

delete

登录后复制

而导致内存泄漏？或者，在复杂的函数调用链中，一个指针被提前释放，却仍有其他部分试图访问它，最终导致程序崩溃——这就是典型的悬空指针问题。裸指针的危险性，很大程度上源于其“无主”的特性。它仅仅是一个地址，不携带任何关于其所指向资源的所有权、生命周期或如何释放的信息。

这使得资源管理变得异常脆弱：

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

内存泄漏（Memory Leaks）：最常见的问题。当动态分配的内存不再被任何指针引用，且未被释放时，这块内存就永远丢失了，直到程序结束。在复杂的控制流、循环或异常处理中，很容易遗漏
```
delete
```
登录后复制
调用。
悬空指针（Dangling Pointers）：当一个指针所指向的内存被释放后，该指针仍然存在并可能被访问。如果后续代码试图解引用这个悬空指针，结果是未定义的行为，轻则数据损坏，重则程序崩溃。
重复释放（Double Free）：如果同一块内存被释放两次，同样会导致未定义行为，通常是程序崩溃。这在多线程环境或复杂的数据结构中尤其难以追踪。
所有权语义模糊：裸指针无法清晰表达谁拥有这块内存，谁负责释放它。这在函数参数传递、对象成员管理等场景下，极易引发误解和错误。

这些问题，即便是有经验的开发者也难以完全避免，因为它们往往潜藏在复杂的程序逻辑和异常路径中，难以通过简单的代码审查发现。

std::unique_ptr是如何解决独占所有权问题的？

std::unique_ptr

登录后复制

是C++11引入的智能指针，它体现了“独占所有权”的概念。这意味着在任何时候，只有一个

unique_ptr

登录后复制

可以指向特定的动态分配对象。这种独占性通过其非拷贝（non-copyable）特性来保证：你不能复制一个

unique_ptr

登录后复制

，但可以将其所有权转移（move）。

它的工作原理相当直接：

独占性：一个
```
unique_ptr
```
登录后复制
实例拥有它所指向资源的所有权。当你创建一个
```
unique_ptr
```
登录后复制
时，它就“霸占”了那块内存。
自动释放：当
```
unique_ptr
```
登录后复制
对象超出其作用域时（例如，函数返回、局部变量生命周期结束），它会自动调用其内部存储的删除器（默认为
```
delete
```
登录后复制
）来释放所管理的内存。这正是RAII的体现。
所有权转移：虽然不能拷贝，但可以通过
```
std::move
```
登录后复制
将所有权从一个
```
unique_ptr
```
登录后复制
转移到另一个。转移后，原来的
```
unique_ptr
```
登录后复制
就变成了空指针。

代码示例：

#include <iostream>
#include <memory>
#include <vector>

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

void processObject(std::unique_ptr<MyObject> obj) {
    if (obj) { // 检查指针是否有效
        obj->doSomething();
    }
    // obj 在这里超出作用域，MyObject 会自动销毁
}

int main() {
    // 使用 std::make_unique 创建 unique_ptr 是推荐做法
    // 它更安全，且可能更高效
    auto ptr1 = std::make_unique<MyObject>(1);
    ptr1->doSomething();

    // 转移所有权
    auto ptr2 = std::move(ptr1); // ptr1 现在是空的
    if (!ptr1) {
        std::cout << "ptr1 is now empty." << std::endl;
    }
    ptr2->doSomething();

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

    // 裸指针的风险对比 (不推荐的做法)
    // MyObject* rawPtr = new MyObject(3);
    // // 忘记 delete 就会内存泄漏
    // delete rawPtr; // 如果忘记这行，内存就泄露了

    // 智能指针在容器中的应用
    std::vector<std::unique_ptr<MyObject>> objects;
    objects.push_back(std::make_unique<MyObject>(4));
    objects.push_back(std::make_unique<MyObject>(5));
    // 当 vector 超出作用域时，所有 MyObject 都会被自动销毁

    return 0;
}

登录后复制

通过

std::unique_ptr

登录后复制

，我们几乎消除了内存泄漏和悬空指针的风险，因为内存的释放被绑定到了

unique_ptr

登录后复制

的生命周期上，由编译器和运行时系统自动管理。它就是为那些明确知道“谁拥有这个资源”的场景而生的。

知网AI智能写作

知网AI智能写作，写文档、写报告如此简单

查看详情

何时应该选择std::shared_ptr而非std::unique_ptr？

当资源需要被多个所有者共享，并且没有一个明确的单一所有者时，

std::shared_ptr

登录后复制

就派上用场了。它通过引用计数（reference counting）机制来管理资源的生命周期。每当一个新的

shared_ptr

登录后复制

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

shared_ptr

登录后复制

超出作用域或被重置时，引用计数就会减少。只有当引用计数归零时，资源才会被释放。

选择

std::shared_ptr

登录后复制

的典型场景包括：

共享数据：多个对象需要访问并共享同一个堆分配的数据结构。
工厂函数返回对象：当一个工厂函数创建了一个对象，但不知道谁最终会拥有它，或者可能有多个消费者。
缓存机制：缓存中的对象可能被多个客户端引用，当所有客户端都不再需要时，对象才应该被清除。
复杂图结构：节点之间相互引用，但没有一个明确的根节点来管理所有子节点的生命周期。

代码示例：

#include <iostream>
#include <memory>
#include <vector>

class Data {
public:
    Data(int val) : value_(val) {
        std::cout << "Data " << value_ << " created." << std::endl;
    }
    ~Data() {
        std::cout << "Data " << value_ << " destroyed." << std::endl;
    }
    void printValue() const {
        std::cout << "Data value: " << value_ << std::endl;
    }
private:
    int value_;
};

void consumer(std::shared_ptr<Data> data_ptr) {
    std::cout << "Consumer: ";
    data_ptr->printValue();
    // data_ptr 在这里超出作用域，引用计数会减少
}

int main() {
    // 推荐使用 std::make_shared 创建 shared_ptr
    // 它能更高效地分配内存，避免两次内存分配
    auto shared_data = std::make_shared<Data>(100); 
    std::cout << "Initial ref count: " << shared_data.use_count() << std::endl; // 1

    {
        auto another_ref = shared_data; // 拷贝，引用计数增加
        std::cout << "Ref count after copy: " << shared_data.use_count() << std::endl; // 2
        another_ref->printValue();
    } // another_ref 超出作用域，引用计数减少

    std::cout << "Ref count after another_ref out of scope: " << shared_data.use_count() << std::endl; // 1

    consumer(shared_data); // 传递拷贝，函数内部引用计数增加，函数返回后减少
    std::cout << "Ref count after consumer call: " << shared_data.use_count() << std::endl; // 1

    // 也可以将 shared_ptr 放入容器
    std::vector<std::shared_ptr<Data>> data_collection;
    data_collection.push_back(shared_data); // 引用计数增加
    std::cout << "Ref count after adding to vector: " << shared_data.use_count() << std::endl; // 2

    // 当 main 函数结束，shared_data 和 data_collection 中的 shared_ptr 都会超出作用域
    // 引用计数最终归零，Data 对象被销毁。
    return 0;
}

登录后复制

尽管

std::shared_ptr

登录后复制

带来了极大的便利，但它并非没有代价。引用计数的维护会带来一些运行时开销，而且如果处理不当，它也可能导致循环引用（circular references），即两个或多个

shared_ptr

登录后复制

相互引用，导致它们的引用计数永远不会归零，从而造成内存泄漏。为了解决这个问题，

std::weak_ptr

登录后复制

应运而生，它提供了一种非拥有性的引用，用于打破循环引用。

std::weak_ptr在解决循环引用中的作用是什么？

std::weak_ptr

登录后复制

是一种非拥有型（non-owning）的智能指针。它指向由

std::shared_ptr

登录后复制

管理的对象，但不会增加对象的引用计数。这意味着

weak_ptr

登录后复制

不会阻止它所指向的对象被销毁。它的主要用途就是解决

std::shared_ptr

登录后复制

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

想象一下，我们有两个类A和B，它们都各自拥有一个

shared_ptr

登录后复制

指向对方。

登录后复制

有一个

shared_ptr<B>

登录后复制

成员，

登录后复制

有一个

shared_ptr<A>

登录后复制

成员。当

登录后复制

和

登录后复制

都被创建并相互引用后，即使外部所有指向

登录后复制

和

登录后复制

的

shared_ptr

登录后复制

都失效了，它们各自内部的

shared_ptr

登录后复制

依然存在，使得引用计数永远不会降到零，导致这两个对象永远不会被销毁，造成内存泄漏。

这时候，

std::weak_ptr

登录后复制

就成了救星。我们可以让其中一个类（例如B）的成员使用

std::weak_ptr

登录后复制

来指向另一个对象（A）。

当
```
B
```
登录后复制
需要访问
```
A
```
登录后复制
时，它会尝试通过
```
weak_ptr
```
登录后复制
的
```
lock()
```
登录后复制
方法获取一个
```
shared_ptr
```
登录后复制
。
如果
```
A
```
登录后复制
对象仍然存在（即它的
```
shared_ptr
```
登录后复制
引用计数不为零），
```
lock()
```
登录后复制
会返回一个有效的
```
shared_ptr
```
登录后复制
。
如果
```
A
```
登录后复制
对象已经被销毁，
```
lock()
```
登录后复制
会返回一个空的
```
shared_ptr
```
登录后复制
。

这样，

登录后复制

对

登录后复制

的引用就不会增加

登录后复制

的引用计数，从而打破了循环，使得当外部所有对

登录后复制

的强引用（

shared_ptr

登录后复制

）消失时，

登录后复制

可以被正常销毁。当

登录后复制

被销毁后，

登录后复制

的

weak_ptr

登录后复制

就会变成空，

登录后复制

也就能在合适的时机被销毁了。

代码示例（循环引用与解决）：

#include <iostream>
#include <memory>

class B; // 前向声明

class A {
public:
    std::shared_ptr<B> b_ptr; // A 拥有 B
    A() { std::cout << "A created." << std::endl; }
    ~A() { std::cout << "A destroyed." << std::endl; }
    void setB(std::shared_ptr<B> b) { b_ptr = b; }
};

class B {
public:
    // std::shared_ptr<A> a_ptr; // 循环引用问题所在
    std::weak_ptr<A> a_ptr; // 使用 weak_ptr 解决循环引用
    B() { std::cout << "B created." << std::endl; }
    ~B() { std::cout << "B destroyed." << std::endl; }
    void setA(std::shared_ptr<A> a) { a_ptr = a; }
    void accessA() {
        if (auto shared_a = a_ptr.lock()) { // 尝试获取 shared_ptr
            std::cout << "B is accessing A." << std::endl;
            // shared_a->... 可以安全访问 A
        } else {
            std::cout << "A is no longer available." << std::endl;
        }
    }
};

int main() {
    std::cout << "--- 尝试创建循环引用 (如果 B 内部是 shared_ptr<A>) ---" << std::endl;
    // 如果 B 内部是 shared_ptr<A>，这里 A 和 B 都不会被销毁
    // {
    //     auto pA = std::make_shared<A>();
    //     auto pB = std::make_shared<B>();
    //     pA->setB(pB);
    //     pB->setA(pA);
    // } // A 和 B 的析构函数都不会被调用，内存泄漏！

    std::cout << "--- 使用 weak_ptr 解决循环引用 ---" << std::endl;
    {
        auto pA = std::make_shared<A>();
        auto pB = std::make_shared<B>();

        pA->setB(pB); // pA 强引用 pB
        pB->setA(pA); // pB 弱引用 pA

        std::cout << "pA ref count: " << pA.use_count() << std::endl; // 1 (来自 main)
        std::cout << "pB ref count: " << pB.use_count() << std::endl; // 2 (来自 main 和 pA->b_ptr)

        pB->accessA();
    } // pA 和 pB 超出作用域，析构函数会被调用
    std::cout << "--- 作用域结束 ---" << std::endl;

    return 0;
}

登录后复制

通过