C++智能指针

最新推荐文章于 2024-03-24 21:40:34 发布
最新推荐文章于 2024-03-24 21:40:34 发布
阅读量229 收藏
点赞数
分类专栏： C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35452533/article/details/77337717
版权

智能指针是用模板实现，创建对象后，对象管理了资源，然后通过析构函数释放掉该资源，以防内存泄漏。

auto_ptr（空间管理权限的转移，永远只有一个指针指向动态开辟的空间）
#include <iostream>
using namespace std;

template<class T>
class AutoPtr
{
public:
    AutoPtr(T* p = NULL)
        :_p(p)
    {
        cout<<"AutoPtr()"<<endl;
    }

    AutoPtr(AutoPtr<T>& ap)
        :_p(ap._p)
    {
        ap._p = NULL;
    }

    AutoPtr<T>& operator =(AutoPtr<T>& ap)
    {
        if(this != &ap)
        {
            if(_p != NULL)
                delete _p;
            _p = ap._p;
            ap._p = NULL;
        }
        return *this;
    }

    ~AutoPtr()
    {
        cout<<"~AutoPtr()"<<endl;
        if(_p)
            delete _p;
    }

    T& operator *()
    {
        return *_p;
    }

    T* operator ->()
    {
        return _p;
    }

private:
    T* _p;
};

struct A
{
    int a;
    int b;
};

int main()
{
    AutoPtr<int> ap1(new int(1));
    AutoPtr<int> ap2(ap1);
    AutoPtr<int> ap3(new int(2));
    ap3 = ap2;

    //cout<<*ap1<<endl;//非法访问
    //cout<<*ap2<<endl;//非法访问
    cout<<*ap3<<endl;


    AutoPtr<A> ap4(new A);
    ap4->a = 1;
    ap4->b = 2;
    cout<<ap4->a<<endl;
    cout<<ap4->b<<endl;

    return 0;
}
auto_ptr（用_owner来标记空间的释放权，防止重复释放同一块空间）
#include <iostream>
using namespace std;

template<class T>
class AutoPtr
{
public:
    AutoPtr(T* p = NULL)
        :_p(p)
        ,_owner(true)
    {
        if(_owner == NULL)
            _owner = false;
    }

    AutoPtr(AutoPtr<T>& ap)
        :_p(ap._p)
        ,_owner(true)
    {
        ap._owner = false;
    }

    AutoPtr<T>& operator =(AutoPtr<T>& ap)
    {
        if(this != &ap)
        {
            if(_p)
                delete _p;

            _p = ap._p;
            _owner = true;
            ap._owner = false;
        }
        return *this;
    }

    ~AutoPtr()
    {
        if(_owner)
        {
            delete _p;
            _p = NULL;
            _owner = false;
        }
    }

    T& operator *()
    {
        return *_p;
    }

    T* operator ->()
    {
        return _p;
    }

private:
    T* _p;
    mutable bool _owner;
};

struct A
{
    int a;
    int b;
};

int main()
{
    AutoPtr<int> ap1(new int(1));
    AutoPtr<int> ap2(ap1);
    AutoPtr<int> ap3(new int(2));
    ap3 = ap2;

    cout<<*ap1<<endl;//非法访问
    cout<<*ap2<<endl;//非法访问
    cout<<*ap3<<endl;


    AutoPtr<A> ap4(new A);
    ap4->a = 10;
    ap4->b = 20;
    cout<<ap4->a<<endl;
    cout<<ap4->b<<endl;

    return 0;
}
scoped_ptr（防止拷贝，防止赋值）
#include <iostream>
using namespace std;

template<class T>
class ScopedPtr
{
public:
    friend void Fun();

    ScopedPtr(T* p = NULL)
    {}

    T& operator *()
    {
        return *_p;
    }

    ~ScopedPtr()
    {
        if(_p)
        {
            delete _p;
            _p = NULL;
        }
    }
private:
    ScopedPtr(ScopedPtr<T>& sp);
    ScopedPtr<T>& operator =(const ScopedPtr<T>& sp);

    T* _p;
};

void Fun()
{
    ScopedPtr<int> sp1(new int);
    ScopedPtr<int> sp2;
    //ScopedPtr<int> sp3(sp1);//友元函数不是类的成员函数，同样无法访问私有成员
}

int main()
{
    Fun();

    ScopedPtr<int> sp1(new int(1));
    ScopedPtr<int> sp2;
    //ScopedPtr<int> sp3(sp1);//类外不能访问类的私有成员
    return 0;
}
scoped_array管理数组
#include <iostream>
using namespace std;

template<class T>
class ScopedArray
{
public:
    ScopedArray(T* p = NULL)
        :_p(p)
    {}

    ~ScopedArray()
    {
        if(_p)
        {
            delete _p;
            _p = NULL;
        }
    }

    T& operator [](int index)
    {
        return _p[index];
    }

    const T& operator [](int index)const
    {
        return _p[index];
    }
private:
    ScopedArray(ScopedArray<T>& sp);
    ScopedArray<T>& operator =(const ScopedArray<T>& sp);

    T* _p;
};

int main()
{
    ScopedArray<int> sp1(new int[10]);
    sp1[0] = 0;
    sp1[1] = 1;

    return 0;
}
shared_ptr（通过引用计数实现对空间的管理）
#include <iostream>
using namespace std;

template<class T>
class SharedPtr
{
public:
    SharedPtr(T* p =NULL)
        :_p(p)
        ,_pcount(NULL)
    {
        if(_p)
            _pcount = new int(1);
    }

    SharedPtr(const SharedPtr<T>& sp)
        :_p(sp._p)
        ,_pcount(sp._pcount)
    {
        (*sp._pcount)++;
    }

    SharedPtr<T>& operator =(const SharedPtr<T>& sp)
    {
        if(this != &sp)
        {
            Release();

            _p = sp._p;
            _pcount = sp._pcount;
            (*sp._pcount)++;
        }
        return *this;
    }

    ~SharedPtr()
    {
        Release();
    }

    T& operator *()
    {
        return *_p;
    }

    T* operator ->()
    {
        return _p;
    }
private:
    void Release()
    {
        if(_p && (--(*_pcount)) == 0)
        {
            delete _p;
            _p = NULL;

            delete _pcount;
            _pcount = NULL;
        }
    }

    T* _p;
    int* _pcount;
};

int main()
{
    SharedPtr<int> sp1(new int(1));
    SharedPtr<int> sp2(sp1);

    SharedPtr<int> sp3(new int(3));
    sp3 = sp1;

    return 0;
}
shared_array管理数组
#include <iostream>
using namespace std;

template<class T>
class SharedArray
{
public:
    SharedArray(T* p =NULL)
        :_p(p)
        ,_pcount(NULL)
    {
        if(_p)
            _pcount = new int(1);
    }

    SharedArray(const SharedArray<T>& sp)
        :_p(sp._p)
        ,_pcount(sp._pcount)
    {
        (*sp._pcount)++;
    }

    SharedArray<T>& operator =(const SharedArray<T>& sp)
    {
        if(this != &sp)
        {
            Release();

            _p = sp._p;
            _pcount = sp._pcount;
            (*sp._pcount)++;
        }
        return *this;
    }

    ~SharedArray()
    {
        Release();
    }

    T& operator *()
    {
        return *_p;
    }

    T* operator ->()
    {
        return _p;
    }

    T& operator [](size_t index)
    {
        return _p[index];
    }

    const T& operator [](size_t index)const
    {
        return _p[index];
    }
private:
    void Release()
    {
        if(_p && (--(*_pcount)) == 0)
        {
            delete _p;
            _p = NULL;

            delete _pcount;
            _pcount = NULL;
        }
    }

    T* _p;
    int* _pcount;
};

int main()
{
    SharedArray<int> sp(new int[10]);
    sp[0] = 0;
    sp[1] = 1;
    sp[2] = 2;

    return 0;
}
░冷░月░
关注
专栏目录
C++ 智能指针
CR7lmz的博客
11-17 374
智能指针 智能指针的使用以及原理： 智能指针的思想：RAll RAll是一种利用对象声明周期来控制程序资源的一种技术。它可以在对象构造时获取资源，在对象析构时候释放资源，完全不用用户自己释放，当然也解决了用原生态指针的缺陷。 RAll思想的好处： 1.不用自己显示释放申请的资源，用户不用考虑什么术后该释放资源，将这些交给编译器即可。 2.用这种方法，对象所需的资源在其生命周期内始终保持有效。 下面...
智能指针什么时候释放？什么时候引用计数为0
weixin_43489941的博客
03-18 2913
智能指针内部有一个计数器，当赋值给别的智能指针或者函数传参拷贝到另一个shared_ptr，计数器就会加1，当函数执行完毕，智能指针对象 就被析构了，此时计数器就会减一，知道计数器变为0 ，说明没人在用这个对象了，就执行delete把它释放掉。 #include <iostream> #include <memory> using namespace std; class Person { public: Person(int age,int height) { this-
17 C++ 高级之智能指针
a136447572的专栏
08-02 487
Android Ndk 学习笔记（目录） #include <iostream> #include <memory> // 智能指针的头文件引入 using namespace std; class Person{ public: ~Person(){ cout << "Person 析构函数" <<endl ; } }; // 智能指针 void usePerson(){ Person * person1
【C++】《C++ 17 入门经典》读书笔记 11 ---- 智能指针：unique_ptr、shared_ptr、weak_ptr
风语留痕
06-29 532
介绍 C++17 中的智能指针：unique_ptr、shared_ptr、weak_ptr。
shellmad-17_C++新特性 智能指针的原理
esjiang的博客
03-10 232
简单的介绍到底什么是智能指针 智能指针: 用起来像指针(注意, 这里用了“像”) 会自己对资源进行释放 自己对资源进行释放 先来写一个简单的例子 class CStudent { public: CStudent() { } void test() { cout << "CStudent" << endl; } private: char* m_pszBuf; int m_nSex; }; 所谓的智能指针是要解决什么问题
c++智能指针最全知识点即面试题目总结
02-27
对于需要面试C++相关岗位的文章，看完这篇文章，如果面试官再问你智能指针，我敢肯定，你一定可以侃侃而谈了~智能指针的面试题，只看这一篇就够了！相信看完这篇文章，妈妈再也不用担心面试官考我智能指针的问题啦...
C++智能指针用法详解
12-22
　用智能指针便可以有效缓解这类问题，本文主要讲解参见的智能指针的用法。包括：std::auto_ptr、boost::scoped_ptr、boost::shared_ptr、boost::scoped_array、boost::shared_array、boost::weak_ptr、boost:: ...
C++智能指针-unique-ptr智能指针详解.pdf
02-27
《C++智能指针——unique_ptr智能指针详解》 智能指针是C++中用于自动管理动态分配内存的一种工具，它可以确保在适当的时候自动释放内存，从而避免内存泄漏的问题。其中，`unique_ptr`是一种特殊的智能指针，它拥有...
智能指针的实现及原理
10-27 8835
 本文主要讨论C++程序设计的一种常用技术——智能指针（smart pointer），主要内容包括引用计数（reference count）和句柄类(handle class)。如果文中有错误或遗漏之处，敬请指出，谢谢！    作者： tyc611, 2007-02-01   当类中有指针成员时，一般有两种方式来管理指针成员：一是采用值型的方式管理，每个类对象都保留一份指针指向的对
c++学习笔记十七(函数指针与智能指针)
qq_41827817的博客
03-15 376
1.auto_ptr 作用：对作用域内的动态分配对象的自动释放 基本类型： #include <iostream> #include <memory> using namespace std; int main(){ int* pn = new int(10); auto_ptr<int> ap(pn); cout << *a...
C++11包含大量的新特性
yangxueyangxue的博客
07-12 191
包含lambda表达式，类型推导keyword : auto、decltype，模板，和智能指针的大量改进。decltype实际上有点像auto的反函数，auto能够让你声明一个变量。而decltype则能够从一个变量或表达式中得到类型。nullptr是为了解决原来C++中NULL的二义性问题而引进的一种新的类型，由于NULL实际上代表的是0。简化的for循环，能够用于遍历数组、容器、s...
C++11新特性：智能指针
最新发布
暮色年华的博客
03-24 1154
C++中动态内存的管理是通过new和delete来完成的，保证new和delete的配对使用。但是有时候会忘记释放内存，甚至有时候我们根本就不知道什么时候释放内存。特别时在多个线程间共享数据时，更难判断内存该何使释放。这种情况下就机器容易产生引用非法内存的指针。由于 C++ 语言没有自动内存回收机制，程序员每次 new 出来的内存都要手动 delete。程序员忘记 delete，流程太复杂，最终导致没有 delete，异常导致程序过早退出，没有执行 delete 的情况并不罕见。
C++智能指针详解（C++11）
Hacker_Free的博客
04-02 345
1. C++为什么需要智能指针 我们知道除了静态内存和栈内存外，每个程序还有一个内存池，这部分内存被称为自由空间或者堆。程序用堆来存储动态分配的对象即那些在程序运行时分配的对象，当动态对象不再使用时，我们的代码必须显式的销毁它们。 在C++中，动态内存的管理是用一对运算符完成的：new和delete。new：在动态内存中为对象分配一块空间并返回一个指向该对象的指针，delete：指向一个动态独享的...
【C++】一文搞懂智能指针
lsz20000813的博客
04-17 608
智能指针基本概念 头文件memory 智能指针的->运算符重载 不带引用计数的智能指针 为什么智能指针要区分带引用计数或不带引用计数呢？ 因为多个智能指针指向同一份资源会引起资源的重复释放，即浅拷贝资源释放的问题，所以有的不带引用计数，但是只能有一个智能指针指向该份资源，有的带引用计数 auto_ptr auto_ptr怎么解决浅拷贝资源多份释放的问题？ 答：永远让最后一个auto_ptr指向该份资源，前边的auto_ptr被置为nullptr，图示如下： 所以auto有很多缺点： 不推荐使用
C++总结笔记（十二）—— 智能指针
baidu_35536188的博客
03-06 822
个人总结
C++智能指针实例详解：内存管理神器
C++智能指针实例详解深入解析了C++编程中解决内存管理问题的关键工具。C++语言原生缺乏自动内存回收功能，导致程序员在使用new分配内存后必须手动调用delete来释放，这易引发内存泄漏或因异常而未释放内存的问题。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值