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_shared_memory

boost::interprocess::basic_managed_shared_memory

Synopsis

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

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

  // public member functions
  void swap(basic_managed_shared_memory &);

  // public static functions
  static bool grow(const char *, size_type);
  static bool shrink_to_fit(const char *);
  static bool grow(const wchar_t *, size_type);
  static bool shrink_to_fit(const wchar_t *);
};

Description

A basic shared memory named object creation class. Initializes the shared memory segment. Inherits all basic functionality from basic_managed_memory_impl<CharType, AllocationAlgorithm, IndexType>*<zwj></zwj>/

basic_managed_shared_memory public construct/copy/destruct

  1. basic_managed_shared_memory();

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

  2. basic_managed_shared_memory(create_only_t, const char * name, size_type size, 
                                const void * addr = 0, 
                                const permissions & perm = permissions());

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

  3. basic_managed_shared_memory(open_or_create_t, const char * name, 
                                size_type size, const void * addr = 0, 
                                const permissions & perm = permissions());

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

  5. basic_managed_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.

  6. basic_managed_shared_memory(open_only_t, const char * name, 
                                const void * addr = 0);

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

  7. basic_managed_shared_memory(create_only_t, const wchar_t * name, 
                                size_type size, const void * addr = 0, 
                                const permissions & perm = permissions());

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

    Note: This function is only available on operating systems with native wchar_t APIs (e.g. Windows).

  8. basic_managed_shared_memory(open_or_create_t, const wchar_t * name, 
                                size_type size, const void * addr = 0, 
                                const permissions & perm = permissions());

    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.

    Note: This function is only available on operating systems with native wchar_t APIs (e.g. Windows).

  9. basic_managed_shared_memory(open_copy_on_write_t, const wchar_t * name, 
                                const void * addr = 0);

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

    Note: This function is only available on operating systems with native wchar_t APIs (e.g. Windows).

  10. basic_managed_shared_memory(open_read_only_t, const wchar_t * name, 
                                const void * addr = 0);

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

    Note: This function is only available on operating systems with native wchar_t APIs (e.g. Windows).

  11. basic_managed_shared_memory(open_only_t, const wchar_t * name, 
                                const void * addr = 0);

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

    Note: This function is only available on operating systems with native wchar_t APIs (e.g. Windows).

  12. basic_managed_shared_memory(basic_managed_shared_memory && moved);

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

  13. basic_managed_shared_memory & operator=(basic_managed_shared_memory && moved);

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

  14. ~basic_managed_shared_memory();

    Destroys *this and indicates that the calling process is finished using the resource. The destructor function will deallocate any system resources allocated by the system for use by this process for this resource. The resource can still be opened again calling the open constructor overload. To erase the resource from the system use remove().

basic_managed_shared_memory public member functions

  1. void swap(basic_managed_shared_memory & other);

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

basic_managed_shared_memory public static functions

  1. static bool grow(const char * shmname, size_type extra_bytes);

    Tries to resize the managed shared memory object so that we have room for more objects.

    This function is not synchronized so no other thread or process should be reading or writing the file

  2. static bool shrink_to_fit(const char * shmname);

    Tries to resize the managed shared memory to minimized the size of the file.

    This function is not synchronized so no other thread or process should be reading or writing the file

  3. static bool grow(const wchar_t * shmname, size_type extra_bytes);

    Tries to resize the managed shared memory object so that we have room for more objects.

    This function is not synchronized so no other thread or process should be reading or writing the file

    Note: This function is only available on operating systems with native wchar_t APIs (e.g. Windows).

  4. static bool shrink_to_fit(const wchar_t * shmname);

    Tries to resize the managed shared memory to minimized the size of the file.

    This function is not synchronized so no other thread or process should be reading or writing the file

    Note: This function is only available on operating systems with native wchar_t APIs (e.g. Windows).


PrevUpHomeNext