std::any::operator=
From cppreference.com
C++
Feature test macros (C++20)
Concepts library (C++20)
Metaprogramming library (C++11)
Ranges library (C++20)
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Utilities library
Type support (basic types, RTTI)
Library feature-test macros (C++20)
(C++11)
(C++20)
(C++26)
(C++20)
Coroutine support (C++20)
Contract support (C++26)
(C++20)(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)(C++20)(C++20)
(C++20)(C++20)(C++20)
General utilities
Relational operators (deprecated in C++20)
(C++20)(C++20)(C++20)
(C++20)(C++20)(C++20)
(C++20)
Swap and type operations
Common vocabulary types
any& operator=( const any& rhs );
(1)
(since C++17)
any& operator=( any&& rhs ) noexcept;
(2)
(since C++17)
template< typename ValueType >
any& operator=( ValueType&& rhs );
(3)
(since C++17)
any& operator=( ValueType&& rhs );
Assigns contents to the contained value.
2) Assigns by moving the state of rhs, as if by std::any (std::move(rhs)).swap(*this). rhs is left in a valid but unspecified state after the assignment.
3) Assigns the type and value of rhs, as if by std::any (std::forward <ValueType>(rhs)).swap(*this). This overload participates in overload resolution only if std::decay_t <ValueType> is not the same type as std::any and std::is_copy_constructible_v <std::decay_t <ValueType>> is true.
[edit] Template parameters
ValueType
-
contained value type
Type requirements
-
std::decay_t <ValueType> must meet the requirements of CopyConstructible.
[edit] Parameters
rhs
-
object whose contained value to assign
[edit] Return value
*this
[edit] Exceptions
1,3) Throws std::bad_alloc or any exception thrown by the constructor of the contained type.
If an exception is thrown for any reason, these functions have no effect (strong exception safety guarantee).
[edit] Example
Run this code
#include <any> #include <cassert> #include <iomanip> #include <iostream> #include <string> #include <typeinfo> int main() { using namespace std::string_literals; std::string cat{"cat"}; std::any a1{42}; std::any a2{cat}; assert (a1.type() == typeid(int)); assert (a2.type() == typeid(std::string )); a1 = a2; // overload (1) assert (a1.type() == typeid(std::string )); assert (a2.type() == typeid(std::string )); assert (std::any_cast <std::string &>(a1) == cat); assert (std::any_cast <std::string &>(a2) == cat); a1 = 96; // overload (3) a2 = "dog"s; // overload (3) a1 = std::move(a2); // overload (2) assert (a1.type() == typeid(std::string )); assert (std::any_cast <std::string &>(a1) == "dog"); // The state of a2 is valid but unspecified. In fact, // it is void in gcc/clang and std::string in msvc. std::cout << "a2.type(): " << std::quoted (a2.type().name()) << '\n'; a1 = std::move(cat); // overload (3) assert (*std::any_cast <std::string >(&a1) == "cat"); // The state of cat is valid but indeterminate: std::cout << "cat: " << std::quoted (cat) << '\n'; }
Possible output:
a2.type(): "void" cat: ""