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

| | | | | ----------------------------------------- | | ------------- | | template< class T > struct is_integral; | | (since C++11) |

std::is_integral is a UnaryTypeTrait.

Checks whether T is an integral type. Provides the member constant value which is equal to true, if T is the type bool, char, char8_t(since C++20), char16_t, char32_t, wchar_t, short, int, long, long long, or any implementation-defined extended integer types, including any signed, unsigned, and cv-qualified variants. Otherwise, value is equal to false.

If the program adds specializations for std::is_integral or std::is_integral_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 Possible implementation
  • 3.5 Example
  • 3.6 See also

[edit] Template parameters

[edit] Helper variable template

| template< class T > constexpr bool is_integral_v = is_integral<T>::value; | | (since C++17) | | ------------------------------------------------------------------------------- | | ------------- |

Inherited from std::integral_constant

Member constants

| | true if T is an integral 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] Possible implementation

// Note: this implementation uses C++20 facilities template struct is_integral : std::bool_constant< requires (T t, T* p, void (*f)(T)) // T* parameter excludes reference types { reinterpret_cast(t); // Exclude class types f(0); // Exclude enumeration types p + t; // Exclude everything not yet excluded but integral types }> {};

[edit] Example

#include   static_assert ( std::is_integral_v == false && std::is_integral_v<int*> == false && std::is_integral_v == true && std::is_integral_v == true && std::is_integral_v == true && std::is_integral_v == true );   class A {}; static_assert(std::is_integral_v == false);   struct B { int x:4; }; static_assert(std::is_integral_v == false); using BF = decltype(B::x); // bit-field's type static_assert(std::is_integral_v == true);   enum E : int {}; static_assert(std::is_integral_v == false);   template constexpr T same(T i) { static_assert(std::is_integral::value, "Integral required."); return i; } static_assert(same('"') == 042);   int main() {}

[edit] See also

| | specifies that a type is an integral type (concept) [edit] | | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | | identifies integer types (public static member constant of std::numeric_limits) [edit] | | | checks if a type is a floating-point type (class template) [edit] | | | checks if a type is an arithmetic type (class template) [edit] | | | checks if a type is an enumeration type (class template) [edit] |