Component bslmf_isfundamental [Package bslmf]

Provide a compile-time check for determining fundamental types. More...

Namespaces
namespace	bslmf
namespace	bsl
Defines
#define	bslmf_IsFundamental   bslmf::IsFundamental

---

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:

Component bslmf_isenum, Component 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. In practice, both traits support both names of the result value, although the all-caps VALUE form is deprecated.

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

---

Define Documentation

#define bslmf_IsFundamental   bslmf::IsFundamental