How deeply does Learn C++ by Example cover is_move_constructible?

Defines rvalue constructibility, distinguishes it from move-constructor presence, and notes implicit-move limitations.

Is_move_constructible

is_move_constructible is a C++ type trait that determines whether a type can be constructed from an rvalue of the same type.

is_move_constructible is a compile-time type trait that asks whether a type can be constructed from an rvalue of that same type. It does not confirm that the type declares a move constructor. section 6.1.4

Checking an abstract type

A compile-time check can assert that Race::Blob is not move constructible. Because Blob is abstract, it cannot be constructed through copies or moves, even though it has a virtual destructor. section 6.1.4

Listing 6.10 Type traits to check for special member functions

#include <type_traits>
void check_properties()
{
    ...                                               #1
    static_assert(
        !std::is_default_constructible_v<Race::Blob>
    );                                                #2
    static_assert(
         std::is_destructible_v<Race::Blob>
    );                                                #2
    static_assert(
        !std::is_copy_constructible_v<Race::Blob>
    );                                                #2
    static_assert(
        !std::is_copy_assignable_v<Race::Blob>
    );                                                #2
    static_assert(
        !std::is_move_constructible_v<Race::Blob>
    );                                                #2
    static_assert(
        !std::is_move_assignable_v<Race::Blob>
    );                                                #2
    static_assert(
         std::has_virtual_destructor_v<Race::Blob>
    );                                                #3
}

Compare move-constructibility with default construction, destruction, copying, and move assignment in one constexpr static_assert checklist. section 6.1.4

A type may accept an apparent move while performing a copy instead. Declaring a destructor can block implicit move operations, so the trait may reveal constructibility without proving that move optimization is available. section 6.1.4

How Learn C++ by Example covers it

liveBook manning.com

Read Learn C++ by Example on liveBook Get the book at manning.com

Related concepts

rvaluemeasures · An rvalue is an expression that does not designate an assignable object and provides a value or temporary object for use in computation.
is_move_assignablecontrasts with · is_move_assignable is a C++ type trait that determines whether an object of a type can be assigned from an rvalue of that type.
is_constructibleuses · is_constructible is a C++ type trait that determines whether a type can be constructed from a specified set of argument types.

This explainer was generated by Manning's knowledge graph from the text of Learn C++ by Example. The section links point to the parts of the book it draws on.