std::reference_constructs_from_temporary

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Diagnostics library

Memory management library

Metaprogramming library (C++11)

General utilities library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Strings library

Text processing library

Numerics library

Date and time library

Input/output library

Filesystem library (C++17)

Concurrency support library (C++11)

Execution control library (C++26)

Technical specifications

Symbols index

External libraries

 

Metaprogramming library

Type traits (C++11)

Compile-time rational arithmetic (C++11)

Compile-time integer sequences (C++14)

integer_sequence (C++14)

Compile-time reflection (C++26)

 

Type traits

Type traits (since C++11)

Type categories is_void is_null_pointer (DR*) is_reflection (C++26) is_array is_pointer is_enum is_union is_class is_function is_reference      is_object is_scalar is_compound is_integral is_floating_point      is_fundamental is_arithmetic is_lvalue_reference is_rvalue_reference is_member_pointer is_member_object_pointer is_member_function_pointer Type properties is_const is_volatile is_empty is_polymorphic is_final (C++14) is_abstract is_aggregate (C++17) is_structural (C++26) is_implicit_lifetime (C++23) is_trivial (deprecated in C++26) is_trivially_copyable is_standard_layout is_literal_type (until C++20*) is_pod (deprecated in C++20) is_signed is_unsigned is_bounded_array (C++20) is_unbounded_array (C++20) is_scoped_enum (C++23) has_unique_object_   representations (C++17)     Type trait constants integral_constantbool_constanttrue_typefalse_type (C++17) Metafunctions conjunction (C++17) disjunction (C++17) negation (C++17)

Supported operations is_constructibleis_trivially_constructibleis_nothrow_constructible is_default_constructibleis_trivially_default_constructibleis_nothrow_default_constructible is_copy_constructibleis_trivially_copy_constructibleis_nothrow_copy_constructible is_move_constructibleis_trivially_move_constructibleis_nothrow_move_constructible is_assignableis_trivially_assignableis_nothrow_assignable is_copy_assignableis_trivially_copy_assignableis_nothrow_copy_assignable is_move_assignableis_trivially_move_assignableis_nothrow_move_assignable is_destructibleis_trivially_destructibleis_nothrow_destructible has_virtual_destructor is_swappable_withis_swappableis_nothrow_swappable_withis_nothrow_swappable (C++17)(C++17)(C++17)(C++17) Relationships and property queries is_same is_convertibleis_nothrow_convertible (C++20) is_layout_compatible (C++20) is_pointer_interconvertible_base_of (C++20) is_pointer_interconvertible_with_class (C++20)     is_corresponding_member (C++20) reference_constructs_from_temporary (C++23) reference_converts_from_temporary (C++23) alignment_of is_base_of is_virtual_base_of (C++26) rank extent is_invocableis_invocable_ris_nothrow_invocableis_nothrow_invocable_r (C++17)(C++17)(C++17)(C++17) is_applicableis_nothrow_applicable (C++26)(C++26) Type modifications remove_cvremove_constremove_volatile add_cvadd_constadd_volatile make_signed make_unsigned remove_reference add_lvalue_referenceadd_rvalue_reference remove_pointer add_pointer remove_extent remove_all_extents Type transformations aligned_storage (deprecated in C++23) aligned_union (deprecated in C++23) decay remove_cvref (C++20) result_ofinvoke_result (until C++20*)(C++17) apply_result (C++26) conditional common_type common_reference (C++20) underlying_type type_identity (C++20) enable_if void_t (C++17)

 

Defined in header <type_traits>
template< class To, class From > struct reference_constructs_from_temporary;		(since C++23)

See More

Let V be std::remove_cv_t<From> if From is a scalar type or cv void, or From otherwise. If To is a reference type, and given a hypothetical expression e such that decltype(e) is V, the variable definition To ref(e); is well-formed and binds a temporary object to ref, then provides the member constant value equal to true. Otherwise, value is false.

If To is an lvalue reference type to a const- but not volatile-qualified object type or an rvalue reference type, both std::remove_reference_t<To> and std::remove_reference_t<From> must be complete types, cv void, or an arrays of unknown bound; otherwise the behavior is undefined.

If an instantiation of a template above depends, directly or indirectly, on an incomplete type, and that instantiation could yield a different result if that type were hypothetically completed, the behavior is undefined.

If the program adds specializations for std::reference_constructs_from_temporary or std::reference_constructs_from_temporary_v, the behavior is undefined.

Helper variable template

template< class To, class From > constexpr bool reference_constructs_from_temporary_v = std::reference_constructs_from_temporary<To, From>::value;		(since C++23)

Inherited from std::integral_constant

Member constants

value [static]

true if To is a reference type, a From value can be bound to To in direct-initialization, and a temporary object would be bound to the reference, false otherwise (public static member constant)

Member functions

operator bool	converts the object to bool, returns value (public member function)
operator() (C++14)	returns value (public member function)

Member types

Type	Definition
value_type	bool
type	std::integral_constant<bool, value>

Notes

std::reference_constructs_from_temporary can be used for rejecting some cases that always produce dangling references.

It is also possible to use member initializer list to reject binding a temporary object to a reference if the compiler has implemented CWG1696.

Example

Run this code

#include <type_traits>

static_assert
(
       std::reference_constructs_from_temporary_v<int&&, int>
    && std::reference_constructs_from_temporary_v<const int&, int>
    && !std::reference_constructs_from_temporary_v<int&&, int&&>
    && !std::reference_constructs_from_temporary_v<const int&, int&&>
    && std::reference_constructs_from_temporary_v<int&&, long&&>
    && std::reference_constructs_from_temporary_v<int&&, long>
);


struct S
{
    operator int() const;
    explicit operator const int&() const;
};

// For reference construction (direct init), explicit conversions are considered,
// so `operator const int&` is found, which is not classified as conversion from a temporary
static_assert(!std::reference_constructs_from_temporary_v<const int&, S>);

// For reference conversion (copy init), explicit conversions are disregarded,
// so `operator int` is found, which produces a temporary to which a `const int&` would bind
static_assert(std::reference_converts_from_temporary_v<const int&, S>);


struct Bad
{
    explicit operator int() const
    {
        return {};
    }
};

struct Fine
{
    explicit operator const int&() const
    {
        static int t;
        return t;
    }
};

template<typename T>
struct Wrapper
{
    T t;

    template<typename TT>
    Wrapper(TT&& tt)
        : t(tt) // The construction of T is done here...
    {
        // ... So if the conversion from TT to T results in a temporary,
        // that temporary will be destroyed when this function returns
        // I.e., it is guaranteed that t will be dangling

        static_assert(
            !std::reference_constructs_from_temporary_v<T, TT>,
            "Unconditionally dangling reference caused by explicit conversion"
        );
    }
};

int main()
{
    // Wrapper<const int&> w_bad(Bad{});
    Wrapper<const int&> w_fine(Fine{});
}

See also

is_constructibleis_trivially_constructibleis_nothrow_constructible (C++11)(C++11)(C++11)	checks if a type has a constructor for specific arguments (class template)
(constructor)	constructs a new tuple (public member function of std::tuple<Types...>)
(constructor)	constructs new pair (public member function of std::pair<T1,T2>)
make_from_tuple (C++17)	construct an object with a tuple of arguments (function template)
reference_converts_from_temporary (C++23)	checks if a reference is bound to a temporary in copy-initialization (class template)
reference_constructs_from_temporary (C++26)	checks if a reference is bound to a temporary in direct-initialization (function)