boost-react-native-bundle

<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> <title>Ownership smart pointers</title> <link rel="stylesheet" href="../../../doc/src/boostbook.css" type="text/css"> <meta name="generator" content="DocBook XSL Stylesheets V1.78.1"> <link rel="home" href="../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset"> <link rel="up" href="../interprocess.html" title="Chapter 14. Boost.Interprocess"> <link rel="prev" href="streams.html" title="Direct iostream formatting: vectorstream and bufferstream"> <link rel="next" href="architecture.html" title="Architecture and internals"> </head> <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> <table cellpadding="2" width="100%"><tr> <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td> <td align="center"><a href="../../../index.html">Home</a></td> <td align="center"><a href="../../../libs/libraries.htm">Libraries</a></td> <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> <td align="center"><a href="../../../more/index.htm">More</a></td> </tr></table> <hr> <div class="spirit-nav"> <a accesskey="p" href="streams.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../interprocess.html"><img src="../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="architecture.html"><img src="../../../doc/src/images/next.png" alt="Next"></a> </div> <div class="section"> <div class="titlepage"><div><div><h2 class="title" style="clear: both"> <a name="interprocess.interprocess_smart_ptr"></a><a class="link" href="interprocess_smart_ptr.html" title="Ownership smart pointers">Ownership smart pointers</a> </h2></div></div></div> <div class="toc"><dl class="toc"> <dt><a href="interprocess_smart_ptr.html#interprocess.interprocess_smart_ptr.intrusive_ptr">Intrusive pointer</a></dt> <dt><a href="interprocess_smart_ptr.html#interprocess.interprocess_smart_ptr.scoped_ptr">Scoped pointer</a></dt> <dt><a href="interprocess_smart_ptr.html#interprocess.interprocess_smart_ptr.shared_ptr">Shared pointer and weak pointer</a></dt> <dt><a href="interprocess_smart_ptr.html#interprocess.interprocess_smart_ptr.unique_ptr">Unique pointer</a></dt> </dl></div> C++ users know the importance of ownership smart pointers when dealing with resources. Boost offers a wide range of such type of pointers: <code class="computeroutput">intrusive_ptr<></code>, <code class="computeroutput">scoped_ptr<></code>, <code class="computeroutput">shared_ptr<></code>... When building complex shared memory/memory mapped files structures, programmers would like to use also the advantages of these smart pointers. The problem is that Boost and C++ TR1 smart pointers are not ready to be used for shared memory. The cause is that those smart pointers contain raw pointers and they use virtual functions, something that is not possible if you want to place your data in shared memory. The virtual function limitation makes even impossible to achieve the same level of functionality of Boost and TR1 with Boost.Interprocess smart pointers. Interprocess ownership smart pointers are mainly "smart pointers containing smart pointers", so we can specify the pointer type they contain. <div class="section"> <div class="titlepage"><div><div><h3 class="title"> <a name="interprocess.interprocess_smart_ptr.intrusive_ptr"></a><a class="link" href="interprocess_smart_ptr.html#interprocess.interprocess_smart_ptr.intrusive_ptr" title="Intrusive pointer">Intrusive pointer</a> </h3></div></div></div> <code class="computeroutput"><a class="link" href="../boost/interprocess/intrusive_ptr.html" title="Class template intrusive_ptr">boost::interprocess::intrusive_ptr</a></code> is the generalization of <code class="computeroutput">boost::intrusive_ptr<></code> to allow non-raw pointers as intrusive pointer members. As the well-known <code class="computeroutput">boost::intrusive_ptr</code> we must specify the pointee type but we also must also specify the pointer type to be stored in the intrusive_ptr: <pre class="programlisting">//!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; </pre> So <code class="computeroutput">boost::interprocess::intrusive_ptr<MyClass, void*></code> is equivalent to <code class="computeroutput">boost::intrusive_ptr<MyClass></code>. But if we want to place the intrusive_ptr in shared memory we must specify a relative pointer type like <code class="computeroutput">boost::interprocess::intrusive_ptr<MyClass, boost::interprocess::offset_ptr<void> ></code> <pre class="programlisting">#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; } </pre> </div> <div class="section"> <div class="titlepage"><div><div><h3 class="title"> <a name="interprocess.interprocess_smart_ptr.scoped_ptr"></a><a class="link" href="interprocess_smart_ptr.html#interprocess.interprocess_smart_ptr.scoped_ptr" title="Scoped pointer">Scoped pointer</a> </h3></div></div></div> <code class="computeroutput">boost::interprocess::scoped_ptr<></code> is the big brother of <code class="computeroutput">boost::scoped_ptr<></code>, which adds a custom deleter to specify how the pointer passed to the scoped_ptr must be destroyed. Also, the <code class="computeroutput">pointer</code> typedef of the deleter will specify the pointer type stored by scoped_ptr. <pre class="programlisting">//!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; </pre> <code class="computeroutput">scoped_ptr<></code> comes handy to implement rollbacks with exceptions: if an exception is thrown or we call <code class="computeroutput">return</code> in the scope of <code class="computeroutput">scoped_ptr<></code> the deleter is automatically called so that the deleter can be considered as a rollback function. If all goes well, we call <code class="computeroutput">release()</code> member function to avoid rollback when the <code class="computeroutput">scoped_ptr</code> goes out of scope. <pre class="programlisting">#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; } </pre> </div> <div class="section"> <div class="titlepage"><div><div><h3 class="title"> <a name="interprocess.interprocess_smart_ptr.shared_ptr"></a><a class="link" href="interprocess_smart_ptr.html#interprocess.interprocess_smart_ptr.shared_ptr" title="Shared pointer and weak pointer">Shared pointer and weak pointer</a> </h3></div></div></div> Boost.Interprocess also offers the possibility of creating non-intrusive reference-counted objects in managed shared memory or mapped files. Unlike <a href="http://www.boost.org/libs/smart_ptr/shared_ptr.htm" target="_top">boost::shared_ptr</a>, due to limitations of mapped segments <code class="computeroutput"><a class="link" href="../boost/interprocess/shared_ptr.html" title="Class template shared_ptr">boost::interprocess::shared_ptr</a></code> cannot take advantage of virtual functions to maintain the same shared pointer type while providing user-defined allocators and deleters. The allocator and the deleter are template parameters of the shared pointer. Since the reference count and other auxiliary data needed by <code class="computeroutput"><a class="link" href="../boost/interprocess/shared_ptr.html" title="Class template shared_ptr">shared_ptr</a></code> must be created also in the managed segment, and the deleter has to delete the object from the segment, the user must specify an allocator object and a deleter object when constructing a non-empty instance of <code class="computeroutput"><a class="link" href="../boost/interprocess/shared_ptr.html" title="Class template shared_ptr">shared_ptr</a></code>, just like Boost.Interprocess containers need to pass allocators in their constructors. Here is the declaration of <code class="computeroutput"><a class="link" href="../boost/interprocess/shared_ptr.html" title="Class template shared_ptr">shared_ptr</a></code>: <pre class="programlisting">template<class T, class VoidAllocator, class Deleter> class shared_ptr; </pre> <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "> <li class="listitem"> T is the type of the pointed type. </li> <li class="listitem"> VoidAllocator is the allocator to be used to allocate auxiliary elements such as the reference count, the deleter... The internal <code class="computeroutput">pointer</code> typedef of the allocator will determine the type of pointer that shared_ptr will internally use, so allocators defining <code class="computeroutput">pointer</code> as <code class="computeroutput">offset_ptr<void></code> will make all internal pointers used by <code class="computeroutput">shared_ptr</code> to be also relative pointers. See <code class="computeroutput"><a class="link" href="../boost/interprocess/allocator.html" title="Class template allocator">boost::interprocess::allocator</a></code> for a working allocator. </li> <li class="listitem"> Deleter is the function object that will be used to destroy the pointed object when the last reference to the object is destroyed. The deleter functor will take a pointer to T of the same category as the void pointer defined by <code class="computeroutput">VoidAllocator::pointer</code>. See <code class="computeroutput"><a class="link" href="../boost/interprocess/deleter.html" title="Class template deleter">boost::interprocess::deleter</a></code> for a generic deleter that erases a object from a managed segment. </li> </ul></div> With correctly specified parameters, Boost.Interprocess users can create objects in shared memory that hold shared pointers pointing to other objects also in shared memory, obtaining the benefits of reference counting. Let's see how to create a shared pointer in a managed shared memory: <pre class="programlisting">#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; } </pre> <code class="computeroutput"><a class="link" href="../boost/interprocess/shared_ptr.html" title="Class template shared_ptr">boost::interprocess::shared_ptr</a></code> is very flexible and configurable (we can specify the allocator and the deleter, for example), but as shown the creation of a shared pointer in managed segments need too much typing. To simplify this usage, <code class="computeroutput"><a class="link" href="../boost/interprocess/shared_ptr.html" title="Class template shared_ptr">boost::interprocess::shared_ptr</a></code> header offers a shared pointer definition helper class (<code class="computeroutput"><a class="link" href="../boost/interprocess/managed_shared_ptr.html" title="Struct template managed_shared_ptr">managed_shared_ptr</a></code>) and a function (<code class="computeroutput"><a class="link" href="../boost/interprocess/make_managed_s_idp66297456.html" title="Function template make_managed_shared_ptr">make_managed_shared_ptr</a></code>) to easily construct a shared pointer from a type allocated in a managed segment with an allocator that will allocate the reference count also in the managed segment and a deleter that will erase the object from the segment. These utilities will use a Boost.Interprocess allocator (<code class="computeroutput"><a class="link" href="../boost/interprocess/allocator.html" ti