NAME

std::any::any - std::any::any

Synopsis

constexpr any() noexcept; (1) (since C++17)
any( const any& other ); (2) (since C++17)
any( any&& other ) noexcept; (3) (since C++17)
template< class ValueType > (4) (since C++17)
any( ValueType&& value );
template< class ValueType, class... Args > (5) (since C++17)
explicit any( std::in_place_type_t<ValueType>, Args&&... args );
template< class ValueType, class U, class... Args >

explicit any( std::in_place_type_t<ValueType>, (6) (since C++17)
std::initializer_list<U> il,

Args&&... args );

Constructs a new any object.

1) Constructs an empty object.
2-3) Copies (2) or moves (3) content of other into a new instance, so that any
content is equivalent in both type and value to those of other prior to the
constructor call, or empty if other is empty. Formally,
2) If other is empty, the constructed object is empty. Otherwise, equivalent to
any(std::in_place_type<T>, std::any_cast<const T&>(other)), where T is the type of
the object contained in other.
3) If other is empty, the constructed object is empty. Otherwise, the constructed
object contains either the object contained in other, or an object of the same type
constructed from the object contained in other, considering that object as an

rvalue.

4) Constructs an object with initial content an object of type
std::decay_t<ValueType>, direct-initialized from std::forward<ValueType>(value).

* This overload participates in overload resolution only if
std::decay_t<ValueType> is not the same type as any nor a specialization of
std::in_place_type_t, and std::is_copy_constructible_v<std::decay_t<ValueType>>
is true.

5) Constructs an object with initial content an object of type
std::decay_t<ValueType>, direct-non-list-initialized from
std::forward<Args>(args)....

* This overload participates in overload resolution only if
std::is_constructible_v<std::decay_t<ValueType>, Args...> and
std::is_copy_constructible_v<std::decay_t<ValueType>> are both true.

6) Constructs an object with initial content an object of type
std::decay_t<ValueType>, direct-non-list-initialized from il,
std::forward<Args>(args)....

* This overload participates in overload resolution only if
std::is_constructible_v<std::decay_t<ValueType>, std::initializer_list<U>&,
Args...> and std::is_copy_constructible_v<std::decay_t<ValueType>> are both
true.

Template parameters

ValueType - contained value type

Type requirements

-
std::decay_t<ValueType> must meet the requirements of CopyConstructible.

Parameters

other - another any object to copy or move from
value - value to initialize the contained value with
il, args - arguments to be passed to the constructor of the contained object

Exceptions

2,4,5,6) Throws any exception thrown by the constructor of the contained type.

Notes

Because the default constructor is constexpr, static std::anys are initialized as
part of static non-local initialization, before any dynamic non-local initialization
begins. This makes it safe to use an object of type std::any in a constructor of any
static object.

Example

// Run this code

#include <utility>
#include <set>
#include <any>
#include <string>
#include <memory>
#include <iostream>
#include <initializer_list>
#include <cxxabi.h>

struct A {
int age;
std::string name;
double salary;
};

// using abi demangle to print nice type name of instance of any holding
void printType(const std::any& a) {
int status;
if (char* p = abi::__cxa_demangle(a.type().name(), 0, 0, &status)){
std::cout << p << '\n';
std::free(p);
}
}

int main(){
// constructor #4: std::any holding int
std::any a1{7};

// constructor #5: std::any holding A, constructed in place
std::any a2(std::in_place_type_t<A>{}, 30, "Ada", 1000.25);

// constructor #6: std::any holding a set of A with custom comparison
auto lambda = [](auto&& l, auto&& r){ return l.age < r.age; };
std::any a3(
std::in_place_type_t<std::set<A, decltype(lambda)>>{},
std::initializer_list<A>{
{39, std::string{"Ada"}, 100.25},
{20, std::string{"Bob"}, 75.5}
},
lambda);

printType(a1);
printType(a2);
printType(a3);
}

Possible output:

int
A
std::set<A, main::{lambda(auto:1&&, auto:2&&)#1}, std::allocator<A> >