首页手记 C++智能指针资料详解与入门教程

C++智能指针资料详解与入门教程

标签：

C++

概述

本文详细介绍了C++智能指针的定义、作用与优势，包括自动内存管理、防止空指针和类型安全等特性。文章进一步探讨了unique_ptr、shared_ptr和weak_ptr三种常用智能指针类型及其应用场景，并提供了具体的代码示例。本文内容旨在帮助读者更好地理解和使用C++智能指针资料。

智能指针简介

什么是智能指针

智能指针是C++中的一种特殊指针类型，它在普通指针的基础上添加了自动管理内存的功能。通过智能指针，程序员可以自动管理内存的生命周期，避免了手动管理内存时出现的内存泄漏和内存访问错误等问题。智能指针可以自动处理内存的释放，当智能指针离开作用域时，它所指向的资源会被自动释放。

智能指针的作用与优势

智能指针的主要作用是管理内存，确保在对象不再需要时能够自动释放。这避免了程序员需要手动管理内存释放的问题，减少了内存泄漏的风险。智能指针提供了一种更安全、更方便的内存管理方式。

智能指针的主要优势包括：

自动内存管理：智能指针能够自动处理内存的释放，减少内存泄漏的风险。
防止空指针：通过重载operator->和operator*，智能指针能够避免使用空指针。
引用计数：某些类型的智能指针（如shared_ptr）使用引用计数机制，可以更好地管理共享资源。
类型安全：智能指针提供了一种类型安全的方式来管理资源。

常用智能指针类型

unique_ptr

std::unique_ptr是一种独占所有权的智能指针，它提供了一种独占资源的管理方式，确保资源不会被意外地复制或共享。unique_ptr使用右值引用（rvalue reference）技术来实现移动语义，从而减少了不必要的资源复制。

基本定义与初始化

unique_ptr可以通过以下几种方式定义和初始化：

直接初始化：

#include <memory>

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

直接使用make_unique：

#include <memory>

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

使用std::move：

#include <memory>

int main() {
    std::unique_ptr<int> ptr1(new int(10));
    std::unique_ptr<int> ptr2 = std::move(ptr1);  // 移动语义
    return 0;
}

移动语义

unique_ptr使用移动语义来避免不必要的资源复制。当一个unique_ptr对象被移动时，其内部资源会被移动到另一个unique_ptr对象，而原对象会被置为无效状态。

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

### shared_ptr

`std::shared_ptr`是一种可以共享所有权的智能指针，它使用引用计数机制来管理资源。多个`shared_ptr`可以共享同一个资源，当最后一个`shared_ptr`离开作用域时，资源会被自动释放。

#### 基本定义与初始化

`shared_ptr`可以通过以下几种方式定义和初始化：

1. **直接初始化**：

```cpp
#include <memory>

int main() {
    std::shared_ptr<int> ptr(new int(10));
    return 0;
}

使用make_shared：

#include <memory>

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

引用计数机制

shared_ptr使用引用计数机制来管理共享资源。当一个shared_ptr被创建时，引用计数会增加；当一个shared_ptr离开作用域时，引用计数会减少，当计数为0时，资源会被释放。

#include <memory>
#include <iostream>

int main() {
    std::shared_ptr<int> ptr1 = std::make_shared<int>(10);
    std::shared_ptr<int> ptr2 = ptr1;  // 引用计数增加到2

    std::cout << "ptr1 is " << *ptr1 << std::endl;  // 输出10
    std::cout << "ptr2 is " << *ptr2 << std::endl;  // 输出10

    ptr1.reset();  // 引用计数减少到1
    ptr2.reset();  // 引用计数减少到0，资源被释放

    return 0;
}

weak_ptr

std::weak_ptr是一种可以观察shared_ptr但不增加引用计数的智能指针。它主要用于解决循环引用问题，防止内存泄漏。

基本定义与初始化

weak_ptr可以通过以下几种方式定义和初始化：

直接初始化：

#include <memory>

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

    return 0;
}

使用std::weak_ptr构造函数：

#include <memory>

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

    return 0;
}

解决循环引用问题

weak_ptr可以避免循环引用问题。当两个shared_ptr相互持有对方，会导致引用计数永远不为0，无法释放资源。使用weak_ptr可以解决这个问题。

#include <memory>
#include <iostream>

class Node {
public:
    std::shared_ptr<Node> next;
};

int main() {
    std::shared_ptr<Node> node1 = std::make_shared<Node>();
    std::weak_ptr<Node> weakNode2(node1);  // 使用weak_ptr避免循环引用

    node1->next = std::make_shared<Node>();
    node1->next->next = node1;  // 循环引用问题

    // 检查weak_ptr是否有效
    if (auto node2 = weakNode2.lock()) {
        std::cout << "Node2 is valid" << std::endl;
    } else {
        std::cout << "Node2 is not valid" << std::endl;
    }

    return 0;
}

unique_ptr使用教程

基本定义与初始化

unique_ptr可以通过多种方式定义和初始化，包括直接初始化、使用make_unique以及通过移动语义转移所有权。

移动语义

示例代码

以下是一些示例代码，展示了如何使用unique_ptr：

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

shared_ptr使用教程

基本定义与初始化

shared_ptr可以通过多种方式定义和初始化，包括直接初始化以及使用make_shared来创建共享对象。

引用计数机制

示例代码

以下是一些示例代码，展示了如何使用shared_ptr：

#include <memory>
#include <iostream>

int main() {
    std::shared_ptr<int> ptr1 = std::make_shared<int>(10);
    std::shared_ptr<int> ptr2 = ptr1;  // 引用计数增加到2

    std::cout << "ptr1 is " << *ptr1 << std::endl;  // 输出10
    std::cout << "ptr2 is " << *ptr2 << std::endl;  // 输出10

    ptr1.reset();  // 引用计数减少到1
    ptr2.reset();  // 引用计数减少到0，资源被释放

    return 0;
}

weak_ptr使用教程

基本定义与初始化

weak_ptr可以通过多种方式定义和初始化，包括直接初始化以及通过shared_ptr构造weak_ptr。

解决循环引用问题

weak_ptr可以避免循环引用问题。当两个shared_ptr相互持有对方，会导致引用计数永远不为0，无法释放资源。使用weak_ptr可以解决这个问题。

示例代码

以下是一些示例代码，展示了如何使用weak_ptr：

#include <memory>
#include <iostream>

class Node {
public:
    std::shared_ptr<Node> next;
};

int main() {
    std::shared_ptr<Node> node1 = std::make_shared<Node>();
    std::weak_ptr<Node> weakNode2(node1);  // 使用weak_ptr避免循环引用

    node1->next = std::make_shared<Node>();
    node1->next->next = node1;  // 循环引用问题

    // 检查weak_ptr是否有效
    if (auto node2 = weakNode2.lock()) {
        std::cout << "Node2 is valid" << std::endl;
    } else {
        std::cout << "Node2 is not valid" << std::endl;
    }

    return 0;
}

实践案例

智能指针在实际项目中的应用示例

在实际项目中，智能指针可以广泛应用于各种场景，以下是几个具体的示例：

示例一：内存管理

在C++项目中，内存管理是一个关键问题。使用智能指针可以有效管理内存，避免内存泄漏和访问错误。

#include <memory>

class Resource {
public:
    Resource() { std::cout << "Resource acquired\n"; }
    ~Resource() { std::cout << "Resource released\n"; }
};

void function() {
    std::unique_ptr<Resource> ptr(new Resource());
    // ptr离开作用域，资源会被自动释放
}

int main() {
    function();
    return 0;
}

示例二：资源共享

在多线程或异步编程中，资源的共享是一个常见需求。使用shared_ptr可以实现资源共享。

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

std::shared_ptr<int> sharedResource;

void worker() {
    if (auto resource = sharedResource.lock()) {
        *resource = 42;
        std::cout << "Resource is " << *resource << std::endl;
    } else {
        std::cout << "Resource is not valid\n";
    }
}

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

    std::thread t(worker);
    t.join();

    return 0;
}

示例三：避免循环引用

在某些场景中，两个对象相互持有对方的指针，可能导致循环引用问题。使用weak_ptr可以解决这个问题。

#include <memory>
#include <iostream>

class A {
public:
    std::shared_ptr<B> b;
};

class B {
public:
    std::weak_ptr<A> a;
};

void check() {
    std::shared_ptr<A> a = std::make_shared<A>();
    a->b = std::make_shared<B>();
    a->b->a = a;

    if (auto b = a->b.lock()) {
        std::cout << "B is valid\n";
    } else {
        std::cout << "B is not valid\n";
    }
}

int main() {
    check();
    return 0;
}

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

幕布斯6054654

手记
篇

粉丝

219

获赞与收藏

1011

关注作者，订阅最新文章

阅读免费教程

Android Studio 编辑器教程

40个小节 11886 244

后端通用面试教程

41个小节 30936 346

网络编程入门教程

20个小节 12729 240

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

C++智能指针资料详解与入门教程

什么是智能指针

智能指针的作用与优势

unique_ptr

基本定义与初始化

移动语义

引用计数机制

weak_ptr

基本定义与初始化

解决循环引用问题

基本定义与初始化

移动语义

示例代码

基本定义与初始化

引用计数机制

示例代码

基本定义与初始化

解决循环引用问题

示例代码

智能指针在实际项目中的应用示例

示例一：内存管理

示例二：资源共享

示例三：避免循环引用

阅读免费教程