std::variant::emplace

 

C++

Language

Standard library headers

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Filesystem library (C++17)

Technical Specifications

 

Utilities library

Type support (basic types, RTTI, type traits)

Dynamic memory management

Error handling

Program utilities

Variadic functions

Date and time

Function objects

initializer_list (C++11)

bitset

hash (C++11)

Relational operators

rel_ops::operator!=rel_ops::operator>rel_ops::operator<=rel_ops::operator>=

optional, any and variant (C++17)

optional

any

variant

in_placein_place_typein_place_indexin_place_tin_place_type_tin_place_index_t

Pairs and tuples

pair

tuple (C++11)

apply (C++17)

make_from_tuple (C++17)

piecewise_construct_t (C++11)

piecewise_construct (C++11)

integer_sequence (C++14)

Swap, forward and move

swap

exchange (C++14)

forward (C++11)

move (C++11)

move_if_noexcept (C++11)

Elementary string conversions

to_chars (C++17)

from_chars (C++17)

chars_format (C++17)

Type operations

declval (C++11)

as_const (C++17)

 

std::variant

Member functions

variant::variant

variant::~variant

variant::operator=

Observers

variant::index

variant::valueless_by_exception

Modifiers

variant::emplace

variant::swap

Non-member functions

visit

holds_alternative

get

get_if

operator==operator!=operator<operator<=operator>operator>=

swap

Helper classes

monostate

bad_variant_access

variant_size

variant_alternative

hash

uses_allocator

Helper objects

variant_npos

 

template <class T, class... Args> T& emplace(Args&&... args);	(1)	(since C++17)
template <class T, class U, class... Args> T& emplace(std::initializer_list<U> il, Args&&... args);	(2)	(since C++17)
template <size_t I, class... Args> std::variant_alternative_t<I, variant>& emplace(Args&&... args);	(3)	(since C++17)
template <size_t I, class U, class... Args> std::variant_alternative_t<I, variant>& emplace(std::initializer_list<U> il, Args&&... args);	(4)	(since C++17)

Creates a new value in-place, in an existing variant object

1) Equivalent to emplace<I>(std::forward<Args>(args)...), where I is the zero-based index of T in Types.... This overload only participates in overload resolution if std::is_constructible_v<T, Args...> is true, and T occurs exactly once in Types...

2) Equivalent to emplace<I>(il, std::forward<Args>(args)...), where I is the zero-based index of T in Types.... This overload only participates in overload resolution if std::is_constructible_v<T, std::initializer_list<U>&, Args...> is true, and T occurs exactly once in Types...

3) First, destroys the currently contained value (if any). Then direct-initializes the contained value as if constructing a value of type T_I with the arguments std::forward<Args>(args).... If an exception is thrown, *this may become valueless_by_exception. This overload only participates in overload resolution if std::is_constructible_v<T_I, Args...> is true. The behavior is undefined if I is not less than sizeof...(Types).

4) First, destroys the currently contained value (if any). Then direct-initializes the contained value as if constructing a value of type T_I with the arguments il, std::forward<Args>(args).... If an exception is thrown, *this may become valueless_by_exception. This overload only participates in overload resolution if std::is_constructible_v<T_I, initializer_list<U>&, Args...> is true. The behavior is undefined if I is not less than sizeof...(Types).

Parameters

args	-	constructor arguments to use when constructing the new value
il	-	initializer_list argument to use when constructing the new value

Return value

A reference to the new contained value.

Exceptions

1-4) Any exception thrown during the initialization of the contained value.

See also

operator=

assigns a variant (public member function)