经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » C » 查看文章
c/c++ 智能指针 shared_ptr 使用
来源：cnblogs　　作者：小石王　　时间：2018/9/27 16:50:24　　对本文有异议

智能指针 shared_ptr 使用

上一篇智能指针是啥玩意，介绍了什么是智能指针。

这一篇简单说说如何使用智能指针。

一，智能指针分3类：今天只唠唠shared_ptr

  • shared_ptr
  • unique_ptr
  • weak_ptr

二，下表是shared_ptr和unique_ptr都支持的操作

操作 功能描述
shared_ptr<T> sp 空智能指针，可以指向类型为T的对象
unique_ptr<T> up 空智能指针，可以指向类型为T的对象
p 将p用作一个条件判断，如果p指向一个对象，则为true
*p 解引用p，获得它指向的对象
p->mem 等价于(*p).mem，访问p所指对象的mem成员
p.get() 返回p中保存的指针。如果指向的对象已经被释放，就是一个危险的指针
swap(p, q)或者p.swap(q) 交换p和q中的指针

上面操作的验证代码

  1. #include <memory>
  2. #include <iostream>
  3. #include <vector>
  5. using namespace std;
  7. class Test{
  8. public:
  9.   Test(int d = 0):data(d){cout << "cr:" << data << endl;}
  10.   ~Test(){cout << "fr:" << data << endl;}
  11.   void fun(){
  12.     cout << "Test func(" << data << ")" << endl;
  13.   }
  14. private:
  15.   int data;
  16. };
  17. int main(){
  18.   //shared_ptr<Test> sp = make_shared<Test>();                                  
  19.   Test* pt = new Test();
  20.   shared_ptr<Test> sp(pt);
  21.   if(sp){
  22.     cout << "sp指向了对象" << endl;
  23.   }
  24.   (*sp).fun();
  25.   shared_ptr<int> isp;
  26.   if(!isp){
  27.     cout << "isp没有指向对象" << endl;
  28.   }
  29.   Test* tmp1 = sp.get();
  30.   auto sp1 = make_shared<Test>(10);
  31.   Test* tmp2 = sp1.get();
  32.   swap(sp, sp1);
  33.   tmp1->fun();//0
  34.   tmp2->fun();//10
  35.   //sp和sp1所指向的对象被交换了
  36.   sp.get()->fun();//10
  37.   sp1.get()->fun();//0
  39. }

三，下表是shared_ptr独有的操作

操作 功能描述
make_shared<T>(args) 返回shared_ptr，指向一个动态分配的类型为T的对象。使用args初始化此对象。
shared_ptr p是q的拷贝；递增q中的计数器。q中的指针必须能转化成T*。
p = q p和q都是shared_ptr，所保存的指针必须能相互转换。递减p的引用计数；递增q的引用计数；如果p的引用计数变为0，则释放p管理的对象的内存。
p.unique() 如果p.use_count()为1，则返回true；否则返回false
p.use_count() 返回与p共享对象的智能指针的数量；性能很低，用于调试。

上面操作的验证代码

  1.   shared_ptr<Test> tsp = make_shared<Test>(11);
  2.   cout << tsp.use_count() << endl;//1                                           
  3.   //tsp1和tsp指向相同的对象，这个对象的计数器加1                                
  4.   shared_ptr<Test> tsp1(tsp);
  5.   cout << tsp.use_count() << endl;//2                                           
  6.   //用tsp1改变了对象的data的值,所以用tsp再访问这个对象，发现对象被改变了        
  7.   tsp1->setData(111);
  8.   tsp->fun();//111                                                              
  10.   shared_ptr<Test> q(new Test(20));
  11.   cout << q.use_count() << endl;//1                                             
  12.   cout << tsp.use_count() << endl;//2                                           
  13.   //如果q不是智能指针,q指向的Test(20)这块内存就泄露了                           
  14.   //q是智能指针，所以自动释放了Test(20)这块内存                                 
  15.   q = tsp;
  16.   cout << q.use_count() << endl;//3                                             
  17.   cout << tsp.use_count() << endl;//3                                           
  18.   if(!q.unique()){
  19.     cout << "不是只有一个智能指针指向了某个对象" << endl;
  20.   }

四，智能指针作为函数的返回值

  1. shared_ptr<Test> hun(int d){
  2.   return make_shared<Test>(d);
  3. }
  4. void use_hun1(int d){
  5.   shared_ptr<Test> p = hun(d);
  6.   p->fun();
  7. }//p离开作用域后，它指向的内存会被自动释放                                      
  8. shared_ptr<Test> use_hun2(int d){
  9.   shared_ptr<Test> p = hun(d);//计数器为1                                       
  10.   return p;//返回p时，计数器递增，为2                                           
  11. }//离开作用域后，计数器递减，为1，因为不为0，所以不会释放

一到四的小例子：

  1. include <memory>
  2. #include <iostream>
  3. #include <vector>
  5. using namespace std;
  7. class Test{
  8. public:
  9.   Test(int d = 0):data(d){cout << "cr:" << data << endl;}
  10.   ~Test(){cout << "fr:" << data << endl;}
  11.   void fun(){
  12.     cout << "Test func(" << data << ")" << endl;
  13.   }
  14.   void setData(int d){
  15.     data = d;
  16.   }
  17. private:
  18.   int data;
  19. };
  21. //test3 智能指针作为函数的返回值                                                
  22. shared_ptr<Test> hun(int d){
  23.   return make_shared<Test>(d);
  24. }
  25. void use_hun1(int d){
  26.   shared_ptr<Test> p = hun(d);
  27.   p->fun();
  28. }//p离开作用域后，它指向的内存会被自动释放                                      
  29. shared_ptr<Test> use_hun2(int d){
  30.   shared_ptr<Test> p = hun(d);//计数器为1                                       
  31.   return p;//返回p时，计数器递增，为2                                           
  32. }//离开作用域后，计数器递减，为1，因为不为0，所以不会释放                       
  33. int main(){
  34.   //test1 shared_ptr和unique_ptr都支持的操作                                    
  35.   /*                                                                            
  36.   //shared_ptr<Test> sp = make_shared<Test>();                                  
  37.   Test* pt = new Test();                                                        
  38.   shared_ptr<Test> sp(pt);                                                      
  39.   if(sp){                                                                       
  40.     cout << "sp指向了对象" << endl;                                             
  41.   }                                                                             
  42.   (*sp).fun();                                                                  
  43.   shared_ptr<int> isp;                                                          
  44.   if(!isp){                                                                     
  45.     cout << "isp没有指向对象" << endl;                                          
  46.   }                                                                             
  47.   Test* tmp1 = sp.get();                                                        
  48.   auto sp1 = make_shared<Test>(10);                                             
  49.   Test* tmp2 = sp1.get();                                                       
  50.   swap(sp, sp1);                                                                
  51.   tmp1->fun();                                                                  
  52.   tmp2->fun();                                                                  
  53.   sp.get()->fun();                                                              
  54.   sp1.get()->fun();                                                             
  55.   */
  57.   //test2 shared_ptr独有的操作                                                   
  58.   /*                                                                            
  59.   shared_ptr<Test> tsp = make_shared<Test>(11);                                 
  60.   cout << tsp.use_count() << endl;//1                                           
  61.   //tsp1和tsp指向相同的对象，这个对象的计数器加1                                
  62.   shared_ptr<Test> tsp1(tsp);                                                   
  63.   cout << tsp.use_count() << endl;//2                                           
  64.   //用tsp1改变了对象的data的值,所以用tsp再访问这个对象，发现对象被改变了        
  65.   tsp1->setData(111);                                                           
  66.   tsp->fun();//111                                                              
  67.                                                                                 
  68.   shared_ptr<Test> q(new Test(20));                                             
  69.   cout << q.use_count() << endl;//1                                             
  70.   cout << tsp.use_count() << endl;//2                                           
  71.   //如果q不是智能指针,q指向的Test(20)这块内存就泄露了                           
  72.   //q是智能指针，所以自动释放了Test(20)这块内存                                 
  73.   q = tsp;                                                                      
  74.   cout << q.use_count() << endl;//3                                             
  75.   cout << tsp.use_count() << endl;//3                                           
  76.   if(!q.unique()){                                                              
  77.     cout << "不是只有一个智能指针指向了某个对象" << endl;                       
  78.   }                                                                             
  79.   */
  81.   //test3 智能指针作为函数的返回值                                              
  82.   /*                                                                            
  83.   auto ap = use_hun2(22);                                                       
  84.   ap->fun();                                                                    
  85.   use_hun1(33);                                                                 
  86.   */
  88. }

github完整代码

五，智能指针的注意事项

把shared_ptr放入容器中时，之后不再需要全部元素，只使用其中一部分的话，要用erase删除那些不再需要使用的shared_ptr。如果不erase那些不再需要使用的shared_ptr，shared_ptr就不会释放它指向的内存。

六，智能指针的小例子，让多个对象共享相同的状态。

  • 有个类shared_vector，里面有个shared_ptr，指向了一个vector，类shared_vector的对象a2拷贝a1时，实现a1和a2共享vector。
  • 类un_shared_vector没有使用shared_ptr，所以没有共享vector。
  1. include <iostream>
  2. #include <memory>
  3. #include <vector>
  4. #include <string>
  6. using namespace std;
  8. class shared_vector{
  9. public:
  10.   typedef vector<string>::size_type size_type;
  11.   shared_vector():data(make_shared<vector<string>>()){}
  12.   shared_vector(initializer_list<string> il):
  13.     data(make_shared<vector<string>>(il)){}
  14.   size_type size()const{return data->size();}
  15.   bool empty()const{return data->empty();}
  16.   //尾部插入，删除元素                                                          
  17.   void push_back(const string& s){data->push_back(s);}
  18.   void pop_back(){data->pop_back();}
  19.   //访问元素                                                                    
  20.   string& front(){return data->front();}
  21.   string& back(){return data->back();}
  23. private:
  24.   shared_ptr<vector<string>> data;
  25. };
  27. class un_shared_vector{
  28. public:
  29.   typedef vector<string>::size_type size_type;
  30.   un_shared_vector():data(vector<string>()){}
  31.   un_shared_vector(initializer_list<string> il):data(il){}
  32.   size_type size()const{return data.size();}
  33.   bool empty()const{return data.empty();}
  34.   //尾部插入，删除元素                                                          
  35.   void push_back(const string& s){data.push_back(s);}
  36.   void pop_back(){data.pop_back();}
  37.   //访问元素                                                                    
  38.   string& front(){return data.front();}
  39.   string& back(){return data.back();}
  41. private:
  42.   vector<string> data;
  43. };
  45. int main(){
  46.   shared_vector sv{"aa","bb"};
  47.   shared_vector sv1(sv);
  48.   //因为sv和sv1共享同一个vector，                                               
  49.   //所以通过sv改变vector后，通过sv1也发现了相同的改变
  50.   sv.push_back("cc");
  51.   cout << sv1.back() << endl;
  53.   un_shared_vector usv{"11","22"};
  54.   un_shared_vector usv1(usv);
  55.   //因为usv和usv1不共享同一个vector，                                           
  56.   //所以通过usv改变vector后，usv1里面的vector没有跟着变化
  57.   usv.push_back("33");
  58.   cout << usv1.back() << endl;
  59.   cout << usv.back() << endl;
  60. }

github完整代码

c/c++ 学习互助QQ群：877684253

本人微信：xiaoshitou5854

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

C热门文章

  • C/C++编程笔记：编写不会在C ++中编译的C程序，我教你呀！
  • 洛谷 P2085 最小函数值
  • 使用C++界面框架ImGUI开发一个简单程序
  • C++ Json解析CJsonObject的详细使用
  • C++编译错误杂记
  • 二分法（二）：采用二分法解决“最小化最大值问题”
  • C++实现json字符串与map的转换
  • C++借助curses库实现俄罗斯方块
  • 长乐培训Day5
  • 【OpenFOAM】——OpenFOAM入门算例学习

    • C推荐文章

  • #8. 「模板」树链剖分
  • 预设型 DP
  • Standard Template Libary or C++ Standard Library
  • 一种优秀的虚拟机内存架构 - AQ
  • 如何让 MGR 不从 Primary 节点克隆数据？
  • TLScanary：Pwn中的利器
  • c++临时对象导致的生命周期问题
  • C++(Qt)-GIS开发-简易瓦片地图下载器
  • 逆向通达信 x 逆向微信 x 逆向Qt
  • C++面向对象

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号