C++智能指针教程：入门与实践

本文深入讲解了C++智能指针教程，涵盖了智能指针的概念、特点以及不同类型的智能指针（如std::unique_ptr、std::shared_ptr和std::weak_ptr）的使用场景和实现细节。通过具体示例，展示了如何避免内存泄漏和循环引用问题，确保资源的正确管理和释放。

智能指针的概念与作用

手动内存管理的挑战

在C++编程中，内存管理是一项至关重要的任务。手动内存管理涉及动态分配和释放内存，这可以通过new和delete关键字实现。然而，手动管理内存存在一些挑战和潜在的风险。

1. 内存泄漏：如果分配的内存没有被正确释放，会导致内存泄漏，随着时间推移，程序会消耗越来越多的内存。
2. 野指针：在删除指针后，如果不及时将其置为nullptr，可能会导致程序访问无效内存地址。
3. 内存覆盖：错误的内存释放顺序可能导致内存覆盖和程序崩溃。

例如，考虑以下代码：

int* ptr = new int(10);
// 使用ptr
delete ptr;
ptr = nullptr;

尽管这段代码看起来是正确的，但很容易引入错误。例如，如果忘记释放内存，就会导致内存泄漏。

智能指针的定义与特点

智能指针是一种封装了指针的类，旨在自动管理内存，减少手动内存管理带来的问题。智能指针通过引用计数或独占所有权的方式管理内存，避免了内存泄漏和野指针的风险。

智能指针的主要特点包括：

1. 自动内存管理：智能指针会在适当的时候自动释放内存，无需显式调用delete。
2. 异常安全：智能指针的设计确保在异常情况下也能确保内存资源的安全释放。
3. 上下文感知：智能指针可以感知对象的生命周期，确保资源在对象不再需要时释放。

常用智能指针类型介绍

C++ 标准库提供了几种类型的智能指针，每种都有不同的用途和特点。

1. std::unique_ptr：独占所有权的智能指针，适用于单个指针的所有权管理。
2. std::shared_ptr：共享所有权的智能指针，允许多个指针共享同一块内存。
3. std::weak_ptr：不拥有对象的智能指针，用于解决循环引用问题。

unique_ptr：独一无二的独占管理

unique_ptr的基本用法

std::unique_ptr 是一种独占所有权的智能指针，意味着它所管理的对象只能由一个 std::unique_ptr 管理。当 std::unique_ptr 被销毁时，它所管理的资源也会被自动释放。

基本用法如下：

#include <iostream>
#include <memory>

int main() {
    // 创建一个 unique_ptr，管理一个整数
    std::unique_ptr<int> uniquePtr = std doubly_linked_list::make_unique<int>(10);

    // 使用 unique_ptr
    std::cout << "Value: " << *uniquePtr << std::endl;

    // unique_ptr 被销毁时会自动释放内存
}

unique_ptr的移动语义

std::unique_ptr 支持移动语义，这意味着可以在不复制对象的情况下将所有权从一个 std::unique_ptr 移动到另一个。

#include <iostream>
#include <memory>

int main() {
    std::unique_ptr<int> ptr = std::make_unique<int>(10);

    // 移动所有权
    std::unique_ptr<int> ptr2 = std::move(ptr);

    // 原始 ptr 现在不再拥有资源
    std::cout << "ptr2: " << *ptr2 << std::endl;
    // std::cout << "ptr: " << *ptr << std::endl; // 会报错，ptr 已经失效
}

unique_ptr的常见应用场景

std::unique_ptr 适用于那些需要独占所有权的场景，例如：

1. 资源独占：当一个资源只能被一个对象管理时，使用 std::unique_ptr 是非常合适的。
2. 函数参数传递：传递独占所有权的资源时，使用 std::unique_ptr 可以确保资源不会被意外释放。

#include <iostream>
#include <memory>

class Resource {
public:
    std::unique_ptr<int> data;

    Resource() : data(std::make_unique<int>(10)) {}
};

void useResource(std::unique_ptr<Resource> res) {
    std::cout << "Data: " << *res->data << std::endl;
}

int main() {
    std::unique_ptr<Resource> res = std::make_unique<Resource>();
    useResource(std::move(res));  // 独占资源传递给函数

    // res 作用域结束时，资源被释放
    return 0;
}

shared_ptr：资源共享的利器

shared_ptr的基本概念

std::shared_ptr 是一种共享所有权的智能指针，允许多个 std::shared_ptr 共享同一块内存。每个 std::shared_ptr 都持有一个引用计数器，当最后一个 std::shared_ptr 被销毁时，所管理的对象会被释放。

基本用法如下：

#include <iostream>
#include <memory>

int main() {
    std::shared_ptr<int> ptrA = std::make_shared<int>(10);
    std::shared_ptr<int> ptrB = ptrA;

    // 两个共享指针共享同一个资源
    std::cout << "ptrA: " << *ptrA << std::endl;
    std::cout << "ptrB: " << *ptrB << std::endl;

    // 当 ptrB 被销毁时，引用计数减一
}

引用计数的实现与管理

std::shared_ptr 内部维护了一个引用计数器，每当一个新的 std::shared_ptr 被创建来管理同一块内存时，引用计数器加一；每当一个 std::shared_ptr 被销毁或被重置时，引用计数器减一。当引用计数器为零时，所管理的资源被释放。

#include <iostream>
#include <memory>

int main() {
    std::shared_ptr<int> ptrA = std::make_shared<int>(10);
    {
        std::shared_ptr<int> ptrB = ptrA;
        std::cout << "ptrA: " << *ptrA << std::endl;
        std::cout << "ptrB: " << *ptrB << std::endl;
    }
    // ptrB 的作用域结束，引用计数减一
    std::cout << "ptrA: " << *ptrA << std::endl;
}

shared_ptr的复制与删除

std::shared_ptr 的复制操作通过构造函数实现，这会增加引用计数器。删除操作则是通过 reset 方法实现，这会减少引用计数器。

#include <iostream>
#include <memory>

int main() {
    std::shared_ptr<int> ptrA = std::make_shared<int>(10);
    {
        std::shared_ptr<int> ptrB = ptrA;
        std::cout << "ptrA: " << *ptrA << std::endl;
        std::cout << "ptrB: " << *ptrB << std::endl;
    }
    // ptrB 作用域结束，引用计数减一
    std::cout << "ptrA: " << *ptrA << std::endl;
    ptrA.reset();  // 手动释放 ptrA
    return 0;
}

weak_ptr：与shared_ptr协同工作

weak_ptr的作用与意义

std::weak_ptr 是一种不拥用对象所有权的智能指针，用于解决 std::shared_ptr 之间的循环引用问题。当使用 std::shared_ptr 时，可能会出现循环引用的情况，导致资源无法被释放，而 std::weak_ptr 可以避免这种情况。

weak_ptr的基本用法

std::weak_ptr 可以从 std::shared_ptr 创建，但不能直接解引用。使用 lock 方法可以获取一个临时的 std::shared_ptr，用于安全地访问对象。

#include <iostream>
#include <memory>

int main() {
    std::shared_ptr<int> ptrA = std::make_shared<int>(10);
    std::weak_ptr<int> weakPtrA = ptrA;

    std::shared_ptr<int> ptrB = weakPtrA.lock();

    if (ptrB) {
        // 安全访问指针
        std::cout << "ptrB: " << *ptrB << std::endl;
    }
}

shared_ptr与weak_ptr的搭配使用

在实际使用中，std::shared_ptr 和 std::weak_ptr 往往一起使用，以避免循环引用。

#include <iostream>
#include <memory>

class MyClass {
public:
    std::weak_ptr<MyClass> weakPtr;

    MyClass(std::weak_ptr<MyClass> wp) : weakPtr(wp) {}
};

int main() {
    std::shared_ptr<MyClass> ptrA = std::make_shared<MyClass>(std::weak_ptr<MyClass>());
    ptrA->weakPtr = ptrA;

    {
        std::shared_ptr<MyClass> ptrB = std::make_shared<MyClass>(ptrA->weakPtr);
    }
    // ptrB 作用域结束，引用计数减一
    // ptrA 依然有效，不会被释放
}

智能指针的比较与选择

unique_ptr、shared_ptr与weak_ptr的对比

三种智能指针各有特点，适用于不同的场景：

• std::unique_ptr：独占所有权，适用于需要独占资源的场景。
• std::shared_ptr：共享所有权，适用于需要共享资源的场景。
• std::weak_ptr：不拥有对象，用于解决循环引用问题。

不同场景下的智能指针选择

在实际开发中，选择合适的智能指针取决于应用场景：

1. 独占所有权：使用 std::unique_ptr，例如资源独占的情况。
2. 共享所有权：使用 std::shared_ptr，例如资源共享的情况。
3. 避免循环引用：使用 std::weak_ptr，例如在 std::shared_ptr 之间存在循环引用时。

实践案例：智能指针的实际应用

使用智能指针管理资源

通过使用智能指针，可以确保资源在程序运行过程中被正确管理和释放。

#include <iostream>
#include <memory>

int main() {
    // 使用 unique_ptr 管理资源
    std::unique_ptr<int> uniquePtr = std::make_unique<int>(10);
    std::cout << "uniquePtr: " << *uniquePtr << std::endl;

    // 使用 shared_ptr 管理资源
    std::shared_ptr<int> sharedPtr = std::make_shared<int>(20);
    std::cout << "sharedPtr: " << *sharedPtr << std::endl;

    return 0;
}

避免内存泄漏与循环引用

下面是一个避免内存泄漏和循环引用的例子：

#include <iostream>
#include <memory>

class Resource {
public:
    std::weak_ptr<Resource> weakPtr;

    Resource(std::weak_ptr<Resource> wp) : weakPtr(wp) {}
};

class Manager {
public:
    std::shared_ptr<Resource> ptr;

    Manager(std::shared_ptr<Resource> r) : ptr(r) {}
};

int main() {
    // 创建 shared_ptr
    auto resource = std::make_shared<Resource>(std::weak_ptr<Resource>());
    resource->weakPtr = resource;

    // 使用 Manager 管理资源
    Manager manager(resource);

    // resource 和 manager 的作用域结束，避免循环引用
    return 0;
}