std::remove_cv,std::remove_const,std::remove_volatile (3) - Linux Man Pages

std::remove_cv,std::remove_const,std::remove_volatile: std::remove_cv,std::remove_const,std::remove_volatile


std::remove_cv,std::remove_const,std::remove_volatile - std::remove_cv,std::remove_const,std::remove_volatile


Defined in header <type_traits>
template< class T > (1) (since C++11)
struct remove_cv;
template< class T > (2) (since C++11)
struct remove_const;
template< class T > (3) (since C++11)
struct remove_volatile;

Provides the member typedef type which is the same as T, except that its topmost cv-qualifiers are removed.
1) removes the topmost const, the topmost volatile, or both, if present.
2) removes the topmost const
3) removes the topmost volatile

Member types

Name Definition
type the type T without cv-qualifier

Helper types

template< class T > (since C++14)
using remove_cv_t = typename remove_cv<T>::type;
template< class T > (since C++14)
using remove_const_t = typename remove_const<T>::type;
template< class T > (since C++14)
using remove_volatile_t = typename remove_volatile<T>::type;

Possible implementation

  template< class T >
  struct remove_cv {
      typedef typename std::remove_volatile<typename std::remove_const<T>::type>::type type;

  template< class T > struct remove_const { typedef T type; };
  template< class T > struct remove_const<const T> { typedef T type; };

  template< class T > struct remove_volatile { typedef T type; };
  template< class T > struct remove_volatile<volatile T> { typedef T type; };


Removing const/volatile from const volatile int * does not modify the type, because the pointer itself is neither const nor volatile.
// Run this code

  #include <iostream>
  #include <type_traits>

  int main() {
      typedef std::remove_cv<const int>::type type1;
      typedef std::remove_cv<volatile int>::type type2;
      typedef std::remove_cv<const volatile int>::type type3;
      typedef std::remove_cv<const volatile int*>::type type4;
      typedef std::remove_cv<int * const volatile>::type type5;

      std::cout << "test1 " << (std::is_same<int, type1>::value
          ? "passed" : "failed") << '\n';
      std::cout << "test2 " << (std::is_same<int, type2>::value
          ? "passed" : "failed") << '\n';
      std::cout << "test3 " << (std::is_same<int, type3>::value
          ? "passed" : "failed") << '\n';
      std::cout << "test4 " << (std::is_same<const volatile int*, type4>::value
          ? "passed" : "failed") << '\n';
      std::cout << "test5 " << (std::is_same<int*, type5>::value
          ? "passed" : "failed") << '\n';


  test1 passed
  test2 passed
  test3 passed
  test4 passed
  test5 passed

See also

is_const checks if a type is const-qualified
             (class template)

is_volatile checks if a type is volatile-qualified
             (class template)

add_volatile adds const or/and volatile specifiers to the given type
             (class template)

remove_cvref combines std::remove_cv and std::remove_reference
             (class template)