【C++ 面试 - 新特性】每日 3 题（二）

本文主要是介绍【C++ 面试 - 新特性】每日 3 题（二），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

✍个人博客：Pandaconda-CSDN博客
📣专栏地址：http://t.csdnimg.cn/fYaBd
📚专栏简介：在这个专栏中，我将会分享 C++ 面试中常见的面试题给大家~
❤️如果有收获的话，欢迎点赞👍收藏📁，您的支持就是我创作的最大动力💪

4. 智能指针的循环引用

定义对象的时候用强智能指针 shared_ptr，而引用对象的使用用弱指针指针 weak_ptr。
循环引用是指使用多个智能指针 share_ptr 时，出现了指针之间相互指向，从而形成环的情况，有点类似于死锁的情况，这种情况下，智能指针往往不能正常调用对象的析构函数，从而造成内存泄漏。举个例子：

#include <iostream>
using namespace std;template <typename T>
class Node
{
public:Node(const T& value):_pPre(NULL), _pNext(NULL), _value(value){cout << "Node()" << endl;}~Node(){cout << "~Node()" << endl;cout << "this:" << this << endl;}shared_ptr<Node<T>> _pPre;shared_ptr<Node<T>> _pNext;T _value;
};void Funtest()
{shared_ptr<Node<int>> sp1(new Node<int>(1));shared_ptr<Node<int>> sp2(new Node<int>(2));cout << "sp1.use_count:" << sp1.use_count() << endl;cout << "sp2.use_count:" << sp2.use_count() << endl;sp1->_pNext = sp2; //sp2的引用+1sp2->_pPre = sp1; //sp1的引用+1cout << "sp1.use_count:" << sp1.use_count() << endl;cout << "sp2.use_count:" << sp2.use_count() << endl;
}int main()
{Funtest();system("pause");return 0;
}
//输出结果
//Node()
//Node()
//sp1.use_count:1
//sp2.use_count:1
//sp1.use_count:2
//sp2.use_count:2

从上面 shared_ptr 的实现中我们知道了只有当引用计数减减之后等于 0，析构时才会释放对象，而上述情况造成了一个僵局，那就是析构对象时先析构 sp2，可是由于 sp2 的空间 sp1 还在使用中，所以 sp2.use_count 减减之后为 1，不释放，sp1 也是相同的道理，由于 sp1 的空间 sp2 还在使用中，所以 sp1.use_count 减减之后为 1，也不释放。sp1 等着 sp2 先释放，sp2 等着 sp1 先释放，二者互不相让，导致最终都没能释放，内存泄漏。
在实际编程过程中，应该尽量避免出现智能指针之前相互指向的情况，如果不可避免，可以使用使用弱指针—— weak_ptr，它不增加引用计数，只要出了作用域就会自动析构。
我们不能通过 weak_ptr 直接访问对象的方法，比如 B 对象中有一个方法 print()，我们不能这样访问，pa->pb_->print()，因为 pb_ 是一个 weak_ptr，应该先把它转化为 shared_ptr：

shared_ptr<B> p = pa->pb_.lock(); 
p->print();

5. 重复构造问题

来看如下代码：

int *p = new int;
shared_ptr<int> ptr1(p);
shared_ptr<int> ptr2(p);
cout<<ptr1.use_count()<<endl;
cout<<ptr2.use_count()<<endl;

这段代码就有问题了，因为 shared_ptr ptr1§ 和 shared_ptr ptr2§ 都调用了 shared_ptr 的构造函数，在它的构造函数中，都重新开辟了引用计数的资源，导致 ptr1 和 ptr2 都记录了一次 new int 的引用计数，都是 1，析构的时候它俩都去释放内存资源，导致释放逻辑错误，如下图所示：
上面两个代码段，分别是 shared_ptr 的构造函数和拷贝构造函数做的事情，导致虽然都是指向同一个 new int 资源，但是对于引用计数对象的管理方式，这两个函数是不一样的，构造函数是新分配引用计数对象，拷贝构造函数只做引用计数增减。
大家知道最开始的代码清单上的代码为什么出错了吧，因为每次调用的都是 shared_ptr 的构造函数，虽然大家管理的资源都是一样的，_Ptr都是指向同一个堆内存，但是_Rep却指向了不同的引用计数对象，并且都记录引用计数是 1，出作用域都去析构，导致问题发生！
代码修改很简单，就是在产生同一资源的多个 shared_ptr 的时候，通过拷贝构造函数或者赋值 operator= 函数进行，不要重新构造，避免产生多个引用计数对象，代码修改如下：

int main()
{A* p = new A();//裸指针指向堆上的对象shared_ptr<A> ptr1(p);//用shared_ptr智能指针管理指针p指向的对象shared_ptr<A> ptr2(ptr1);//用ptr1拷贝构造ptr2//下面两次打印都是2，最终随着ptr1和ptr2析构，资源只释放一次，正确！cout << ptr1.use_count() << endl;cout << ptr2.use_count() << endl;return 0;
}
2.5 多线程访问共享对象的安全问题
可以通过指针指针解决多线程访问共享对象的安全问题，防止对象已经析构了还去访问，用 weak_ptr 就可以去侦测 shared_ptr 的对象是否已经释放。
class A
{public:A(){cout<<"A()"<<endl;}~A(){cout<<"~A()"<<endl;}void testA(){cout<<"非常好用的方法！"<<endl;}
};// 子线程
void handler01(weak_ptr<A> pw)
{std::this_thread::sleep_for(std::chrono::seconds(2));// q访问A对象的时候，需要侦测一下A对象是否存活shared_ptr<A> sp = pw.lock();if(sp!=nullptr){sp->testA();}else{cout<<"A对象已经析构，不能在访问！"<<endl;}
}// main线程
int main()
{{shared_ptr<A> p(new A());thread t1(handler01, weak_ptr<A>(p));t1.detach();}std::this_thread::sleep_for(std::chrono::seconds(10));return 0;
}