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)