Component bslmf_ispolymorphic [Package bslmf]

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

Namespaces
namespace	bslmf
namespace	bsl
Defines
#define	bslmf_IsPolymorphic   bslmf::IsPolymorphic

---

Detailed Description

Outline

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

Purpose:

Provide a compile-time check for determining polymorphic types.

Classes:

bsl::is_polymorphic	standard meta-function for detecting polymorphic types
bsl::is_polymorphic_v	the result value of the meta-function
bslmf::IsPolymorphic	meta-function for detecting polymorphic types

Description:

This component defines two meta-functions, bsl::is_polymorphic and BloombergLP::bslmf::IsPolymorphic and a template variable bsl::is_polymorphic_v, that represents the result value of the bsl::is_polymorphic meta-function. All of these meta-functions may be used to query whether a type is a polymorphic class as defined in the C++11 standard [class.virtual]. A class is polymorphic if it has at least one virtual function. Note that the destructor of such a class should always be declared virtual. Therefore, another definition of polymorphic is whether a class has a virtual destructor.

bsl::is_polymorphic has the same syntax as the is_polymorphic template defined in the C++11 standard [meta.unary.prop], while bslmf::IsPolymorphic was devised before is_polymorphic was standardized. bsl::is_polymorphic meets the requirements of the C++11 standard with two exceptions:

1. The compilation will fail if the meta-function is used to evaluate a union type, unless one of the following compilers, which provide an intrinsic operation to detect this specific trait, is used:

   • gcc 4.3 or later
   • Visual C++ 2008 or later

2. The meta-function will yield false positives, claiming non-polymorphic types are polymorphic, for types using virtual inheritance. This case is known to be handled correctly for the following compilers only:

   • Compilers with intrinsic support, listed above
   • IBM XLC

The two meta-functions are functionally equivalent. The major difference between them is that the result for bsl::is_polymorphic is indicated by the class member value, while the result for bslmf::IsPolymorphic is indicated by the class member VALUE. bsl::is_polymorphic should be preferred over bslmf::IsPolymorphic, and in general, should be used by new components.

Note that the template variable is_polymorphic_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_polymorphic_v is defined as an inline constexpr bool variable. Otherwise, if the compiler supports the variable templates C++14 compiler feature, bsl::is_polymorphic_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: Verify Polymorphic Types:

Suppose that we want to assert whether a particular type is a polymorphic type.

First, we define two types in a non-polymorphic hierarchy, MyStruct and MyDerivedStruct:

  struct MyStruct {
      void nonvirtualMethod();
  };
  struct MyDerivedStruct : public MyStruct {
  };

Then, we define two types in a polymorphic hierarchy, MyClass and MyDerivedClass:

  class MyClass {
    public:
      MyClass();
      virtual ~MyClass();  // makes 'MyClass' polymorphic
  };

  class MyDerivedClass : public MyClass {
    public:
      MyDerivedClass();
      virtual ~MyDerivedClass();
  };

Now, assert that the two types in the non-polymorphic hierarchy are not polymorphic, and that the two types in the polymorphic hierarchy are polymorphic using bsl::is_polymorphic:

  assert(false == bsl::is_polymorphic<MyStruct          >::value);
  assert(false == bsl::is_polymorphic<MyStruct         *>::value);
  assert(false == bsl::is_polymorphic<MyDerivedStruct&  >::value);
  assert(false == bsl::is_polymorphic<MyDerivedStruct  *>::value);

  assert(true  == bsl::is_polymorphic<      MyClass    >::value);
  assert(false == bsl::is_polymorphic<const MyClass&   >::value);
  assert(false == bsl::is_polymorphic<      MyClass   *>::value);
  assert(true  == bsl::is_polymorphic<MyDerivedClass   >::value);
  assert(false == bsl::is_polymorphic<MyDerivedClass&  >::value);
  assert(false == bsl::is_polymorphic<MyDerivedClass  *>::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_polymorphic_v variable as follows:

#ifdef BSLS_COMPILERFEATURES_SUPPORT_VARIABLE_TEMPLATES
  assert(false == bsl::is_polymorphic_v<MyStruct          >);
  assert(false == bsl::is_polymorphic_v<MyStruct         *>);
  assert(false == bsl::is_polymorphic_v<MyDerivedStruct&  >);
  assert(false == bsl::is_polymorphic_v<MyDerivedStruct  *>);

  assert(true  == bsl::is_polymorphic_v<      MyClass    >);
  assert(false == bsl::is_polymorphic_v<const MyClass&   >);
  assert(false == bsl::is_polymorphic_v<      MyClass   *>);
  assert(true  == bsl::is_polymorphic_v<MyDerivedClass   >);
  assert(false == bsl::is_polymorphic_v<MyDerivedClass&  >);
  assert(false == bsl::is_polymorphic_v<MyDerivedClass  *>);
#endif

---

Define Documentation

#define bslmf_IsPolymorphic   bslmf::IsPolymorphic