c++11&14-智能指针要点汇总

2023-07-23 20:19:06 77

学c++的人都知道，在c++里面有一个痛点，就是动态内存的管理，就我所经历的一些问题来看，很多莫名其妙的问题，最后都发现是内存管理不当引起的。

但像java等其他一些语言则不会有这样的问题，为什么呢，因为它们有很好的处理内存的方法，比如java的垃圾回收机制，现在，我们c++终于也有了智能指针。

1.什么是智能指针

简单地说，智能指针是用对象去管理一个资源指针，同时用一个计数器计算引用当前指针对象的个数，当管理指针的对象增加或减少时，计数器也相应加1或减1，当最后一个指针管理对象销毁时，计数器为1，此时在销毁指针管理对象的同时，也对指针管理对象所管理的指针进行delete操作。

下面我们介绍两个常用的智能指针std::shared_ptr和std::weak_ptr。

1.1std::shared_ptr

std::shared_ptr包装了new操作符动态分配的内存，可以自由拷贝复制，基本上是使用最多的一个智能指针类型。

下面是一个代码例子：

#include
#include
classTest
{
public:
Test()
{
std::cout<<"Test()"<p1=std::make_shared();
std::cout<<"1ref:"<p2=p1;
std::cout<<"2ref:"<
结果如下：

Test()

1ref:1

2ref:2

3ref:1

~Test()

针对代码解读如下：
std::make_shared里面调用了new操作符分配内存；

第二个p1.use_count()之所以显示为2，是因为增加了引用对象p2,而随着大括号的结束，p2的作用域结束，所以p1的引用计数变回1，而随着main函数的结束，p1的作用域结束，此时检测到计数为1，那就会在销毁p1的同时，调用p1的析构函数delete掉之前分配的内存空间；
1.2std::weak_ptr
std::weak_ptr有什么特点呢？与std::shared_ptr最大的差别是在赋值的时候，不会引起智能指针计数增加。
weak_ptr被设计为与shared_ptr共同工作，可以从一个shared_ptr或者另一个weak_ptr对象构造，获得资源的观测权。但weak_ptr没有共享资源，它的构造不会引起指针引用计数的增加。同样，在weak_ptr析构时也不会导致引用计数的减少，它只是一个静静地观察者。weak_ptr没有重载operator*和->，这是特意的，因为它不共享指针，不能操作资源，这是它弱的原因。如要操作资源，则必须使用一个非常重要的成员函数lock()从被观测的shared_ptr获得一个可用的shared_ptr对象，从而操作资源。
1.2.1std::shared_ptr相互引用会有什么后果
代码如下：
#include
#include
classTestB;
classTestA
{
public:
TestA()
{
std::cout<<"TestA()"<test_ptr)
{
m_TestB_Ptr=test_ptr;
}
~TestA()
{
std::cout<<"~TestA()"<m_TestB_Ptr;//TestB的智能指针
};
classTestB
{
public:
TestB()
{
std::cout<<"TestB()"<test_ptr)
{
m_TestA_Ptr=test_ptr;
}
~TestB()
{
std::cout<<"~TestB()"<m_TestA_Ptr;//TestA的智能指针
};
intmain()
{
std::shared_ptrptr_a=std::make_shared();
std::shared_ptrptr_b=std::make_shared();
ptr_a->ReferTestB(ptr_b);
ptr_b->ReferTestB(ptr_a);
return0;
}

运行结果：

TestA()

TestB()

可以看到，上面代码中，我们创建了一个TestA和一个TestB的对象，但在整个main函数都运行完后，都没看到两个对象被析构，这是为什么呢？
原来，智能指针ptr_a中引用了ptr_b，同样ptr_b中也引用了ptr_a，在main函数退出前，ptr_a和ptr_b的引用计数均为2，退出main函数后，引用计数均变为1，也就是相互引用。
这等效于说：
ptr_a对ptr_b说，哎，我说ptr_b，我现在的条件是，你先释放我，我才能释放你，这是天生的，造物者决定的，改不了；

ptr_b也对ptr_a说，我的条件也是一样，你先释放我，我才能释放你，怎么办？

是吧，大家都没错，相互引用导致的问题就是释放条件的冲突，最终也可能导致内存泄漏。
1.2.2std::weak_ptr如何解决相互引用的问题
我们在上面的代码基础上使用std::weak_ptr进行修改，如下：
#include
#include
classTestB;
classTestA
{
public:
TestA()
{
std::cout<<"TestA()"<test_ptr)
{
m_TestB_Ptr=test_ptr;
}
voidTestWork()
{
std::cout<<"~TestA::TestWork()"<m_TestB_Ptr;
};
classTestB
{
public:
TestB()
{
std::cout<<"TestB()"<test_ptr)
{
m_TestA_Ptr=test_ptr;
}
voidTestWork()
{
std::cout<<"~TestB::TestWork()"<tmp=m_TestA_Ptr.lock();
tmp->TestWork();
std::cout<<"2refa:"<m_TestA_Ptr;
};
intmain()
{
std::shared_ptrptr_a=std::make_shared();
std::shared_ptrptr_b=std::make_shared();
ptr_a->ReferTestB(ptr_b);
ptr_b->ReferTestB(ptr_a);
std::cout<<"1refa:"<
运行结果：

TestA()

TestB()

1refa:1

1refb:1

~TestA::TestWork()

2refa:2

~TestB()

~TestA()

预览

由以上代码运行结果我们可以看到：
所有的对象最后都能正常释放，不会存在上一个例子中的内存没有释放的问题;

ptr_a和ptr_b在main函数中退出前，引用计数均为1，也就是说，在TestA和TestB中对std::weak_ptr的相互引用，不会导致计数的增加。在TestB析构函数中，调用std::shared_ptrtmp=m_TestA_Ptr.lock()，把std::weak_ptr类型转换成std::shared_ptr类型，然后对TestA对象进行调用。
1.2.3std::weak_ptr支持的调用
weak_ptrw;	//空weak_ptr可以指向类型为T的对象
weak_ptrw(shared_ptrsp);	//与sp指向相同对象的weak_ptr,T必须能转换为sp指向的类型
w=p;	//p可以是shared_ptr或者weak_ptr，赋值后w和p共享对象
w.reset();	//weak_ptr置为空
w.use_count();	//与w共享对象的shared_ptr的计数
w.expired();	//w.use_count()为0则返回true，否则返回false
w.lock();	//w.expired()为true，返回空的shared_ptr;否则返回指向w的shared_ptr

1.3std::unique_ptr
uniqut_ptr是一种对资源具有排他性拥有权的智能指针，即一个对象资源只能同时被一个unique_ptr指向。
1.3.1初始化方式


使用new
T*pT=newT();
std::unique_ptrup1(pT);

通过make_unique
autopT=make_unique();

通过move()函数
//up也是一个std::unique_ptr指针
unique_ptrup1=std::move(up);

1.3.2unique_ptr不能被复制或者拷贝
unique_ptrup(newT());//ok
unique_ptrup1(up);//error,cannotbecopy
unique_ptrup2=up;//error,cannotbeassigned

1.3.3unique_ptr可以移动赋值或者移动拷贝
unique_ptrpT(newT());
unique_ptrpT2=std::move(pT);	//移动赋值，此时pT被销毁，为空
unique_ptrpT3(std::move(pt2));//移动拷贝，此时pT2被销毁，为空

1.3.4unique_ptr可以作为函数的返回值
unique_ptrGetPtr();//functiongettheuniquepointer
unique_ptrpT=GetPtr();//ok

1.3.5使用范例
#include
intmain()
{
	std::unique_ptrpInt;
	pInt.reset(newint());
	int*p=pInt.release();//释放所有权
	//由于unique_ptr有std::unique_ptr的重载函数，所以它可以用来管理数组资源
	std::unique_ptrpArray(newint[3]{1,3,3});
}

2.智能指针小结
可以看出，智能指针其实是std::shared_ptr和std::unique_ptr,std::shared_ptr可以有多个引用对象，但不能互相引用，而std::unique_ptr只能有一个引用，不能赋值或者拷贝，但可以移动赋值和移动拷贝，std::weak_ptr实际上是对std::shared_ptr的补充，它并不能对对象进行具体的操作。
注意：shared_ptr,weak_ptr,unique_ptr这些都是模板，并不是指针或者其他的。
以上就是c++11&14-智能指针要点汇总的详细内容，更多关于c++11&14智能指针的资料请关注毛票票其它相关文章！

c++11&14-智能指针要点汇总

热门推荐

随机推荐