【C++】智能指针

一、为什么需要智能指针？

智能指针就是帮我们 C++ 程序员管理动态分配的内存的，它会帮助我们自动释放 new 出来的内存，从而 避免内存泄漏。

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

// 动态分配内存，没有释放就return
void memoryLeak1()
{
	string *str = new string("动态分配内存！");
	return;
}

// 动态分配内存，虽然有些释放内存的代码，但是被半路截胡return了
int memoryLeak2()
{
	string *str = new string("内存泄露！");
	// ...

	// 发生某些异常，需要结束函数
	if (1)
    {
		return -1;
	}
	// 另外，使用try、catch结束函数，也会造成内存泄漏！

	delete str;	// 虽然写了释放内存的代码，但是遭到函数中段返回，使得指针没有得到释放
	return 1;
}

int main()
{
	memoryLeak1();
	memoryLeak2();

	return 0;
} 

1. 在 memoryLeak1 函数中，new 了一个字符串指针，但是没有 delete 就已经 return 结束函数了，导致内存没有被释放，内存泄露。
2. 在 memoryLeak2 函数中，new 了一个字符串指针，虽然在函数末尾有些释放内存的代码 delete str，但是在 delete 之前就已经 return 了，所以内存也没有被释放，内存泄露。

使用指针，我们没有释放，就会造成内存泄露。但是如果使用普通对象就不会。

如果我们分配的动态内存都交由有生命周期的对象来处理，那么在对象过期时，让它的析构函数删除指向的内存，这看似是一个不错的方案。智能指针就是通过这个原理来解决指针自动释放的问题的。

在 C++ 中，动态内存管理是通过一对运算符来完成的：

1. new，在动态内存中为对象分配空间并返回一个指向该对象的指针，我们可以选择对对象进行初始化。
2. delete，接受一个动态对象的指针，销毁该对象，并释放与之关联的内存。

动态内存的使用很容易出现问题，因为确保在正确的时间释放内存是极其困难的。有时使用完对象后，忘记释放内存，造成内存泄漏的问题。

void MemoryLeaks()
{
    // 1.内存申请了忘记释放
    int* p1 = (int*)malloc(sizeof(int));
    int* p2 = new int;
 ?
 ? // 2.异常安全问题
 ? int* p3 = new int[10];
 ?
 ? Func(); // 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.
 ?
 ? delete[] p3;
}

内存泄漏非常常见，解决方案分为两种：

1. 事前预防型。如智能指针等。
2. 事后查错型。如泄漏检测工具。

三、智能指针的使用及原理

1、RAII

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

所谓的智能指针的本质就是一个类模板，它可以创建任意类型的指针对象，当智能指针对象使用完之后，对象会自动调用析构函数去释放该指针所指向的空间。

下面是智能指针的基本框架，所有的智能指针类模板中都需要包含一个指针对象，构造函数和析构函数。

template<class T>
class smartptr // 自定义的智能指针
{
public:
    smartptr (T* _ptr) // 构造函数
 ? ?    : ptr(_ptr)
 ?  {}

 ? ?~smartptr () // 析构函数
 ?  {
 ? ?    if(ptr!=nullptr)
 ? ? ? ?{
            cout << "smartptr: delete" << endl;
            delete ptr;
            ptr = nullptr;
        }
 ?  }
private:
    T* ptr; // 指针对象
};

template<class T>
class smartptr // 自定义的智能指针
{
public:
    smartptr (T* _ptr) // 构造函数
 ? ?    : ptr(_ptr)
 ?  {}

 ? ?~smartptr () // 析构函数
 ?  {
 ? ?    if(ptr!=nullptr)
 ? ? ? ?{
            cout << "smartptr: delete" << endl;
            delete ptr;
            ptr = nullptr;
        }
 ?  }

    T& operator*() {return *ptr;} // 重载出*运算符

    T* operator->() {return ptr;} // 重载出->运算符
private:
    T* ptr; // 指针对象
};

int main()
{
    smartptr<int> ptr1(new int(1)); // 指向int类型的智能指针
    smartptr<string> ptr2(new string("string")); // 指向string类型的智能指针
    cout << *ptr1 << endl;
    cout << ptr2->c_str() << endl;
    return 0;
}

ptr2 和 ptr1 指向的同一块空间，当 ptr2 被销毁时，它会调用它的析构函数去 delete 该资源对象，当 ptr1 被销毁时,也会去调用它的析构函数去释放 ptr1 所指向的资源。

所以，当程序结束时，ptr2 先被销毁，同时释放 ptr2 所指向的资源，然后 ptr1 被销毁，也去释放它所指向的资源对象，那么相同的资源对象就会被释放两次，因此导致程序崩溃。（资源对象被释放后，如果再去释放该资源，程序就会崩溃）

所以，我们 不能使用原生的拷贝构造函数和赋值重载函数，并且自己定义的拷贝构造函数和赋值重载函数 需要考虑只能释放一次资源对象的问题。

1. RAII 特性。
2. 重载 operator* 和 opertaor->，具有像指针一样的行为。

---

3、std::auto_ptr

cplusplus.com/reference/memory/auto_ptr/

C++98 版本的库中就提供了 auto_ptr 的智能指针，该指针解决上诉的问题采取的措施是管理权转移的思想，也就是原对象拷贝给新对象的时候， 原对象就会被设置为 nullptr ，此时就只有新对象指向一块资源空间。

int main()
{
    auto_ptr<int> ptr1(new int);
    auto_ptr<int> ptr2(ptr1); // ptr1置为nullptr
    return 0;
}

如果 auto_ptr 调用拷贝构造函数或者赋值重载函数后，再去使用原来的对象的话，那么整个程序就会崩溃掉（因为原来的对象被设置为 nullptr)，这对程序是有很大的伤害的，所以很多公司会禁用 auto_ptr 智能指针。

---

（1）auto_ptr 的拷贝构造函数和赋值重载函数的实现

// 管理权转移，转移后就不能使用源对象
auto_ptr(auto_ptr ap) // auto_ptr的拷贝构造函数
    : ptr(ap.ptr)
{
    ap.ptr = nullptr;
}

auto_ptr<T> operator=(auto_ptr<T>& ap) // auto_ptr的赋值重载函数
{
    if(ptr != ap.ptr)
    {
        ptr = ap.ptr;
        ap.ptr = nullptr;
    }
    return ptr;
}

---

（2）auto_ptr 被 C++11 抛弃的主要原因

a. 复制或者赋值都会改变资源的所有权

// auto_ptr被C++11抛弃的主要原因：
auto_ptr<string> p1(new string("I'm xyl!"));
auto_ptr<string> p2(new string("I'm age 19."));

cout << "p1：" << p1.get() << endl;
cout << "p2：" << p2.get() << endl;

// p2赋值给p1后，首先p1会先将自己原先托管的指针释放掉，然后接收托管p2所托管的指针
// 然后p2所托管的指针制NULL，也就是p1托管了p2托管的指针，而p2放弃了托管
p1 = p2;	
cout << "p1 = p2 赋值后：" << endl;
cout << "p1：" << p1.get() << endl;
cout << "p2：" << p2.get() << endl;

---

b. 在 STL 容器中使用 auto_ptr 存在着重大风险，因为容器内的元素必须支持可复制和可赋值

vector<auto_ptr<string>> vec;
auto_ptr<string> p3(new string("I'm p3"));
auto_ptr<string> p4(new string("I'm p4"));

// 必须使用std::move修饰成右值，才可以进行插入容器中
vec.push_back(std::move(p3));
vec.push_back(std::move(p4));

cout << "vec.at(0)：" <<  *vec.at(0) << endl;
cout << "vec[1]：" <<  *vec[1] << endl;

// 风险：
vec[0] = vec[1]; // 如果进行赋值，就又回到了上面一个问题中
cout << "vec.at(0)：" << *vec.at(0) << endl;
cout << "vec[1]：" << *vec[1] << endl;

（访问越界）

---

c. 不支持对象数组的内存管理

auto_ptr<int[]> array(new int[5]); // 不能这样定义

所以 C++11 选择使用更严谨的 unique_ptr 取代了 auto_ptr。

---

（3）std::auto_ptr 的模拟实现

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

template <class T>
class auto_ptr
{
public:
	auto_ptr(T* ptr)
		:_ptr(ptr)
	{}

	// 管理权转移，解决二次释放的问题
	auto_ptr(auto_ptr<T> & sp)
		:_ptr(sp._ptr)
	{
        // 管理权转移
		sp._ptr = nullptr;
	}

    auto_ptr<T>& operator=(auto_ptr<T>& sp)
    {
        // 检测是否为自己给自己赋值
        if (this != &ap)
        {
            // 释放当前对象中资源
            if (_ptr)
                delete _ptr;

            // 转移ap中资源到当前对象中
            _ptr = sp._ptr;
            sp._ptr = NULL;
        }
        return *this;
    }

	~auto_ptr()
    {
		if (_ptr)
        {
            cout << "delete:" << _ptr << endl;
			delete _ptr;
			_ptr = nullptr;

		}
	}

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

	T* operator->()
    {
		return _ptr;
	}
private:
	T* _ptr;
};

---

4、std::unique_ptr

C++11 用更严谨的 unique_ptr 取代了 auto_ptr。

cplusplus.com/reference/memory/unique_ptr/

---

（1）实现原理

unique_ptr 是 C++11 版本库中提供的智能指针， 它直接将拷贝构造函数和赋值重载函数给禁用掉， 因此不让其进行拷贝和赋值，是 简单粗暴的防拷贝 ，下面简化模拟实现了一份 unique_ptr 来了解它的原理。

int main()
{
    unique_ptr<int> ptr1(new int);
    //unique_ptr<int> ptr2(ptr1); // error，不能调用unique_ptr的拷贝构造

    unique_ptr<int> ptr3(new int);
    ptr3 = ptr1; // error，不能调用unique_ptr的赋值构造

    return 0;
}

---

（2）unique_ptr 的拷贝函数和赋值重载函数

template<class T>
class unique_ptr
{
public:
    //unique_ptr的拷贝构造函数和赋值重载构造给禁用掉
    unique_ptr(unique_ptr&) = delete;
    operator=(unique_ptr&) = delete;
private:
    T* ptr;
};

---

（3）std::unique_ptr 的模拟实现

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

namespace xyl
{
    template <class T>
    class unique_ptr
    {
    public:
        unique_ptr(T* ptr)
            :_ptr(ptr)
        {}

        ~unique_ptr()
        {
            if (_ptr)
            {
                cout << "delete:" << _ptr << endl;
                delete _ptr;
            }
        }
        
        // 像指针一样使用
        T& operator*()
        {
            return *_ptr;
        }
    
        T* operator->()
        {
            return _ptr;
        }
 
        // 防拷贝:两种方式都可以
        unique_ptr(const unique_ptr<T>& sp) = delete;

        unique_ptr<T>& operator=(const unique_ptr<T>& sp) = delete;
    private:
        T* _ptr;
    };
}

---

5、std::shared_ptr

cplusplus.com/reference/memory/shared_ptr/

share_ptr 是 C++11 版本库中的智能指针， shared_ptr 允许多个智能指针可以指向同一块资源，并且能够保证共享的资源只会被释放一次，因此程序不会发生崩溃。

---

（1）实现原理

是 通过引用 计数 的方式来 实现多个 shared_ptr 对象之间共享资源 。例如，老师晚上在下班之前都会通知，让最后走的学生记得把门锁下。

1. shared_ptr 在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。
2. 在对象被销毁时（也就是析构函数调用），说明自己不使用该资源了，对象的引用计数减一。
3. 如果引用计数是 0，就说明自己是最后一个使用该资源的对象，必须释放该资源；
4. 如果不是 0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。

std::shared_ptr::get 获取指针，存储的指针指向?shared_ptr 对象解引用的对象，通常与其拥有的指针相同。头文件为 #include <memory>。?返回 ptr 中保存的指针，要小心使用，若智能指针释放了其对象，返回的指针所指向的对象也就消失了。get?用来将指针的访问权限传递给代码，你只有在确定代码不会 delete 指针的情况下，才能使用?get?。特别是，永远不要用?get?初始化另一个智能指针或者为另一个智能指针赋值，因为这样会造成二次释放。

int main()
{
    shared_ptr<int> ptr6(new int(2));
    cout << ptr6.get() << endl;
    shared_ptr<int> ptr7 = ptr6;
    cout << ptr7.get() << endl;
    cout << ptr6.get() << endl;
    return 0;
}

销毁过程：?

（2）shared_ptrd 的实现

赋值重载的三种情况:

1. ptr1 = ptr1；智能指针自己给自己赋值，不做处理。
2. ptr2 = ptr1；如果 ptr1 和 ptr2 指向同一块空间，不做处理。
3. ptr2 = ptr1；如果 ptr2 和 ptr1 指向的空间不一样,处理过程如下：

• 因为 _ptrcount 指向的对象是在堆上，因此所有的线程都能够访问到该资源，多线程在修改 _ptrcount 时，则会出现线程安全问题，因此需要在修改 _prtcount 时需要用锁来保证其数据的正确性。
• "*" 会返回 ptr 指向的对象，为什么不需要锁对其进行保护？因为 ptr 返回的对象有可能被读或者被写，这个不是指针内部所考虑的，而是由调用者进行考虑的。

template<class T>
class shared_ptr
{
public:
    shared_ptr(T* _ptr) // 构造函数
        : ptr(_ptr)
    {
        ptrcount = new int(1);
        mt = new mutex;
    }

    void AddCount()
    {
        mt->lock();
        (*ptrcount)++;
        mt->unlock();
    }

    shared_ptr(shared_ptr<T>& sp)
    {
        if(sp.ptr != ptr)
        {
            Realse();//释放旧资源
            ptr = sp.ptr;
            ptrcount = sp.ptrcount;
            mt = sp.mt;
            AddCount();
        }
        return *this;
    }

    ~shared_ptr() // 析构函数
    {
        Realse();
    }

    int& use_count()
    {
        return *ptrcount;
    }

    void Realse()
    {
        bool deleteflag = false;
        mt->lock();
        if(--(*ptrcount)==0)
        {
            delete ptrcount;
            delete ptr;
            ptrcount = nullptr;
            ptr = nullptr;
            deleteflag = true;
        }
        mt-lock();

        if(deleteflag == true)
        {
            delete mt;
            mt = nullptr;
        }
    }
    T& operator*() {return *ptr;} // 重载出*运算符

    T* operator->() {return ptr;} // 重载出->运算符
private:
    T* ptr; // 指针对象
    int* ptrcount; // 引用计数
    mutex* mt;
};

1. 智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时?++ /?--，这个操作不是原子的，引用计数原来是 1，++ 了两次，可能还是 2，这样引用计数就错乱了。会导致资源未释放或者程序崩溃的问题。所以只能指针中引用计数 ++、-- 是需要加锁的，也就是说引用计数的操作是线程安全的。
2. 智能指针管理的对象存放在堆上，两个线程中同时去访问，会导致线程安全问题。

演示引用计数线程安全问题，就把 AddRefCount 和 SubRefCount 中的锁去掉。

演示可能不出现线程安全问题，因为线程安全问题是偶现性问题，main 函数的 n 改大一些概率就变大了，就容易出现了。

下面代码我们使用 SharedPtr 演示，是为了方便演示引用计数的线程安全问题，将代码中的 SharedPtr 换成 shared_ptr 进行测试，可以验证库的 shared_ptr，发现结论是一样的。?

struct Date
{
    int _year = 0;
    int _month = 0;
    int _day = 0;
};

void SharePtrFunc(xyl::shared_ptr<Date>& sp, size_t n, mutex& mtx)
{
    cout << sp.get() << endl;

    for (size_t i = 0; i < n; ++i)
    {
        // 这里智能指针拷贝会++计数，智能指针析构会--计数，这里是线程安全的。
        xyl::shared_ptr<Date> copy(sp);

        // 这里智能指针访问管理的资源，不是线程安全的。所以我们看看这些值两个线程++了2n次，但是最终看到的结果，并一定是加了2n
        {
            unique_lock<mutex> lk(mtx);
            copy->_year++;
            copy->_month++;
            copy->_day++;
        }
    }
}

int main()
{
    xyl::shared_ptr<Date> p(new Date);
    cout << p.get() << endl;
    const size_t n = 100000;
    mutex mtx;
    thread t1(SharePtrFunc, std::ref(p), n, std::ref(mtx));
    thread t2(SharePtrFunc, std::ref(p), n, std::ref(mtx));

    t1.join();
    t2.join();

    cout << p->_year << endl;
    cout << p->_month << endl;
    cout << p->_day << endl;

    cout << p.use_count() << endl;

    return 0;
}

（4）std::shared_ptr 的循环引用

shared_ptr 固然好用，但是它也会有问题存在。

假设我们要使用定义一个双向链表，如果想要让创建出来的链表的节点都定义成 shared_ptr 智能指针，那么就需要将节点内的 _pre 和 _next 都定义成 shared_ptr 的智能指针。

如果定义成普通指针，那么就不能赋值给 shared_ptr 的智能指针。

当其中两个节点互相引用的时候，就会出现循环引用的现象。如下所示：

struct ListNode
{
    int _data;
    shared_ptr<ListNode> _pre;
    shared_ptr<ListNode> _next;
    ~ListNode() { cout << "~ListNode()" << endl; }
};

int main()
{
    shared_ptr<ListNode> node1(new ListNode);
    shared_ptr<ListNode> node2(new ListNode);
    cout << node1.use_count() << endl;
    cout << node2.use_count() << endl;

    node1->_next = node2;
    node2->_pre = node1;
    cout << node1.use_count() << endl;
    cout << node2.use_count() << endl;

    return 0;
}

• ?use_count（）: 返回智能指针对象的引用计数。

1. node1 和 node2 两个智能指针对象指向两个节点，引用计数变成 1，我们不需要手动?delete。
2. node1 的 _next 指向 node2，node2 的 _pre?指向 node1，引用计数变成 2。
3. node1 和 node2 析构，引用计数减到 1，但是 _next 还指向下一个节点，_pre?还指向上一个节点。也就是说 _next 析构了，node2 就释放了；_pre?析构了，node1 就释放了。
4. 但是，_next 属于 node 的成员，node1 释放了，_next 才会析构，而 node1 由 _pre?管理，_pre?属于 node2 成员，所以这就叫循环引用，谁也不会释放。

解决方案：在引用计数的场景下，把节点中的 _pre 和 _next 改成 weak_ptr 就可以了。
原理：node1->_next = node2; 和 node2->_prev = node1; 时，weak_ptr 的 _next 和 _pre 不会增加 node1 和 node2 的引用计数。?

struct ListNode
{
    int _data;
    weak_ptr<ListNode> _pre;
    weak_ptr<ListNode> _next;
    ~ListNode(){ cout << "~ListNode()" << endl; }
};

int main()
{
    shared_ptr<ListNode> node1(new ListNode);
    shared_ptr<ListNode> node2(new ListNode);
    cout << node1.use_count() << endl;
    cout << node2.use_count() << endl;

    node1->_next = node2;
    node2->_pre = node1;

    cout << node1.use_count() << endl;
    cout << node2.use_count() << endl;

    return 0;
}

如果不是 new 出来的对象该如何通过智能指针管理呢？

当 我们释放一个指向数组的指针的时候， delete[] 后面的空方括号是必须存在，它指示编译器此指针指向的是一个对象数组的第一个元素，如果我们在 delete 一个指向数组的指针中忽略了方括号，那么程序可能在执行时没有任何警告下发生行为异常。?

int* ptr = new int[10];
delete[] ptr;
//delete ptr; //error

我们如果在动态内存中创建出一个数组，用一个 shared_ptr 对象去指向该数组，当 shared_ptr 使用完后，就会去调用析构函数，由于 shared_ptr 默认的删除方式是 delete ptr，后面没有带方括号，那么程序就会崩掉。

如果我们打开了一个文件，返回一个文件指针，让一个 shared_ptr 对象去指向该文件，那么在调用析构函数的时候就不能采用 delete 方法，而是使用 close() 函数去关闭该文件。

因此，shared_ptr 类中提供了一个构造函数可以自定义一个删除器去指定析构函数的删除方式。

这个自定义删除器可以是函数指针，仿函数，lamber，包装器。

【仿函数的删除器】

shared_ptr 中的析构函数会去调用 DelArry 仿函数去释放动态数组。

（5）std::shared_ptr 和 std::weak_ptr 的模拟实现

// 引用计数支持多个拷贝管理同一个资源，最后一个析构对象释放资源
namespace xyl
{
    template <class T>
    class shared_ptr
    {
    public:
        shared_ptr(T* ptr = nullptr)
            : _ptr(ptr)
            , _pRefCount(new int(1))
            , _pmtx(new mutex)
        {}
 
        shared_ptr(const shared_ptr<T>& sp)
            : _ptr(sp._ptr)
            , _pRefCount(sp._pRefCount)
            , _pmtx(sp._pmtx)
        {
            AddRef();
        }

        void Release()
        {
            _pmtx->lock();
            bool flag = false;
            if (--(*_pRefCount) == 0 && _ptr)
            {
                cout << "delete:" << _ptr << endl;
                delete _ptr;
                delete _pRefCount;
                flag = true;
            }
            _pmtx->unlock();
            if (flag == true)
            {
                delete _pmtx;
            }
        }
 
        void AddRef()
        {
            _pmtx->lock();
            ++(*_pRefCount);
            _pmtx->unlock();
        }

        shared_ptr<T>& operator=(const shared_ptr<T>& sp)
        {
            //if (this != &sp)
            if (_ptr != sp._ptr)
            {
                Release();
                _ptr = sp._ptr;
                _pRefCount = sp._pRefCount;
                _pmtx = sp._pmtx;
                AddRef();
            }
            return *this;
        }

        int use_count()
        {
            return *_pRefCount;
        }
 
        ~shared_ptr()
        {
            Release();
        }
 
        // 像指针一样使用
        T& operator*()
        {
            return *_ptr;
        }
 
        T* operator->()
        {
            return _ptr;
        }
 
        T* get() const
        {
            return _ptr;
        }
    private:
        T* _ptr;
        int* _pRefCount;
        mutex* _pmtx;
    };
 ? ?
 ? ?// 简化版本的weak_ptr实现
    template<class T>
    class weak_ptr
    {
    public:
        weak_ptr()
            : _ptr(nullptr)
        {}
 
        weak_ptr(const shared_ptr<T>& sp)
            :_ptr(sp.get())
        {}
 
        weak_ptr<T>& operator=(const shared_ptr<T>& sp)
        {
            _ptr = sp.get();
            return *this;
        }
 
        T& operator*()
        {
            return *_ptr;
        }
 
        T* operator->()
        {
            return _ptr;
        }
    private:
        T* _ptr;
    };
}

四、C++11?和?boost?中智能指针的关系

1. C++98 中产生了第一个智能指针 auto_ptr。
2. C++boost 给出了更实用的 scoped_ptr 和 shared_ptr 和 weak_ptr。
3. C++TR1，引入了 shared_ptr 等。不过注意的是 TR1 并不是标准版。
4. C++11，引入了 unique_ptr 和 shared_ptr 和 weak_ptr。需要注意的是 unique_ptr 对应boost?的 scoped_ptr。并且这些智能指针的实现原理是参考 boost 中的实现的。