std::add_cv,std::add_const,std::add_volatile(3)

NAME
std::add_cv,std::add_const,std::add_volatile - std::add_cv,std::add_const,std::add_volatile

Synopsis
   Defined in header <type_traits>
   template< class T > (1) (since C++11)
   struct add_cv;
   template< class T > (2) (since C++11)
   struct add_const;
   template< class T > (3) (since C++11)
   struct add_volatile;
   Provides the member typedef type which is the same as T, except it has a
   cv-qualifier added (unless T is a function, a reference, or already has this
   cv-qualifier)
   1) adds both const and volatile
   2) adds const
   3) adds volatile
   If the program adds specializations for any of the templates described on this page,
   the behavior is undefined.

Member types
   Name Definition
   type the type T with the cv-qualifier

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

Possible implementation
   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; };

Notes
   These transformation traits can be used to establish non-deduced contexts in
   template argument deduction:
 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); // error, deduced conflicting types for 'T'
 g(4.2, 0); // OK, calls g<double>

Example
// Run this code
 #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();
 }

Output:
 Non-cv
 Const
 Volatile
 Const-volatile

See also
   is_const checks if a type is const-qualified
   (C++11) (class template)
   is_volatile checks if a type is volatile-qualified
   (C++11) (class template)
   remove_cv
   remove_const
   remove_volatile removes const and/or volatile specifiers from the given type
   (C++11) (class template)
   (C++11)
   (C++11)
   as_const obtains a reference to const to its argument
   (C++17) (function template)