文章讲述了智能指针的概念，特别是auto_ptr、unique_ptr和shared_ptr的作用，以及它们如何防止内存泄漏。介绍了内存泄漏的实例，并强调了C++11后unique_ptr的使用替代auto_ptr的原因。还讨论了weak_ptr在配合shared_ptr时的应用，以避免循环引用导致的内存问题。
什么是智能指针？用我的理解来解释就是帮助我们防止开辟空间之后忘记释放而导致内存泄漏的得力小助手！
一、为什么要用智能指针，内存泄漏的例子
#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(void) {
memoryLeak1();
memoryLeak2();
return 0;
}
memoryLeak1函数中，new了一个字符串指针，但是没有delete就已经return结束函数了，导致内存没有被释放，内存泄露！
memoryLeak2函数中，new了一个字符串指针，虽然在函数末尾有些释放内存的代码delete str，但是在delete之前就已经return了，所以内存也没有被释放，内存泄露！
使用指针，我们没有释放，就会造成内存泄露。但是我们使用普通对象却不会！
思考：如果我们分配的动态内存都交由有生命周期的对象来处理，那么在对象过期时，让它的析构函数删除指向的内存，这看似是一个 very nice 的方案？
智能指针就是通过这个原理来解决指针自动释放的问题！
C++98 提供了 auto_ptr 模板的解决方案
C++11 增加unique_ptr、shared_ptr 和weak_ptr
二、auto_ptr
使用智能指针：
// 定义智能指针
auto_ptr<Test> test(new Test);
智能指针可以像普通指针那样使用：
int main(void) {
//Test *test = new Test;
auto_ptr<Test> test(new Test);
cout << "test->debug：" << test->getDebug() << endl;
cout << "(*test).debug：" << (*test).getDebug() << endl;
return 0;
}
自动调用了析构函数。
为什么智能指针可以像普通指针那样使用？？？
因为其里面重载了 * 和 -> 运算符， * 返回普通对象，而 -> 返回指针对象。
智能指针的三个常用函数：get（）,release（）和reset（）
1.get（）获取智能指针托管的指针地址
// 定义智能指针
auto_ptr<Test> test(new Test);
Test *tmp = test.get(); // 获取指针返回
cout << "tmp->debug：" << tmp->getDebug() << endl;
//函数原型
_NODISCARD _Ty * get() const noexcept
{ // return wrapped pointer
return (_Myptr);
}
2.release（）取消智能指针对动态内存的托管
// 定义智能指针
auto_ptr<Test> test(new Test);
Test *tmp2 = test.release(); // 取消智能指针对动态内存的托管
delete tmp2; // 之前分配的内存需要自己手动释放
//函数原型
_Ty * release() noexcept
{ // return wrapped pointer and give up ownership
_Ty * _Tmp = _Myptr;
_Myptr = nullptr;
return (_Tmp);
}
3.reset（）重置智能指针托管的内存地址，如果地址不一致，原来的会被析构掉
// 定义智能指针
auto_ptr<Test> test(new Test);
test.reset(); // 释放掉智能指针托管的指针内存，并将其置NULL
test.reset(new Test()); // 释放掉智能指针托管的指针内存，并将参数指针取代之
//函数原型
void reset(_Ty * _Ptr = nullptr)
{ // destroy designated object and store new pointer
if (_Ptr != _Myptr)
delete _Myptr;
_Myptr = _Ptr;
}
使用建议：
1.尽可能不要将auto_ptr变量定义为全局变量或指针
2.除非自己知道后果，不要把auto_ptr 智能指针赋值给同类型的另外一个 智能指针；
3.C++11 后auto_ptr 已经被“抛弃”，已使用unique_ptr替代！C++11后不建议使用auto_ptr。
auto_ptr 被C++11抛弃的主要原因：
1). 复制或者赋值都会改变资源的所有权
// auto_ptr 被C++11抛弃的主要原因
auto_ptr<string> p1(new string("I'm Li Ming!"));
auto_ptr<string> p2(new string("I'm age 22."));
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;
2). 在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;
3). 不支持对象数组的内存管理
auto_ptr<int[]> array(new int[5]); // 不能这样定义三、unique_ptr
auto_ptr是用于C++11之前的智能指针。由于 auto_ptr 基于排他所有权模式：两个指针不能指向同一个资源，复制或赋值都会改变资源的所有权。auto_ptr 主要有三大问题：
- 复制和赋值会改变资源的所有权，不符合人的直觉。
- 在 STL 容器中使用auto_ptr存在重大风险，因为容器内的元素必需支持可复制（copy constructable）和可赋值（assignable）。
- 不支持对象数组的操作
以上问题已经在上面体现出来了，下面将使用unique_ptr解决这些问题。
所以，C++11用更严谨的unique_ptr 取代了auto_ptr！
unique_ptr 和 auto_ptr用法几乎一样，除了一些特殊。
unique_ptr特性
- 基于排他所有权模式：两个指针不能指向同一个资源
- 无法进行左值unique_ptr复制构造，也无法进行左值复制赋值操作，但允许临时右值赋值构造和赋值
- 保存指向某个对象的指针，当它本身离开作用域时会自动释放它指向的对象。
- 在容器中保存指针是安全的
A. 无法进行左值复制赋值操作，但允许临时右值赋值构造和赋值
unique_ptr<string> p1(new string("I'm Li Ming!"));
unique_ptr<string> p2(new string("I'm age 22."));
cout << "p1：" << p1.get() << endl;
cout << "p2：" << p2.get() << endl;
p1 = p2; // 禁止左值赋值
unique_ptr<string> p3(p2); // 禁止左值赋值构造
unique_ptr<string> p3(std::move(p1));
p1 = std::move(p2); // 使用move把左值转成右值就可以赋值了，效果和auto_ptr赋值一样
cout << "p1 = p2 赋值后：" << endl;
cout << "p1：" << p1.get() << endl;
cout << "p2：" << p2.get() << endl;
B. 在 STL 容器中使用unique_ptr，不允许直接赋值
vector<unique_ptr<string>> vec;
unique_ptr<string> p3(new string("I'm P3"));
unique_ptr<string> p4(new string("I'm P4"));
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]; /* 不允许直接赋值 */
vec[0] = std::move(vec[1]); // 需要使用move修饰，使得程序员知道后果
cout << "vec.at(0)：" << *vec.at(0) << endl;
cout << "vec[1]：" << *vec[1] << endl;
C. 支持对象数组的内存管理
// 会自动调用delete [] 函数去释放内存
unique_ptr<int[]> array(new int[5]); // 支持这样定义
除了上面ABC三项外，unique_ptr的其余用法都与auto_ptr用法一致。
3.1 auto_ptr 与 unique_ptr智能指针的内存管理陷阱
auto_ptr<string> p1;
string *str = new string("智能指针的内存管理陷阱");
p1.reset(str); // p1托管str指针
{
auto_ptr<string> p2;
p2.reset(str); // p2接管str指针时，会先取消p1的托管，然后再对str的托管
}
// 此时p1已经没有托管内容指针了，为NULL，在使用它就会内存报错！
cout << "str：" << *p1 << endl;
这是由于auto_ptr 与 unique_ptr的排他性所导致的！
为了解决这样的问题，我们可以使用shared_ptr指针指针！
四、shared_ptr
熟悉了unique_ptr 后，其实我们发现unique_ptr 这种排他型的内存管理并不能适应所有情况，有很大的局限！如果需要多个指针变量共享怎么办？
如果有一种方式，可以记录引用特定内存对象的智能指针数量，当复制或拷贝时，引用计数加1，当智能指针析构时，引用计数减1，如果计数为零，代表已经没有指针指向这块内存，那么我们就释放它！这就是 shared_ptr 采用的策略！
class Person {
public:
Person(int v) {
this->no = v;
cout << "构造函数 \t no = " << this->no << endl;
}
~Person() {
cout << "析构函数 \t no = " << this->no << endl;
}
private:
int no;
};
// 仿函数，内存删除
class DestructPerson {
public:
void operator() (Person *pt) {
cout << "DestructPerson..." << endl;
delete pt;
}
};
1.引用计数的使用
调用use_count函数可以获得当前托管指针的引用计数。
shared_ptr<Person> sp1;
shared_ptr<Person> sp2(new Person(2));
// 获取智能指针管控的共享指针的数量 use_count()：引用计数
cout << "sp1 use_count() = " << sp1.use_count() << endl;
cout << "sp2 use_count() = " << sp2.use_count() << endl << endl;
// 共享
sp1 = sp2;
cout << "sp1 use_count() = " << sp1.use_count() << endl;
cout << "sp2 use_count() = " << sp2.use_count() << endl << endl;
shared_ptr<Person> sp3(sp1);
cout << "sp1 use_count() = " << sp1.use_count() << endl;
cout << "sp2 use_count() = " << sp2.use_count() << endl;
cout << "sp2 use_count() = " << sp3.use_count() << endl << endl;
如上代码，sp1 = sp2; 和 shared_ptr< Person > sp3(sp1);就是在使用引用计数了。
sp1 = sp2; --> sp1和sp2共同托管同一个指针，所以他们的引用计数为2；
shared_ptr< Person > sp3(sp1); --> sp1和sp2和sp3共同托管同一个指针，所以他们的引用计数为3；
shared_ptr使用陷阱
shared_ptr作为被管控的对象的成员时，小心因循环引用造成无法释放资源!
如下代码：
Boy类中有Girl的智能指针；
Girl类中有Boy的智能指针；
当他们交叉互相持有对方的管理对象时…
#include <iostream>
#include <string>
#include <memory>
using namespace std;
class Girl;
class Boy {
public:
Boy() {
cout << "Boy 构造函数" << endl;
}
~Boy() {
cout << "~Boy 析构函数" << endl;
}
void setGirlFriend(shared_ptr<Girl> _girlFriend) {
this->girlFriend = _girlFriend;
}
private:
shared_ptr<Girl> girlFriend;
};
class Girl {
public:
Girl() {
cout << "Girl 构造函数" << endl;
}
~Girl() {
cout << "~Girl 析构函数" << endl;
}
void setBoyFriend(shared_ptr<Boy> _boyFriend) {
this->boyFriend = _boyFriend;
}
private:
shared_ptr<Boy> boyFriend;
};
void useTrap() {
shared_ptr<Boy> spBoy(new Boy());
shared_ptr<Girl> spGirl(new Girl());
// 陷阱用法
spBoy->setGirlFriend(spGirl);
spGirl->setBoyFriend(spBoy);
// 此时boy和girl的引用计数都是2
}
int main(void) {
useTrap();
system("pause");
return 0;
}
可以看出，程序结束了，但是并没有释放内存，这是为什么呢？？？
当我们执行useTrap函数时，注意，是没有结束此函数，boy和girl指针其实是被两个智能指针托管的，所以他们的引用计数是2
useTrap函数结束后，函数中定义的智能指针被清掉，boy和girl指针的引用计数减1，还剩下1，对象中的智能指针还是托管他们的，所以函数结束后没有将boy和gilr指针释放的原因就是于此。
所以在使用shared_ptr智能指针时，要注意避免对象交叉使用智能指针的情况！ 否则会导致内存泄露！
当然，这也是有办法解决的，那就是使用weak_ptr弱指针。
五、weak_ptr指针
weak_ptr 设计的目的是为配合 shared_ptr 而引入的一种智能指针来协助 shared_ptr 工作, 它只可以从一个 shared_ptr 或另一个 weak_ptr 对象构造, 它的构造和析构不会引起引用记数的增加或减少。 同时weak_ptr 没有重载*和->但可以使用 lock 获得一个可用的 shared_ptr 对象。
1.弱指针的使用；
weak_ptr wpGirl_1; // 定义空的弱指针
weak_ptr wpGirl_2(spGirl); // 使用共享指针构造
wpGirl_1 = spGirl; // 允许共享指针赋值给弱指针
2.弱指针也可以获得引用计数；
wpGirl_1.use_count()
3.弱指针不支持 * 和 -> 对指针的访问；
4.
shared_ptr<Girl> sp_girl;
sp_girl = wpGirl_1.lock();
// 使用完之后，再将共享指针置NULL即可
sp_girl = NULL;
在必要的使用可以转换成共享指针 lock()；
使用代码：
shared_ptr<Boy> spBoy(new Boy());
shared_ptr<Girl> spGirl(new Girl());
// 弱指针的使用
weak_ptr<Girl> wpGirl_1; // 定义空的弱指针
weak_ptr<Girl> wpGirl_2(spGirl); // 使用共享指针构造
wpGirl_1 = spGirl; // 允许共享指针赋值给弱指针
cout << "spGirl \t use_count = " << spGirl.use_count() << endl;
cout << "wpGirl_1 \t use_count = " << wpGirl_1.use_count() << endl;
// 弱指针不支持 * 和 -> 对指针的访问
/*wpGirl_1->setBoyFriend(spBoy);
(*wpGirl_1).setBoyFriend(spBoy);*/
// 在必要的使用可以转换成共享指针
shared_ptr<Girl> sp_girl;
sp_girl = wpGirl_1.lock();
cout << sp_girl.use_count() << endl;
// 使用完之后，再将共享指针置NULL即可
sp_girl = NULL;
在类中使用弱指针接管共享指针，在需要使用时就转换成共享指针去使用即可！
扫一扫
393
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
