std::any::operator=

 

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

 

Utilities library

Language support Type support (basic types, RTTI) Library feature-test macros (C++20) Program utilities Variadic functions initializer_list (C++11) is_constant_evaluated (C++20) is_within_lifetime (C++26) source_location (C++20) Coroutine support (C++20) Contract support (C++26) Three-way comparison three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

General utilities Function objects Bit manipulation (C++20) bitset hash (C++11) Relational operators (deprecated in C++20) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Integer comparison functions cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Swap and type operations swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Common vocabulary types pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

std::any

Member functions

any::any

any::~any

any::operator=

Modifiers

any::emplace

any::reset

any::swap

Observers

any::has_value

any::type

Non-member functions

swap(std::any)

any_cast

make_any

Helper classes

bad_any_cast

 

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)

Assigns contents to the contained value.

1) Assigns by copying the state of rhs, as if by std::any(rhs).swap(*this).

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.

Template parameters

ValueType	-	contained value type
Type requirements
- std::decay_t<ValueType> must meet the requirements of CopyConstructible.

Parameters

rhs

-

object whose contained value to assign

Return value

*this

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).

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: ""

See also

(constructor)

constructs an any object (public member function)