std::is_const - cppreference.com (original) (raw)

| | | | | -------------------------------------- | | ------------- | | 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.

Contents

• 1 Template parameters
• 2 Helper variable template
• 3 Inherited from std::integral_constant
  • 3.1 Member constants
  • 3.2 Member functions
  • 3.3 Member types
  • 3.4 Notes
  • 3.5 Possible implementation
  • 3.6 Example
  • 3.7 See also

[edit] Template parameters

[edit] Helper variable template

| template< class T > 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

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

Member types

[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 constness is to remove the reference:is_const<typename remove_reference<T>::type>.

[edit] Possible implementation

[edit] Example

#include   static_assert(std::is_same_v<const int*, int const*>, "Remember, constness binds tightly inside pointers."); static_assert(!std::is_const_v); static_assert(std::is_const_v); static_assert(!std::is_const_v<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:   static_assert(!std::is_const_v<decltype(&S::foo)>, "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 static_assert(!std::is_const_v<decltype(sfp)>, "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 static_assert(std::is_const_v<decltype(csfp)>, "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] |