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