| Home | Libraries | People | FAQ | More

## Class template offset_ptr

boost::interprocess::offset_ptr

## Synopsis

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

    template<typename PointedType, typename DifferenceType, typename OffsetType,
             std::size_t OffsetAlignment>
    class offset_ptr {
    public:
      // types
      typedef PointedType                     element_type;
      typedef PointedType *                   pointer;
      typedef unspecified                     reference;
      typedef unspecified                     value_type;
      typedef DifferenceType                  difference_type;
      typedef std::random_access_iterator_tag iterator_category;
      typedef OffsetType                      offset_type;

      // member classes/structs/unions
      template<typename U>
      struct rebind {
        // types
        typedef offset_ptr< U, DifferenceType, OffsetType, OffsetAlignment > other;
      };

      // construct/copy/destruct
      offset_ptr() noexcept;
      offset_ptr(pointer) noexcept;
      template<typename T> offset_ptr(T *, unspecified = 0) noexcept;
      offset_ptr(const offset_ptr &) noexcept;
      template<typename T2>
        offset_ptr(const offset_ptr< T2, DifferenceType, OffsetType, OffsetAlignment > &) noexcept;
      template<typename T2, typename P2, typename O2, std::size_t A2>
        offset_ptr(const offset_ptr< T2, P2, O2, A2 > &, unspecified) noexcept;
      template<typename T2, typename P2, typename O2, std::size_t A2>
        offset_ptr(const offset_ptr< T2, P2, O2, A2 > &, unspecified) noexcept;
      template<typename T2, typename P2, typename O2, std::size_t A2>
        offset_ptr(const offset_ptr< T2, P2, O2, A2 > &, unspecified) noexcept;
      template<typename T2, typename P2, typename O2, std::size_t A2>
        offset_ptr(const offset_ptr< T2, P2, O2, A2 > &, unspecified) noexcept;
      BOOST_FORCEINLINE offset_ptr & operator=(pointer) noexcept;
      BOOST_FORCEINLINE offset_ptr & operator=(const offset_ptr &) noexcept;
      template<typename T2>
        BOOST_FORCEINLINE offset_ptr &
        operator=(const offset_ptr< T2, DifferenceType, OffsetType, OffsetAlignment > &) noexcept;

      // public member functions
      BOOST_FORCEINLINE pointer get() const noexcept;
      BOOST_FORCEINLINE offset_type get_offset() const noexcept;
      BOOST_FORCEINLINE pointer operator->() const noexcept;
      BOOST_FORCEINLINE reference operator*() const noexcept;
      BOOST_FORCEINLINE reference operator[](difference_type) const noexcept;
      BOOST_FORCEINLINE offset_ptr & operator+=(difference_type) noexcept;
      BOOST_FORCEINLINE offset_ptr & operator-=(difference_type) noexcept;
      BOOST_FORCEINLINE offset_ptr & operator++(void) noexcept;
      BOOST_FORCEINLINE offset_ptr operator++(int) noexcept;
      BOOST_FORCEINLINE offset_ptr & operator--(void) noexcept;
      BOOST_FORCEINLINE offset_ptr operator--(int) noexcept;
      explicit operator bool() const noexcept;
      BOOST_FORCEINLINE bool operator!() const noexcept;

      // public static functions
      static BOOST_FORCEINLINE offset_ptr pointer_to(reference) noexcept;

      // friend functions
      BOOST_FORCEINLINE friend offset_ptr
      operator+(difference_type, offset_ptr) noexcept;
      BOOST_FORCEINLINE friend offset_ptr
      operator+(offset_ptr, difference_type) noexcept;
      BOOST_FORCEINLINE friend offset_ptr
      operator-(offset_ptr, difference_type) noexcept;
      BOOST_FORCEINLINE friend offset_ptr
      operator-(difference_type, offset_ptr) noexcept;
      BOOST_FORCEINLINE friend difference_type
      operator-(const offset_ptr &, const offset_ptr &) noexcept;

      // private member functions
      template<typename T2>
        BOOST_FORCEINLINE void
        assign(const offset_ptr< T2, DifferenceType, OffsetType, OffsetAlignment > &,
               unspecified) noexcept;
      template<typename T2>
        BOOST_FORCEINLINE void
        assign(const offset_ptr< T2, DifferenceType, OffsetType, OffsetAlignment > &,
               unspecified) noexcept;
    };

## Description

A smart pointer that stores the offset between between the pointer and the the object it points. This allows offset allows special properties, since the pointer is independent from the address of the pointee, if the pointer and the pointee are still separated by the same offset. This feature converts offset_ptr in a smart pointer that can be placed in shared memory and memory mapped files mapped in different addresses in every process.

b>Note: offset_ptr uses implementation defined properties, present in most platforms, for performance reasons:

- Assumes that uintptr_t representation of nullptr is (uintptr_t)zero.

- Assumes that incrementing a uintptr_t obtained from a pointer is equivalent to incrementing the pointer and then converting it back to uintptr_t.

### Template Parameters

1.     typename PointedType

   The type of the pointee.

2.     typename DifferenceType

   A signed integer type that can represent the arithmetic operations on the pointer

3.     typename OffsetType

   An unsigned integer type that can represent the distance between two pointers reinterpret_cast-ed as unsigned integers. This type should be at least of the same size of std::uintptr_t. In some systems it's possible to communicate between 32 and 64 bit processes using 64 bit offsets.

4.     std::size_t OffsetAlignment

   Alignment of the OffsetType stored inside. In some systems might be necessary to align it to 64 bits in order to communicate 32 and 64 bit processes using 64 bit offsets.

### `offset_ptr` public construct/copy/destruct

1.     offset_ptr() noexcept;

   Default constructor (null pointer). Never throws.

2.     offset_ptr(pointer ptr) noexcept;

   Constructor from raw pointer (allows "0" pointer conversion). Never throws.

3.     template<typename T> offset_ptr(T * ptr, unspecified = 0) noexcept;

   Constructor from other pointer. Never throws.

4.     offset_ptr(const offset_ptr & ptr) noexcept;

   Constructor from other `offset_ptr` Never throws.

5.     template<typename T2>
         offset_ptr(const offset_ptr< T2, DifferenceType, OffsetType, OffsetAlignment > & ptr) noexcept;

   Constructor from other `offset_ptr`. If pointers of pointee types are convertible, offset_ptrs will be convertibles. Never throws.

6.     template<typename T2, typename P2, typename O2, std::size_t A2>
         offset_ptr(const offset_ptr< T2, P2, O2, A2 > & r, unspecified) noexcept;

   Emulates static_cast operator. Never throws.

7.     template<typename T2, typename P2, typename O2, std::size_t A2>
         offset_ptr(const offset_ptr< T2, P2, O2, A2 > & r, unspecified) noexcept;

   Emulates const_cast operator. Never throws.

8.     template<typename T2, typename P2, typename O2, std::size_t A2>
         offset_ptr(const offset_ptr< T2, P2, O2, A2 > & r, unspecified) noexcept;

   Emulates dynamic_cast operator. Never throws.

9.     template<typename T2, typename P2, typename O2, std::size_t A2>
         offset_ptr(const offset_ptr< T2, P2, O2, A2 > & r, unspecified) noexcept;

   Emulates reinterpret_cast operator. Never throws.

10.     BOOST_FORCEINLINE offset_ptr & operator=(pointer from) noexcept;

    Assignment from pointer (saves extra conversion). Never throws.

11.     BOOST_FORCEINLINE offset_ptr & operator=(const offset_ptr & ptr) noexcept;

    Assignment from other `offset_ptr`. Never throws.

12.     template<typename T2>
          BOOST_FORCEINLINE offset_ptr &
          operator=(const offset_ptr< T2, DifferenceType, OffsetType, OffsetAlignment > & ptr) noexcept;

    Assignment from related `offset_ptr`. If pointers of pointee types are assignable, offset_ptrs will be assignable. Never throws.

### `offset_ptr` public member functions

1.     BOOST_FORCEINLINE pointer get() const noexcept;

   Obtains raw pointer from offset. Never throws.

2.     BOOST_FORCEINLINE offset_type get_offset() const noexcept;

3.     BOOST_FORCEINLINE pointer operator->() const noexcept;

   Pointer-like -> operator. It can return 0 pointer. Never throws.

4.     BOOST_FORCEINLINE reference operator*() const noexcept;

   Dereferencing operator, if it is a null `offset_ptr` behavior is undefined. Never throws.

5.     BOOST_FORCEINLINE reference operator[](difference_type idx) const noexcept;

   Indexing operator. Never throws.

6.     BOOST_FORCEINLINE offset_ptr & operator+=(difference_type offset) noexcept;

   `offset_ptr` += difference_type. Never throws.

7.     BOOST_FORCEINLINE offset_ptr & operator-=(difference_type offset) noexcept;

   `offset_ptr` -= difference_type. Never throws.

8.     BOOST_FORCEINLINE offset_ptr & operator++(void) noexcept;

   ++offset_ptr. Never throws.

9.     BOOST_FORCEINLINE offset_ptr operator++(int) noexcept;

   offset_ptr++. Never throws.

10.     BOOST_FORCEINLINE offset_ptr & operator--(void) noexcept;

    <ndash></ndash>`offset_ptr`. Never throws.

11.     BOOST_FORCEINLINE offset_ptr operator--(int) noexcept;

    `offset_ptr`<ndash></ndash>. Never throws.

12.     explicit operator bool() const noexcept;

    safe bool conversion operator. Never throws.

13.     BOOST_FORCEINLINE bool operator!() const noexcept;

    Not operator. Not needed in theory, but improves portability. Never throws

### `offset_ptr` public static functions

1.     static BOOST_FORCEINLINE offset_ptr pointer_to(reference r) noexcept;

   Compatibility with pointer_traits

### `offset_ptr` friend functions

1.     BOOST_FORCEINLINE friend offset_ptr
       operator+(difference_type diff, offset_ptr right) noexcept;

   difference_type + `offset_ptr` operation

2.     BOOST_FORCEINLINE friend offset_ptr
       operator+(offset_ptr left, difference_type diff) noexcept;

   `offset_ptr` + difference_type operation

3.     BOOST_FORCEINLINE friend offset_ptr
       operator-(offset_ptr left, difference_type diff) noexcept;

   `offset_ptr` - diff operation

4.     BOOST_FORCEINLINE friend offset_ptr
       operator-(difference_type diff, offset_ptr right) noexcept;

   `offset_ptr` - diff operation

5.     BOOST_FORCEINLINE friend difference_type
       operator-(const offset_ptr & pt, const offset_ptr & pt2) noexcept;

   `offset_ptr` - `offset_ptr` operation

### `offset_ptr` private member functions

1.     template<typename T2>
         BOOST_FORCEINLINE void
         assign(const offset_ptr< T2, DifferenceType, OffsetType, OffsetAlignment > & ptr,
                unspecified) noexcept;

2.     template<typename T2>
         BOOST_FORCEINLINE void
         assign(const offset_ptr< T2, DifferenceType, OffsetType, OffsetAlignment > & ptr,
                unspecified) noexcept;