< cpp‎ | types
Metaprogramming library
Type traits
Type categories
Type properties
(C++11)(until C++20*)
(C++11)(deprecated in C++20)
Type trait constants
Supported operations
Relationships and property queries
Type modifications
Type transformations
(C++11)(deprecated in C++23)
(C++11)(deprecated in C++23)

(C++11)(until C++20*)(C++17)
Compile-time rational arithmetic
Compile-time integer sequences
Defined in header <type_traits>
template< class T >
struct is_const;
(since C++11)

std::is_const is a UnaryTypeTrait.

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.

If the program adds specializations for std::is_const or std::is_const_v, the behavior is undefined.


[edit] Template parameters

T - a type to check

[edit] Helper variable template

template< class T >
inline constexpr bool is_const_v = is_const<T>::value;
(since C++17)

Inherited from std::integral_constant

Member constants

true if T is a const-qualified type, false otherwise
(public static member constant)

Member functions

operator bool
converts the object to bool, returns value
(public member function)
returns value
(public member function)

Member types

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

[edit] 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>.

[edit] Possible implementation

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

[edit] Example

#include <type_traits>
static_assert(std::is_same_v<const int*, int const*>,
    "Remember, const-ness binds tightly inside pointers.");
static_assert(std::is_const_v<const int>);
static_assert(std::is_const_v<int* const>,
    "Because the pointer itself can't be changed but the int pointed at can.");
static_assert(!std::is_const_v<const int*>,
    "Because the pointer itself can be changed but not the int pointed at.");
static_assert(!std::is_const_v<const int&>);
static_assert(std::is_const_v<std::remove_reference_t<const int&>>);
struct S
    void foo() const {}
    void bar() const {}
int main()
    // A const member function is const in a different way:
        "Because &S::foo is a pointer.");
    using S_mem_fun_ptr = void(S::*)() const;
    S_mem_fun_ptr sfp = &S::foo;
    sfp = &S::bar; // OK, can be re-pointed
        "Because sfp is the same pointer type and thus can be re-pointed.");
    const S_mem_fun_ptr csfp = &S::foo;
    // csfp = &S::bar; // Error
        "Because csfp cannot be re-pointed.");

[edit] See also

checks if a type is volatile-qualified
(class template) [edit]
obtains a reference to const to its argument
(function template) [edit]