< 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_scalar;
(since C++11)

std::is_scalar is a UnaryTypeTrait.

If T is a scalar type, provides the member constant value equal true. For any other type, value is false.

If the program adds specializations for std::is_scalar or std::is_scalar_v, the behavior is undefined.


[edit] Template parameters

T - a type to check

[edit] Helper variable template

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

Inherited from std::integral_constant

Member constants

true if T is a scalar 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

Each individual memory location in the C++ memory model, including the hidden memory locations used by language features (e.g. virtual table pointer), has scalar type (or is a sequence of adjacent bit-fields of non-zero length). Sequencing of side-effects in expression evaluation, inter-thread synchronization, and dependency ordering are all defined in terms of individual scalar objects.

[edit] Possible implementation

template<class T>
struct is_scalar : std::integral_constant<bool, std::is_arithmetic<T>::value
                                             || std::is_enum<T>::value
                                             || std::is_pointer<T>::value
                                             || std::is_member_pointer<T>::value
                                             || std::is_null_pointer<T>::value>

[edit] Example

#include <iostream>
#include <type_traits>
#include <typeinfo>
#include <utility>
template<typename Head, typename... Tail>
void are_scalars(Head&& head, Tail&&... tail)
    using T = std::decay_t<decltype(head)>;
    std::cout << typeid(T).name() << " is "
              << (std::is_scalar_v<T> ? "" : "not ")
              << "a scalar\n";
    if constexpr (sizeof... (Tail))
int main()
    struct S { int m; } s;
    int S::* mp = &S::m;
    enum class E { e };
    are_scalars(42, 3.14, E::e, "str", mp, nullptr, s);

Possible output:

int is a scalar
double is a scalar
main::E is a scalar
char const* is a scalar
int main::S::* is a scalar
nullptr is a scalar
main::S is not a scalar

[edit] See also

checks if a type is an arithmetic type
(class template) [edit]
checks if a type is an enumeration type
(class template) [edit]
checks if a type is a pointer type
(class template) [edit]
checks if a type is a pointer to a non-static member function or object
(class template) [edit]