std::is_const(3)

NAME
std::is_const - std::is_const

Synopsis
   Defined in header <type_traits>
   template< class T > (since C++11)
   struct is_const;
   If T is a const-qualified type (that is, const, or const volatile), provides the
   member constant value equal to true. For any other type, value is false.
   The behavior of a program that adds specializations for is_const
   or is_const_v
   (since C++17) is undefined.

Template parameters
   T - a type to check
  Helper variable template
   template< class T > (since C++17)
   inline constexpr bool is_const_v = is_const<T>::value; Inherited from std::integral_constant

Member constants
   value true if T is a const-qualified type , false otherwise
   [static] (public static member constant)

Member functions
   operator bool converts the object to bool, returns value
                 (public member function)
   operator() returns value
   (C++14) (public member function)

Member types
   Type Definition
   value_type bool
   type std::integral_constant<bool, value>

Notes
   If T is a reference type then is_const<T>::value is always false. The proper way to
   check a potentially-reference type for const-ness is to remove the reference:
   is_const<typename remove_reference<T>::type>.

Possible implementation
   template<class T> struct is_const : std::false_type {};
   template<class T> struct is_const<const T> : std::true_type {};

Example
// Run this code
 #include <iostream>
 #include <type_traits>
 int main()
 {
     std::cout << std::boolalpha
         << std::is_const_v<int> << '\n' // false
         << std::is_const_v<const int> << '\n' // true
         << std::is_const_v<const int*> // false
         << " because the pointer itself can be changed but not the int pointed at\n"
         << std::is_const_v<int* const> // true
         << " because the pointer itself can't be changed but the int pointed at can\n"
         << std::is_const_v<const int&> << '\n' // false
         << std::is_const_v<std::remove_reference_t<const int&>> << '\n' // true
         ;
 }

Output:
 false
 true
 false because the pointer itself can be changed but not the int pointed at
 true because the pointer itself can't be changed but the int pointed at can
 false
 true

See also
   is_volatile checks if a type is volatile-qualified
   (C++11) (class template)
   as_const obtains a reference to const to its argument
   (C++17) (function template)