bslmf_istriviallydefaultconstructible

Detailed Description

Outline

• Purpose
• Classes
• Description
  • Usage
    • Example 1: Verify Whether Types are Trivially Default-Constructible

Purpose

Provide a compile-time check for trivially default-constructible.

Classes

• bsl::is_trivially_default_constructible: trait meta-function
• bsl::is_trivially_default_constructible_v: the result value

See also

bslmf_integerconstant, bslmf_nestedtraitdeclaration

Description

This component defines a meta-function, bsl::is_trivially_default_constructible and a template variable bsl::is_trivially_default_constructible_v, that represents the result value of the bsl::is_trivially_default_constructible meta-function, that may be used to query whether a type has a trivial default constructor as defined in section 12.1.5 of the C++11 standard [class.ctor].

bsl::is_trivially_default_constructible has the same syntax as the is_trivially_default_constructible template from the C++11 standard [meta.unary.prop]. However, unlike the template defined in the C++11 standard, which can determine the correct value for all types without requiring specialization, bsl::is_trivially_default_constructible can, by default, determine the value for the following type categories only:

Type Category        Has Trivial Default Constructor
-------------------  -------------------------------
reference types      false
fundamental types    true
enums                true
pointers             true
pointers to members  true

For all other types, bsl::is_trivially_default_constructible returns false, unless the type is explicitly specified to be trivially default-constructible, which can be done in two ways:

1. Define a template specialization for bsl::is_trivially_default_constructible having the type as the template parameter that inherits directly from bsl::true_type.
2. Use the BSLMF_NESTED_TRAIT_DECLARATION macro to define bsl::is_trivially_default_constructible as the trait in the class definition of the type.

Note that the template variable is_trivially_default_constructible_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_trivially_default_constructible_v is defined as an inline constexpr bool variable. Otherwise, if the compiler supports the variable templates C++14 compiler feature, bsl::is_trivially_default_constructible_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 Whether Types are Trivially Default-Constructible

Suppose that we want to assert whether a type is trivially default-constructible.

First, we define a set of types to evaluate:

typedef int MyFundamentalType;
typedef int& MyFundamentalTypeReference;
 
class MyTriviallyDefaultConstructibleType {
};
 
struct MyNonTriviallyDefaultConstructibleType {
 
    int d_data;
 
    MyNonTriviallyDefaultConstructibleType()
    : d_data(1)
    {
    }
};

Then, since user-defined types cannot be automatically evaluated by is_trivially_default_constructible, we define a template specialization to specify that MyTriviallyDefaultConstructibleType is trivially default-constructible:

namespace bsl {
 
template <>
struct is_trivially_default_constructible<
                    MyTriviallyDefaultConstructibleType> : bsl::true_type {
    // This template specialization for
    // 'is_trivially_default_constructible' indicates that
    // 'MyTriviallyDefaultConstructibleType' is a trivially
    // default-constructible type.
};
 
}  // close namespace bsl

Now, we verify whether each type is trivially default-constructible using bsl::is_trivially_default_constructible:

assert(true  ==
        bsl::is_trivially_default_constructible<MyFundamentalType>::value);
assert(false ==
    bsl::is_trivially_default_constructible<
                                       MyFundamentalTypeReference>::value);
assert(true  ==
    bsl::is_trivially_default_constructible<
                              MyTriviallyDefaultConstructibleType>::value);
assert(false ==
    bsl::is_trivially_default_constructible<
                           MyNonTriviallyDefaultConstructibleType>::value);

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

#ifdef BSLS_COMPILERFEATURES_SUPPORT_VARIABLE_TEMPLATES
  assert(true  ==
          bsl::is_trivially_default_constructible_v<MyFundamentalType>);
  assert(false ==
      bsl::is_trivially_default_constructible_v<MyFundamentalTypeReference>);
  assert(true  ==
      bsl::is_trivially_default_constructible_v<
                                       MyTriviallyDefaultConstructibleType>);
  assert(false ==
      bsl::is_trivially_default_constructible_v<
                                    MyNonTriviallyDefaultConstructibleType>);
#endif