Namespaces
Variants

std::experimental:: propagate_const

From cppreference.net
C++
Experimental
Library fundamentals v2
std::experimental::propagate_const
Défini dans l'en-tête <experimental/propagate_const>
template < class T >
class propagate_const ;
(bibliothèque fondamentale TS v2)

std::experimental::propagate_const est un wrapper à propagation de constance pour les pointeurs et les objets de type pointeur. Il traite le pointeur encapsulé comme un pointeur vers const lorsqu'il est accédé via un chemin d'accès const , d'où son nom.

La classe satisfait aux exigences de MoveConstructible et MoveAssignable si le type sous-jacent de type pointeur satisfait à l'exigence correspondante, mais propagate_const n'est ni CopyConstructible ni CopyAssignable .

Exigences de type
-
T doit être un type pointeur-vers-objet non qualifié cv ou un type classe de type pointeur non qualifié cv, comme spécifié ci-dessous.

Table des matières

Exigences sur les types de classes de type pointeur

Si T est un type de classe, il doit satisfaire aux exigences de cette sous-section.

Étant donné

  • t , une expression lvalue modifiable de type T ,
  • ct , une lvalue de type const T qui désigne le même objet que t (équivalent à std:: as_const ( t ) depuis C++17),
  • element_type , un type d'objet.

Les expressions suivantes doivent être valides et avoir leurs effets spécifiés :

Expression Type de retour Préconditions Sémantique opérationnelle
t. get ( ) element_type *
ct. get ( ) element_type * ou const element_type * t. get ( ) == ct. get ( )
* t element_type & t. get ( ) ! = nullptr * t fait référence au même objet que * ( t. get ( ) )
* ct element_type & ou const element_type & ct. get ( ) ! = nullptr * ct fait référence au même objet que * ( ct. get ( ) )
t. operator - > ( ) element_type * t. get ( ) ! = nullptr t. operator - > ( ) == t. get ( )
ct. operator - > ( ) element_type * ou const element_type * ct. get ( ) ! = nullptr ct. operator - > ( ) == ct. get ( )
( bool ) t bool ( bool ) t est équivalent à t. get ( ) ! = nullptr
( bool ) ct bool ( bool ) ct est équivalent à ct. get ( ) ! = nullptr

De plus, T et const T doivent être contextuellement convertibles en bool .

De plus, si T est implicitement convertible en element_type * , alors ( element_type * ) t doit être égal à t. get ( ) . De même, si const T est implicitement convertible en const element_type * , alors ( const element_type * ) ct doit être égal à ct. get ( ) .

Types membres

Type de membre Définition
element_type std:: remove_reference_t < decltype ( * std:: declval < T & > ( ) ) > , le type de l'objet pointé par T

Fonctions membres

construit un nouveau propagate_const
(fonction membre publique)
(destructor)
(implicitly declared)
détruit un propagate_const , en détruisant le pointeur contenu
(fonction membre publique)
assigne l'objet propagate_const
(fonction membre publique)
échange le pointeur encapsulé
(fonction membre publique)
Observateurs
retourne un pointeur vers l'objet pointé par le pointeur encapsulé
(fonction membre publique)
vérifie si le pointeur encapsulé est nul
(fonction membre publique)
déréférence le pointeur encapsulé
(fonction membre publique)
fonction de conversion implicite en pointeur
(fonction membre publique)

Fonctions non membres

compare à un autre propagate_const , un autre pointeur, ou avec nullptr
(modèle de fonction)
spécialise l'algorithme swap
(modèle de fonction)
récupère une référence à l'objet de type pointeur encapsulé
(modèle de fonction)

Classes d'assistance

prise en charge du hachage pour propagate_const
(spécialisation de modèle de classe)
spécialisations des objets fonction de comparaison standard pour propagate_const
(spécialisation de modèle de classe)

Exemple

Exécuter ce 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();
}

Sortie : 

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

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Applicable à Comportement publié Comportement corrigé
LWG 3136 LFTSv2 types T sans signification comme int * const , void * , ou const PtrLike étaient autorisés interdit