std::optional<T>::emplace

	(1)
template< class... Args > T& emplace( Args&&... args );		(с C++17) (до C++20)
template< class... Args > constexpr T& emplace( Args&&... args );		(с C++20)
	(2)
template< class U, class... Args > T& emplace( std::initializer_list<U> ilist, Args&&... args );		(с C++17) (до C++20)
template< class U, class... Args > constexpr T& emplace( std::initializer_list<U> ilist, Args&&... args );		(с C++20)

Создаёт содержащее значение на месте. Если *this уже содержит значение перед вызовом, содержащее значение уничтожается вызовом его деструктора.

1) Инициализирует содержащее значение путём прямой инициализации (но не прямой инициализации списком) с std::forward<Args>(args)... в качестве параметров.

2) Инициализирует содержащее значение, вызвав его конструктор с ilist, std::forward<Args>(args)... в качестве параметров. Этот перегруз участвует в разрешении перегрузки только если std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value является true.

Параметры

args...	-	аргументы, передаваемые в конструктор
ilist	-	список инициализации, передаваемый в конструктор
Требования к типу
-`T` должен быть создаваемым из `Args...` для перегрузки (1)
-`T` должен быть создаваемым из `std::initializer_list` и `Args...` для перегрузки (2)

Возвращаемое значение

Ссылка на новое содержащее значение.

Исключение

Любое исключение, выброшенное выбранным конструктором T. Если выброшено исключение, *this не содержит значения после этого вызова (предыдущее содержащее значение, если таковое было, было уничтожено).

Пример

#include <optional>
#include <iostream>
 
struct A {
    std::string s;
    A(std::string str) : s(std::move(str)), id{n++} { note("+ constructed"); }
    ~A() { note("~ destructed"); }
    A(const A& o) : s(o.s), id{n++} { note("+ copy constructed"); }
    A(A&& o) : s(std::move(o.s)), id{n++} { note("+ move constructed"); }
    A& operator=(const A& other) {
        s = other.s;
        note("= copy assigned");
        return *this;
    }
    A& operator=(A&& other) {
        s = std::move(other.s);
        note("= move assigned");
        return *this;
    }
    inline static int n{};
    int id{};
    void note(auto s) { std::cout << "  " << s << " #" << id << '\n'; }
};
 
int main()
{
    std::optional<A> opt;
 
    std::cout << "Assign:\n";
    opt = A("Lorem ipsum dolor sit amet, consectetur adipiscing elit nec.");
 
    std::cout << "Emplace:\n";
    // As opt contains a value it will also destroy that value
    opt.emplace("Lorem ipsum dolor sit amet, consectetur efficitur.");
 
    std::cout << "End example\n";
}

Вывод:

Assign:
  + constructed #0
  + move constructed #1
  ~ destructed #0
Emplace:
  ~ destructed #1
  + constructed #2
End example
  ~ destructed #2

Отчеты об ошибках

Следующие отчеты об ошибках, изменяющие поведение, были применены ретроактивно к ранее опубликованным стандартам C++.

DR	Применён к	Поведение, как опубликовано	Правильное поведение
P2231R1	C++20	`emplace` не был constexpr, в то время как необходимые операции могут быть constexpr в C++20	сделано constexpr

См. также

operator=

присваивает содержимое
(общедоступный член-функция)

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/utility/optional/emplace