为了账号安全，请及时绑定邮箱和手机立即绑定
首页 手记 C++智能指针学习：从入门到实践

C++智能指针学习：从入门到实践

标签：
C++
概述

本文详细介绍了C++智能指针的学习内容，涵盖智能指针的基本概念、使用场景以及常见类型如std::unique_ptr、std::shared_ptr和std::weak_ptr的特性和应用。通过智能指针，可以有效避免内存泄漏和悬挂指针问题，简化内存管理，提高代码的安全性和可维护性。

智能指针简介

智能指针是C++中用于管理动态分配内存的一种工具。它们旨在简化内存管理，避免内存泄漏并减少内存管理中的错误。传统指针（如int*）需要程序员手动管理内存的分配和释放，这很容易导致内存泄漏或悬挂指针的问题。智能指针通过自动化内存管理，解决了这些问题，使得代码更加安全和易于维护。

智能指针的概念

智能指针是一种封装了普通指针的对象。它们继承了普通指针的基本功能，同时提供了自动化的内存管理功能。智能指针可以自动释放所管理的对象，从而避免了内存泄漏。常见的智能指针类型包括std::unique_ptr、std::shared_ptr和std::weak_ptr，它们分别适用于不同的场景。

为什么要使用智能指针

传统指针在内存管理方面存在以下问题：

  1. 内存泄漏：程序员可能忘记释放不再使用的内存，导致内存泄露。
  2. 悬挂指针：指针指向已经被释放的内存，使用这种指针会导致程序崩溃。
  3. 多重释放：如果同一个指针被多次释放，会导致未定义行为。

智能指针通过自动释放内存避免了这些问题。例如，std::unique_ptr会在指针超出作用域时自动释放内存，std::shared_ptr则通过引用计数管理多个共享指针的生命周期。

智能指针的基本类型介绍

C++ 标准库提供了多种智能指针类型，每种类型都有其特定的用途和行为：

  1. std::unique_ptr：用于管理单个独占资源的所有权。它确保资源的唯一所有权，并在指针超出作用域时自动释放资源。
  2. std::shared_ptr：用于管理多个共享资源的所有权。它通过引用计数机制，在没有其他指针指向资源时自动释放资源。
  3. std::weak_ptr：用于监视由std::shared_ptr管理的对象，但不增加引用计数。它常用于避免循环引用的问题。

std::unique_ptr

std::unique_ptr 是 C++11 标准库中引入的一种智能指针，用于管理单个独占资源的所有权。它确保资源的唯一所有权，并在指针超出作用域时自动释放资源。

std::unique_ptr的定义和使用

std::unique_ptr 类型在 <memory> 头文件中定义。要使用std::unique_ptr，首先需要包含该头文件。std::unique_ptr 类型可以通过直接初始化或使用make_unique函数来创建。

示例代码：

#include <memory>

int main() {
    // 直接初始化
    std::unique_ptr<int> ptr1(new int(10));

    // 使用 make_unique 函数
    std::unique_ptr<int> ptr2 = std::make_unique<int>(20);

    // 资源释放
    return 0;
}

如何管理单个对象的生命周期

std::unique_ptr 确保资源的唯一所有权，这意味着你不能将一个std::unique_ptr对象的资源转移给另一个std::unique_ptr对象。如果需要转移所有权，可以使用std::move函数。

示例代码：

#include <memory>

int main() {
    std::unique_ptr<int> ptr1(new int(10));
    std::unique_ptr<int> ptr2;

    // 移动所有权
    ptr2 = std::move(ptr1);

    // 现在 ptr1 不再持有资源
    // 资源由 ptr2 持有
    return 0;
}

unique_ptr的常用方法和注意事项

std::unique_ptr 提供了许多有用的方法，例如reset、release和swap。这些方法可以帮助你更好地管理资源。

  • reset：释放当前持有的资源，并可以选择性地绑定新的资源。
  • release：释放当前持有的资源但不删除它。
  • swap：交换两个std::unique_ptr对象持有的资源。

示例代码：

#include <memory>

int main() {
    std::unique_ptr<int> ptr1(new int(10));
    std::unique_ptr<int> ptr2(new int(20));

    // 使用 reset 方法
    ptr1.reset();
    ptr1.reset(new int(30));

    // 使用 release 方法
    int* raw_ptr = ptr2.release();
    *raw_ptr = 40;  // 修改原生指针

    // 使用 swap 方法
    ptr1.swap(ptr2);

    return 0;
}

注意事项：

  • std::unique_ptr 不能用于多线程环境，因为它没有实现线程安全。
  • 不能将一个std::unique_ptr对象的资源转移给另一个std::unique_ptr对象，除非使用std::move函数。

std::shared_ptr

std::shared_ptr 是 C++ 标准库中的一种智能指针，用于管理多个共享资源的所有权。它通过引用计数机制，在没有其他指针指向资源时自动释放资源。std::shared_ptr 非常适合需要多个指针共享同一资源的情况。

std::shared_ptr的定义和使用

std::shared_ptr 类型同样在 <memory> 头文件中定义。要使用std::shared_ptr，首先需要包含该头文件。std::shared_ptr 类型可以通过直接初始化或使用make_shared函数来创建。

示例代码：

#include <memory>

int main() {
    // 直接初始化
    std::shared_ptr<int> ptr1(new int(10));

    // 使用 make_shared 函数
    std::shared_ptr<int> ptr2 = std::make_shared<int>(20);

    // 资源释放
    return 0;
}

如何实现多个指针共享一个对象

std::shared_ptr 允许多个指针共享同一个资源，并且每个指针都有相同的生命周期。当最后一个引用被删除时，资源会被自动释放。

示例代码：

#include <iostream>
#include <memory>

int main() {
    std::shared_ptr<int> ptr1 = std::make_shared<int>(10);
    std::shared_ptr<int> ptr2 = ptr1;

    // 输出引用计数
    std::cout << "ptr1 use count: " << ptr1.use_count() << std::endl;
    std::cout << "ptr2 use count: " << ptr2.use_count() << std::endl;

    // 参考计数应该为2
    return 0;
}

shared_ptr的引用计数机制

std::shared_ptr 通过引用计数机制管理资源的生命周期。每个std::shared_ptr对象都会有一个引用计数器，用来跟踪有多少个std::shared_ptr对象在引用同一个资源。当引用计数为零时，资源会被自动释放。

示例代码：

#include <iostream>
#include <memory>

int main() {
    std::shared_ptr<int> ptr1 = std::make_shared<int>(10);
    std::shared_ptr<int> ptr2 = ptr1;

    std::cout << "ptr1 use count: " << ptr1.use_count() << std::endl;
    std::cout << "ptr2 use count: " << ptr2.use_count() << std::endl;

    // ptr2 被删除时，引用计数会减少
    ptr2.reset();

    std::cout << "ptr1 use count after ptr2 reset: " << ptr1.use_count() << std::endl;

    // ptr1 被删除时，引用计数为零，资源被释放
    ptr1.reset();

    return 0;
}

多线程环境下的使用

在多线程环境下，std::shared_ptr 的引用计数机制也需要考虑线程安全。

示例代码：

#include <iostream>
#include <memory>
#include <thread>

std::shared_ptr<int> globalPtr;

void threadFunction() {
    if (auto localPtr = globalPtr.lock()) {
        *localPtr = 20;
        std::cout << "Thread: " << *localPtr << std::endl;
    }
}

int main() {
    globalPtr = std::make_shared<int>(10);

    std::thread thread1(threadFunction);
    std::thread thread2(threadFunction);

    thread1.join();
    thread2.join();

    return 0;
}

std::weak_ptr

std::weak_ptr 是 C++ 标准库中的一种智能指针，用于监视由std::shared_ptr管理的对象，但不增加引用计数。它常用于避免循环引用的问题。

std::weak_ptr的定义和使用

std::weak_ptr 类型同样在 <memory> 头文件中定义。要使用std::weak_ptr，首先需要包含该头文件。std::weak_ptr 类型可以通过std::shared_ptr对象来创建。

示例代码：

#include <memory>

int main() {
    std::shared_ptr<int> ptr1 = std::make_shared<int>(10);
    std::weak_ptr<int> weakPtr1(ptr1);

    // 资源释放
    return 0;
}

解决循环引用问题

在使用std::shared_ptr时，如果两个对象彼此引用对方，会导致循环引用，资源永远不会被释放。std::weak_ptr 可以帮助解决这个问题，因为它不会增加引用计数。

示例代码：

#include <iostream>
#include <memory>

class Node {
public:
    std::shared_ptr<Node> next;
    std::weak_ptr<Node> prev;

    Node() : next(nullptr), prev(nullptr) {}
};

void printCounts(const std::shared_ptr<Node>& node) {
    if (node) {
        std::cout << "Node " << node->next.use_count() << " " << node->prev.use_count() << std::endl;
    }
}

int main() {
    std::shared_ptr<Node> node1 = std::make_shared<Node>();
    std::shared_ptr<Node> node2 = std::make_shared<Node>();

    node1->next = node2;
    node2->prev = node1;

    printCounts(node1);
    printCounts(node2);

    return 0;
}

在上述代码中，如果使用std::shared_ptr替代std::weak_ptr来表示prev，那么会导致循环引用问题。

weak_ptr与shared_ptr的关系

std::weak_ptr 和std::shared_ptr之间存在一种类似于父类和子类的关系。std::weak_ptr可以转换为std::shared_ptr，但是std::shared_ptr不能转换为std::weak_ptr。

示例代码：

#include <memory>

int main() {
    std::shared_ptr<int> ptr1 = std::make_shared<int>(10);
    std::weak_ptr<int> weakPtr1(ptr1);

    // 从 weak_ptr 转换为 shared_ptr
    std::shared_ptr<int> ptr2 = weakPtr1.lock();

    return 0;
}

智能指针的应用场景

处理动态内存管理

智能指针简化了动态内存管理，避免了手动管理内存的复杂性。例如，std::unique_ptr和std::shared_ptr可以自动释放资源，确保资源在适当的时间被释放。

示例代码：

#include <iostream>
#include <memory>

int main() {
    std::unique_ptr<int> ptr1(new int(10));
    std::shared_ptr<int> ptr2 = std::make_shared<int>(20);

    // 输出指针内容
    std::cout << "ptr1 value: " << *ptr1 << std::endl;
    std::cout << "ptr2 value: " << *ptr2 << std::endl;

    return 0;
}

异常安全的内存管理

智能指针确保了异常安全的内存管理。如果在使用智能指针时发生异常，资源将被自动释放，防止内存泄漏。

示例代码：

#include <iostream>
#include <memory>

void process(int* ptr) {
    // 模拟异常
    throw std::runtime_error("Error processing");
}

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

    try {
        process(ptr.get());
    } catch (const std::exception& e) {
        std::cout << "Exception caught: " << e.what() << std::endl;
    }

    // ptr 在此之后会被自动释放
    return 0;
}

跨函数调用的内存管理

智能指针在跨函数调用中特别有用，确保资源在函数调用结束后被正确释放。

示例代码：

#include <iostream>
#include <memory>

void process(std::shared_ptr<int> ptr) {
    *ptr = 20;
}

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

    process(ptr);

    std::cout << "ptr value: " << *ptr << std::endl;

    return 0;
}

常见问题和最佳实践

常见错误和陷阱

  1. 多重释放：由于std::unique_ptr确保了唯一的资源所有权，如果你尝试释放同一个资源两次，会导致未定义行为。
  2. 循环引用：如果两个std::shared_ptr对象互相引用对方，会导致引用计数永远不为零，资源永远不会被释放。使用std::weak_ptr可以解决这个问题。
  3. 误用std::weak_ptr：std::weak_ptr不能用于访问资源，需要通过lock方法转换为std::shared_ptr才能访问资源。

示例代码：

#include <iostream>
#include <memory>

int main() {
    std::shared_ptr<int> ptr1 = std::make_shared<int>(10);
    std::weak_ptr<int> weakPtr(ptr1);

    // 尝试直接访问 weakPtr
    // 这会导致编译错误
    // std::cout << *weakPtr << std::endl;

    // 正确的访问方式
    if (auto sharedPtr = weakPtr.lock()) {
        std::cout << *sharedPtr << std::endl;
    } else {
        std::cout << "Weak pointer expired" << std::endl;
    }

    return 0;
}

智能指针的性能考虑

智能指针通常会带来一些额外的性能开销，这是因为它们需要维护额外的数据结构（如引用计数）。在某些性能敏感的应用中，这些开销可能会影响程序的性能。

  • std::unique_ptr：std::unique_ptr的性能开销相对较小，因为它只包含一个指针和一个拥有者。
  • std::shared_ptr：std::shared_ptr的性能开销较大，因为它需要维护引用计数。在多线程环境中，可能还需要加锁。
  • std::weak_ptr：std::weak_ptr的性能开销较小，因为它不增加引用计数。

如何选择合适的智能指针类型

选择合适的智能指针类型取决于你的具体需求和场景：

  • 单个独占资源：使用std::unique_ptr。例如，当你管理资源的唯一所有权时，std::unique_ptr是最佳选择。
  • 多个共享资源：使用std::shared_ptr。例如，当你需要多个指针共享同一个资源时，std::shared_ptr可以避免循环引用问题。
  • 监视资源但不增加引用计数：使用std::weak_ptr。例如，当你需要监视由std::shared_ptr管理的对象，但不增加引用计数时，std::weak_ptr是最佳选择。

示例代码：


#include <iostream>
#include <memory>

int main() {
    // 使用 unique_ptr
    std::unique_ptr<int> uniquePtr(new int(10));

    // 使用 shared_ptr
    std::shared_ptr<int> sharedPtr = std::make_shared<int>(20);

    // 使用 weak_ptr
    std::weak_ptr<int> weakPtr(sharedPtr);

    return 0;
}
``

总结而言，智能指针是一种强大的工具，可以简化C++中的内存管理。通过了解不同类型的智能指针及其最佳实践，你可以编写更安全、更高效的代码。
点击查看更多内容
发表于 2024.12.13 18:19， 共 22 人浏览

本文原创发布于慕课网 ，转载请注明出处，谢谢合作

举报
为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

作者其他优质文章

正在加载中

慕虎7371278

手记
篇
粉丝
203
获赞与收藏
874

关注作者，订阅最新文章

阅读免费教程

  • 推荐
  • 评论
  • 收藏
  • 共同学习，写下你的评论
感谢您的支持，我会继续努力的～
扫码打赏，你说多少就多少
赞赏金额会直接到老师账户
支付方式
打开微信扫一扫，即可进行扫码打赏哦
今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与 放弃机会
意见反馈 帮助中心 APP下载
官方微信

举报

0/150
提交
取消