智能指针是存储指向动态分配(堆内存)对象指针的类。
通用实现技术是使用引用计数。每使用它一次,引用计数加1,每析构一次,引用计数减1,减为0时,删除所指向的堆内存。
C++11提供三种智能指针,std::shared_ptr,std::unique_prt和std::weak_ptr。需引用头文件。
4.1 shared_ptr共享的智能指针
shared_ptr使用引用计数,每一个shared_ptr的拷贝都指向相同的内存。在最后一个shared_ptr析构时,内存被释放。
4.1.1 shared_ptr基本用法
1.初始化
[1]构造函数
std::shared_ptr<int> p(new int(10));
[2]std::make_shared辅助函数
auto p = std::make_shared<int>(10);
优先使用,更高效
[3]reset方法
std::shared_ptr p;
p.reset(new int(10));
2.获取原始指针
auto p = std::make_shared<int>(10);
int *ptr = p.get();
// 智能指针不能打印,打印智能指针的原始指针地址
cout << "ptr:" << ptr << endl;
3.指定删除器
智能指针初始化时可以指定删除器:
void DeleteIntPtr(int *p) {
delete p;
}
std::shared_ptr<int> p(new int, DeleteIntPtr);
当p的引用计数为0时,会自动调用DeleteIntPtr删除器来释放对象的内存。
删除器可以写为lamda表达式:
std::shared_ptr<int> p(new int, [](int *p){ delete p; });
注意:
shared_ptr管理动态数组时,需要指定删除器。因为shared_ptr的默认删除器不支持数组对象:
std::shared_ptr<int> p(new int[10], [](int *p){ delete[] p; }); //delete[]
4.1.2 使用shared_ptr注意的问题
1.不要用一个原始指针初始化多个shared_ptr
int *p = new int;
shared_ptr<int> ptr1(p);
shared_ptr<int> ptr2(p);
会导致重复析构
2.不要在函数实参中创建shared_ptr
f(shared_ptr<int>(new int), g())
函数参数的执行顺序是由编译器决定的,上述参数的执行顺序可能是,
new int,g(),shared_ptr,此时如果g()发生异常shared_ptr没有执行,则出现内存泄漏。
解决方法:
shard_ptr<int> p(new int);
f(p, g());
3.不要将this指针作为shared_ptr直接返回出来,应该使用shared_from_this()返回this指针
this指针是裸指针,直接返回出来可能导致重复析构:
class A {
shared_ptr<A> GetSelf() {
return shared_ptr<A>(this);
}
};
int main() {
shared_ptr<A> sp1(new A);
shared_ptr<A> sp2 = sp1->GetSelf();
return 0;
}
离开作用域后,this将会被构造的两个智能指针各自析构,导致重复析构。
解决方法:
class A:public std::enable_shared_from_this<A> {
shared_ptr<A> GetSelf() {
return shared_from_this();
}
};
int main() {
shared_ptr<A> sp1(new A);
shared_ptr<A> sp2 = sp1->GetSelf();
return 0;
}
使用shared_from_this()原因见4.3.2。
4.避免循环引用,循环引用会导致内存泄漏
典型场景:
class A;
class B;
class A {
std::shared_ptr<B> ptrb;
~A() {
cout << "A is deleted!" << endl;
}
}
class B {
std::shared_ptr<A> ptra;
~B() {
cout << "B is deleted!" << endl;
}
}
void TestPtr() {
std::shared_ptr<A> pa(new A);
std::shared_ptr<B> pb(new B);
pa->ptrb = pb;
pb->ptra = pa;
}
测试结果是A和B都不会被析构,存在内存泄漏。循环引用导致pa和pb的引用计数为2,离开作用域后,pa和pb的引用计数减为1,不会被析构。
解决方法:
把A和B任何一个成员变量改为weak_ptr,见4.3.3。
4.2 unique_ptr独占的智能指针
unique_ptr不允许其他智能指针来共享其内部的指针,不允许赋值(复制)操作。
unique_ptr<T> p(new T);
unique_ptr<T> p1 = p; //错误,不能复制
unique_ptr不允许复制,但允许转移,这样它本身就不再拥有原来指针的所有权了。
unique_ptr<T> p(new T);
unique_ptr<T> p1 = std::move(p); //正确
C++14提供了make_unique来创建unique_ptr。
unique_ptr可以指向一个数组,shared_ptr不可以。
std::unique_ptr<int []> p(new int[10]); //正确
p[9] = 9;
std::shared_ptr<int []> p(new int[10]); //错误
std::unique_ptr指定删除器的时候和std::shared_ptr不一样,需要确定删除器的类型。
std::shared_ptr<int> ptr(new int(1), [](int *p){ delete p;}); //正确
std::unique_ptr<int> ptr(new int(1), [](int *p){ delete p;}); //错误
std::unique_ptr<int, void(*)(int *)> ptr(new int(1), [](int *p){ delete p;}); //错误
使用场景:
如果希望只有一个智能指针管理资源或数组则用unique_ptr,希望多个智能指针管理资源则用shared_ptr。
4.3 weak_ptr弱引用的智能指针
weak_ptr,它的构造不会增加引用计数,它的析构不会减少引用计数。它不共享指针,所以没有重载*和->操作符。
主要目的是通过shared_ptr获得资源的监视权,来监视shared_ptr中管理的资源是否存在。
4.3.1 weak_ptr基本用法
1.通过use_count()来获得当前观测资源的引用计数
shared_ptr<int> sp(new int(10));
weak_ptr<int> wp(sp);
cout << wp.use_count() << endl; //1
2.通过expired()来判断当前观测资源是否已经释放
shared_ptr<int> sp(new int(10));
weak_ptr<int> wp(sp);
if(wp.expired()) {
cout << "监测指针被释放,weak_ptr无效!"
} else {
cout << "监测指针未被释放,weak_ptr有效!"
}
3.通过lock()来获取所监视的shared_ptr
shared_ptr<int> sp(new int(10));
weak_ptr<int> wp(sp);
auto spt = wp.lock();
cout << *spt << endl; //10
4.3.2 weak_ptr返回this指针
解释4.1.2第3点,3.不要将this指针作为shared_ptr直接返回出来,应该使用shared_from_this()返回this指针
class A:public std::enable_shared_from_this<A> {
shared_ptr<A> GetSelf() {
return shared_from_this();
}
};
int main() {
shared_ptr<A> sp1(new A);
shared_ptr<A> sp2 = sp1->GetSelf();
return 0;
}
std::enable_shared_from_this类中有一个weak_ptr,调用shared_from_this()时会调用这个weak_ptr的lock(),返回监测的shared_ptr。
weak_ptr不会增加引用计数,所以不会出现重复析构的问题。
4.3.3 weak_ptr解决循环引用问题
解释4.1.2第4点,4.避免循环引用,循环引用会导致内存泄漏
解决方法:
class A;
class B;
class A {
std::shared_ptr<B> ptrb;
~A() {
cout << "A is deleted!" << endl;
}
}
class B {
std::weak_ptr<A> ptra; //改为weak_ptr
~B() {
cout << "B is deleted!" << endl;
}
}
void TestPtr() {
std::shared_ptr<A> pa(new A);
std::shared_ptr<B> pb(new B);
pa->ptrb = pb;
pb->ptra = pa;
}
解释:
ptra时weak_ptr,引用计数不会增加,所以pa的引用计数为1.析构时pa的引用计数减少为0,对象A正常析构。
pa析构后,ptrb引用计数2减为1,离开作用域后,pb的引用计数1减为0,对象B正常析构。
4.4 通过智能指针管理第三方库分配的内存
void *p = GetHandle()->Create();
//do something...
GetHandle()->Release();
优化为:
void *p = GetHandle()->Create();
std::shared_ptr<void> sp(p, [this](void *p){ GetHandle()->Release(p);});
上述代码可以保证任何时候能正确释放第三方库分配的内存。