C++ 11 智能指针 自动内存管理

于 2024-08-13 08:27:59 发布
阅读量456 收藏 3
点赞数 16
分类专栏： c++11 c/c++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gopher9511/article/details/141144349
版权
c/c++ 同时被 2 个专栏收录
78 篇文章 0 订阅
订阅专栏
c++11
9 篇文章 0 订阅
订阅专栏

自动内存管理

RAII（Resource Acquisition Is Initialization）资源获取即初始化

是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。

RAII 的一般做法是这样的：
在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，
最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。

这种做法有两大好处：
①不需要显式地释放资源。
②采用这种方式，对象所需的资源在其生命期内始终保持有效。

此时，所托管的资源，随对象的创建而获取，随对象的消失而消失，
即所谓的 RAII思想：资源获取即初始化。

#include <iostream>
#include <memory>
using namespace  std;


class A{
public:
    A(){
        cout<<"A()"<<endl;
    }
    ~A(){
        cout<<"~A()"<<endl;
    }
    void dis(){
        cout<<"A::void dis()"<<endl;
    }
};
void func(){
    auto_ptr<A> ap(new A);
    ap->dis();

}

int main(){
    func();
}

原理上，是代理了被托管的对象指针，管理对象的生命周期，即实现自动释放。其
行为类似于所托管的对象指针，原因是，重载了 operator->和 operator*。

auto_ptr的弃用

#include <iostream>
#include <memory>
using namespace std;

int main()
{
    int *p = new int(10); // 动态分配一个 int，初始值为 10
    {
        unique_ptr<int> up(p); // 使用 unique_ptr 管理 p
        cout << *up << endl; // 输出 10
    } // up 超出作用域，自动释放 p

    // 这里再次使用 p 会导致未定义行为，因为 p 已经被释放
    unique_ptr<int> up2(p); // 这行代码会导致错误
    cout << *up2 << endl;

    // 正确的做法是直接使用 unique_ptr 管理动态内存
    unique_ptr<int> up3(new int(10));
    cout << *up3 << endl; // 输出 10

    return 0;
}

uniqu_ptr

uniqu_ptr 的使用方法，基本上等同于 auto_ptr, 不同之处，就在于实现了资源的
唯一, 既不可以拷贝也不可以赋值。

#include <iostream>
#include <memory>
using namespace  std;


class A{
public:
    A(){
        cout<<"A()"<<endl;
    }
    ~A(){
        cout<<"~A()"<<endl;
    }
    void dis(){
        cout<<"A::void dis()"<<endl;
    }
};
void func(){
    unique_ptr<A> ap(new A);//ok
    ap->dis();
    unique_ptr<A> ap2(ap);//编译不过
    ap2->dis();
}

int main(){
    func();
}

unique_ptr 可以用于数组。

#include <iostream>
#include <memory>
using namespace std;

class A {
public:
    // 构造函数
    A() {
        cout << "A()" << endl; // 输出构造函数被调用的信息
    }

    // 析构函数
    ~A() {
        cout << "~A()" << endl; // 输出析构函数被调用的信息
    }

    // 成员函数，用于显示信息
    void dis() {
        cout << "A::void dis()" << endl; // 输出成员函数被调用的信息
    }
};

int main() {
    // 创建一个 unique_ptr 智能指针，指向一个包含10个整数的数组，并初始化前四个元素
    unique_ptr<int[]> up(new int[10]{1, 2, 3, 4});

    // 遍历数组并输出每个元素的值
    for (int i = 0; i < 10; i++)
        cout << up[i] << endl;

    // 创建一个 unique_ptr 智能指针，指向一个包含20个A类对象的数组
    unique_ptr<A[]> up2(new A[20]);

    // 遍历数组并调用每个A类对象的dis()成员函数
    for (int i = 0; i < 20; i++)
        up2[i].dis();

    return 0; // 返回0，表示程序正常结束
}

unique_ptr 常用接口

在这里插入图片描述

#include <iostream>
#include <memory>
using namespace std;

class Copy {
public:
    // 构造函数，接受一个整数参数
    Copy(int i) : _i(new int(i)) {
        cout << "Copy(int i) " << "this: " << this << " _i " << _i << endl; // 输出构造函数被调用的信息
    }

    // 拷贝构造函数
    Copy(const Copy &another) : _i(new int(*another._i)) {
        cout << " Copy(const Copy & another)" << endl; // 输出拷贝构造函数被调用的信息
    }

    // 析构函数
    ~Copy() {
        cout << " ~Copy() " << this << endl; // 输出析构函数被调用的信息
    }

    // 成员函数，用于显示信息
    void dis() {
        cout << "Copy::void dis()" << endl; // 输出成员函数被调用的信息
    }

    int *_i; // 指向动态分配内存的指针
};

int main() {
    // 创建一个 unique_ptr 智能指针，托管一个新创建的 Copy 对象
    unique_ptr<Copy> up(new Copy(1));

    // 检查 unique_ptr 是否托管了资源
    if (!up) {
        cout << "无资源" << endl;
    } else {
        cout << "有资源" << endl;
    }

    // 获取托管资源的指针
    cout << up.get() << endl; // 输出托管资源的指针地址

    // 放弃托管，返回资源指针
    Copy *c = up.release();

    // 手动释放资源
    delete c;

    return 0; // 返回0，表示程序正常结束
}

reset

#include <iostream>
#include <memory>
using namespace std;

class Copy {
public:
    // 构造函数，接受一个整数参数
    Copy(int i) : _i(new int(i)) {
        cout << "Copy(int i) " << "this: " << this << " _i " << _i << endl; // 输出构造函数被调用的信息
    }

    // 拷贝构造函数
    Copy(const Copy &another) : _i(new int(*another._i)) {
        cout << " Copy(const Copy & another)" << endl; // 输出拷贝构造函数被调用的信息
    }

    // 析构函数
    ~Copy() {
        cout << " ~Copy() " << this << endl; // 输出析构函数被调用的信息
    }

    // 成员函数，用于显示信息
    void dis() {
        cout << "Copy::void dis()" << endl; // 输出成员函数被调用的信息
    }

    int *_i; // 指向动态分配内存的指针
};

int main() {
    {
        // 创建一个 unique_ptr 智能指针，托管一个新创建的 Copy 对象
        unique_ptr<Copy> up(new Copy(1));

        // 重置 unique_ptr，托管一个新的 Copy 对象，旧的资源会被释放
        up.reset(new Copy(2));

        // 重置 unique_ptr，不托管任何资源，旧的资源会被释放
        up.reset();

        cout << "{}内" << endl; 
    }
    cout << "{}外" << endl; 

    return 0; 
}

unique_ptr 移动

//todo unique_ptr 智能指针
#include <iostream>
#include <memory>
using namespace std;

class Copy
{
public:
    Copy(int i):_i(new int(i))
    {
        cout<<"Copy(int i) "<<"this: "<<this<<" _i "<<_i<<endl;
    }
    Copy(const Copy & another)
            :_i(new int(*another._i))
    {
        cout<<" Copy(const Copy & another)"<<endl;
    }
    ~Copy(){
        cout<<" ~Copy() "<<this<<endl;
    }

    // 成员函数，用于显示信息
    void dis() {
        cout << "Copy::void dis()  _i="<< *_i << endl; // 输出成员函数被调用的信息
    }
    int *_i;
};

int main(){

    unique_ptr<Copy> up(new Copy(100));

    unique_ptr<Copy> up2=std::move(up);

    up2->dis();//Copy::void dis()  _i=100
    up->dis();//up此时不再可用
    return 0;

}

shared_ptr

uinque_ptr 解决了 auto_ptr 中引用同一个对象的问题，方式就是不可引用同一个对象。

shared_ptr 解决了 auto_ptr 中引用同一个对象，共同拥有一个资源，
但不会重析构的问题，

原理是，在内部保持一个引用计数，并且仅当引用计数为 0 才能被删除，不可以用数组。

常用接口

在这里插入图片描述

引用计数

//todo shared_ptr 智能指针
#include <iostream>
#include <memory>
using namespace std;

void func(shared_ptr<int> sp)
{
//
    sp.reset(); //此处仅将自己所累积的计数减 1
    cout<<sp.use_count()<<endl;
    sp.reset(); //此时 reset 等价于 sp 对象消失，若己为零，则不再减 1.
}
int main(){
    //引用计数,每次被引用引用计数加1,对象消失-1
    shared_ptr<int> sp(new int(10));
    cout<<*sp<<endl;//10
    cout<<"use_count:"<<sp.use_count()<<endl;//use_count:1

    shared_ptr<int> sp2(sp);
    cout<<*sp2<<endl;//10

    cout<<"use_count:"<<sp.use_count()<<endl;//use_count:2
    cout<<"use_count:"<<sp2.use_count()<<endl;//use_count:2

    return 0;

}

shared_ptr单独的引用计数


#include <iostream>
#include <memory>
using namespace std;
class A
{
public:
    A()
    {
        cout<<"A()"<<this<<endl;
    }
    ~A()
    {
        cout<<"~A()"<<this<<endl;
    }
    void dis()
    {
        cout<<"A::void dis()"<<endl;
    }
};


int main()
{
    {
        //创建一个 shared_ptr 智能指针，托管一个新创建的 A 对象
        shared_ptr<A> sp(new A);
        //创建两个 shared_ptr 智能指针，共享同一个托管对象
        shared_ptr<A> sp2(sp);
        shared_ptr<A> sp3(sp);

        //输出当前托管对象的引用计数
        cout<<sp.use_count()<<endl;
        //重置 shared_ptr，减少引用计数，但不会影响其他 shared_ptr 的引用计数
        sp.reset();
        sp.reset();
        sp.reset();
        cout<<sp.use_count()<<endl;//0
        cout<<"+++++++++++++++++++++"<<endl;
    }
    cout<<"======================"<<endl;


}

输出
A()0x1544ddb1760
3
0
+++++++++++++++++++++
~A()0x1544ddb1760
======================

示例1


#include <iostream>
#include <memory>
using namespace std;
class A
{
public:
    A()
    {
        cout<<"A()"<<this<<endl;
    }
    ~A()
    {
        cout<<"~A()"<<this<<endl;
    }
    void dis()
    {
        cout<<"A::void dis()"<<endl;
    }
};

void func(shared_ptr<A> sp){
    sp.reset();
    //此时已经取消托管后面的sp.reset();无用
    sp.reset();
    cout<<sp.use_count()<<endl;//2
}
int main()
{
    shared_ptr<A> sp(new A);
    cout<<sp.use_count()<<endl;//1
    func(sp);
    cout<<sp.use_count()<<endl;//1
}

示例2


#include <iostream>
#include <memory>
using namespace std;
class A
{
public:
    A()
    {
        cout<<"A()"<<this<<endl;
    }
    ~A()
    {
        cout<<"~A()"<<this<<endl;
    }
    void dis()
    {
        cout<<"A::void dis()"<<endl;
    }
};

void func(shared_ptr<A> sp){
    if(sp.unique()){
        cout<<"true"<<endl;
    } else{
        cout<<"false"<<endl;//输出:false
    }


    sp.reset();
    //此时已经取消托管后面的sp.reset();无用
    sp.reset();
    cout<<sp.use_count()<<endl;//2
}
int main()
{
    shared_ptr<A> sp(new A);
    cout<<sp.use_count()<<endl;//1
    //判断sp托管是否唯一
    if(sp.unique()){
        cout<<"true"<<endl;//true
    }
    func(sp);
    cout<<sp.use_count()<<endl;//1
}

shared_ptr 移动

//todo shared_ptr 移动
#include <iostream>
#include <memory>
using namespace std;
class A
{
public:
    A()
    {
        cout<<"A()"<<this<<endl;
    }
    ~A()
    {
        cout<<"~A()"<<this<<endl;
    }
    void dis()
    {
        cout<<"A::void dis()"<<endl;
    }
};

int main()
{
    shared_ptr<A> sp(new A);
    shared_ptr<A> sp2(sp);
    shared_ptr<A> sp3(sp);
    cout<<sp.use_count()<<endl;//3

    shared_ptr<A> spm =std::move(sp);
    cout<<spm.use_count()<<endl;//3
    cout<<sp2.use_count()<<endl;//3
    cout<<sp3.use_count()<<endl;//3

}

shared_ptr 引用传递

//todo shared_ptr 移动
#include <iostream>
#include <memory>
using namespace std;
class A
{
public:
    A()
    {
        cout<<"A()"<<this<<endl;
    }
    ~A()
    {
        cout<<"~A()"<<this<<endl;
    }
    void dis()
    {
        cout<<"A::void dis()"<<endl;
    }
};


void func(shared_ptr<A>& sp){ //引用传递,,不用引用会use_count+1
    cout<<sp.use_count()<<endl;//1
}
int main()
{
    shared_ptr<A> sp(new A);
    func (sp);
    cout<<sp.use_count()<<endl;//1
    
}
MarkTop1
关注
  • 16
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++如何用智能指针管理内存资源
09-07
为了解决这个问题，C++引入了智能指针，这是一种特殊类型的指针，能够自动管理内存资源，从而减少内存泄漏和悬垂指针的风险。智能指针是RAII（Resource Acquisition Is Initialization）原则的体现，它在对象创建时...
c++11智能指针
01-06
智能指针类对象封装了自动释放内存的功能 从而避免内存泄漏 例如 void remodel(std::string & str) { std::string * ps = new std::string(str); //str = ps; return; //内存泄漏 } void remodel1(std::string &...
c++ 11 智能指针 解决内存泄露问题
一个老菜鸟的学习分享
03-07 1553
c++11 智能指针总结
C++ 智能指针 - 全部用法详解
cpp_learner的博客
08-02 6万+
血的教训？不学智能指针，本人丢了一份工作。
C++进阶--C++11智能指针
sushang的博客
02-07 1557
智能指针不是指针，是一个管理指针的类，用来存储指向动态分配对象的指针，负责自动释放动态分配的对象，防止堆内存泄漏。动态分配的资源，交给一个类对象去管理，当类对象生命周期结束时，自动调用析构函数释放资源。RAII是resource acquisition is initialization的缩写，意为“资源获取即初始化”。它是 C++ 之父 Bjarne Stroustrup 提出的设计理念，其核心是把资源和对象的生命周期绑定，对象创建获取资源，对象销毁释放资源。
c++—内存管理、智能指针、内存池
m0_72814368的博客
05-25 1027
c++—内存管理、智能指针、内存池
C++ 以智能指针管理内存资源
Dablelv 的博客专栏。
10-13 1504
C++ 作为一门应用广泛的高级编程语言，却没有像 Java、C# 等语言拥有垃圾回收（Garbage Collection ）机制来自动进行内存管理，这也是C++ 一直被诟病的一点。C++ 在发展的过程中，一直致力于解决内存泄漏，C++ 虽然基于效率的考虑，没有采用垃圾回收机制，但从 C++98 开始，推出了智能指针（Smart Pointer）来管理内存资源，以弥补 C++ 在内存管理上的技术空白。
C++11内存管理优化：智能指针
qq_38493448的博客
03-06 814
文章目录内存管理优化C++11之前的auto_ptrshared_ptr共享的智能指针使用方式注意问题unique_ptr独占的智能指针使用方式weak_ptr基本用法智能指针的使用选择 内存管理优化 C++11提供智能指针来帮助管理内存，智能指针可以自动删除分配的内存 C++11提供三种智能指针：std::shared_ptr，std::unique_ptr，std::weak_ptr使用时需要引用头文件memory C++11之前的auto_ptr C++11之前的auto_ptr设计上有很多坑，若通过
C++11智能指针知识汇总与整理
leiyang2014的博客
12-19 1097
C++最初堆内存资源释放是需要手动释放的，后期在C++11上增加了对内存有良好的管理的智能指针，本文主要讲解了C++11常用的三大智能指针的原理，特点，方法
【C++11】智能指针
weixin_60478154的博客
04-02 7387
【C++11】智能指针
C++ STL 四种智能指针
热门推荐
Dablelv 的博客专栏。
08-07 7万+
auto_ptrunique_ptrshared_ptrweak_ptrauto_ptr 是 C++98 提出的，C++11 已将其摒弃，并提出了 unique_ptr 替代 auto_ptr。虽然 auto_ptr 已被摒弃，但在实际项目中仍可使用，但建议使用更加安全的 unique_ptr，后文会详细叙述。shared_ptr 和 weak_ptr 则是 C+11 从准标准库 Boost 中引入的两种智能指针。
c++11之智能指针
qq_56673429的博客
05-18 2万+
前言：面试的时候被问到智能指针了，答的很糟糕，这几天重新学习了智能指针。下面是我对c++智能指针的理解与总结，希望能帮到大家，同时提升自己。 一，什么是智能指针 在C++中没有垃圾回收机制，必须自己释放分配的内存，否则就会造成内存泄露。解决这个问题最有效的方法是使用智能指针（smart pointer）。智能指针是存储指向动态分配（堆）对象指针的类，用于生存期的控制，能够确保在离开指针所在作用域时，自动地销毁动态分配的对象，防止内存泄露。智能指针的核心实现技术是引用计数，每使用它一次，内部引用计数加1.
C++智能指针用法详解
12-22
　由于 C++ 语言没有自动内存回收机制，程序员每次 new 出来的内存都要手动 delete。程序员忘记 delete，流程太复杂，终导致没有 delete，异常导致程序过早退出，没有执行 delete 的情况并不罕见。 　用智能指针便...
C++11智能指针中的 unique_ptr实例详解
12-17
在C++11中，智能指针是一种管理动态分配对象生命周期的工具，它们负责在不再需要对象时自动释放内存。本篇文章重点讲解的是`unique_ptr`，它是C++11新引入的一种智能指针，强调对对象的唯一所有权。 1. **unique_...
C++笔记5•内存管理•
最新发布
qq_64446190的博客
08-12 658
内存管理
c++ error: ‘*’ does not name a type； did you mean ‘**’?
xiaozhi
08-08 473
c++ error: ‘*’ does not name a type； did you mean ‘**’?
STL中的迭代器失效（vector为例）
2302_80190394的博客
08-08 353
STL中的迭代器失效（vector为例）
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
qq_19319481的博客
08-09 333
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
C语言一维数组(含数组二分查找)
hdxbufcbjuhg的博客
08-09 1185
在⼀个升序的数组中查找指定的数字n，很容易想到的⽅法就是遍历数组，但是这种⽅法效率⽐较低。比如我们之前写的猜数字游戏，会生成一个随机数来让玩家猜，范围是1~100，那玩家会从1开始一个一个猜吗，不会吧，那样就太慢了，我们一般会从整体的一半开始猜，比如猜50，告诉你大了还是小了，这样只需要一步就可以排除庞大数字中的一半，比如假设猜1 ~ 10000，猜5000后就可以知道猜大了还是小了，直接排除了5000个数字，效率很快，这就是⼆分查找，也叫折半查找。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

MarkTop1

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值