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 cv-unqualified pointer-to-object type or a cv-unqualified pointer-like
   class type, as specified below.

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 a 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== compares to another
   operator!= propagate_const, another
   operator< pointer, or with nullptr
   operator<= (function template)
   operator>
   operator>=
                        specializes the swap
   std::experimental::swap(std::experimental::propagate_const) algorithm
                        (function template)
                        retrieves a reference to
                        the wrapped pointer-like
   get_underlying 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 <experimental/propagate_const>
 #include <iostream>
 #include <memory>
 struct X
 {
     void g() const { std::cout << "X::g (const)\n"; }
     void g() { std::cout << "X::g (non-const)\n"; }
 };
 struct Y
 {
     Y() : m_propConstX(std::make_unique<X>()), m_autoPtrX(std::make_unique<X>()) {}
     void f() const
     {
         std::cout << "Y::f (const)\n";
         m_propConstX->g();
         m_autoPtrX->g();
     }
     void f()
     {
         std::cout << "Y::f (non-const)\n";
         m_propConstX->g();
         m_autoPtrX->g();
     }
     std::experimental::propagate_const<std::unique_ptr<X>> m_propConstX;
     std::unique_ptr<X> m_autoPtrX;
 };
 int main()
 {
     Y y;
     y.f();
     const Y cy;
     cy.f();
 }

Output:
 Y::f (non-const)
 X::g (non-const)
 X::g (non-const)
 Y::f (const)
 X::g (const)
 X::g (non-const)
   Defect reports
   The following behavior-changing defect reports were applied retroactively to
   previously published C++ standards.
      DR Applied to Behavior as published Correct behavior
   LWG 3136 LFTSv2 meaningless T like int* const, void*, or const disallowed
                       PtrLike were allowed