智能指针

最新推荐文章于 2024-03-22 10:17:06 发布

blank

最新推荐文章于 2024-03-22 10:17:06 发布

阅读量71

点赞数

分类专栏： C++ 文章标签： c++

本文链接：https://blog.csdn.net/weixin_43867777/article/details/104224967

版权

C++ 专栏收录该内容

32 篇文章 0 订阅

订阅专栏

智能指针是行为类似于指针的类对象，但这种对象还有其他功能。我们主要了解可帮助管理动态内存分配的智能指针模板。

1、为什么需要智能指针

下面我们先分析一下下面这段程序有没有什么内存方面的问题？提示一下：注意分析MergeSort函数中的问题。

#include <vector>
void _MergeSort(int* a, int left, int right, int* tmp) {
	 if (left >= right) return;
	 
	 int mid = left + ((right - left) >> 1);
	 // [left, mid]
	 // [mid+1, right]
	 _MergeSort(a, left, mid, tmp);
	 _MergeSort(a, mid + 1, right, tmp);
	 int begin1 = left, end1 = mid;
	 int begin2 = mid + 1, end2 = right;
	 int index = left;
 while (begin1 <= end1 && begin2 <= end2)
 {
	 if (a[begin1] < a[begin2])
	 tmp[index++] = a[begin1++];
	 else
	 tmp[index++] = a[begin2++];
	 }
	 while (begin1 <= end1)
	 tmp[index++] = a[begin1++];
	 while (begin2 <= end2)
	 tmp[index++] = a[begin2++];
	 memcpy(a + left, tmp + left, sizeof(int)*(right - left + 1));
}
void MergeSort(int* a, int n) {
	 int* tmp = (int*)malloc(sizeof(int)*n);
	 _MergeSort(a, 0, n - 1, tmp);
	 
	 // 这里假设处理了一些其他逻辑
	 vector<int> v(1000000000, 10);
	 // ...
	 
	 // free(tmp);
}
int main()
{
	 int a[5] = { 4, 5, 2, 3, 1 };
	 MergeSort(a, 5);
 	 return 0; 
}

问题分析：上面的问题分析出来我们发现有以下两个问题？

malloc出来的空间，没有进行释放，存在内存泄漏的问题。
异常安全问题。如果在malloc和free之间如果存在抛异常，那么还是有内存泄漏。这种问题就叫异常安全。

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

2.1 RAII
RAII (Resource Acquisition Is Initialization)是一种利用对象生命周期来控制程序资源（如内存、文件句柄、互斥量等等）的简单技术。
**在对象构造时获取资源，**接着控制对资源的访问使之在对象的生命周期内始终保持有效，**最后在对象析构的时候释放资源。**借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做法有两大好处：

不需要显示地释放资源
采用这种方式，对象所需的资源在其生命期内始终保持有效

// 使用RAII思想设计的SmartPtr类
template<class T>
class SmartPtr {
public:
 	SmartPtr(T* ptr = nullptr)
		 : _ptr(ptr)
 	{}
	 ~SmartPtr()
	 {
	 	if(_ptr)
			 delete _ptr;
	 }

private:
 T* _ptr;
};
void MergeSort(int* a, int n) {
	 int* tmp = (int*)malloc(sizeof(int)*n);
	 // tmp指针委托给了sp对象，给tmp指针找了一个可怕的女朋友！天天管着你，直到你go die^^
	 SmartPtr<int> sp(tmp);
	 // _MergeSort(a, 0, n - 1, tmp);
	 
	 
	 // 这里假设处理了一些其他逻辑
	 vector<int> v(1000000000, 10);
	 // ...
}
int main()
{
	 try {
		 int a[5] = { 4, 5, 2, 3, 1 };
		 MergeSort(a, 5);
	 }
	 catch(const exception& e)
	 {
		 cout<<e.what()<<endl;
	 }
	 return 0; 
}

2.2 智能指针的原理
上述的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可以通过 -> qu 访问所指空间的内容，因此：AutoPtr模板类中还得需要将、->重载下，才可以让其像指针一样去使用。*

template<class T>
class SmartPtr {
public:
	 SmartPtr(T* ptr = nullptr)
	 : _ptr(ptr)
	 {}
	 ~SmartPtr()
	 {
		 if(_ptr)
			 delete _ptr;
	 }
	 
	 T& operator*() {return *_ptr;}
	 T* operator->() {return _ptr;}
private:
	 T* _ptr;
};
struct Date
{
	 int _year;
	 int _month;
	 int _day;
};
int main()
{
	 SmartPtr<int> sp1(new int);
	 *sp1 = 10
	 cout<<*sp1<<endl;
	 
	 SmartPtr<int> sparray(new Date);
	 // 需要注意的是这里应该是sparray.operator->()->_year = 2018;
	 // 本来应该是sparray->->_year这里语法上为了可读性，省略了一个->
	 sparray->_year = 2018;
	 sparray->_month = 1;
	 sparray->_day = 1;
}

总结以下智能指针的原理：

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

2.3 std::auto_ptr
C++98版本的库中就提供了auto_ptr的智能指针。下面演示的auto_ptr的使用及问题

// C++库中的智能指针都定义在memory这个头文件中
#include <memory>
class Date
{
public:
	 Date() { cout << "Date()" << endl;}
	 ~Date(){ cout << "~Date()" << endl;}
	 int _year;
	 int _month;
	 int _day;
};
int main()
{
	 auto_ptr<Date> ap(new Date);
	 auto_ptr<Date> copy(ap);
	 // auto_ptr的问题：当对象拷贝或者赋值后，前面的对象就悬空了
	 // C++98中设计的auto_ptr问题是非常明显的，所以实际中很多公司明确规定了不能使用auto_ptr
	 ap->_year = 2018;
	 return 0; 
}

auto_ptr的实现原理：管理权转移的思想，下面简化模拟实现了一份AutoPtr来了解它的原理

// 模拟实现一份简答的AutoPtr,了解原理
template<class T>
class AutoPtr
{
public:
	 AutoPtr(T* ptr = NULL)
		 : _ptr(ptr)
	 {}
	 
	 ~AutoPtr()
	 {
		 if(_ptr)
			 delete _ptr;
	 }
 
	 // 一旦发生拷贝，就将ap中资源转移到当前对象中，然后另ap与其所管理资源断开联系，
	 // 这样就解决了一块空间被多个对象使用而造成程序奔溃问题
	 AutoPtr(AutoPtr<T>& ap)
	 : _ptr(ap._ptr)
	 {
	 ap._ptr = NULL;
	 }
	 
	 AutoPtr<T>& operator=(AutoPtr<T>& ap)
	 {
	 // 检测是否为自己给自己赋值
	 if(this != &ap)
	 {
		 // 释放当前对象中资源
		 if(_ptr)
			 delete _ptr;
		 
		 // 转移ap中资源到当前对象中
		 _ptr = ap._ptr;
		 ap._ptr = NULL;
	 }
	 
	 return *this;
    }
 	T& operator*() {return *_ptr;}
    T* operator->() { return _ptr;}
private:
	 T* _ptr;
};
int main()
{
	 AutoPtr<Date> ap(new Date);
	 
	 // 现在再从实现原理层来分析会发现，这里拷贝后把ap对象的指针赋空了，导致ap对象悬空
	 // 通过ap对象访问资源时就会出现问题。
	 AutoPtr<Date> copy(ap);
	 ap->_year = 2018;
	 return 0; 
}

2.4 std::unique_ptr
unique_ptr的实现原理：简单粗暴的防拷贝。

// 模拟实现一份简答的UniquePtr,了解原理
template<class T>
class UniquePtr
{
public:
	 UniquePtr(T * ptr = nullptr) 
	 	: _ptr(ptr)
	 {}
	 ~UniquePtr() 
	 {
	 	if(_ptr)
	 		delete _ptr;
	 }
	 T& operator*() {return *_ptr;}
	 T* operator->() {return _ptr;}	
private:
	 // C++98防拷贝的方式：只声明不实现+声明成私有
	 UniquePtr(UniquePtr<T> const &);
	 UniquePtr & operator=(UniquePtr<T> const &);
	 
	 // C++11防拷贝的方式：delete
	 UniquePtr(UniquePtr<T> const &) = delete;
	 UniquePtr & operator=(UniquePtr<T> const &) = delete;
 
private:
 	T * _ptr;
};

2.5 std::shared_ptr
C++11中开始提供更靠谱的并且支持拷贝的shared_ptr
shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源例如：老师晚上在下班之前都会通知，让最后走的学生记得把门锁下。

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

std::shared_ptr的线程安全问题
通过下面的程序我们来测试shared_ptr的线程安全问题。需要注意的是shared_ptr的线程安全分为两方面：

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

这三个智能指针模板（auto_ptr、unique_ptr和shared_ptr）都定义了类似指针的对象，可以将new获得（直接或间接）的地址赋给这种对象。当智能指针过期时，其析构函数将使用delete来释放内存。因此，如果将new返回的地址赋给这些对象，将无需记住稍后释放这些内存：在智能指针过期时，这些内存将自动被释放。
要创建智能指针对象，必须包含头文件memory，该文件模板定义。然后使用通常的模板语法来实例化所需类型的指针。

3.C++11和boost中智能指针的关系

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