Component bslmf_issame [Package bslmf]

Provide a meta-function for testing if two types are the same. More...

Classes
struct	bsl::is_same< t_TYPE1, t_TYPE2 >
struct	bsl::is_same< t_TYPE, t_TYPE >

---

Detailed Description

Outline

• Purpose
• Classes
• Description
  • Usage
    • Example 1: Determine Same Types

Purpose:

Provide a meta-function for testing if two types are the same.

Classes:

bsl::is_same	standard meta-function for testing if two types are the same
bsl::is_same_v	the result value of the standard meta-function
bslmf::IsSame	meta-function for testing if two types are the same

Description:

This component defines two meta-functions, bsl::is_same and BloombergLP::bslmf::IsSame and a template variable bsl::is_same_v, that represents the result value of the bsl::is_same meta-function. All these meta-functions may be used to query whether two types are the same. Two types are the same if they name the same type having the same cv-qualifications.

bsl::is_same meets the requirements of the is_same template defined in the C++11 standard [meta.rel], while bslmf::IsSame was devised before is_same was standardized.

The two meta-functions are functionally equivalent. The major difference between them is that the result for bsl::is_same is indicated by the class member value, while the result for bslmf::IsSame is indicated by the class member VALUE.

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

Also note that the template variable is_same_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_same_v is defined as an inline constexpr bool variable. Otherwise, if the compiler supports the variable templates C++14 compiler feature, bsl::is_same_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.

Usage:

In this section we show intended use of this component.

Example 1: Determine Same Types:

Suppose that we have several pairs of types and want to assert whether the types in each pair are the same.

First, we define several typedefs:

  typedef       int    INT1;
  typedef       double DOUBLE;
  typedef       short  SHORT;
  typedef const short  CONST_SHORT;
  typedef       int    INT2;
  typedef       int&   INT_REF;

Now, we instantiate the bsl::is_same template for certain pairs of the typedefs and assert the value static data member of each instantiation:

  assert(true  == (bsl::is_same<INT1, INT2>::value));
  assert(false == (bsl::is_same<INT, DOUBLE>::value));

Note that a const-qualified type is considered distinct from the non-'const' (but otherwise identical) type:

  assert(false == (bsl::is_same<SHORT, CONST_SHORT>::value));

Similarly, a t_TYPE and a reference to t_TYPE (t_TYPE&) are distinct:

  assert(false == (bsl::is_same<INT, INT_REF>::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_same_v variable as follows:

#ifdef BSLS_COMPILERFEATURES_SUPPORT_VARIABLE_TEMPLATES
  assert(false == (bsl::is_same_v<SHORT, CONST_SHORT>));
  assert(false == (bsl::is_same_v<INT, INT_REF>));
#endif