| Home | Libraries | People | FAQ | More

## Class template basic_managed_windows_shared_memory

boost::interprocess::basic_managed_windows_shared_memory

## Synopsis

    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(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(unspecified);
      basic_managed_windows_shared_memory& operator=(unspecified);
      ~basic_managed_windows_shared_memory();

      // public member functions
      void swap(basic_managed_windows_shared_memory &) ;
    };

## 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(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.

2.     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.

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

   Connects to a created shared memory and it's the segment manager. Never throws.

4.     basic_managed_windows_shared_memory(unspecified moved);

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

5.     basic_managed_windows_shared_memory& operator=(unspecified moved);

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

6.     ~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.