C++:线上课程2_15（智能指针auto_ptr）

已于 2022-03-30 20:34:13 修改
阅读量76 收藏
点赞数 1
分类专栏： C++(线上) 文章标签： linux git c++
于 2022-03-25 19:40:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48580892/article/details/123733494
版权

RAII与智能指针
auto_ptr的弃用原因
unique_ptr的使用
shared_ptr的使用&线程安全
weak_ptr的作用

文章目录

智能指针

1.什么是RAII？

RAll (Resource Acquisition ls lnitialization）是由c++之父Bjarne Stroustrup提出的，中文翻译为资源获取即初始化，使用局部对象来管理资源的技术称为资源获取即初始化；这里的资源主要是指操作系统中有限的东西如内存(heap)，网络套接字，互斥量，文件句柄等等，局部对象是指存储在栈的对象，它的生命周期是由操作系统来管理的无需人工介入。

2.RAII的原理

资源的使用一般经历三个步骤:
a.获取资源(创建对象)（操作系统内核资源：线程，进程，文件等等）
b.使用资源
c.销毁资源（析构对象)

3.裸指针

不能判断指针指向一个对象还是一组对象，所以销毁不能进行

int main()
{
    //裸指针
    int* ip = NULL;
    Object* op = NULL;
}

3.1裸指针存在问题

  1. 难以区分指向的是单个对象还是一个数组;

  2. 使用完指针之后无法判断是否应该销毁指针，因为无法判断指针是否“拥有”指向的对象;

  3. 在已经确定需要销毁指针的情况下，也无法确定是用delete关键字删除，还是有其他特殊的销毁机制，例如通过将指针传入某个特定的销毁函数来销毁指针;

  4. 即便已经确定了销毁指针的方法，由于1的原因，仍然无法确定到底是用delete(销毁单个对象)还是 delete[ ] (销毁一个数组);

  5. 假设上述的问题都解决了，也很难保证在代码的所有路径中(分支结构，异常导致的跳转)，有且仅有一次销毁指针操作;任何一条路径遗漏都可能导致内存泄露，而销毁多次则会导致未定义行为;

  6. 理论上没有方法来分辨一个指针是否处于悬挂状态;

4.智能指针(my_auto_ptr弃用)

4.1示例1

#include<iostream>
#include<list>
#include<vector>
#include<queue>
#include<stack>
#include<stdio.h>
using namespace std;

class Object
{
public:
    int value;
public:
    Object(int x = 0) :value(x)
    {
        cout << "Create Object : " << this << endl;
    }
    ~Object()
    {
        cout << "Destroy Object : " << this << endl;
    }
};
template<class _Ty>
class my_auto_ptr
{
private:
    bool _Owns;
    _Ty* _Ptr;
public:
    my_auto_ptr(_Ty* p = NULL) :_Owns(p != NULL), _Ptr(p) {}
    ~my_auto_ptr()
    {
        if (_Owns)
        {
            delete _Ptr;
        }
        _Ptr = NULL;
    }
};
void fun()
{
    my_auto_ptr<Object> obj(new Object(10));
}
int main()
{
    fun();
}

运行结果
在这里插入图片描述

4.2示例2

#include<iostream>
#include<list>
#include<vector>
#include<queue>
#include<stack>
#include<stdio.h>
using namespace std;

class Object
{
public:
    int value;
public:
    Object(int x = 0) :value(x)
    {
        cout << "Create Object : " << this << endl;
    }
    ~Object()
    {
        cout << "Destroy Object : " << this << endl;
    }
    int& Value()
    {
        return value;
    }
    const int& Value() const
    {
        return value;
    }
};
template<class _Ty>
class my_auto_ptr
{
private:
    bool _Owns;
    _Ty* _Ptr;
public:
    my_auto_ptr(_Ty* p = NULL) :_Owns(p != NULL), _Ptr(p) {}
    ~my_auto_ptr()
    {
        if (_Owns)
        {
            delete _Ptr;
        }
        _Ptr = NULL;
    }
    _Ty* get() const
    {
        return _Ptr;
    }
    _Ty& operator*() const
    {
        return *(get());
    }
    _Ty* operator->() const
    {
        return get();
    }
};

void fun()
{
    my_auto_ptr<Object> obj(new Object(10));

    cout << obj->Value() << endl;//重载指向符
    cout << (*obj).Value() << endl;//重载解引用
}
int main()
{
    fun();
}

运行结果
在这里插入图片描述

4.3示例3

    my_auto_ptr(const my_auto_ptr& op) :_Owns(op._Owns)
    {
        if (Owns)
        {
            _Ptr = op._Ptr;
        }
    }
    int main()
{
    my_auto_ptr<Object> pobja(new Object(19));
    my_auto_ptr<Object> pobjb(pobja);//
}
//pobja和pobjb两个对象共同拥有同一个资源

4.4完整代码

my_auto_ptr 所有代码

#include<iostream>
#include<list>
#include<vector>
#include<queue>
#include<stack>
#include<stdio.h>
using namespace std;

class Object
{
public:
    int value;
public:
    Object(int x = 0) :value(x)
    {
        cout << "Create Object : " << this << endl;
    }
    ~Object()
    {
        cout << "Destroy Object : " << this << endl;
    }
    int& Value()
    {
        return value;
    }
    const int& Value() const
    {
        return value;
    }
};

template<class _Ty>
class my_auto_ptr
{
private:
    bool _Owns;
    _Ty* _Ptr;
public:
    my_auto_ptr(_Ty* p = NULL) :_Owns(p != NULL), _Ptr(p) {}
    ~my_auto_ptr()
    {
        if (_Owns)
        {
            delete _Ptr;
        }
        _Ptr = NULL;
    }
    my_auto_ptr(const my_auto_ptr& op) :_Owns(op._Owns)//拷贝构造函数（转移拥有权）
    {
        if (Owns)
        {
            _Ptr = op._Ptr;
        }
    }
    _Ty* get() const
    {
        return _Ptr;
    }
    _Ty& operator*() const
    {
        return *(get());
    }
    _Ty* operator->() const
    {
        return get();
    }
    void reset(_Ty* p = NULL)//重置函数
    {
        if (_Owns)
        {
            delete _Ptr;
        }
        _Ptr = NULL;
    }
    _Ty* release()//释放函数
    {
        _Ty* tmp = NULL;
        if (_Owns)
        {
            ((my_auto_ptr*)this)->_Owns = false;
            tmp = _Ptr;
            ((my_auto_ptr*)this)->_Ptr = NULL;
        }
        return tmp;
    }
};
void fun(my_auto_ptr<Object> apx)
{
    int x = apx->Value();
    cout << x << endl;
}
int main()
{
    my_auto_ptr<Object> pobja(new Object(19));
    fun(pobja);
    int a = pobja->Value();
    my_auto_ptr<Object> pobjb(pobja);
}

5.智能指针(拥有独有对象所有权语义的智能指针)

5.1unique_ptr指针特点

不允许赋值，不允许用一个对象初始化另一个对象，不允许

void fun(std::unique_ptr<Object> apx)
{
    std::unique_ptr<Object> obj(new Object(10));
    return obj;
}
int main()
{
    std::unique_ptr<Object> pobja(new Object(10));
    std::unique_ptr<Object> pobjb(pobja);//不允许用一个对象初始化另一个对象（原因：底层代码删除了拷贝构造函数）
    std::unique_ptr<Object> pobjb;
    pobjb = pobja;//不允许赋值

    fun(pobja);//编译错误
    pobja = fun();//编译错误，拷贝构造函数无参

    return 0;
}

5.2unique_ptr全部代码

#include<iostream>
#include<list>
#include<vector>
#include<queue>
#include<stack>
#include<stdio.h>
using namespace std;
template<class _Ty>
class my_unique_ptr
{
private:
    int value;
public:
    _Ty* _Ptr;
    my_unique_ptr(const my_unique_ptr&) = delete;
    my_unique_ptr& operator=(const my_unique_ptr&) = delete;

public:
    typedef _Ty* pointer;
    typedef _Ty element_type;
public:
    my_unique_ptr(_Ty* p = NULL) :_Ptr(p) {}
    ~my_unique_ptr()
    {
        delete _Ptr;
    }
    my_unique_ptr(my_unique_ptr&& _Y)
    {
        _Ptr = _Y._Ptr;
        _Y._Ptr = NULL;
    }
    my_unique_ptr& operator=(my_unique_ptr&& _Y)
    {
        if (this == &_Y)
        {
            return *this;
        }
        delete _Ptr;
        _Ptr = _Y._Ptr;
        _Y._Ptr = NULL;
        return *this;
    }
};
class Object
{
public:
    int value;
public:
    Object(int x = 0) :value(x)
    {
        cout << "Create Object : " << this << endl;
    }
    ~Object()
    {
        cout << "Destroy Object : " << this << endl;
    }
    int& Value()
    {
        return value;
    }
    const int& Value() const
    {
        return value;
    }
};
std::unique_ptr<Object> fun()
{
    std::unique_ptr<Object> obj(new Object(10));
    return obj;
}

int main()
{
    std::unique_ptr<Object> pobja(new Object(100));
    std::unique_ptr<Object> pobjb(std::move(pobja));

    pobja = (std::unique_ptr<Object>&&)(pobjb);
    pobja = std::move(pobjb);

    return 0;
}

5.3代码示例(unique_ptr代码示例)

using namespace std;

template<class T,class D>//完全泛化
class my_unique_ptr
{
public:
    my_unique_ptr()
    {
        cout << "T,D" << endl;
    }
};

template<class T, class D>//部分特化
class  my_unique_ptr<T*, D*>
{
public:
    my_unique_ptr()
    {
        cout << "const T*,D*" << endl;
    }
};

template<class T, class D>//部分特化
class  my_unique_ptr<const T*, D*>
{
public:
    my_unique_ptr()
    {
        cout << "const T*,D*" << endl;
    }
};

template<>//完全特化
class  my_unique_ptr<const char*, const char*>
{
public:
    my_unique_ptr()
    {
        cout << "const char*,const char*" << endl;
    }
};

template<class T, class D>
class my_unique_ptr<T[], D>
{
public:
    my_unique_ptr()
    {
        cout << "T[],D" << endl;
    }
};

int main()
{
    my_unique_ptr<int, int> a;
    my_unique_ptr<int[], int> b;

    return 0;
}

5.4代码示例(unique_ptr代码示例)

class Object
{
public:
    int value;
public:
    Object(int x = 0) :value(x)
    {
        cout << "Create Object : " << this << endl;
    }
    ~Object()
    {
        cout << "Destroy Object : " << this << endl;
    }
    int& Value()
    {
        return value;
    }
    const int& Value() const
    {
        return value;
    }
};
struct delete_object
{
    void operator()(Object* op)
    {
        if (op == NULL) return;
        delete op;
    }
};
int main()
{
    std::unique_ptr<Object> pobja(new Object(10));
    std::unique_ptr<Object, delete_object> pobjb(new Object(20));

    return 0;
}

运行结果

在这里插入图片描述

何小柒（qi)～
关注
专栏目录
C++:线上课程2_28（STL list）
小柒的秃头之路
04-13 984
文章目录一、STL1.几种插入函数的区别2.vector和智能指针二、List1、List存储结构 一、STL 1.几种插入函数的区别 objevc.reserve(100);//只进行空间的扩充，不进行对象的创建 objevc.resize(100);//既进行空间的扩充，又进行对象的创建 class Object { private: int value; public: Object(int x = 0) :value(x) { cout << " Object "
C++:线上课程3_4——3_5(alloc)
小柒的秃头之路
04-24 1624
文章目录一、二、 一、 二、
C++智能指针 unique_ptr
线上幽灵
08-06 268
C++智能指针 unique_ptr unique_ptr 独占所指向的对象, 同一时刻只能有一个 unique_ptr 指向给定对象(通过禁止拷贝语义, 只有移动语义来实现), 定义于 memory (非memory.h)中, 命名空间为 std. 标准库早期版本中定义了 auto_ptr, 它具有 unique_ptr 的部分特征, 但不是全部, 例如, 不能在容器中保存 auto_ptr...
C++智能指针 shared_ptr
线上幽灵
08-06 213
C++智能指针 shared_ptr shared_ptr 是一个标准的共享所有权的智能指针, 允许多个指针指向同一个对象. 定义在 memory 文件中(非memory.h), 命名空间为 std. shared_ptr 是为了解决 auto_ptr 在对象所有权上的局限性(auto_ptr 是独占的), 在使用引用计数的机制上提供了可以共享所有权的智能指针, 当然这需要额外的开销: 　　...
关于 智能指针 的线程安全问题
天行健，地势坤
09-04 4582
智能指针是非线程安全的，多线程下修改共享的智能指针的时候需要有同步机制
C++重温笔记(三): C++的引用竟然也有点深不可测
Miracle8070
10-06 680
1. 写在前面 c++在线编译工具，可快速进行实验: https://www.dooccn.com/cpp/ 这段时间打算重新把c++捡起来， 实习给我的一个体会就是算法工程师是去解决实际问题的，所以呢，不能被算法或者工程局限住，应时刻提高解决问题的能力，在这个过程中，我发现cpp很重要， 正好这段时间也在接触些c++开发相关的任务，所有想借这个机会把c++重新学习一遍。 在推荐领域， 目前我接触到的算法模型方面主要是基于Python， 而线上的服务全是c++(算法侧， 业务那边基本上用go)，我们所谓的模
记c++坑：7.记一次由智能指针导致的内存泄漏问题解决
Coder-Coder
11-20 973
目录项目背景问题产生 项目背景 我们的主要产品是一个针对个人用户的c/s,b/s混合架构的应用，为了对我们产品的一些新功能调试，压力测试，以及对线上服务的监控，我使用c++开发了一个机器人程序。这个程序中90%的设计和代码由我完成，除了其中的一个基于udp通信的库，使用了enet，然而这个库在之前不可追溯的几任维护者手中，将其代码进行了修改，居然在里面掺杂了tcp通信的功能！这完全违背了设计模式的...
C++学习笔记（6）
weixin_44824965的博客
12-16 334
智能指针、浅深拷贝、箭头操作符、std::vector及其优化、库的静/动态链接
C++项目：【负载均衡式在线OJ】
这是一个非常有意思的博主
10-11 2493
这个项目是基于负载均衡的在线OJ，能够自动分配服务器资源，保持平衡的情况下为用户提供良好的编程运行环境，让代码快速运行和提交。
C++ 应用软件开发从入门到精通详解
热门推荐
dvlinker的技术专栏
06-21 2万+
本文详细介绍一下Windows平台下用C++开发应用软件的诸多内容，以供大家借鉴或参考。
C/C++ 内存泄漏-原因、避免以及定位
yx5666的博客
10-27 710
作为C/C++开发人员，内存泄漏是最容易遇到的问题之一，这是由C/C++语言的特性引起的。C/C++语言与其他语言不同，需要开发者去申请和释放内存，即需要开发者去管理内存，如果内存使用不当，就容易造成或者。今天，借助此文，分析下项目中经常遇到的导致内存泄漏的原因，以及如何避免和定位内存泄漏。
游戏开发面试答案篇（一）-- C++篇​
weixin_60795832的博客
09-09 1144
游戏开发程序岗面试题答案版C++篇
【RAII】RAII 技术（内存安全解决技术/自动化解锁技术）
小鱼菜鸟的博客
04-11 274
目录 介绍 RAII技术在锁上的应用 互斥锁 RAII技术在指针上的应用 智能指针 介绍 RAII ：Resource Acquisition Is Initialisation (RAII) (任何资源的获取都应该发生在类的构造函数中，资源的释放应发生在析构函数中，即资源的生命周期与对象绑定) RAII是一种使用在面向对象语言中的资...
Qt OpenGL相机系统
dayuhaitang1的博客
11-05 708
Qt OpenGL相机系统
【Linux】：信号与信号产生
Yikefore的博客
09-12 928
信号的基本概念、对信号的理解、信号的多种产生方式以及核心转储的详细介绍！
【Linux】uImage头部信息详细解析
最新发布
W__winter的博客
09-16 1138
【代码】【Linux】uImage头部信息详细解析。
【Linux】ldd常见问题
zclinux的博客
09-11 1041
当你自己编译程序时，可以通过。
Linux如何使用sed命令进行文本替换
yang295242361的博客
09-12 512
在Linux中，sed（Stream Editor）是一个用于处理文本流的命令行工具，它非常适合用于执行基本的文本转换。sed可以读取输入的文本文件，根据指定的指令对文本进行处理，并将结果输出到标准输出设备。
C++智能指针详解：unique_ptr, weak_ptr, shared_ptr, auto_ptr
"本文主要介绍了C++中的四种智能指针：auto_ptr、unique_ptr、shared_ptr和weak_ptr，包括它们的使用方式、工作机制以及可能存在的缺陷。智能指针是为了解决C++中动态内存管理和指针操作可能导致的问题，如内存泄漏...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值