C++智能指针

1. 智能指针

所谓智能指针其实是一些模板类,它们负责自动管理一个指针的内存,免去了手动 new/delete 的麻烦,这个类的构造函数中传入一个普通指针,析构函数中释放传入的指针。智能指针的类都是栈上的对象,所以当函数(或程序)结束时会自动被释放。

智能指针利用了RAII(资源获取即初始化)的技术,对普通指针进行封装,使得其行为像一个指针,但其实是一个对象。把资源放进对象内,用资源来管理对象,便是 C++ 编程中最重要的编程技法之一,即 RAII ,它是 "Resource Acquisition Is Initialization" 的首字母缩写。

智能指针的作用:方便堆内存管理

  • 忘记delete 内存:会导致内存泄漏问题,且除非是内存耗尽否则很难检测到这种错误。
  • 使用已经释放掉的对象:如果能够记得在释放掉内存后将指针置空并在下次使用前判空,尚可避免这种错误。
  • 同一块内存释放两次:如果有两个指针指向相同的动态分配对象,则很容易发生这种错误。
  • 发生异常时的内存泄漏:若在new 和 delete 之间发生异常,则会导致内存泄漏。

野指针(wild pointer)就是没有被初始化过的指针

在这里插入图片描述

2. 三种智能指针

C++11中所新增的智能指针包括shared_ptrunique_ptrweak_ptr,在C++11之前还存在auto_ptr(C++17废弃)。三种类型都定义在头文件memory中。auto_ptr可能导致对同一块堆空间进行多次delete,即当两个智能指针都指向同一个堆空间时,每个智能指针都会delete一下这个堆空间,这会导致未定义行为。

让所有的智能指针都有名字

智能指针为解决资源泄漏、编写异常安全代码提供了一种解决方案,那么他是万能的良药吗?使用智能指针,就不会再有资源泄漏了吗?请看下面的代码:

上面的函数调用,看起来是安全的,但在现实世界中,其实不然:由于C++并未定义一个表达式的求值顺序,因此上述函数调用除了func在最后得到调用之外是可以确定,其他的执行序列则很可能被拆分成如下步骤:

  • 1、分配内存给T1
  • 2、分配内存给T2
  • 3、构造T1对象
  • 4、构造T2对象
  • 5、构造T1的智能指针对象
  • 6、构造T2的智能指针对象
  • 7、调用func

此时,如果程序在第3步失败,那T1和T2对象所分配内存必然泄漏。而解决这个问题的方案也很简单,就是不要在函数实参中创建shared_ptr,抛弃临时对象,让所有的智能指针都有名字,就可以避免此类问题的发生。比如以下代码:

优先选用make_shared/make_unique而非直接使用new。简单说来,相比于直接使用new表达式,make系列函数有三个优点消除了重复代码、改进了异常安全性和生成的目标代码尺寸更小速度更快

shared_ptr

  • shared_ptr多个指针指向相同的对象,使用引用计数来完成自动析构的功能。
  • shared_ptr的引用计数是线程安全的,但是其对象的写操作在多线程环境下需要加锁实现。
  • 不要用同一个指针初始化多个shared_ptr,这样可能会造成二次释放
std::unique_ptr<int> ptr0 = std::make_unique<int>(); //C++14 以及之后才可以
std::shared_ptr<int> ptr1 = std::make_shared<int>(); //C++11可以
 //or
std::unique_ptr<int> ptr0(new int);
std::unique_ptr<int> ptr1(new int);

尽量使用第一种方法,这也是C++官方推荐的。


#include<iostream>
#include<memory>

using namespace std;

int main() {
    int a = 10;
    shared_ptr<int> ptra = make_shared<int>(a);
    shared_ptr<int> ptra2(ptra);     //拷贝构造函数
    cout << ptra.use_count() << endl;   //2

    int b = 20;
    int *pb = &b;

    shared_ptr<int> ptrb = make_shared<int>(b);
    ptra2 = ptrb;
    pb = ptrb.get();    //获取指针

    cout << ptra.use_count() << endl;   //1
    cout << ptrb.use_count() << endl;   //2

    return 0;
}

shared_ptr 的问题

  • shared_ptr的尺寸是裸指针的两倍:因为内部既包含一个指向该资源的裸指针,也包含一个指向该资源的引用计数的裸指针。
  • 引用计数的内存必须动态分配
  • 引用计数的递增和递减必须是原子操作:原子操作一般比非原子操作慢。我们的实现版本里为了简单起见没有实现原子操作。
  • shared_ptr 的循环引用问题:shared_ptr 意味着你的引用和原对象是一个强联系。你的引用不解开,原对象就不能销毁。滥用强联系,这在一个运行时间长、规模比较大,或者是资源较为紧缺的系统中,极易造成隐性的内存泄漏,这会成为一个灾难性的问题。更糟的是,滥用强联系可能造成循环引用的灾难。即:B持有指向A内成员的一个shared_ptr,A也持有指向B内成员的一个 shared_ptr,此时A和B的生命周期互相由对方决定,事实上都无法从内存中销毁。 更进一步,循环引用不只是两方的情况,只要引用链成环都会出现问题。weak_ptr 的用处 就是用来辅助解决循环引用

weak_ptr

  • weak_ptr是为了配合shared_ptr而引入的一种智能指针,它不具备普通指针的行为,没有重载operator*和->。其最大的作用是协助shared_ptr工作,像旁观者那样检测资源的使用情况,解决shared_ptr相互引用时的死锁问题。
  • weak_ptr可以从一个shared_ptr或另一个weak_ptr对象构造,获得资源的观测权。
  • weak_ptr没有共享资源,它的构造不会引起指针引用计数的增加。使用weak_ptr的成员函数use_count()可以观测资源的引用计数。
  • 另一个成员函数expired()等价于判断use_count()==0
  • weak_ptr和shared_ptr之间可以相互转化,shared_ptr可以直接赋值给它,它可以通过调用lock函数来获得shared_ptr。
#if 1
#include<iostream>
#include<memory>
using namespace std;
class B;
class A
{
public:
    shared_ptr<B> pb_;
    ~A()
    {
        cout<<"A delete."<<endl;
    }


};

class B 
{
    public:
        shared_ptr<A> pa_;
        ~B()
        {
            cout<<"B delete."<<endl;
        }
};

void fun()
{
    shared_ptr<B> pb(new B());
    shared_ptr<A> pa(new A());
    pb->pa_ = pa;
    pa->pb_ = pb;
    cout<<pb.use_count()<<endl;
    cout<<pa.use_count()<<endl;
}

int main()
{
    fun();
    return 0;

}

#endif

 运行结果

分析
可以看到fun函数中pa ,pb之间互相引用,两个资源的引用计数为2,当要跳出函数时,智能指针pa,pb析构时两个资源引用计数会减一,但是两者引用计数还是为1,导致跳出函数时资源没有被释放(A B的析构函数没有被调用),
如果把其中一个改为weak_ptr就可以了,我们把类A里面的shared_ptr<B> pb_; 改为weak_ptr<B> pb_;

     

这样的话,资源B的引用开始就只有1,当pb析构时,B的计数变为0,B得到释放,B释放的同时也会使A的计数减一,同时pa析构时使A的计数减一,那么A的计数为0,A得到释放。

shared_ptr的实现

shared_ptr 必须管理一个计数器指针,在初始化和删除时需要修改这个指针的内容。所以它必须有2个成员对象:计数器的指针和数据指针: T* (that is returned by operator-> and dereferenced in operator*) and a aux* where aux is a inner abstract class that contains:

  • a counter (incremented / decremented upon copy-assign / destroy)
  • whatever is needed to make increment / decrement atomic (not needed if specific platform atomic INC/DEC is available)
  • an abstract virtual destroy()=0;
  • a virtual destructor.

所以通过shared_ptr 初始化一个变量,它所占的内存为机器内存地址的2倍,64位的系统为16bit。

Such aux class (the actual name depends on the implementation) is derived by a family of templatized classes (parametrized on the type given by the explicit constructor, say U derived from T), that add:

  • a pointer to the object (same as T*, but with the actual type: this is needed to properly manage all the cases of T being a base for whatever U having multiple T in the derivation hierarchy)
  • a copy of the deletor object given as deletion policy to the explicit constructor (or the default deletor just doing delete p, where p is the U* above)
  • the override of the destroy method, calling the deleter functor.

一个骨架实现:

template<class T>
class shared_ptr
{
    struct aux
    {
        unsigned count;

        aux() :count(1) {}
        virtual void destroy()=0;
        virtual ~aux() {} //must be polymorphic
    };

    template<class U, class Deleter>
    struct auximpl: public aux
    {
        U* p;
        Deleter d;

        auximpl(U* pu, Deleter x) :p(pu), d(x) {}
        virtual void destroy() { d(p); } 
    };

    template<class U>
    struct default_deleter
    {
        void operator()(U* p) const { delete p; }
    };

    aux* pa;
    T* pt;

    void inc() { if(pa) interlocked_inc(pa->count); }

    void dec() 
    { 
        if(pa && !interlocked_dec(pa->count)) 
        {  pa->destroy(); delete pa; }
    }

public:

    shared_ptr() :pa(), pt() {}

    template<class U, class Deleter>
    shared_ptr(U* pu, Deleter d) :pa(new auximpl<U,Deleter>(pu,d)), pt(pu) {}

    template<class U>
    explicit shared_ptr(U* pu) :pa(new auximpl<U,default_deleter<U> >(pu,default_deleter<U>())), pt(pu) {}

    shared_ptr(const shared_ptr& s) :pa(s.pa), pt(s.pt) { inc(); }

    template<class U>
    shared_ptr(const shared_ptr<U>& s) :pa(s.pa), pt(s.pt) { inc(); }

    ~shared_ptr() { dec(); }

    shared_ptr& operator=(const shared_ptr& s)
    {
        if(this!=&s)
        {
            dec();
            pa = s.pa; pt=s.pt;
            inc();
        }        
        return *this;
    }

    T* operator->() const { return pt; }
    T& operator*() const { return *pt; }
};

Where weak_ptr interoperability is required a second counter (weak_count) is required in aux (will be incremented / decremented by weak_ptr), and delete pa must happen only when both the counters reach zero.

 unique_ptr

  • unique_ptr 唯一拥有所指对象,同一时刻只能有一个unique_ptr指向给定对象,这是通过禁止拷贝语义、只允许移动语义来实现的。
  • unique_ptr指针本身的生命周期是从创建开始,直到离开作用域。在智能指针生命周期内,可以改变指针所指向对象,如创建智能指针时使用构造函数指定、通过reset方法重新指定、通过release方法释放所有权、通过移动语义转移所有权。
  • 只有一个智能指针能真正指向一个特定的对象,也只有该指针能析构这个对象所占用的空间,直到把这个指针赋给另一个指针,后一个指针才能真正指向这个对象,而前一个指针就不再起作用了,从而避免了两次delete而导致的未定义行为。

#include<iostream>
#include<memory>

using namespace std;

int main() {
    {
        unique_ptr<int> uptr(new int(10));  //绑定动态对象

        unique_ptr<int> uptr2 = uptr;   //不能赋值
        unique_ptr<int> uptr2(uptr);    //不能拷贝

        unique_ptr<int> uptr2 = std::move(uptr);    //转换所有权
        uptr2.release();    //释放所有权
    }
    
    //超出uptr作用域,内存释放
}

3. 智能指针的实现

总体来说,实现智能指针的主要任务在于实现引用计数的维护。

首先不应该直接在智能指针类中维护引用计数,这是因为如果有多个智能指针对象指向同一对象,若改变引用计数的值,需要找到这个对象的所有智能指针对象,从而改变所有的引用计数。

所以,有两个思路可以考虑:一个是使用辅助类来维护引用计数,另一个构造句柄类

其中,辅助类采用继承的方式实现,这种方式的缺点是实现比较复杂,需要所有使用智能指针的对象都先继承自辅助类。

句柄类的方式,是在智能指针类中维护一个指向引用计数的指针,这个引用计数是一个单独的内存空间中。

3.1 使用辅助类维护引用计数

定义一个具体类(U_Ptr)来封装引用计数和指针。在创建智能指针类之前,这个类的所有成员皆为私有类型,因为它不被普通用户所使用。为了只为智能指针使用,还需要把智能指针类声明为该类的友元。类中包含含两个数据成员:计数count与之前HasPtr类中的指针( int *ptr;)。图示:
在这里插入图片描述

#ifndef _UPtr_H
#define _UPtr_H
#include <iostream>
using namespace std;

template <typename T>
class HasPtr;

template <typename T>
class U_Ptr {
    private:
    friend class HasPtr<T>;

    U_Ptr(T *p);
    ~U_Ptr();
    
    T *m_ip;
    int m_useCount;
};

template <typename T> 
U_Ptr<T>::U_Ptr(T *p)
    :m_ip(p)
    ,m_useCount(1)
{

}

template <typename T> 
U_Ptr<T>::~U_Ptr()
{
    cout<<"U_Ptr destruct"<<endl;
    if (NULL != m_ip) {
    	delete m_ip;
    	m_ip = NULL;
    }
}
#endif

#ifndef _HasPtr_H
#define _HasPtr_H
#include "uPtr.h"
#include <iostream>
using namespace std;
template <class T>
class HasPtr {

    public:
        HasPtr(T *p, int i);
        HasPtr(const HasPtr &ptr);
        HasPtr& operator=(const HasPtr &rhs);
        ~HasPtr();
        T *get_ptr() const;
        void set_ptr(T *p);

        int get_int() const;
        void set_int(int i);

        T get_ptr_val() const;
        void set_ptr_val(T val);

    private:
        U_Ptr<T> *m_uptr;
        int m_val;

};
template <typename T>
HasPtr<T>::HasPtr(T *p, int i)
    :m_uptr(new U_Ptr<T>(p))
    ,m_val(i)
{
    cout<<"HasPtr constructor"<<endl;
}

template <typename T>
HasPtr<T>::HasPtr(const HasPtr &ptr)
    :m_uptr(ptr.m_uptr)
    ,m_val(ptr.m_val)
{
    ++m_uptr->m_useCount;
    cout<<"HasPtr copy constructor m_uptr->m_useCount = "<<m_uptr->m_useCount<<endl;
}

template <typename T>
HasPtr<T>& HasPtr<T>::operator=(const HasPtr &rhs)
{
    bool uptrIsSame = this->m_uptr == rhs.m_uptr;
    cout<<"HasPtr assignment rhs.m_uptr->m_useCount = "<<rhs.m_uptr->m_useCount<<endl;
    cout<<"HasPtr assignment m_uptr->m_useCount = "<<m_uptr->m_useCount<<endl;
    if (!uptrIsSame) {
        ++rhs.m_uptr->m_useCount;
        if (--m_uptr->m_useCount == 0) {
            delete m_uptr;
            m_uptr = NULL;
        }
        m_uptr = rhs.m_uptr;
        m_val = rhs.m_val;
    }
    return *this;
}

template <typename T>
T *HasPtr<T>::get_ptr() const {
    return m_uptr->m_ip;
}

template <typename T>
void HasPtr<T>::set_ptr(T *p) {
    m_uptr->m_ip = p;
}

template <typename T>
int HasPtr<T>::get_int() const {
    return m_val;
}

template <typename T>
void HasPtr<T>::set_int(int i) {
    m_val = i;
}

template <typename T>
T HasPtr<T>::get_ptr_val() const {
    return *m_uptr->m_ip;
}

template <typename T>
void HasPtr<T>::set_ptr_val(T val) {
    *m_uptr->m_ip = val;
}

template <typename T>
HasPtr<T>::~HasPtr() {
    cout<<"HasPtr destruct m_uptr->m_useCount = "<<m_uptr->m_useCount<<endl;
    if (--m_uptr->m_useCount == 0) {
        delete m_uptr;
        m_uptr = NULL;
    }
}
#endif

int main() {
    int *p = new int(12);
    HasPtr<int> ptr(p, 20);
    HasPtr<int> ptr1(ptr);
    HasPtr<int> ptr2(ptr1);
    {
        HasPtr<int> ptr3 = ptr1;
        ptr3 = ptr;
    }
    return 0;
}

3.2 智能指针类中维护引用计数(句柄类)

#include <iostream>
#include <memory>

template<typename T>
class SmartPointer {
private:
    T* _ptr;
    size_t* _count;
public:
    SmartPointer(T* ptr = nullptr) :
            _ptr(ptr) {
        if (_ptr) { //需要判读,否则引用一个空指针会有问题
            _count = new size_t(1);
        } else {
            _count = new size_t(0);
        }
    }

    SmartPointer(const SmartPointer& ptr) {
        if (this != &ptr) {
            this->_ptr = ptr._ptr;
            this->_count = ptr._count;
            (*this->_count)++;
        }
    }

    SmartPointer& operator=(const SmartPointer& ptr) {
        if (this->_ptr == ptr._ptr) {
            return *this;
        }

        if (this->_ptr) {
            (*this->_count)--;
            if (this->_count == 0) {
                delete this->_ptr;
                delete this->_count;
            }
        }

        this->_ptr = ptr._ptr;
        this->_count = ptr._count;
        (*this->_count)++;
        return *this;
    }

    T& operator*() {
        assert(this->_ptr == nullptr);
        return *(this->_ptr);

    }

    T* operator->() {
        assert(this->_ptr == nullptr);
        return this->_ptr;
    }

    ~SmartPointer() {
        (*this->_count)--;
        if (*this->_count == 0) {
            delete this->_ptr;
            delete this->_count;
        }
    }

    size_t use_count(){
        return *this->_count;
    }
};

int main() {
    {
        SmartPointer<int> sp(new int(10));
        SmartPointer<int> sp2(sp);
        SmartPointer<int> sp3(new int(20));
        sp2 = sp3;
        std::cout << sp.use_count() << std::endl;
        std::cout << sp3.use_count() << std::endl;
    }
    //delete operator
}

4. 实战

  • 使用 std::tr1::enable_shared_from_this 作为基类。比如:
class A : public std::tr1::enable_shared_from_this<A>
{
public:
    std::tr1::shared_ptr<A> getSharedPtr() {
    return shared_from_this();
  }
};

当使用了 shared_ptr 的时候,我们可能需要在所有的地方都使用它,否则就不容易达到管理生存期的目的了。但有的时候,我们手头上只有对象的原始指针,比如在对象的函数内部,我们只有 this。这就迫切的需要一个功能:如何从对象的裸指针中,生成我们需要的 shared_ptr。

有人可能会觉得这个简单,shared_ptr a(this); 不就行了么?很遗憾的告诉你,这样不行,会出问题。为什么呢?因为这里的 a,手中对 this 的引用计数只有 1,它无法知道其他地方智能指针对 this 这个指针(就是这个对象)的引用情况,因此当 a 的生命周期结束(比如函数返回)的时候,this 就会被它毫不留情的释放掉,其他地方的相关智能指针,手中拿着的该对象指针已经变成非法。因此,我们需要使用std::tr1::enable_shared_from_this 作为基类将类的this指针的引用导出来.

 5. 参考

  • 5
    点赞
  • 27
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值