目录
编辑
一.什么是智能指针
1.RAII
2.智能智能指针
二.为什么需要智能指针
1.内存泄漏
a. 什么是内存泄漏，内存泄漏的危害
b.内存泄漏分类
c.如何检测内存泄漏
d.如何避免内存泄漏
总结一下:
2.为什么需要智能指针以及智能指针的原理
三.智能指针的使用
1.C++98中的败笔智能指针auto_ptr
2.C++11中的智能指针
a.unique_ptr 不可拷贝的智能指针
一.什么是智能指针
1.RAII
2.智能智能指针
在程序中创建一个专门管理在程序中申请资源的类，通过这个类管理我们申请的资源。
二.为什么需要智能指针
1.内存泄漏
a. 什么是内存泄漏，内存泄漏的危害
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;
}b.内存泄漏分类
c.如何检测内存泄漏
d.如何避免内存泄漏
总结一下:
2.为什么需要智能指针以及智能指针的原理
#include <iostream>
#include <string>
using namespace std;
int main(void)
{
string* str_ptr = new string;
func();
delete str_ptr;
return 0;
}对于上面的代码，关于str_ptr中申请的堆中的资源，此时我们需要手动释放，那么当程序没有问题的运行完成时，此时程序完成对我们申请的资源的释放，但是如果在中间的func（）函数发生错误抛异常了，会改变我们程序的执行顺序，此时我们释放代码就不会被执行了。
此时我们就会想如果有一个可以自己知道自己什么该死的空间就好了。
此时就有人提出智能指针的概念了。
通过一个类来管理我们申请的资源，该类的析构函数在类对象出作用域的时候会自动被调用，会自动的清理我们的资源。
template<class T>
class SmartPtr {
public:
SmartPtr(T* ptr = nullptr)
: _ptr(ptr)
{}
~SmartPtr()
{
if(_ptr)
delete _ptr;
}
private:
T* _ptr;
};
int div()
{
int a, b;
cin >> a >> b;
if (b == 0)
throw invalid_argument("除0错误");
return a / b;
}
void Func()
{
ShardPtr<int> sp1(new int);
ShardPtr<int> sp2(new int);
cout << div() << endl;
}
int main()
{
try {
Func();
}
catch(const exception& e)
{
cout<<e.what()<<endl;
}
return 0;
}三.智能指针的使用
1.C++98中的败笔智能指针auto_ptr
#include <memory>
#include <iostream>
using namespace std;
class A
{
public:
A(int a)
:_a(a)
{
cout << "A()" << endl;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
};
int main(void)
{
auto_ptr<A> ap1(new A(1));
auto_ptr<A> ap2(new A(2));
auto_ptr<A> ap3;
ap3 = ap1;
return 0;
}
此时我们发现这个auto_ptr在进行拷贝的时候是转移资源的使用权，此后我们在使用ap1
这个智能指针的时候就无法使用了。
2.C++11中的智能指针
a.unique_ptr 不可拷贝的智能指针
类的对象不可以进行拷贝的两个方法：
将该类的拷贝构造函数私有化。
unique_ptr(unique_ptr<T>& up) = delete; 已删除该函数。
template<class T>
class unique_ptr
{
public:
// RAII
// 像指针一样
unique_ptr(T* ptr)
:_ptr(ptr)
{}
~unique_ptr()
{
cout << "delete:" << _ptr << endl;
delete _ptr;
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
// ap3(ap1)
// 管理权转移
// 防拷贝
unique_ptr(unique_ptr<T>& ap) = delete;
unique_ptr<T>& operator=(unique_ptr<T>& ap) = delete;
private:
T* _ptr;
};b.share_ptr 可以拷贝的智能指针
template<class T>
class shared_ptr
{
public:
// RAII
// 像指针一样
shared_ptr(T* ptr = nullptr)
:_ptr(ptr)
,_pcount(new int(1))
{}
// function<void(T*)> _del;
template<class D>
shared_ptr(T* ptr, D del)
:_ptr(ptr)
, _pcount(new int(1))
, _del(del)
{}
~shared_ptr()
{
if (--(*_pcount) == 0)
{
cout << "delete:" << _ptr << endl;
//delete _ptr;
_del(_ptr);
delete _pcount;
}
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
// sp3(sp1)
shared_ptr(const shared_ptr<T>& sp)
:_ptr(sp._ptr)
,_pcount(sp._pcount)
{
++(*_pcount);
}
// sp1 = sp5
// sp6 = sp6
// sp4 = sp5
shared_ptr<T>& operator=(const shared_ptr<T>& sp)
{
if (_ptr == sp._ptr)
return *this;
if (--(*_pcount) == 0)
{
delete _ptr;
delete _pcount;
}
_ptr = sp._ptr;
_pcount = sp._pcount;
++(*_pcount);
return *this;
}
int use_count() const
{
return *_pcount;
}
T* get() const
{
return _ptr;
}
private:
T* _ptr;
int* _pcount;
function<void(T*)> _del = [](T* ptr) {delete ptr; };
};
c.weak_ptr 用来解决share_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;
};四.定制删除器
上面的代码没法自动释放new到的多个空间
解决方法 ：
