Boost C++ Libraries 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 to view this page for the latest version.

Class mapped_region



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

class mapped_region {
  // construct/copy/destruct
  template<typename MemoryMappable> 
    mapped_region(const MemoryMappable &, mode_t, offset_t = 0, 
                  std::size_t = 0, const void * = 0);
  mapped_region(mapped_region &&);
  mapped_region& operator=(mapped_region &&);

  // public member functions
  std::size_t get_size() const;
  void * get_address() const;
  offset_t get_offset() const;
  mode_t get_mode() const;
  bool flush(std::size_t = 0, std::size_t = 0) ;
  void swap(mapped_region &) ;

  // public static functions
  static std::size_t get_page_size() ;


The mapped_region class represents a portion or region created from a memory_mappable object.

mapped_region public construct/copy/destruct

  1. template<typename MemoryMappable> 
      mapped_region(const MemoryMappable & mapping, mode_t mode, 
                    offset_t offset = 0, std::size_t size = 0, 
                    const void * address = 0);

    Creates a mapping region of the mapped memory "mapping", starting in offset "offset", and the mapping's size will be "size". The mapping can be opened for read-only "read_only" or read-write "read_write.

  2. mapped_region();

    Default constructor. Address and size and offset will be 0. Does not throw

  3. mapped_region(mapped_region && other);

    Move constructor. *this will be constructed taking ownership of "other"'s region and "other" will be left in default constructor state.

  4. mapped_region& operator=(mapped_region && other);

    Move assignment. If *this owns a memory mapped region, it will be destroyed and it will take ownership of "other"'s memory mapped region.

  5. ~mapped_region();

    Destroys the mapped region. Does not throw

mapped_region public member functions

  1. std::size_t get_size() const;

    Returns the size of the mapping. Note for windows users: If windows_shared_memory is mapped using 0 as the size, it returns 0 because the size is unknown. Never throws.

  2. void * get_address() const;

    Returns the base address of the mapping. Never throws.

  3. offset_t get_offset() const;

    Returns the offset of the mapping from the beginning of the mapped memory. Never throws.

  4. mode_t get_mode() const;

    Returns the mode of the mapping used to construct the mapped file. Never throws.

  5. bool flush(std::size_t mapping_offset = 0, std::size_t numbytes = 0) ;

    Flushes to the disk a byte range within the mapped memory. Never throws

  6. void swap(mapped_region & other) ;

    Swaps the mapped_region with another mapped region

mapped_region public static functions

  1. static std::size_t get_page_size() ;

    Returns the size of the page. This size is the minimum memory that will be used by the system when mapping a memory mappable source.