<type_traits>

class template
<type_traits>

std::is_arithmetic

template <class T> struct is_arithmetic;
Is arithmetic type

Trait class that identifies whether T is an arithmetic type (either an integral or a floating point type).

It inherits from integral_constant as being either true_type or false_type, depending on whether T is an arithmetic type:

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

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

Enums are not considered arithmetic types in C++ (see is_enum).

This is a compound type trait defined with the same behavior as:
1
2
3
template<class T>
struct is_arithmetic : std::integral_constant < bool,
         is_integral<T>::value || is_floating_point<T>::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:

Example

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

int main() {
  std::cout << std::boolalpha;
  std::cout << "is_arithmetic:" << std::endl;
  std::cout << "char: " << std::is_arithmetic<char>::value << std::endl;
  std::cout << "float: " << std::is_arithmetic<float>::value << std::endl;
  std::cout << "float*: " << std::is_arithmetic<float*>::value << std::endl;
  std::cout << "complex<double>: " << std::is_arithmetic<std::complex<double>>::value << std::endl;
  return 0;
}


Output:
is_arithmetic:
char: true
float: true
float*: false
complex<double>: false

See also