bslmf_isfundamental

Macros
#define	bslmf_IsFundamental   bslmf::IsFundamental
	This alias is defined for backward compatibility.

Detailed Description

Outline

• Purpose
• Classes
• Description
  • Usage
    • Example 1: Verify Fundamental Types

Purpose

Provide a compile-time check for determining fundamental types.

Classes

• bsl::is_fundamental: standard meta-function for detecting fundamental types
• bsl::is_fundamental_v: the result value of bsl::is_fundamental
• bslmf::IsFundamental: meta-function for detecting fundamental types

See also

bslmf_isenum, bslmf_ispointer

Description

This component defines two meta-functions, bsl::is_fundamental and BloombergLP::bslmf::IsFundamental and a template variable bsl::is_fundamental_v, that represents the result value of the bsl::is_fundamental meta-function. All these meta-functions may be used to query whether a type is a fundamental type.

bsl::is_fundamental meets the requirements of the is_fundamental template defined in the C++11 standard [meta.unary.comp], while bslmf::Fundamental was devised before is_fundamental was standardized.

The two meta-functions are functionally equivalent except on reference of fundamental types. Lvalue-references to fundamental types are determined as fundamental types by bslmf::IsFundamental, but not by bsl::is_fundamental. Rvalue-references, on compilers that support them, are not deemed to be fundamental by either trait. In expected use, the result for bsl::is_fundamental is indicated by the class member value, while the result for bslmf::Fundamental is indicated by the class member value.

Note that bsl::is_fundamental should be preferred over bslmf::Fundamental, and in general, should be used by new components.

Also note that the template variable is_fundamental_v is defined in the C++17 standard as an inline variable. If the current compiler supports the inline variable C++17 compiler feature, bsl::is_fundamental_v is defined as an inline constexpr bool variable. Otherwise, if the compiler supports the variable templates C++14 compiler feature, bsl::is_fundamental_v is defined as a non-inline constexpr bool variable. See BSLS_COMPILERFEATURES_SUPPORT_INLINE_VARIABLES and BSLS_COMPILERFEATURES_SUPPORT_VARIABLE_TEMPLATES macros in bsls_compilerfeatures component for details.

The C++ fundamental types are described in the C++ standard [basic.fundamental], and consist of the following distinct types, and cv-qualified variations of these types:

bool
char
signed char
unsigned char
wchar_t
char16_t
char32_t
short int                                    (also referred to as "short")
unsigned short int                  (also referred to as "unsigned short")
int
unsigned int
long int                                      (also referred to as "long")
unsigned long int                    (also referred to as "unsigned long")
long long int                            (also referred to as "long long")
unsigned long long int          (also referred to as "unsigned long long")
float
double
long double
void
nullptr_t

Usage

In this section we show intended use of this component.

Example 1: Verify Fundamental Types

Suppose that we want to assert whether a set of types are fundamental types.

Now, we instantiate the bsl::is_fundamental template for several non-fundamental and fundamental types, and assert the value static data member of each instantiation:

assert(true  == bsl::is_fundamental<int>::value);
assert(false == bsl::is_fundamental<int&>::value);
assert(true  == bsl::is_fundamental<long long  >::value);
assert(false == bsl::is_fundamental<long long *>::value);

Note that if the current compiler supports the variable templates C++14 feature then we can re-write the snippet of code above using the bsl::is_fundamental_v variable as follows:

#ifdef BSLS_COMPILERFEATURES_SUPPORT_VARIABLE_TEMPLATES
  assert(true  == bsl::is_fundamental_v<int>);
  assert(false == bsl::is_fundamental_v<int&>);
  assert(true  == bsl::is_fundamental_v<long long  >);
  assert(false == bsl::is_fundamental_v<long long *>);
#endif

Macro Definition Documentation

bslmf_IsFundamental

#define bslmf_IsFundamental   bslmf::IsFundamental