Namespaces
Variants

std:: add_cv, std:: add_const, std:: add_volatile

From cppreference.net
C++
Metaprogramming library
Type traits
Type categories
(C++11)
(C++11) ( DR* )
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Type properties
(C++11)
(C++11)
(C++11)
(C++11)
(C++14)
(C++11)
(C++17)
(C++23)
(C++11) (deprecated in C++26)
(C++11)
(C++11)
(C++11) ( until C++20* )
(C++11) (deprecated in C++20)
(C++11)
(C++11)
(C++20)
(C++20)
(C++23)
(C++17)
Type trait constants
(C++11) (C++17) (C++11) (C++11)
Metafunctions
(C++17)
(C++17)
(C++17)
Supported operations
Relationships and property queries
Type modifications
(C++11) (C++11) (C++11)
add_cv add_const add_volatile
(C++11) (C++11) (C++11)
(C++11)
(C++11)
Type transformations
(C++11) (deprecated in C++23)
(C++11) (deprecated in C++23)
(C++11)
(C++20)
(C++11) ( until C++20* ) (C++17)

Compile-time rational arithmetic
Compile-time integer sequences
(C++14)
Definiert im Header <type_traits>
template < class T >
struct add_cv ;
(1) (seit C++11)
template < class T >
struct add_const ;
(2) (seit C++11)
template < class T >
struct add_volatile ;
(3) (seit C++11)

Bietet den Member-Typedef type an, welcher derselbe wie T ist, außer dass ein CV-Qualifizierer hinzugefügt wurde (es sei denn, T ist eine Funktion, eine Referenz oder hat bereits diesen CV-Qualifizierer)

1) fügt sowohl const als auch volatile
2) fügt const
3) fügt volatile

Wenn das Programm Spezialisierungen für irgendeine der auf dieser Seite beschriebenen Templates hinzufügt, ist das Verhalten undefiniert.

Inhaltsverzeichnis

Mitgliedertypen

Name Definition
type der Typ T mit dem CV-Qualifizierer

Hilfstypen

template < class T >
using add_cv_t = typename add_cv < T > :: type ;
(seit C++14)
template < class T >
using add_const_t = typename add_const < T > :: type ;
(seit C++14)
template < class T >
using add_volatile_t = typename add_volatile < T > :: type ;
(seit C++14)

Mögliche Implementierung 

template<class T> struct add_cv { typedef const volatile T type; };
template<class T> struct add_const { typedef const T type; };
template<class T> struct add_volatile { typedef volatile T type; };

Hinweise

Diese Transformationstraits können verwendet werden, um non-deduced contexts in der Template-Argumentableitung zu etablieren: 

template<class T>
void f(const T&, const T&);
template<class T>
void g(const T&, std::add_const_t<T>&);
f(4.2, 0); // Fehler: widersprüchliche Typen für 'T' abgeleitet
g(4.2, 0); // OK, ruft g<double> auf

Beispiel

Diesen Code ausführen 
#include <iostream>
#include <type_traits>
struct foo
{
    void m() { std::cout << "Non-cv\n"; }
    void m() const { std::cout << "Const\n"; }
    void m() volatile { std::cout << "Volatile\n"; }
    void m() const volatile { std::cout << "Const-volatile\n"; }
};
int main()
{
    foo{}.m();
    std::add_const<foo>::type{}.m();
    std::add_volatile<foo>::type{}.m();
    std::add_cv<foo>::type{}.m();
}

Ausgabe: 

Non-cv
Const
Volatile
Const-volatile

Siehe auch

(C++11)
prüft, ob ein Typ const-qualifiziert ist
(Klassen-Template)
(C++11)
prüft, ob ein Typ volatile-qualifiziert ist
(Klassen-Template)
(C++11) (C++11) (C++11)
entfernt const und/oder volatile Spezifizierer vom gegebenen Typ
(Klassen-Template)
(C++17)
erhält eine Referenz auf const zu seinem Argument
(Funktions-Template)