Boost.Interprocess使用手册翻译之十一：所有权的智能指针（Ownership smart pointers）

十一．所有权的智能指针

浸入式指针（Intrusive pointer） 作用域指针（Scoped pointer） 共享指针和弱指针（Shared pointer and weak pointer） 唯一指针（Unique pointer）

当处理资源时，C++使用者知道所有权智能指针的重要性。Boost提供了广泛的这些类型的指针：intrusive_ptr<>, scoped_ptr<>,shared_ptr<>...

当构建复杂的共享内存/内存映射文件结构时，程序员可能会想使用这些智能指针的优势。问题是Boost和C++TR1智能指针并不能在共享内存中使用。原因是这些指针包含了原始指针并且使用了虚函数，因此如果你想在共享内存中放置数据，那是不可能的。虚函数限制使甚至使用Boost.Interprocess智能指针也不能获得相同等级的Boost和TR1功能。

进程间所有权智能指针主要是“包含智能指针的智能指针”，因此我们能够指定它们包含的指针类型。

浸入式指针

boost::interprocess::intrusive_ptr 是 boost::intrusive_ptr<>的泛化，它允许非原始指针做为浸入式指针的成员。对于著名的boost::intrusive_ptr ，我们必须指定指针对象类型，但是我们也必须指定存储在intrusive_ptr中的指针类型：

//!The intrusive_ptr class template stores a pointer to an object
//!with an embedded reference count. intrusive_ptr is parameterized on
//!T (the type of the object pointed to) and VoidPointer(a void pointer type 
//!that defines the type of pointer that intrusive_ptr will store).
//!intrusive_ptr<T, void *> defines a class with a T* member whereas
//!intrusive_ptr<T, offset_ptr<void> > defines a class with a offset_ptr<T> member.
//!Relies on unqualified calls to:
//! 
//!void intrusive_ptr_add_ref(T * p);
//!void intrusive_ptr_release(T * p);
//!
//!with (p != 0)
//!
//!The object is responsible for destroying itself.
template<class T, class VoidPointer>
class intrusive_ptr;

因此boost::interprocess::intrusive_ptr<MyClass, void*>与boost::intrusive_ptr<MyClass>等价。但如果我们想在共享内存中放置intrusive_ptr，我们必须指定一个相对指针类型，比如boost::interprocess::intrusive_ptr<MyClass, boost::interprocess::offset_ptr<void> >

#include <boost/interprocess/managed_shared_memory.hpp>
#include <boost/interprocess/smart_ptr/intrusive_ptr.hpp>
 
using namespace boost::interprocess;
 
namespace N {
 
//A class that has an internal reference count
class reference_counted_class
{
   private:
   //Non-copyable
   reference_counted_class(const reference_counted_class  &);
   //Non-assignable
   reference_counted_class & operator=(const reference_counted_class &);
   //A typedef to save typing
   typedef managed_shared_memory::segment_manager segment_manager;
   //This is the reference count
   unsigned int m_use_count;
   //The segment manager allows deletion from shared memory segment
   offset_ptr<segment_manager> mp_segment_manager;
 
   public:
   //Constructor
   reference_counted_class(segment_manager *s_mngr)
   : m_use_count(0), mp_segment_manager(s_mngr){}
   //Destructor
   ~reference_counted_class(){}
 
   public:
   //Returns the reference count
   unsigned int use_count() const
   {  return m_use_count;   }
 
   //Adds a reference
   inline friend void intrusive_ptr_add_ref(reference_counted_class * p)
   {  ++p->m_use_count; }
 
   //Releases a reference
   inline friend void intrusive_ptr_release(reference_counted_class * p)
   {  if(--p->m_use_count == 0)  p->mp_segment_manager->destroy_ptr(p); }
};
 
}  //namespace N {
 
//A class that has an intrusive pointer to reference_counted_class
class intrusive_ptr_owner
{
   typedef intrusive_ptr<N::reference_counted_class,
                           offset_ptr<void> > intrusive_ptr_t;
   intrusive_ptr_t m_intrusive_ptr;
 
   public:
   //Takes a pointer to the reference counted class
   intrusive_ptr_owner(N::reference_counted_class *ptr)
      : m_intrusive_ptr(ptr){}
};
 
int main()
{
   //Remove shared memory on construction and destruction
   struct shm_remove
   {
      shm_remove() { shared_memory_object::remove("MySharedMemory"); }
      ~shm_remove(){ shared_memory_object::remove("MySharedMemory"); }
   } remover;
 
   //Create shared memory
   managed_shared_memory shmem(create_only, "MySharedMemory", 10000);
 
   //Create the unique reference counted object in shared memory
   N::reference_counted_class *ref_counted =
      shmem.construct<N::reference_counted_class>
         ("ref_counted")(shmem.get_segment_manager());
 
   //Create an array of ten intrusive pointer owners in shared memory
   intrusive_ptr_owner *intrusive_owner_array =
      shmem.construct<intrusive_ptr_owner>
         (anonymous_instance)[10](ref_counted);
 
   //Now test that reference count is ten
   if(ref_counted->use_count() != 10)
      return 1;
 
   //Now destroy the array of intrusive pointer owners
   //This should destroy every intrusive_ptr and because of
   //that reference_counted_class will be destroyed
   shmem.destroy_ptr(intrusive_owner_array);
 
   //Now the reference counted object should have been destroyed
   if(shmem.find<intrusive_ptr_owner>("ref_counted").first)
      return 1;
   //Success!
   return 0;
}

作用域指针

boost::interprocess::scoped_ptr<>是boost::scoped_ptr<>的大哥，它增加了一个定制的删除器用于指定如何销毁传入至scoped_ptr的指针。并且，删除器的指针类型定义也将指定被scoped_ptr存储的指针类型。

//!scoped_ptr stores a pointer to a dynamically allocated object. 
//!The object pointed to is guaranteed to be deleted, either on destruction
//!of the scoped_ptr, or via an explicit reset. The user can avoid this
//!deletion using release().
//!scoped_ptr is parameterized on T (the type of the object pointed to) and 
//!Deleter (the functor to be executed to delete the internal pointer).
//!The internal pointer will be of the same pointer type as typename 
//!Deleter::pointer type (that is, if typename Deleter::pointer is 
//!offset_ptr<void>, the internal pointer will be offset_ptr<T>).
template<class T, class Deleter>
class scoped_ptr;

scoped_ptr<>在执行异常回滚时是得心应手的：如果抛出异常或我们在scoped_ptr<>作用域内调用了return，删除器将自动调用以便删除器能被认为是一个回滚函数。如果一切顺利，当scoped_ptr超出作用域时，我们调用release()成员函数来避免回滚。

#include <boost/interprocess/managed_shared_memory.hpp>
#include <boost/interprocess/smart_ptr/scoped_ptr.hpp>
 
using namespace boost::interprocess;
 
class my_class
{};
 
class my_exception
{};
 
//A functor that destroys the shared memory object
template<class T>
class my_deleter
{
   private:
   //A typedef to save typing
   typedef managed_shared_memory::segment_manager segment_manager;
   //This my_deleter is created in the stack, not in shared memory,
   //so we can use raw pointers
   segment_manager *mp_segment_manager;
 
   public:
   //This typedef will specify the pointer type that
   //scoped_ptr will store
   typedef T *pointer;
   //Constructor
   my_deleter(segment_manager *s_mngr)
   : mp_segment_manager(s_mngr){}
 
   void operator()(pointer object_to_delete)
   {  mp_segment_manager->destroy_ptr(object_to_delete);  }
};
 
int main ()
{
   //Create shared memory
   //Remove shared memory on construction and destruction
   struct shm_remove
   {
      shm_remove() { shared_memory_object::remove("MySharedMemory"); }
      ~shm_remove(){ shared_memory_object::remove("MySharedMemory"); }
   } remover;
 
   managed_shared_memory shmem(create_only, "MySharedMemory", 10000);
 
   //In the first try, there will be no exceptions
   //in the second try we will throw an exception
   for(int i = 0; i < 2; ++i){
      //Create an object in shared memory
      my_class * my_object = shmem.construct<my_class>("my_object")();
      my_class * my_object2 = shmem.construct<my_class>(anonymous_instance)();
      shmem.destroy_ptr(my_object2);
 
      //Since the next shared memory allocation can throw
      //assign it to a scoped_ptr so that if an exception occurs
      //we destroy the object automatically
      my_deleter<my_class> d(shmem.get_segment_manager());
 
      try{
         scoped_ptr<my_class, my_deleter<my_class> > s_ptr(my_object, d);
         //Let's emulate a exception capable operation
         //In the second try, throw an exception
         if(i == 1){
            throw(my_exception());
         }
         //If we have passed the dangerous zone
         //we can release the scoped pointer
         //to avoid destruction
         s_ptr.release();
      }
      catch(const my_exception &){}
      //Here, scoped_ptr is destroyed
      //so it we haven't thrown an exception
      //the object should be there, otherwise, destroyed
      if(i == 0){
         //Make sure the object is alive
         if(!shmem.find<my_class>("my_object").first){
            return 1;
         }
         //Now we can use it and delete it manually
         shmem.destroy<my_class>("my_object");
      }
      else{
         //Make sure the object has been deleted
         if(shmem.find<my_class>("my_object").first){
            return 1;
         }
      }
   }
   return 0;
}

共享指针和弱指针

Boost.Interprocess也提供了在托管共享内存或映射文件中创建非浸入式引用计数（non-intrusive reference-counted）对象的可能性。

与boost::shared_ptr不同，由于映射片段的限制，当提供用户自定义的分配器和删除器时boost::interprocess::shared_ptr不能使用虚函数来维护同样的共享指针类型。分配器和删除器是共享指针的模板参数。

由于引用计数和其他shared_ptr 需要的辅助数据也必须在托管内存片段中被创建，并且删除器必须从片段中删除对象，因此当构建一个非空的shared_ptr 实例时，用户必须指定一个分配器对象和删除器对象，就好像Boost.Interprocess容器需要在它们构造函数中传入分配器一样。

下面是shared_ptr的声明：

template<class T, class VoidAllocator, class Deleter>
class shared_ptr;

• T是指向的类型的类型。
• VoidAllocator是用来分配辅助成员例如引用计数、删除器等的分配器。分配器的内部指针类型定义将决定shared_ptr内部使用的指针类型，因此分配器定义指针offset_ptr<void>将使得所有shared_ptr使用的内部指针也是相对指针。参考boost::interprocess::allocator以获取工作分配器的详细信息。
• Deleter是函数对象，当对对象的最后一个引用被销毁后，它被用来销毁指向的对象。删除器函数将使用一个与VoidAllocator::pointer定义的空指针一样的T指针。参考boost::interprocess::deleter 以获取从一个托管内存片段上删除一个对象的通常的删除器的详细信息。

采用正确指定的参数，Boost.Interprocess用户能够创建对象在共享内存中，它承载了指向此共享内存中其他对象的共享指针，获得引用计数的好处。让我们看看如何在一个托管共享内存中创建一个共享指针：

#include <boost/interprocess/managed_shared_memory.hpp>
#include <boost/interprocess/smart_ptr/shared_ptr.hpp>
#include <boost/interprocess/allocators/allocator.hpp>
#include <boost/interprocess/smart_ptr/deleter.hpp>
#include <cassert>
 
using namespace boost::interprocess;
 
//This is type of the object we want to share
class MyType
{};
 
typedef managed_shared_memory::segment_manager segment_manager_type;
typedef allocator<void, segment_manager_type>  void_allocator_type;
typedef deleter<MyType, segment_manager_type>  deleter_type;
typedef shared_ptr<MyType, void_allocator_type, deleter_type> my_shared_ptr;
 
int main ()
{
   //Remove shared memory on construction and destruction
   struct shm_remove
   {
      shm_remove() { shared_memory_object::remove("MySharedMemory"); }
      ~shm_remove(){ shared_memory_object::remove("MySharedMemory"); }
   } remover;
 
   managed_shared_memory segment(create_only, "MySharedMemory", 4096);
 
   //Create a shared pointer in shared memory
   //pointing to a newly created object in the segment
   my_shared_ptr &shared_ptr_instance =
      *segment.construct<my_shared_ptr>("shared ptr")
         //Arguments to construct the shared pointer
         ( segment.construct<MyType>("object to share")()      //object to own
         , void_allocator_type(segment.get_segment_manager())  //allocator
         , deleter_type(segment.get_segment_manager())         //deleter
         );
   assert(shared_ptr_instance.use_count() == 1);
 
   //Destroy "shared ptr". "object to share" will be automatically destroyed
   segment.destroy_ptr(&shared_ptr_instance);
 
   return 0;
}

boost::interprocess::shared_ptr是非常弹性和可配置的（例如，我们能指定分配器和删除器），但是如上示，在托管内存片段上创建共享指针需要太多代码了。

为简化使用，boost::interprocess::shared_ptr头文件提供了一个共享指针定义帮助类（managed_shared_ptr）和一个函数（make_managed_shared_ptr）来简化从一个分配在托管内存片段上的类型构建一个共享指针，它带一个在托管内存片段上分配引用计数的分配器和一个从片段中删除对象的删除器。

这些工具将使用Boost.Interprocess分配器（boost::interprocess::allocator）和删除器（boost::interprocess::deleter）来做它们的工作。之前的共享指针定义能够被简化成如下：

typedef managed_shared_ptr<MyType, managed_shared_memory>::type my_shared_ptr;

并且共享指针的创建能够简化为：

my_shared_ptr sh_ptr = make_managed_shared_ptr
   (segment.construct<MyType>("object to share")(), segment);

Boost.Interprocess也提供了一个弱指针名为weak_ptr （它相对应的工具为 managed_weak_ptr和make_managed_weak_ptr）来对shared_ptr拥有的对象执行非所属观察。

现在，让我们看看一个使用shared_ptr和weak_ptr的详细例子：

#include <boost/interprocess/managed_mapped_file.hpp>
#include <boost/interprocess/smart_ptr/shared_ptr.hpp>
#include <boost/interprocess/smart_ptr/weak_ptr.hpp>
#include <cassert>
 
using namespace boost::interprocess;
 
//This is type of the object we want to share
struct type_to_share
{};
 
//This is the type of a shared pointer to the previous type
//that will be built in the mapped file
typedef managed_shared_ptr<type_to_share, managed_mapped_file>::type shared_ptr_type;
typedef managed_weak_ptr<type_to_share, managed_mapped_file>::type   weak_ptr_type;
 
//This is a type holding a shared pointer
struct shared_ptr_owner
{
   shared_ptr_owner(const shared_ptr_type &other_shared_ptr)
      : shared_ptr_(other_shared_ptr)
   {}
 
   shared_ptr_owner(const shared_ptr_owner &other_owner)
      : shared_ptr_(other_owner.shared_ptr_)
   {}
 
   shared_ptr_type shared_ptr_;
   //...
};
 
int main ()
{
   //Define file names
   const char *MappedFile  = "MyMappedFile";
 
   //Destroy any previous file with the name to be used.
   struct file_remove
   {
      file_remove(const char *MappedFile)
         : MappedFile_(MappedFile) { file_mapping::remove(MappedFile_); }
      ~file_remove(){ file_mapping::remove(MappedFile_); }
      const char *MappedFile_;
   } remover(MappedFile);
   {
      managed_mapped_file file(create_only, MappedFile, 65536);
 
      //Construct the shared type in the file and
      //pass ownership to this local shared pointer
      shared_ptr_type local_shared_ptr = make_managed_shared_ptr
         (file.construct<type_to_share>("object to share")(), file);
      assert(local_shared_ptr.use_count() == 1);
 
      //Share ownership of the object between local_shared_ptr and a new "owner1"
      shared_ptr_owner *owner1 =
         file.construct<shared_ptr_owner>("owner1")(local_shared_ptr);
      assert(local_shared_ptr.use_count() == 2);
 
      //local_shared_ptr releases object ownership
      local_shared_ptr.reset();
      assert(local_shared_ptr.use_count() == 0);
      assert(owner1->shared_ptr_.use_count() == 1);
 
      //Share ownership of the object between "owner1" and a new "owner2"
      shared_ptr_owner *owner2 =
         file.construct<shared_ptr_owner>("owner2")(*owner1);
      assert(owner1->shared_ptr_.use_count() == 2);
      assert(owner2->shared_ptr_.use_count() == 2);
      assert(owner1->shared_ptr_.get() == owner2->shared_ptr_.get());
 
      //The mapped file is unmapped here. Objects have been flushed to disk
   }
   {
      //Reopen the mapped file and find again all owners
      managed_mapped_file file(open_only, MappedFile);
 
      shared_ptr_owner *owner1 = file.find<shared_ptr_owner>("owner1").first;
      shared_ptr_owner *owner2 = file.find<shared_ptr_owner>("owner2").first;
      assert(owner1 && owner2);
 
      //Check everything is as expected
      assert(file.find<type_to_share>("object to share").first != 0);
      assert(owner1->shared_ptr_.use_count() == 2);
      assert(owner2->shared_ptr_.use_count() == 2);
      assert(owner1->shared_ptr_.get() == owner2->shared_ptr_.get());
 
      //Now destroy one of the owners, the reference count drops.
      file.destroy_ptr(owner1);
      assert(owner2->shared_ptr_.use_count() == 1);
 
      //Create a weak pointer
      weak_ptr_type local_observer1(owner2->shared_ptr_);
      assert(local_observer1.use_count() == owner2->shared_ptr_.use_count());
 
      {  //Create a local shared pointer from the weak pointer
      shared_ptr_type local_shared_ptr = local_observer1.lock();
      assert(local_observer1.use_count() == owner2->shared_ptr_.use_count());
      assert(local_observer1.use_count() == 2);
      }
 
      //Now destroy the remaining owner. "object to share" will be destroyed
      file.destroy_ptr(owner2);
      assert(file.find<type_to_share>("object to share").first == 0);
 
      //Test observer
      assert(local_observer1.expired());
      assert(local_observer1.use_count() == 0);
 
      //The reference count will be deallocated when all weak pointers
      //disappear. After that, the file is unmapped.
   }
   return 0;
}

一般来说，Boost.Interprocess的shared_ptr和weak_ptr使用和它们对应的boost::shared_ptr和boost::weak_ptr是非常类似的，但它们需要更多的模板参数和更多的运行时参数在其构造函数中。

就好像boost::shared_ptr能被存储在STL容器中一样，shared_ptr也能被存储在Boost.Interprocess容器中。

如果一个程序员仅使用shared_ptr来插入动态构建于托管内存片段上的对象至容器中，但不需要与其他对象共享此对象的所有权，则unique_ptr是一个更快速和易用的替代品。

唯一指针

唯一所有权智能指针是非常有用的，它将程序员从非共享对象手工资源中解放出来。Boost.Interprocess的unique_ptr与scoped_ptr很类似，但它是活动的并且能够很容易的插入至Boost.Interprocess容器。这是唯一指针类声明：

template <class T, class D>
class unique_ptr;

• T是unique_ptr指向的对象的类型。
• D是删除器，当唯一指针被销毁时（并且如果还拥有对象的所有权），它将删除unique_ptr指向的类型对象。如果删除器定义了一个内部指针类型，unique_ptr将使用一个相同类型的内部指针。因此，如果D::pointer是offset_ptr<T>，则唯一指针将存储一个相对指针而不是原始指针。这允许放置unique_ptr在共享内存和内存映射文件中。

unique_ptr能释放存储的指针的所有权，因此它也能被用做一个回滚函数。此类的一个主要特性是不可拷贝性，仅能移动。当一个唯一指针被移动至另一个，则指针的所有权从源唯一指针转移至目标唯一指针。如果目标唯一指针拥有一个对象，则在拥有新对象之前，原对象先被删除。

unique_ptr也提供了辅助类型用于简化定义和构建唯一指针，它能被放置在托管内存片段中，并且能从片段中正确删除拥有的对象：managed_unique_ptr和make_managed_unique_ptr工具。

下面我们看一个使用unique_ptr的例子，包括创建这些对象的容器：

#include <boost/interprocess/managed_mapped_file.hpp>
#include <boost/interprocess/smart_ptr/unique_ptr.hpp>
#include <boost/interprocess/containers/vector.hpp>
#include <boost/interprocess/containers/list.hpp>
#include <boost/interprocess/allocators/allocator.hpp>
#include <cassert>
 
using namespace boost::interprocess;
 
//This is type of the object we'll allocate dynamically
struct MyType
{
   MyType(int number = 0)
      :  number_(number)
   {}
   int number_;
};
 
//This is the type of a unique pointer to the previous type
//that will be built in the mapped file
typedef managed_unique_ptr<MyType, managed_mapped_file>::type unique_ptr_type;
 
//Define containers of unique pointer. Unique pointer simplifies object management
typedef vector
   < unique_ptr_type
   , allocator<unique_ptr_type, managed_mapped_file::segment_manager>
   > unique_ptr_vector_t;
 
typedef list
   < unique_ptr_type
   , allocator<unique_ptr_type, managed_mapped_file::segment_manager>
   > unique_ptr_list_t;
 
int main ()
{
   //Define file names
   const char *MappedFile  = "MyMappedFile";
 
   //Destroy any previous file with the name to be used.
   struct file_remove
   {
      file_remove(const char *MappedFile)
         : MappedFile_(MappedFile) { file_mapping::remove(MappedFile_); }
      ~file_remove(){ file_mapping::remove(MappedFile_); }
      const char *MappedFile_;
   } remover(MappedFile);
   {
      managed_mapped_file file(create_only, MappedFile, 65536);
 
      //Construct an object in the file and
      //pass ownership to this local unique pointer
      unique_ptr_type local_unique_ptr (make_managed_unique_ptr
         (file.construct<MyType>("unique object")(), file));
      assert(local_unique_ptr.get() != 0);
 
      //Reset the unique pointer. The object is automatically destroyed
      local_unique_ptr.reset();
      assert(file.find<MyType>("unique object").first == 0);
 
      //Now create a vector of unique pointers
      unique_ptr_vector_t *unique_vector =
         file.construct<unique_ptr_vector_t>("unique vector")(file.get_segment_manager());
 
      //Speed optimization
      unique_vector->reserve(100);
 
      //Now insert all values
      for(int i = 0; i < 100; ++i){
         unique_ptr_type p(make_managed_unique_ptr(file.construct<MyType>(anonymous_instance)(i), file));
         unique_vector->push_back(boost::move(p));
         assert(unique_vector->back()->number_ == i);
      }
 
      //Now create a list of unique pointers
      unique_ptr_list_t *unique_list =
         file.construct<unique_ptr_list_t>("unique list")(file.get_segment_manager());
 
      //Pass ownership of all values to the list
      for(int i = 99; !unique_vector->empty(); --i){
         unique_list->push_front(boost::move(unique_vector->back()));
         //The unique ptr of the vector is now empty...
         assert(unique_vector->back() == 0);
         unique_vector->pop_back();
         //...and the list has taken ownership of the value
         assert(unique_list->front() != 0);
         assert(unique_list->front()->number_ == i);
      }
      assert(unique_list->size() == 100);
 
      //Now destroy the empty vector.
      file.destroy_ptr(unique_vector);
      //The mapped file is unmapped here. Objects have been flushed to disk
   }
   {
      //Reopen the mapped file and find again the list
      managed_mapped_file file(open_only, MappedFile);
 
      unique_ptr_list_t   *unique_list =
         file.find<unique_ptr_list_t>("unique list").first;
      assert(unique_list);
      assert(unique_list->size() == 100);
 
      unique_ptr_list_t::const_iterator list_it = unique_list->begin();
      for(int i = 0; i < 100; ++i, ++list_it){
         assert((*list_it)->number_ == i);
      }
 
      //Now destroy the list. All elements will be automatically deallocated.
      file.destroy_ptr(unique_list);
   }
   return 0;
}