Chinaunix首页 | 论坛 | 博客

Aimerの博客

首页　| 　博文目录　| 　关于我

夏目玲子

  • 博客访问： 584569
  • 博文数量： 104
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 1559
  • 用 户 组： 普通用户
  • 注册时间： 2014-08-21 00:58
个人简介

锻炼精神,首先要锻炼肉体

文章分类

全部博文（104）

文章存档

2018年（1）

2016年（1）

2015年（101）

2014年（1）

我的朋友
最近访客
推荐博文
相关博文
[c++,boost]shared_ptr 与 scoped_ptr 的不同和他们的使用方法

分类： C/C++

2015-05-11 15:24:06

1.shared_ptr  和 scoped_ptr 的不同之处

1.1.shared_ptr 是允许转让的，而 scoped_ptr 是不允许权限转让的，转让的代码实现和定义在后面几段中有详细介绍，
不过简单的说就是 scoped_ptr 不支持同时创建两个指向相同类型的 scoped_ptr 指针让他们指向同一个对象实例

1.2.shared_ptr 可以作为标准容器的元素，而 scoped_ptr 是不可以的

1.3. shared_ptr 支持空指针的创建(常用于查找对象指针的时候，如果查找不到返回空指针的情况，因为在这种情况下不能够简单的返回 NULL )，而scoped_ptr 却不支持空指针

1.4. shared_ptr 支持引用计数，只有它支持引用计数，所谓的引用计数就是指:
创建一个对象 T ， 然后创建多个指向该对象的 shared_ptr n1...nx ;  每个指针 n* 通过调用 n*.use_count () 方法的返回值(int)便可以获知，
当前除了自己以外是否还有其它的shared_ptr 指针指向该对象实例 T。返回值(int) 便可以称作是该对象 T 的引用计数。
只有当引用计数的数值为 0 的时候，调用 shared_ptr.reset() 方法才会将该对象 T 的空间进行释放，
否则仅仅是当前调用 reset() 方法的shared_ptr 指针所指向的引用计数数值 -1 ，并断开指针和对象之间的关联。

做实验的时候，很多代码都是在前面的基础之上进行修改的，多少有一些重复的地方

2. scoped_ptr 和 shared_ptr 的模板定义方法
2.1. boost::scoped_ptr

点击(此处)折叠或打开

  1. namespace boost {

  3.     template<typename T> class scoped_ptr : noncopyable {
  4.     public:
  5.         explicit scoped_ptr(T* p = 0);
  6.         ~scoped_ptr();

  8.         void reset(T* p = 0);

  10.         T& operator*() const;
  11.         T* operator->() const;
  12.         T* get() const;

  14.         void swap(scoped_ptr& b);
  15.     };

  17.     template<typename T>
  18.     void swap(scoped_ptr<T> & a, scoped_ptr<T> & b);
  19. }
2.2. boost::shared_ptr 

点击(此处)折叠或打开

  1. template <typename T>
  2. class shared_ptr
  3. {
  4.   public :
  5.     typedef T element_type ;
  6.     
  7.     shared_ptr () ;
  8.     template<typename Y >
  9.     explicit shared_ptr ( Y *p ) ;
  10.     
  11.     template <typename Y , typename D>
  12.     shared_ptr ( Y*p , D d ) ;
  13.     
  14.     ~shared_ptr () ;
  15.     
  16.      shared_ptr (shared_ptr const & r ) ;
  17.     
  18.     template <typename Y>
  19.     explicit shared_ptr ( std::auto_ptr <Y> & r ) ;
  20.     
  21.     shared_ptr & operator=(shared_ptr const &r ) ;
  22.     
  23.     template <typename Y>
  24.     shared_ptr &operator= (shared_ptr<Y> const &r ) ;
  25.     
  26.     template <typename Y>
  27.     shared_ptr &operator=(std::auto_ptr<Y> &r ) ;
  28.     
  29.     void reset () ;
  30.     
  31.     template <typename Y>
  32.     void reset ( Y* p ) ;
  33.     
  34.     template <typename Y, typename D>
  35.     void reset ( Y*p , D d ) ;
  36.     
  37.     T & operator*() const ;
  38.     T * operator->() const ;
  39.     T * get () const ;
  40.     
  41.     
  42.     bool unique () const ;
  43.     long use_count () const ;
  44.     
  45.     operator unspecified-bool-type () const ;
  46.     void swap( shared_ptr & b ) ;
  47. } ;


3. 代码实例转让的含义
   

点击(此处)折叠或打开

  1. #include <boost/shared_ptr.hpp>
  2. #include <boost/scoped_ptr.hpp>
  3. #include <cstdio>
  4. #include <cstdlib>
  5. #include <iostream>

  7. /**
  8. this file is used to justify the difference between boost::scoped_ptr and boost::shared_ptr
  9. results:
  10. 1. shared_ptr can hands in its possion on an object , however the scoped_ptr doesn't
  11. 2. when you write something to let scoped_ptr hands in its possion on some object
  12.     spaces allocated to that object will be released immediately
  13.     but , unfortunately the output contents won't be shown on the screen cause the error message
  14.     
  15.     by Aimer
  16. */



  20. template <typename T>
  21. class sharedPtr
  22. {
  23.     public :
  24.     typedef boost::shared_ptr<T> type ;
  25. } ;

  27. template <typename T>
  28. class scopedPtr
  29. {
  30.     public :
  31.     typedef boost::scoped_ptr<T> type ;
  32. } ;

  34. class obj
  35. {
  36.     public :
  37.       obj ( std::string& n )
  38.      {
  39.          name = n ;
  40.          std::cout << "you get a obj " << name << std::endl ;
  41.      }
  42.      
  43.      void print ()
  44.      {
  45.          std::cout << "the programmer loves " <<name << std::endl ;
  46.      }
  47.      
  48.      ~obj ()
  49.      {
  50.         std::cout << "good bye " << name << std::endl;
  51.      }
  52.      
  53.      private :
  54.      std::string name ;
  55. } ;


  58. int main ( void )
  59. {
  60.     std::string name ("kylin_zhang") ;
  61.     
  62.     // first we test whether shared_ptr can transfer the possion of a obj instance
  63.     sharedPtr<obj>::type p1 (new obj(name)) ;
  64.     sharedPtr<obj>::type p2 = p1 ;
  65.     
  66.     p2->print () ;
  67.     
  68.     
  69.     // then we test whether the scoped_ptr can hand in its possion of a obj
  70.     std::string name_ ("singer aimer") ;
  71.     scopedPtr<obj>::type q1 (new obj(name_)) ;
  72.     
  73.     
  74.  /*
  75.     remove the notes , if you want to check the error message
  76.     scopedPtr<obj>::type q2  =  q1 ;
  77. */
  78.     std::cout << std::endl ;
  79.     
  80.     std::cout << "here we will transfer the posssion from q1 to q2" <<std::endl;
  81.     scopedPtr<obj>::type q2 ;
  82.     q1.swap (q2) ;
  83.     // after this q1's object is handed to q2 , so , q1->print() will prompt error message
  84.     
  85.     
  86.     q2->print () ;
  87.     
  88.     
  89.    // q1->print () ; this will cause error , cause the space could only be visited by q2 itself
  90.    
  91.    
  92.    // here we test whether the scoped_ptr can use scopedPtr<T>::type () ; to create an empty scoped pointer
  93.   // scopedPtr<obj>::type empty = scopedPtr<obj>::type() ;
  94.    
  95.    sharedPtr<obj>::type spEmpty = sharedPtr<obj>::type() ;
  96.    
  97.     
  98.     std::cout << "end of file pointers release their objects' space" <<std::endl ;
  99.     
  100.     return 0 ;
  101. }

4. boost 中的 explicit/noncopyable 来实现 scoped_ptr 的禁止转让功能 ,   scoped_ptr 通过swap 来实现一定程度的转让功能
 

点击(此处)折叠或打开

  1. #include <boost/shared_ptr.hpp>
  2. #include <boost/scoped_ptr.hpp>
  3. #include <cstdio>
  4. #include <cstdlib>
  5. #include <iostream>

  7. /**
  8. this file is used to justify the difference between boost::scoped_ptr and boost::shared_ptr
  9. results:
  10. 1. shared_ptr can hands in its possion on an object , however the scoped_ptr doesn't
  11. 2. when you write something to let scoped_ptr hands in its possion on some object
  12.     spaces allocated to that object will be released immediately
  13.     but , unfortunately the output contents won't be shown on the screen cause the error message
  14.     
  15.     by Aimer
  16. */



  20. template <typename T>
  21. class sharedPtr
  22. {
  23.     public :
  24.     typedef boost::shared_ptr<T> type ;
  25. } ;

  27. template <typename T>
  28. class scopedPtr
  29. {
  30.     public :
  31.     typedef boost::scoped_ptr<T> type ;
  32. } ;

  34. class obj
  35. {
  36.     public :
  37.       obj ( std::string& n )
  38.      {
  39.          name = n ;
  40.          std::cout << "you get a obj " << name << std::endl ;
  41.      }
  42.      
  43.      void print ()
  44.      {
  45.          std::cout << "the programmer loves " <<name << std::endl ;
  46.      }
  47.      
  48.      ~obj ()
  49.      {
  50.         std::cout << "good bye " << name << std::endl;
  51.      }
  52.      
  53.      private :
  54.      std::string name ;
  55. } ;


  58. int main ( void )
  59. {
  60.     std::string name ("kylin_zhang") ;
  61.     
  62.     // first we test whether shared_ptr can transfer the possion of a obj instance
  63.     sharedPtr<obj>::type p1 (new obj(name)) ;
  64.     sharedPtr<obj>::type p2 = p1 ;
  65.     
  66.     p2->print () ;
  67.     
  68.     
  69.     // then we test whether the scoped_ptr can hand in its possion of a obj
  70.     std::string name_ ("singer aimer") ;
  71.     scopedPtr<obj>::type q1 (new obj(name_)) ;
  72.     
  73.     
  74.  /*
  75.     remove the notes , if you want to check the error message
  76. */
  77.     std::cout << std::endl ;
  78.     
  79.     std::cout << "here we will transfer the posssion from q1 to q2" <<std::endl;
  80.     scopedPtr<obj>::type q2 ;
  81.     q1.swap (q2) ;
  82.     // after this q1's object is handed to q2 , so , q1->print() will prompt error message
  83.     
  84.     
  85.     q2->print () ;
  86.     
  87.     
  88.    // q1->print () ; this will cause error , cause the space could only be visited by q2 itself
  89.     
  90.     std::cout << "end of file pointers release their objects' space" <<std::endl ;
  91.     
  92.     return 0 ;
  93. }

点击(此处)折叠或打开

  1. #include <cstdio>
  2. #include <iostream>
  3. #include <cstdlib>

  5. /**
  6.  this test is used to testify how does explicit works on class ' s constructors

  8.  by Aimer 5/11/2015
  9. **/

  11. class obj1
  12. {
  13. public :
  14.    explicit obj1 ( const obj1 & o )
  15.    {
  16.        name = o.name ;
  17.    }
  18.    
  19.    explicit obj1 ( std::string& n )
  20.     {
  21.         name = n ;
  22.     }
  23.     void print ()
  24.     {
  25.         std::cout << " my name is obj1's " << name << std::endl ;
  26.     }
  27. public :
  28.     std::string name ;

  30. } ;

  32. class obj2
  33. {
  34. public :
  35.     obj2( const obj2 &o)
  36.     {
  37.         name = o.name+" copyed " ;
  38.     }
  39.     
  40.     obj2( std::string & n )
  41.     {
  42.         name = n;
  43.     }
  44.     
  45.     void print ()
  46.     {
  47.         std::cout << "my name is obj2's " << name << std::endl ;
  48.     }
  49.     
  50.     private :
  51.     std::string name ;

  53. } ;


  56. int main ( )
  57. {
  58.     std::string name ("kylin") ;
  59.     
  60. std::cout << "ok here we test the explicit obj1's string and non-explicit obj2's string constructor " << std::endl ;
  61.     
  62.     
  63.     /*
  64.     this will arise error , cause the explicit of string parameter constructor
  65.     obj1 obj1_1 = name ;
  66.     obj1_1.print() ;
  67.     */
  68.     
  69.     // this will be ok
  70.     obj2 obj2_1 = name ;
  71.     obj2_1.print () ;
  72.     
  73. std::cout << "---------------------------------------------------------------------------------------------"<<std::endl ;
  74. std::cout << "ok here we test the explicit obj1's string and non-explicit obj2's object & constructors " << std::endl ;
  75.     
  76.     /**
  77.        right ! , following codes will arise error again , because of the explicit again
  78.        
  79.        obj1 obj1_2 = obj1_1 ;
  80.        obj1_2.print () ;
  81.     */
  82.     
  83.     
  84.     obj2 obj2_2 = obj2_1 ;
  85.     obj2_2.print () ;
  86.     
  87.     
  88.     return 0 ;
  89.     
  90. }


点击(此处)折叠或打开

  1. #include <cstdio>
  2. #include <iostream>
  3. #include <cstdlib>

  5. /**
  6.  this test is used to testify how does explicit works on class ' s constructors

  8.  by Aimer 5/11/2015
  9. **/

  11. class obj1
  12. {
  13. public :
  14.    explicit obj1 ( const obj1 & o )
  15.    {
  16.        name = o.name+" copyed " ;
  17.    }
  18.    
  19.    explicit obj1 ( std::string& n )
  20.     {
  21.         name = n ;
  22.     }
  23.     void print ()
  24.     {
  25.         std::cout << " my name is obj1's " << name << std::endl ;
  26.     }
  27. public :
  28.     std::string name ;

  30. } ;

  32. class obj2
  33. {
  34. public :
  35.     obj2( const obj2 &o)
  36.     {
  37.         name = o.name+" copyed " ;
  38.     }
  39.     
  40.     obj2( std::string & n )
  41.     {
  42.         name = n;
  43.     }
  44.     
  45.     void print ()
  46.     {
  47.         std::cout << "my name is obj2's " << name << std::endl ;
  48.     }
  49.     
  50.     private :
  51.     std::string name ;

  53. } ;


  56. int main ( )
  57. {
  58.     std::string name ("kylin") ;
  59.     
  60. std::cout << "ok here we test the explicit obj1's string and non-explicit obj2's string constructor " << std::endl ;
  61.     
  62.     
  63.     /*
  64.     this will arise error , cause the explicit of string parameter constructor
  65.     obj1 obj1_1 = name ;
  66.     obj1_1.print() ;
  67.     */
  68.     
  69.     // this will be ok
  70.     obj2 obj2_1 = name ;
  71.     obj2_1.print () ;
  72.     
  73. std::cout << "---------------------------------------------------------------------------------------------"<<std::endl ;
  74. std::cout << "ok here we test the explicit obj1's string and non-explicit obj2's object & constructors " << std::endl ;
  75.     
  76.     /**
  77.        right ! , following codes will arise error again , because of the explicit
  78.        
  79.        obj1 obj1_2 = obj1_1 ;
  80.        obj1_2.print () ;
  81.     */
  82.     obj1 obj(name) ; // here we creates an obj1 's instance in right rules
  83.     obj.print () ; // if this work , it means every goes well in obj
  84.     
  85.     obj1 obj1_3 (obj) ; // this line goes all right , cause explicit could not detect this , you can use noncopyable from boost
  86.                         // to ban this , may be that's why we will use boost::noncopyable
  87.     obj1_3.print () ;
  88.     
  89.     obj2 obj2_2 = obj2_1 ;
  90.     obj2_2.print () ;
  91.     
  92.     
  93.     return 0 ;
  94.     
  95. }

5. shared_ptr和scoped_ptr 的声明与使用方法
    

点击(此处)折叠或打开

  1. /**
  2. in this test , i will show you how to packed scoped_ptr and shared_ptr by template meta-function and
  3. how to create an instance (both struct and class) by scoped_ptr

  5. by Aimer

  7. 2015/5/11
  8. */

  10. #include <cstdio>
  11. #include <string>
  12. #include <iostream>
  13. #include <cassert>

  15. #include <boost/scoped_ptr.hpp>
  16. #include <boost/shared_ptr.hpp>

  18. template <typename T>
  19. class scopedPtr
  20. {
  21. public :
  22.    typedef boost::scoped_ptr<T> type ;
  23. } ;


  26. template <typename T>
  27. class sharedPtr
  28. {
  29. public :
  30.    typedef boost::shared_ptr<T> type ;
  31. } ;


  34. typedef struct node
  35. {
  36.     node () : file_name(NULL) , fp(NULL)
  37.     {}
  38.     node ( std::string &path ) : file_name ( path )
  39.     {
  40.         fp = fopen (path.c_str() , "r") ;
  41.         
  42.        // assert ( fp ) ;
  43.     }
  44.     
  45.     ~node ()
  46.     {
  47.         std::cout << "release node_t " << file_name << std::endl ;
  48.     }
  49.     
  50.     void print ()
  51.        {
  52.            std::cout << "node open " << file_name << std::endl ;
  53.        }

  55.     std::string file_name ;
  56.     FILE* fp ;
  57.     
  58. }node_t ;

  60. class FileManager
  61. {
  62.     public :
  63.        FileManager () : file_name ( NULL ) , fp( NULL )
  64.        {}
  65.        FileManager ( std::string &name )
  66.        {
  67.           file_name = name ;
  68.           
  69.           fp = fopen ( file_name.c_str() , "r" ) ;
  70.           
  71.           //assert (fp) ;
  72.        }
  73.        
  74.        ~FileManager ()
  75.        {
  76.          std::cout << "release FileManager " << file_name << std::endl ;
  77.        }
  78.        
  79.        void print ()
  80.        {
  81.            std::cout << "FileManager open " << file_name << std::endl ;
  82.        }
  83.     private :
  84.      std::string file_name ;
  85.      FILE *fp ;
  86. } ;


  89. int main ()
  90. {
  91.     std::string name = "aimer.txt" ;
  92.    /*
  93.     FileManager *pFileManger = new FileManager( name ) ;
  94.     node_t* pNode = new node_t (name ) ;
  95.     */

  97. // here is how to create an instance (class/struct type) by boost::scoped_ptr by its constructor
  98.     std::cout << "============================ scoped_ptr tests = =======================================" << std::endl ;
  99.     scopedPtr<FileManager>::type pFileManager ( new FileManager( name ) ) ;
  100.     scopedPtr<node_t>::type pNode ( new node_t(name) ) ;
  101.     
  102.     scopedPtr<FileManager>::type pFileManager1 ;
  103.     scopedPtr<node_t>::type pNode1 ;
  104.     
  105. // here is another way to create an instance (class/struct type) by boost::scoped_ptr by its constructor
  106. // it works well on shared_ptr but doesn't work well on scoped_ptr
  107. // std::string name_ = "kokia.txt" ;
  108.     
  109. // pFileManager1 = scopedPtr<FileManager> ( new FileManager (name_) ) ;
  110. // pNode1 = scopedPtr<node_t>::type ( new node_t (name_)) ;


  113. // here is how to use boost::scoped_ptr to call the instance's function
  114.     
  115.     pFileManager->print () ;
  116.     
  117.     pNode->print () ;
  118.     
  119.     std::cout << "=================  shared_ptr tests ===========================" << std::endl ;
  120.     
  121.     std::string name1 ("shared_ptr ---> kylin_zhang ") ;
  122.     sharedPtr<FileManager>::type spFileManager( new FileManager(name1)) ;
  123.     sharedPtr<node_t>::type spNode ( new node_t( name1 ) ) ;

  125.     spFileManager->print() ;
  126.     spNode->print () ;
  127.     
  128.     // here we will test another way to create instances (class / struct ) by shared ptr
  129.     
  130.     sharedPtr<FileManager>::type spFileManager1 ;
  131.     sharedPtr<node_t>::type spNode1 ;
  132.     
  133.     std::string name2("shared_ptr ----> naruto ") ;
  134.     
  135.     spFileManager1 = sharedPtr<FileManager>::type ( new FileManager ( name2)) ;
  136.     spFileManager1->print () ;
  137.     
  138.     spNode1 = sharedPtr<node_t>::type ( new node_t ( name2) ) ;
  139.     spNode1->print () ;
  140.     
  141.     /*
  142.     here we got another conclusion :
  143.     boost::shared_ptr support the second way to create an instance (struct/class)
  144.     but the boost::scoped_ptr not
  145.     
  146.     it must have soemthing to do with the authority transfer of scoped_ptr
  147.     */
  148.     
  149.     
  150.     std::cout << "============== === destructor call  == ==========================" << std::endl ;
  151.     std::cout << " next you will see , before the end of the program scoped_ptr will call the 
  152.                     corresponding destruct methods" <<std::endl ;
  153.     
  154.     
  155.     return 0 ;
  156. }
  

6.关于 shared_ptr 中的引用计数的使用实例
 
 

点击(此处)折叠或打开

  1. #include <cstdio>
  2. #include <iostream>

  4. #include <boost/shared_ptr.hpp>

  6. template <typename T>
  7. class sharedPtr
  8. {
  9.     public :
  10.      typedef boost::shared_ptr<T> type ;
  11. } ;

  13. typedef struct node
  14. {
  15.     std::string name ;
  16.     node () : name(NULL)
  17.     {}
  18.     node ( std::string &n ) : name (n )
  19.     {}
  20.     
  21.     ~node ()
  22.     {
  23.         std::cout << "release node " << name << std::endl ;
  24.     }
  25.         
  26.     void print ()
  27.     {
  28.         std::cout << "node name " << name << std::endl;
  29.     }
  30.     
  31. } node_t ;


  34. template <typename T>
  35. class shared_node
  36. {
  37. public :
  38.     shared_node ( typename sharedPtr<T>::type& n ) :node ( n )
  39.     {
  40.          // n->print () ;
  41.         
  42.     }
  43.   /*
  44.     this constructor will not change the counter , because , it re-new an object
  45.     instead of create a pointer lets multi-pointers point to a same object's space
  46.     
  47.     shared_node ( typename sharedPtr<T>::type n ) : node ( new T( *n) )
  48.     {
  49.       // node = typename sharedPtr<T>::type ( new T(*n) ) ; // counter == 1
  50.     }
  51. */
  52.     void print ()
  53.     {
  54.         std::cout<< "reference counter : " << node.use_count() << std::endl ;
  55.         node->print () ;
  56.     }
  57. private :
  58.     typename sharedPtr<T>::type node ;
  59. } ;


  62. template <typename T>
  63. void print_func ( typename sharedPtr<T>::type n)
  64. {
  65.     std::cout << "reference counter :" << n.use_count() << std::endl ;
  66.     n->print () ;
  67. }

  69. int main ()
  70. {
  71.     std::string name ("kylin_zhang") ;
  72.     
  73.     std::cout << "================= print_func shows=======================" <<std::endl ;
  74.     
  75.     sharedPtr<node_t>::type p ( new node_t (name) ) ; // use counter = 1
  76.     
  77.     print_func<node_t>(p) ; // use counter = 2 , after get out of method , counter = 1
  78.     
  79.     std::cout << "================= shared_node print shows=======================" <<std::endl ;
  80.     
  81.  // sharedPtr<shared_node<node_t> >::type s1(p) , s2(p) ;
  82.     
  83.    shared_node<node_t> s1(p) , s2(p) ;

  85.    std::cout << "p 's use counter " << p.use_count () << std::endl; // p's counter = 3
  86.    
  87.    s1.print () ; // counter =1
  88.   
  89.    s2.print () ; // s2's p's counter =1
  90.    
  91.    
  92.    while ( p.use_count() != 0 )
  93.     {
  94.         std::cout << "use counter " << p.use_count() << std::endl ;
  95.         p.reset() ;
  96.         
  97.         // theory until p's use_counter == 0 , will p call delete method to release the space , if use_counter != 0 only executing use_counter-- operation
  98.         // but , in practice , p.reset() once , p.use_count() == 0 , what this hell ? i do not clear
  99.     }
  100.     std::cout << "================= destructor shows=======================" <<std::endl ;
  101.     return 0 ;
  102. }
end
on line codes reference :

转让 


转让 adds swap 


adds explicity but without noncopyable 


adds other detail 


usage of scoped_ptr and shared_ptr


final usage of scoped_ptr and shared_ptr :


something about reference counter of shared_ptr 
阅读(3933) | 评论(0) | 转发(0) |
1

上一篇：[c++]基于 boost 模板编程的缓冲池实现

下一篇：[python]使用 python 编写日志模块

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6