C++ users know the importance of ownership smart pointers when dealing with
resources. Boost offers a wide range of such type of pointers: intrusive_ptr<>,
scoped_ptr<>,
shared_ptr<>...

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.

boost::interprocess::intrusive_ptr
is the generalization of boost::intrusive_ptr<> to allow non-raw pointers as intrusive
pointer members. As the well-known boost::intrusive_ptr
we must specify the pointee type but we also must also specify the pointer
type to be stored in the intrusive_ptr:

So boost::interprocess::intrusive_ptr<MyClass,void*>
is equivalent to boost::intrusive_ptr<MyClass>.
But if we want to place the intrusive_ptr in shared memory we must specify
a relative pointer type like 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>usingnamespaceboost::interprocess;namespaceN{//A class that has an internal reference count
classreference_counted_class{private://Non-copyable
reference_counted_class(constreference_counted_class&);//Non-assignable
reference_counted_class&operator=(constreference_counted_class&);//A typedef to save typing
typedefmanaged_shared_memory::segment_managersegment_manager;//This is the reference count
unsignedintm_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
unsignedintuse_count()const{returnm_use_count;}//Adds a reference
inlinefriendvoidintrusive_ptr_add_ref(reference_counted_class*p){++p->m_use_count;}//Releases a reference
inlinefriendvoidintrusive_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
classintrusive_ptr_owner{typedefintrusive_ptr<N::reference_counted_class,offset_ptr<void>>intrusive_ptr_t;intrusive_ptr_tm_intrusive_ptr;public://Takes a pointer to the reference counted class
intrusive_ptr_owner(N::reference_counted_class*ptr):m_intrusive_ptr(ptr){}};intmain(){//Remove shared memory on construction and destruction
structshm_remove{shm_remove(){shared_memory_object::remove("MySharedMemory");}~shm_remove(){shared_memory_object::remove("MySharedMemory");}}remover;//Create shared memory
managed_shared_memoryshmem(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)return1;//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)return1;//Success!
return0;}

boost::interprocess::scoped_ptr<>
is the big brother of boost::scoped_ptr<>, which adds a custom deleter to specify
how the pointer passed to the scoped_ptr must be destroyed. Also, the pointer typedef of the deleter will specify
the pointer type stored by 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<classT,classDeleter>classscoped_ptr;

scoped_ptr<>
comes handy to implement rollbacks with
exceptions: if an exception is thrown or we call return
in the scope of scoped_ptr<> the deleter is automatically called
so that the deleter can be considered as a rollback
function. If all goes well, we call release() member function to avoid rollback when
the scoped_ptr goes out of
scope.

#include<boost/interprocess/managed_shared_memory.hpp>#include<boost/interprocess/smart_ptr/scoped_ptr.hpp>usingnamespaceboost::interprocess;classmy_class{};classmy_exception{};//A functor that destroys the shared memory object
template<classT>classmy_deleter{private://A typedef to save typing
typedefmanaged_shared_memory::segment_managersegment_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
typedefT*pointer;//Constructor
my_deleter(segment_manager*s_mngr):mp_segment_manager(s_mngr){}voidoperator()(pointerobject_to_delete){mp_segment_manager->destroy_ptr(object_to_delete);}};intmain(){//Create shared memory
//Remove shared memory on construction and destruction
structshm_remove{shm_remove(){shared_memory_object::remove("MySharedMemory");}~shm_remove(){shared_memory_object::remove("MySharedMemory");}}remover;managed_shared_memoryshmem(create_only,"MySharedMemory",10000);//In the first try, there will be no exceptions
//in the second try we will throw an exception
for(inti=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(constmy_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){return1;}//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){return1;}}}return0;}

Unlike boost::shared_ptr,
due to limitations of mapped segments boost::interprocess::shared_ptr
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 shared_ptr
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 shared_ptr,
just like Boost.Interprocess containers
need to pass allocators in their constructors.

VoidAllocator is the allocator to be used to allocate auxiliary elements
such as the reference count, the deleter... The internal pointer typedef of the allocator will
determine the type of pointer that shared_ptr will internally use, so allocators
defining pointer as offset_ptr<void>
will make all internal pointers used by shared_ptr
to be also relative pointers. See boost::interprocess::allocator
for a working allocator.

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 VoidAllocator::pointer.
See boost::interprocess::deleter
for a generic deleter that erases a object from a managed segment.

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:

#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>usingnamespaceboost::interprocess;//This is type of the object we want to share
classMyType{};typedefmanaged_shared_memory::segment_managersegment_manager_type;typedefallocator<void,segment_manager_type>void_allocator_type;typedefdeleter<MyType,segment_manager_type>deleter_type;typedefshared_ptr<MyType,void_allocator_type,deleter_type>my_shared_ptr;intmain(){//Remove shared memory on construction and destruction
structshm_remove{shm_remove(){shared_memory_object::remove("MySharedMemory");}~shm_remove(){shared_memory_object::remove("MySharedMemory");}}remover;managed_shared_memorysegment(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);return0;}

boost::interprocess::shared_ptr
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, boost::interprocess::shared_ptr
header offers a shared pointer definition helper class (managed_shared_ptr)
and a function (make_managed_shared_ptr)
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.

#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>usingnamespaceboost::interprocess;//This is type of the object we want to share
structtype_to_share{};//This is the type of a shared pointer to the previous type
//that will be built in the mapped file
typedefmanaged_shared_ptr<type_to_share,managed_mapped_file>::typeshared_ptr_type;typedefmanaged_weak_ptr<type_to_share,managed_mapped_file>::typeweak_ptr_type;//This is a type holding a shared pointer
structshared_ptr_owner{shared_ptr_owner(constshared_ptr_type&other_shared_ptr):shared_ptr_(other_shared_ptr){}shared_ptr_owner(constshared_ptr_owner&other_owner):shared_ptr_(other_owner.shared_ptr_){}shared_ptr_typeshared_ptr_;//...
};intmain(){//Destroy any previous file with the name to be used.
structfile_remove{file_remove(){file_mapping::remove("MyMappedFile");}~file_remove(){file_mapping::remove("MyMappedFile");}}remover;{managed_mapped_filefile(create_only,"MyMappedFile",4096);//Construct the shared type in the file and
//pass ownership to this local shared pointer
shared_ptr_typelocal_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_filefile(open_only,"MyMappedFile");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_typelocal_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_typelocal_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.
}return0;}

If a programmer just uses shared_ptr
to be able to insert objects dynamically constructed in the managed segment
in a container, but does not need to share the ownership of that object with
other objects unique_ptr
is a much faster and easier to use alternative.

Unique ownership smart pointers are really useful to free programmers from
manual resource liberation of non-shared objects. Boost.Interprocess'
unique_ptr is
much like scoped_ptr
but it's moveable and can be easily inserted
in Boost.Interprocess containers. Here is
the declaration of the unique pointer class:

D is the deleter that will erase the object type of the object pointed
by unique_ptr
when the unique pointer is destroyed (and if still owns ownership of the
object). If the deleter defines an internal pointer
typedef, unique_ptr
will use an internal pointer of the same type. So if D::pointer
is offset_ptr<T>
the unique pointer will store a relative pointer instead of a raw one.
This allows placing unique_ptr
in shared memory and memory-mapped files.

unique_ptr can
release the ownership of the stored pointer so it's useful also to be used
as a rollback function. One of the main properties of the class is that
is not copyable, but only moveable. When
a unique pointer is moved to another one, the ownership of the pointer is
transferred from the source unique pointer to the target unique pointer.
If the target unique pointer owned an object, that object is first deleted
before taking ownership of the new object.

Here we see an example of the use unique_ptr
including creating containers of such objects:

#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>usingnamespaceboost::interprocess;//This is type of the object we'll allocate dynamically
structMyType{MyType(intnumber=0):number_(number){}intnumber_;};//This is the type of a unique pointer to the previous type
//that will be built in the mapped file
typedefmanaged_unique_ptr<MyType,managed_mapped_file>::typeunique_ptr_type;//Define containers of unique pointer. Unique pointer simplifies object management
typedefvector<unique_ptr_type,allocator<unique_ptr_type,managed_mapped_file::segment_manager>>unique_ptr_vector_t;typedeflist<unique_ptr_type,allocator<unique_ptr_type,managed_mapped_file::segment_manager>>unique_ptr_list_t;intmain(){//Destroy any previous file with the name to be used.
structfile_remove{file_remove(){file_mapping::remove("MyMappedFile");}~file_remove(){file_mapping::remove("MyMappedFile");}}remover;{managed_mapped_filefile(create_only,"MyMappedFile",65536);//Construct an object in the file and
//pass ownership to this local unique pointer
unique_ptr_typelocal_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(inti=0;i<100;++i){unique_ptr_typep(make_managed_unique_ptr(file.construct<MyType>(anonymous_instance)(i),file));unique_vector->push_back(boost::interprocess::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(inti=99;!unique_vector->empty();--i){unique_list->push_front(boost::interprocess::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_filefile(open_only,"MyMappedFile");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_iteratorlist_it=unique_list->begin();for(inti=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);}return0;}