c++学习之智能指针
前言：在此之前我们已经学习到了异常的使用，虽然异常在大部分情况都还可以，但也存在太多缺陷，对于异常的问题，入内存泄漏，在复杂的场景下使用起来也是非常麻烦。为了更好的解决这些问题，c++11中引入了智能指针。
目录
一，什么是智能指针？
二，智能指针的使用
简化autoptr
简化uniqueptr
简化weakptr
定制删除器
一，什么是智能指针？
智能指针（RAII）是一种C++标准库提供的对象，用于管理动态分配的内存（用对象生命后期来控制程序资源）。智能指针本身是一个类对象，它封装了指向动态分配的内存的指针，并提供了自动释放内存的机制。智能指针的行为类似于常规指针，可以通过解引用操作符（*）和成员访问操作符（->）来访问内存中的数据。C++11引入了3个智能指针类型：
std::unique_ptr
std::shared_ptr
std::weak_ptr
二，智能指针的使用
我们还是先给一个例子，这里就是空间得不到释放。
//还是以分母不能为零为例
double Division(int x, int y)
{
if (y == 0)
{
throw invalid_argument("除零错误");//这里我们是直接使用库里异常(无效参数)
}
else
{
return double(x) / double(y);
}
}
//如果不采用异常的重新抛出，如何释放这里的arr？
void Func()
{
int* arr = new int[10];
int x; int y;
cin >> x >> y;
Division(x, y);
delete []arr;
arr = nullptr;
cout << " reliszed delete arr" << endl;
}
int main()
{
try
{
Func();
}
catch (exception& e)
{
cout << e.what();
}
return 0;
}解决办法：我们封装一个指针，将我们的这个需要释放的指针给这个只针对想，只针对象在跳出生命周期后会自动调用析构函数来释放这里的空间。
而这里就是RAII----通过控制对象的生命周期来控制资源的释放
templateclass Smartptr
{
public:
Smartptr(T *ptr):_ptr(ptr)
{}
~Smartptr()
{
delete []_ptr;
cout << "delete ptr" << endl;
}
private:
T* _ptr;
};
//还是以分母不能为零为例
double Division(int x, int y)
{
if (y == 0)
{
throw invalid_argument("除零错误");//这里我们是直接使用库里异常(无效参数)
}
else
{
return double(x) / double(y);
}
}
//如果不采用异常的重新抛出，如何释放这里的arr？
void Func()
{
int* arr = new int[10];
int x; int y;
cin >> x >> y;
//在此之前，使用一个指针对象来控制我的生命后期
//无异常，正常使用，有异常，生命周期结束，释放空间
Smartptr p(arr);
Division(x, y);
/*delete []arr;
arr = nullptr;
cout << " reliszed delete arr" << endl;*/
}
int main()
{
try
{
Func();
}
catch (exception& e)
{
cout << e.what();
}
return 0;
} 但是智能指针并不是这么简单就完了，我们的目的是要把它当作指针一样使用。因此整体我们还要实现他的一些接口。
templateclass Smartptr
{
public:
Smartptr(T* ptr) :_ptr(ptr)
{}
~Smartptr()
{
delete _ptr;
cout << "delete ptr" << endl;
}
//使它想指针一样使用
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
}; 但此时的智能指针还存在问题，首先就是赋值，浅拷贝会释放两次，我们可能会想到再写一个拷贝构造不经行了吗，事实上这里使用深拷贝是解决不掉问题的。
这里的内存问题，不同于之前的容器，比如vector，我们实例化一个对象并初始化内容，系统就为对象分配该空间并初始化，拷贝给另一个对象，系统会为该对象分配资源并初始化。即他们的空间与资源是不一样的，但是对于智能指针，我们就是管理这一部分资源，无论拷贝给谁，谁管理这一部分资源，深拷贝的话，那我拷贝几次，有几份该资源，这并不属于(RAII)我们使用智能指针的理念。
那么如何解决这样的问题，这里我们就使用 引用计数的方法来进行拷贝与释放。
再此之前，根据c++的发展也是不断提出更新新的方案：
简化autoptr
templateclass Autoptr
{
public:
Autoptr(T* ptr) :_ptr(ptr)
{}
~Autoptr()
{
delete _ptr;
cout << "delete ptr" << endl;
_ptr = nullptr;
}
//通过管理权转移的方式实现拷贝
// 把我拷贝给你
Autoptr(Autoptr& p)
:_ptr(p._ptr)
{
//通过把我置空，将资源转移给你
p._ptr = nullptr;
}
//使它想指针一样使用
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
}; autoptr的原理很简单，给谁拷贝，就把"权限"给谁（原本资源的位置），再把自己置空，实现资源转移，但这种写法显而易见的就是，空指针的访问，若有人不熟悉这个指针的原理，去访问拷贝后的原指针，就会导致对象悬空。
使用autoptr使得很多人被坑，之后出现第二个版本
简化uniqueptr
uniqueptr的做法比较绝，既然拷贝有问题，那干脆不支持你拷贝赋值了，通过私有只申明不实现的方法使我们无法访问拷贝构造。
templateclass Uniqueptr
{
public:
Uniqueptr(T* ptr) :_ptr(ptr)
{}
~Uniqueptr()
{
delete _ptr;
cout << "delete ptr" << endl;
_ptr = nullptr;
}
//
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
//c++11做法
/*Uniquetptr(Uniquetptr p) = delete;
Uniquetptr& operator=(Uniquetptr p) - delete;*/
private:
//只申明不实现 c++98做法
Uniqueptr(Uniqueptr& p);//拷贝构造
Uniqueptr& operator=(Uniqueptr p);//赋值
T* _ptr;
}; 但是不能拷贝不能解决根本问题，总有要拷贝的情况，因此又出来第三代智能指针。
简化sharedptr
sharedptr就是金泰主要认识的智能指针，通过引用技术的方式，实现赋值。
在实现的时候，我们增加一个参数count,count再调用构造函数时会被初始化为1，在拷贝的时候，此时这里的_ptr与原来的指向同一空间，这里的count也与原来的count指向同一空间，且对于拷贝给的这个count++，再调用析构时，对应的count只有一份，count先--,若count==0，说明到达释放的条件。就实现了资源的转移。
但是对于赋值，是分两种情况的，一种是同类资源的赋值。
一种是一类资源的赋值。
templateclass Sharedptr
{
public:
Sharedptr(T* ptr) :_ptr(ptr),count(new int (1))
{}
~Sharedptr()
{
(*count)--;
release();
}
void release()
{
if ((*count)== 0)
{
delete _ptr;
delete count;
cout << "finish released" << endl;
_ptr = nullptr;
count = nullptr;
}
}
Sharedptr(const Sharedptr& ptr)
:_ptr(ptr._ptr),
count(ptr.count)
{
++(*ptr.count);//拷贝的时候次数加加
}
//重载赋值 this=ptr
Sharedptr operator=(const Sharedptr& ptr)
{
//赋值的时候表示 把我这份资源交给你,你的资源被覆盖掉
//判断不是自身赋值
if (ptr.count != this->count)
{
//左边赋值给右边 因此右边被覆盖掉 先count--代表右边已经被析构一次
*(this->count)--;
//判断此时为空不
if (*(ptr.count) == 0)
{
release();
}
//不为空就进行覆盖
this->count = ptr.count;
this->_ptr = ptr._ptr;
//覆盖后此时的ptr指向 左边的资源
//因此左边的count++
*(this->count)++;
}
return *this;
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
int* count;
}; 计数是几就代表此时有多少个对象指向这里的资源。
此时的sharedptr已经基本实现我们的期望了，但在使用中又发现了一个无法解决的问题：循环引用。循环引用会导致死循环。
struct ListNode
{
ListNode()
{
cout << "调用构造" << endl;
}
~ListNode()
{
cout << "调用析构" << endl;
}
int data;
Sharedptr next;
Sharedptr prev;
};
void test_sharedptr1()
{
//假设害怕这里的节点得不到释放，我们用sharedptr来管理
Sharedptr p1 = new ListNode();
Sharedptr p2 = new ListNode();
p1->next = p2;
p2->prev = p1;
}
int main()
{
test_sharedptr1();
return 0;
}
我们模拟一个双链表的节点的链接，此时运行这个程序就会崩掉，但是删除其中一个的链接，调用就会成功，这里主要原因就是析构死循环了。
若是有一次链接
若是如上代码的两次链接
即先释放两个对象，此时都为1，在释放两个其中的节点，而释放其中的一个节点是被牵制的，需要我们再次看 上一个牵制的。如此往上，就形成了一个死循环，导致资源没有被释放。
库里加了explicet就不可以通过转换构造函数实现隐式类型转换的发生。
简化weakptr
为了专门解决也这个问题，再sharedptr的基础修改，引入了weakptr。这里的weakptr已经不属于RAII了,这里的已经不是智能指针了，使用weakptr,在这个地方不会引用计数。
templateclass Sharedptr
{
public:
Sharedptr():_ptr(nullptr), count(new int(1))
{}
Sharedptr(T* ptr) :_ptr(ptr),count(new int (1))
{}
~Sharedptr()
{
(*count)--;
release();
}
void release()
{
if ((*count)== 0)
{
delete _ptr;
delete count;
//cout << "finish released" << endl;
_ptr = nullptr;
count = nullptr;
}
}
Sharedptr(const Sharedptr& ptr)
:_ptr(ptr._ptr),
count(ptr.count)
{
++(*ptr.count);//拷贝的时候次数加加
}
//重载赋值 this=ptr
Sharedptr operator=(const Sharedptr& ptr)
{
//赋值的时候表示 把我这份资源交给你,你的资源被覆盖掉
//判断不是自身赋值
if (ptr.count != this->count)
{
//左边赋值给右边 因此右边被覆盖掉 先count--代表右边已经被析构一次
*(this->count)--;
//判断此时为空不
if (*(ptr.count) == 0)
{
release();
}
//不为空就进行覆盖
this->count = ptr.count;
this->_ptr = ptr._ptr;
//覆盖后此时的ptr指向 左边的资源
//因此左边的count++
*(this->count)++;
}
return *this;
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
int use_count()const
{
return *count;
}
T* get()const
{
return _ptr;
}
private:
T* _ptr;
int* count;
};
templateclass Weakptr
{
public:
//weakptr就不参与计数
Weakptr() :_ptr(nullptr)
{
}
Weakptr(const Sharedptr& p):_ptr(p.get())
{
}
Weakptr& operator=(const Sharedptr& p)
{
_ptr = p.get();
return *this;
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
};
定制删除器
上述的我们都是针对单一的指针，若是指针数组，释放就不会正确释放，程序是崩溃的，为了使我们的释放要考虑周全，因此这里释放我们可以使用仿函数，lambda或者函数指针进行删除。
由于库中的删除器，实在构造里调用的，因此我们在实现时，通过在构造传参，增加一个包装器，来初始化，之后析构的时候调用包装器，并在默认情况下给缺省值。
templateclass Sharedptr
{
public:
Sharedptr() :_ptr(nullptr), count(new int(1))
{}
template
Sharedptr(T* ptr, DEL del) :_ptr(ptr),count(new int (1)), del(del)
{}
~Sharedptr()
{
(*count)--;
release();
}
void release()
{
if ((*count)== 0)
{
del(_ptr) ;
delete count;
//cout << "finish released" << endl;
_ptr = nullptr;
count = nullptr;
}
}
Sharedptr(const Sharedptr& ptr)
:_ptr(ptr._ptr),
count(ptr.count)
{
++(*ptr.count);//拷贝的时候次数加加
}
//重载赋值 this=ptr
Sharedptr operator=(const Sharedptr& ptr)
{
//赋值的时候表示 把我这份资源交给你,你的资源被覆盖掉
//判断不是自身赋值
if (ptr.count != this->count)
{
//左边赋值给右边 因此右边被覆盖掉 先count--代表右边已经被析构一次
*(this->count)--;
//判断此时为空不
if (*(ptr.count) == 0)
{
release();
}
//不为空就进行覆盖
this->count = ptr.count;
this->_ptr = ptr._ptr;
//覆盖后此时的ptr指向 左边的资源
//因此左边的count++
*(this->count)++;
}
return *this;
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
int use_count()const
{
return *count;
}
T* get()const
{
return _ptr;
}
private:
T* _ptr;
int* count;
function del = [](T* ptr) {delete ptr; };
};