C++

Reference

<type_traits>

class template
<type_traits>

std::is_fundamental

template <class T> struct is_fundamental;
Is fundamental type

Trait class that identifies whether T is a fundamental type.

It inherits from integral_constant as being either true_type or false_type, depending on whether T is one of the following types:

fundamental arithmetic types
integral typesbool
char
char16_t
char32_t
wchar_t
signed char
short int
int
long int
long long int
unsigned char
unsigned short int
unsigned int
unsigned long int
unsigned long long int
floating point typesfloat
double
long double
voidvoid
null pointerstd::nullptr_t

All fundamental types, along with all their aliases (like those in cstdint), are considered fundamental types by this class, including their const and volatile qualified variants.

Enums, along with pointers, references, classes and functions are not considered fundamental types in C++.

This is a compound type trait defined with the same behavior as:
1
2
3
4
 
template<class T>
struct is_fundamental : std::integral_constant < bool,
         is_integral<T>::value || is_floating_point<T>::value || is_void<T>:: value ||
         is_same<nullptr_t, typename remove_cv<T>::type>::value> {};

Template parameters

T
A type.

Member types

Inherited from integral_constant:
member typedefinition
value_typebool
typeeither true_type or false_type

Member constants

Inherited from integral_constant:
member constantdefinition
valueeither true or false

Member functions

Inherited from integral_constant:
operator bool
Returns value (public member function)

Example

1
2
3
4
5
6
7
8
9
10
11
12
13
 
// is_fundamental example
#include <iostream>
#include <type_traits>

int main() {
  std::cout << std::boolalpha;
  std::cout << "is_fundamental:" << std::endl;
  std::cout << "unsigned: " << std::is_fundamental<unsigned>::value << std::endl;
  std::cout << "float: " << std::is_fundamental<float>::value << std::endl;
  std::cout << "float*: " << std::is_fundamental<float*>::value << std::endl;
  std::cout << "decltype(nullptr): " << std::is_fundamental<decltype(nullptr)>::value << std::endl;
  return 0;
}

Output:
is_fundamental:
unsigned: true
float: true
float*: false
decltype(nullptr): true


See also

is_compound
Is compound type (class template)
is_object
Is object type (class template)
is_integral
Is integral (class template)
is_floating_point
Is floating point (class template)
is_void
Is void (class template)
is_signed
Is signed type (class template)
is_unsigned
Is unsigned type (class template)