bslmf_issame

Macros
#define	bslmf_IsSame   bslmf::IsSame
	This alias is defined for backward compatibility.

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

Macro Definition Documentation

bslmf_IsSame

#define bslmf_IsSame   bslmf::IsSame