FreeBSD Manual Pages
std::optional::emplace(3) C++ Standard Libary std::optional::emplace(3) NAME std::optional::emplace - std::optional::emplace Synopsis template< class... Args > (since C++17) T& emplace( Args&&... args ); (until C++20) template< class... Args > (since C++20) constexpr T& emplace( Args&&... args ); template< class U, class... Args > (1) (since C++17) T& emplace( std::initializer_list<U> ilist, (until C++20) Args&&... args ); (2) template< class U, class... Args > constexpr T& emplace( std::initializer_list<U> (since C++20) ilist, Args&&... args ); Constructs the contained value in-place. If *this already contains a value before the call, the contained value is destroyed by calling its destruc- tor. 1) Initializes the contained value by direct-initializing (but not direct-list-initializing) with std::forward<Args>(args)... as para- meters. 2) Initializes the contained value by calling its constructor with ilist, std::forward<Args>(args)... as parameters. This overload partici- pates in overload resolution only if std::is_constructible<T, std::initial- izer_list<U>&, Args&&...>::value is true. Parameters args... - the arguments to pass to the constructor ilist - the initializer list to pass to the con- structor Type requirements - T must be constructible from Args... for overload (1) - T must be constructible from std::initializer_list and Args... for overload (2) Return value A reference to the new contained value. Exceptions Any exception thrown by the selected constructor of T. If an excep- tion is thrown, *this does not contain a value after this call (the previously con- tained value, if any, had been destroyed). Example // Run this code #include <optional> #include <iostream> struct A { std::string s; A(std::string str) : s(std::move(str)), id{n++} { note("+ con- structed"); } ~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 con- structed"); } 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"; } Output: Assign: + constructed #0 + move constructed #1 ~ destructed #0 Emplace: ~ destructed #1 + constructed #2 End example ~ destructed #2 Defect reports The following behavior-changing defect reports were applied retroac- tively to previously published C++ standards. DR Applied to Behavior as published Correct behavior P2231R1 C++20 emplace was not constexpr while the required made constexpr operations can be constexpr in C++20 See also operator= assigns contents (public member function) http://cppreference.com 2022.07.31 std::optional::emplace(3)
NAME | Synopsis | Parameters | Type requirements | Return value | Exceptions | Example | Output: | See also
Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::optional::emplace&sektion=3&manpath=FreeBSD+Ports+15.0>