Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

This is the documentation for an old version of boost. Click here for the latest Boost documentation.
PrevUpHomeNext

Class template basic_managed_windows_shared_memory

boost::interprocess::basic_managed_windows_shared_memory

Synopsis

// In header: <boost/interprocess/managed_windows_shared_memory.hpp>

template<typename CharType, typename AllocationAlgorithm, 
         template< class IndexConfig > class IndexType> 
class basic_managed_windows_shared_memory {
public:
  // construct/copy/destruct
  basic_managed_windows_shared_memory();
  basic_managed_windows_shared_memory(create_only_t, const char *, 
                                      std::size_t, const void * = 0);
  basic_managed_windows_shared_memory(open_or_create_t, const char *, 
                                      std::size_t, const void * = 0);
  basic_managed_windows_shared_memory(open_only_t, const char *, 
                                      const void * = 0);
  basic_managed_windows_shared_memory(open_copy_on_write_t, const char *, 
                                      const void * = 0);
  basic_managed_windows_shared_memory(open_read_only_t, const char *, 
                                      const void * = 0);
  basic_managed_windows_shared_memory(basic_managed_windows_shared_memory &&);
  basic_managed_windows_shared_memory& 
  operator=(basic_managed_windows_shared_memory &&);
  ~basic_managed_windows_shared_memory();

  // public member functions
  void swap(basic_managed_windows_shared_memory &&) ;
  template<typename T> std::pair< T *, std::size_t > find(char_ptr_holder_t) ;
};

Description

A basic managed windows shared memory creation class. Initializes the shared memory segment. Inherits all basic functionality from basic_managed_memory_impl<CharType, AllocationAlgorithm, IndexType> Unlike basic_managed_shared_memory, it has no kernel persistence and the shared memory is destroyed when all processes destroy all their windows_shared_memory objects and mapped regions for the same shared memory or the processes end/crash.

Warning: basic_managed_windows_shared_memory and basic_managed_shared_memory can't communicate between them.

basic_managed_windows_shared_memory public construct/copy/destruct

  1. basic_managed_windows_shared_memory();

    Default constructor. Does nothing. Useful in combination with move semantics

  2. basic_managed_windows_shared_memory(create_only_t create_only, 
                                        const char * name, std::size_t size, 
                                        const void * addr = 0);

    Creates shared memory and creates and places the segment manager. This can throw.

  3. basic_managed_windows_shared_memory(open_or_create_t open_or_create, 
                                        const char * name, std::size_t size, 
                                        const void * addr = 0);

    Creates shared memory and creates and places the segment manager if segment was not created. If segment was created it connects to the segment. This can throw.

  4. basic_managed_windows_shared_memory(open_only_t open_only, const char * name, 
                                        const void * addr = 0);

    Connects to a created shared memory and its segment manager. This can throw.

  5. basic_managed_windows_shared_memory(open_copy_on_write_t, const char * name, 
                                        const void * addr = 0);

    Connects to a created shared memory and its segment manager in copy_on_write mode. This can throw.

  6. basic_managed_windows_shared_memory(open_read_only_t, const char * name, 
                                        const void * addr = 0);

    Connects to a created shared memory and its segment manager in read-only mode. This can throw.

  7. basic_managed_windows_shared_memory(basic_managed_windows_shared_memory && moved);

    Moves the ownership of "moved"'s managed memory to *this. Does not throw

  8. basic_managed_windows_shared_memory& 
    operator=(basic_managed_windows_shared_memory && moved);

    Moves the ownership of "moved"'s managed memory to *this. Does not throw

  9. ~basic_managed_windows_shared_memory();

    Destroys *this and indicates that the calling process is finished using the resource. All mapped regions are still valid after destruction. When all mapped regions and basic_managed_windows_shared_memory objects referring the shared memory are destroyed, the operating system will destroy the shared memory.

basic_managed_windows_shared_memory public member functions

  1. void swap(basic_managed_windows_shared_memory && other) ;

    Swaps the ownership of the managed mapped memories managed by *this and other. Never throws.

  2. template<typename T> 
      std::pair< T *, std::size_t > find(char_ptr_holder_t name) ;

    Tries to find a previous named allocation address. Returns a memory buffer and the object count. If not found returned pointer is 0. Never throws.


PrevUpHomeNext