std::experimental::propagate_const(3)

NAME
std::experimental::propagate_const - std::experimental::propagate_const

Synopsis
   Defined in header <experimental/propagate_const>
   template<class T> (library fundamentals TS v2)
   class propagate_const;
   std::experimental::propagate_const is a const-propagating wrapper for pointers and
   pointer-like objects. It treats the wrapped pointer as a pointer to const when
   accessed through a const access path, hence the name.
   The class satisfies the requirements of MoveConstructible and MoveAssignable if the
   underlying pointer-like type satisfies the corresponding requirement, but
   propagate_const is neither CopyConstructible nor CopyAssignable.

Type requirements
   -
   T must be an object pointer type or a pointer-like class type, as specified below.
   The program is ill-formed if T is an array type, reference type, pointer to function
   type, pointer to (possibly cv-qualified) void, or if decltype(*std::declval<T&>())
   is not an lvalue reference type.
  Requirements on pointer-like class types
   If T is a class type, it must satisfy the requirements in this subsection.
   Given
     * t, a modifiable lvalue expression of type T
     * ct, a const T& bound to T
     * element_type, an object type
   The following expressions must be valid and have their specified effects:
     Expression Return type Pre-conditions Operational semantics
   t.get() element_type*
   ct.get() element_type* or const t.get() == ct.get()
                   element_type*
   *t element_type& t.get() != nullptr *t refers to the same
                        object as *(t.get())
   *ct element_type& or const ct.get() != nullptr *ct refers to the same
                   element_type& object as *(ct.get())
   t.operator->() element_type* t.get() != nullptr t.operator->() == t.get()
   ct.operator->() element_type* or const ct.get() != nullptr ct.operator->() ==
                   element_type* ct.get()
   (bool)t bool (bool)t is equivalent to
                        t.get() != nullptr
   (bool)ct bool (bool)ct is equivalent to
                        ct.get() != nullptr
   Further, T and const T shall be contextually convertible to bool.
   In addition, if T is implicitly convertible to element_type*, then (element_type*)t
   shall be equal to t.get(). Similarly, if const T is implicitly convertible to const
   element_type*, then (const element_type*)ct shall be equal to ct.get().

Member types
   Member type Definition
   element_type std::remove_reference_t<decltype(*std::declval<T&>())>, the type of the
                object pointed to by T

Member functions
   constructor constructs a new propagate_const
                        (public member function)
   destructor destructs an propagate_const, destroying the contained
   (implicitly declared) pointer
                        (public member function)
   operator= assigns the propagate_const object
                        (public member function)
   swap swaps the wrapped pointer
                        (public member function)

Observers
                        returns a pointer to the object pointed to by the
   get wrapped pointer
                        (public member function)
   operator bool checks if the wrapped pointer is null
                        (public member function)
   operator* dereferences the wrapped pointer
   operator-> (public member function)
   operator element_type* implicit conversion function to pointer
   operator const element_type* (public member function)

Non-member functions
   operator==
   operator!= compares to another
   operator< propagate_const, another
   operator<= pointer, or with nullptr
   operator> (function template)
   operator>=
                        specializes the swap
   std::experimental::swap(std::experimental::propagate_const) algorithm
                        (function template)
                        Retrieves a reference to
   get_underlying the wrapped pointer-like
                        object
                        (function template)

Helper classes
                        hash support for
   std::hash<std::experimental::propagate_const> propagate_const
                        (class template
                        specialization)
   std::equal_to<std::experimental::propagate_const> Specializations of the
   std::not_equal_to<std::experimental::propagate_const> standard comparison function
   std::less<std::experimental::propagate_const> objects for propagate_const
   std::greater<std::experimental::propagate_const> (class template
   std::less_equal<std::experimental::propagate_const> specialization)
   std::greater_equal<std::experimental::propagate_const>

Example
// Run this code
 #include <iostream>
 #include <memory>
 #include <experimental/propagate_const>
 struct X
 {
     void g() const { std::cout << "g (const)\n"; }
     void g() { std::cout << "g (non-const)\n"; }
 };
 struct Y
 {
     Y() : m_ptrX(std::make_unique<X>()) { }
     void f() const
     {
         std::cout << "f (const)\n";
         m_ptrX->g();
     }
     void f()
     {
         std::cout << "f (non-const)\n";
         m_ptrX->g();
     }
     std::experimental::propagate_const<std::unique_ptr<X>> m_ptrX;
 };
 int main()
 {
     Y y;
     y.f();
     const Y cy;
     cy.f();
 }

Output:
 f (non-const)
 g (non-const)
 f (const)
 g (const)