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

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

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

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

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

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

delete

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

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

• 内存泄漏（Memory Leaks）：最常见的问题。当动态分配的内存不再被任何指针引用，且未被释放时，这块内存就永远丢失了，直到程序结束。在复杂的控制流、循环或异常处理中，很容易遗漏

  delete

  调用。
• 悬空指针（Dangling Pointers）：当一个指针所指向的内存被释放后，该指针仍然存在并可能被访问。如果后续代码试图解引用这个悬空指针，结果是未定义的行为，轻则数据损坏，重则程序崩溃。
• 重复释放（Double Free）：如果同一块内存被释放两次，同样会导致未定义行为，通常是程序崩溃。这在多线程环境或复杂的数据结构中尤其难以追踪。
• 所有权语义模糊：裸指针无法清晰表达谁拥有这块内存，谁负责释放它。这在函数参数传递、对象成员管理等场景下，极易引发误解和错误。

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

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

std::unique_ptr

unique_ptr

unique_ptr

它的工作原理相当直接：

1. 独占性：一个

   unique_ptr

   实例拥有它所指向资源的所有权。当你创建一个

   unique_ptr

   时，它就“霸占”了那块内存。
2. 自动释放：当

   unique_ptr

   对象超出其作用域时（例如，函数返回、局部变量生命周期结束），它会自动调用其内部存储的删除器（默认为

   delete

   ）来释放所管理的内存。这正是RAII的体现。
3. 所有权转移：虽然不能拷贝，但可以通过

   std::move

   将所有权从一个

   unique_ptr

   转移到另一个。转移后，原来的

   unique_ptr

   就变成了空指针。

代码示例：

#include 
#include 
#include 

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 obj) {
    if (obj) { // 检查指针是否有效
        obj->doSomething();
    }
    // obj 在这里超出作用域，MyObject 会自动销毁
}

int main() {
    // 使用 std::make_unique 创建 unique_ptr 是推荐做法
    // 它更安全，且可能更高效
    auto ptr1 = std::make_unique(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> objects;
    objects.push_back(std::make_unique(4));
    objects.push_back(std::make_unique(5));
    // 当 vector 超出作用域时，所有 MyObject 都会被自动销毁

    return 0;
}

通过

std::unique_ptr

unique_ptr

课游记AI

AI原生学习产品

下载

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

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

std::shared_ptr

shared_ptr

shared_ptr

选择

std::shared_ptr

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

代码示例：

#include 
#include 
#include 

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_ptr) {
    std::cout << "Consumer: ";
    data_ptr->printValue();
    // data_ptr 在这里超出作用域，引用计数会减少
}

int main() {
    // 推荐使用 std::make_shared 创建 shared_ptr
    // 它能更高效地分配内存，避免两次内存分配
    auto shared_data = std::make_shared(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> 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

shared_ptr

std::weak_ptr

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

std::weak_ptr

std::shared_ptr

weak_ptr

std::shared_ptr

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

shared_ptr

A

shared_ptr

B

shared_ptr

A

B

A

B

shared_ptr

shared_ptr

std::weak_ptr

std::weak_ptr

B

A

A

A

shared_ptr

A

A

B

weak_ptr

B

#include 
#include 

class B; // 前向声明

class A {
public:
    std::shared_ptr 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_ptr = b; }
};

class B {
public:
    // std::shared_ptr a_ptr; // 循环引用问题所在
    std::weak_ptr 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_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) ---" << std::endl;
    // 如果 B 内部是 shared_ptr，这里 A 和 B 都不会被销毁
    // {
    //     auto pA = std::make_shared();
    //     auto pB = std::make_shared();
    //     pA->setB(pB);
    //     pB->setA(pA);
    // } // A 和 B 的析构函数都不会被调用，内存泄漏！

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

        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;
}

std::weak_ptr

shared_ptr

shared_ptr