Namespaces
Variants

std::experimental:: propagate_const

From cppreference.net
C++
Experimental
Library fundamentals v2
std::experimental::propagate_const
template < class T >
class propagate_const ;
(Library Fundamentals TS v2)

std::experimental::propagate_const ist ein const-verbreitender Wrapper für Zeiger und zeigerähnliche Objekte. Er behandelt den eingeschlossenen Zeiger als Zeiger auf const , wenn über einen const -Zugriffspfad zugegriffen wird, daher der Name.

Die Klasse erfüllt die Anforderungen von MoveConstructible und MoveAssignable , falls der zugrundeliegende zeigerähnliche Typ die entsprechende Anforderung erfüllt, aber propagate_const ist weder CopyConstructible noch CopyAssignable .

Typanforderungen
-
T muss ein cv-unqualifizierter Zeiger-auf-Objekt-Typ oder ein cv-unqualifizierter zeigerähnlicher Klassentyp sein, wie nachstehend angegeben.

Inhaltsverzeichnis

Anforderungen an zeigerähnliche Klassentypen

Wenn T ein Klassentyp ist, muss es die Anforderungen in diesem Unterabschnitt erfüllen.

Gegeben

  • t , ein modifizierbarer Lvalue-Ausdruck vom Typ T ,
  • ct , ein Lvalue vom Typ const T , der dasselbe Objekt bezeichnet wie t (äquivalent zu std:: as_const ( t ) seit C++17),
  • element_type , ein Objekttyp.

Die folgenden Ausdrücke müssen gültig sein und ihre spezifizierten Effekte haben:

Ausdruck Rückgabetyp Vorbedingungen Operationelle Semantik
t. get ( ) element_type *
ct. get ( ) element_type * oder const element_type * t. get ( ) == ct. get ( )
* t element_type & t. get ( ) ! = nullptr * t referenziert dasselbe Objekt wie * ( t. get ( ) )
* ct element_type & oder const element_type & ct. get ( ) ! = nullptr * ct referenziert dasselbe Objekt wie * ( ct. get ( ) )
t. operator - > ( ) element_type * t. get ( ) ! = nullptr t. operator - > ( ) == t. get ( )
ct. operator - > ( ) element_type * oder const element_type * ct. get ( ) ! = nullptr ct. operator - > ( ) == ct. get ( )
( bool ) t bool ( bool ) t ist äquivalent zu t. get ( ) ! = nullptr
( bool ) ct bool ( bool ) ct ist äquivalent zu ct. get ( ) ! = nullptr

Ferner müssen T und const T kontextuell zu bool konvertierbar sein.

Zusätzlich, falls T implizit konvertierbar zu element_type * ist, dann muss ( element_type * ) t gleich t. get ( ) sein. Ebenso, falls const T implizit konvertierbar zu const element_type * ist, dann muss ( const element_type * ) ct gleich ct. get ( ) sein.

Mitgliedertypen

Mitgliedtyp Definition
element_type std:: remove_reference_t < decltype ( * std:: declval < T & > ( ) ) > , der Typ des Objekts, auf das durch T gezeigt wird

Memberfunktionen

konstruiert ein neues propagate_const
(public member function)
(destructor)
(implicitly declared)
zerstört ein propagate_const , zerstört den enthaltenen Zeiger
(public member function)
weist das propagate_const -Objekt zu
(public member function)
tauscht den eingeschlossenen Zeiger
(public member function)
Beobachter
gibt einen Zeiger auf das Objekt zurück, auf das der eingeschlossene Zeiger zeigt
(public member function)
prüft, ob der eingeschlossene Zeiger null ist
(public member function)
dereferenziert den eingeschlossenen Zeiger
(public member function)
implizite Konvertierungsfunktion zu Zeiger
(public member function)

Nicht-Member-Funktionen

vergleicht mit einem anderen propagate_const , einem anderen Zeiger oder mit nullptr
(Funktions-Template)
spezialisiert den swap -Algorithmus
(Funktions-Template)
ruft eine Referenz auf das eingeschlossene zeigerartige Objekt ab
(Funktions-Template)

Hilfsklassen

Hash-Unterstützung für propagate_const
(Klassen-Template-Spezialisierung)
Spezialisierungen der standardmäßigen Vergleichsfunktionsobjekte für propagate_const
(Klassen-Template-Spezialisierung)

Beispiel

Diesen Code ausführen 
#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();
}

Ausgabe: 

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

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
LWG 3136 LFTSv2 bedeutungslose T wie int * const , void * , oder const PtrLike waren erlaubt nicht erlaubt