Namespaces
Variants

std::experimental:: propagate_const

From cppreference.net
C++
Experimental
Library fundamentals v2
std::experimental::propagate_const
Definido en el encabezado <experimental/propagate_const>
template < class T >
class propagate_const ;
(library fundamentals TS v2)

std::experimental::propagate_const es un contenedor que propaga constancia para punteros y objetos similares a punteros. Trata el puntero encapsulado como un puntero a const cuando se accede a través de una ruta de acceso const , de ahí su nombre.

La clase satisface los requisitos de MoveConstructible y MoveAssignable si el tipo subyacente similar a puntero satisface el requisito correspondiente, pero propagate_const no es CopyConstructible ni CopyAssignable .

Requisitos de tipo
-
T debe ser un tipo puntero-a-objeto sin calificadores cv o un tipo de clase similar-a-puntero sin calificadores cv, como se especifica a continuación.

Contenidos

Requisitos para tipos de clase similares a punteros

Si T es un tipo de clase, debe satisfacer los requisitos en esta subsección.

Dado

  • t , una expresión lvalue modificable de tipo T ,
  • ct , un lvalue de tipo const T que denota el mismo objeto que t (equivalente a std:: as_const ( t ) desde C++17),
  • element_type , un tipo de objeto.

Las siguientes expresiones deben ser válidas y tener sus efectos especificados:

Expresión Tipo de retorno Precondiciones Semántica operacional
t. get ( ) element_type *
ct. get ( ) element_type * o const element_type * t. get ( ) == ct. get ( )
* t element_type & t. get ( ) ! = nullptr * t referencia al mismo objeto que * ( t. get ( ) )
* ct element_type & o const element_type & ct. get ( ) ! = nullptr * ct referencia al mismo objeto que * ( ct. get ( ) )
t. operator - > ( ) element_type * t. get ( ) ! = nullptr t. operator - > ( ) == t. get ( )
ct. operator - > ( ) element_type * o const element_type * ct. get ( ) ! = nullptr ct. operator - > ( ) == ct. get ( )
( bool ) t bool ( bool ) t es equivalente a t. get ( ) ! = nullptr
( bool ) ct bool ( bool ) ct es equivalente a ct. get ( ) ! = nullptr

Además, T y const T deberán ser contextualmente convertibles a bool .

Además, si T es implícitamente convertible a element_type * , entonces ( element_type * ) t deberá ser igual a t. get ( ) . Similarmente, si const T es implícitamente convertible a const element_type * , entonces ( const element_type * ) ct deberá ser igual a ct. get ( ) .

Tipos de miembros

Tipo de miembro Definición
element_type std:: remove_reference_t < decltype ( * std:: declval < T & > ( ) ) > , el tipo del objeto apuntado por T

Funciones miembro

construye un nuevo propagate_const
(función miembro pública)
(destructor)
(implicitly declared)
destruye un propagate_const , eliminando el puntero contenido
(función miembro pública)
asigna el objeto propagate_const
(función miembro pública)
intercambia el puntero encapsulado
(función miembro pública)
Observadores
devuelve un puntero al objeto apuntado por el puntero encapsulado
(función miembro pública)
comprueba si el puntero encapsulado es nulo
(función miembro pública)
desreferencia el puntero encapsulado
(función miembro pública)
función de conversión implícita a puntero
(función miembro pública)

Funciones no miembro

compara con otro propagate_const , otro puntero, o con nullptr
(plantilla de función)
especializa el algoritmo swap
(plantilla de función)
obtiene una referencia al objeto similar a puntero encapsulado
(plantilla de función)

Clases auxiliares

soporte de hash para propagate_const
(especialización de plantilla de clase)
especializaciones de los objetos de función de comparación estándar para propagate_const
(especialización de plantilla de clase)

Ejemplo

Ejecutar este código 
#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();
}

Salida: 

Y::f (non-const)
X::g (non-const)
X::g (non-const)
Y::f (const)
X::g (const)
X::g (non-const)

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares publicados anteriormente de C++.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 3136 LFTSv2 se permitían tipos T sin sentido como int * const , void * , o const PtrLike no permitido