stdexperimentalpropagate_const(3)
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 element_type* t.get() == ct.get() *t element_type& t.get() != nullptr *t refers to the same object as *(t.get()) ct element_type& or const element_type& ct.get() != nullptr ct refers to the same object as (ct.get()) t.operator->() element_type t.get() != nullptr t.operator->() == t.get() ct.operator->() element_type or const element_type ct.get() != nullptr ct.operator->() == 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
destructor destructs an propagate_const, destroying the contained pointer
Observers
Non-member functions
operator==
operator!= compares to another propagate_const, another pointer, or with nullptr
operator< (function template)
operator<=
operator>
operator>=
Helper classes
std::equal_to<std::experimental::propagate_const> std::not_equal_to<std::experimental::propagate_const> Specializations of the standard comparison function objects for propagate_const std::less<std::experimental::propagate_const> (class template specialization) std::greater<std::experimental::propagate_const> std::less_equal<std::experimental::propagate_const> 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: