20 General utilities library [utilities]

20.8 Storage for any type [any]

20.8.4 Non-member functions [any.nonmembers]

🔗
void swap(any& x, any& y) noexcept;
1
#
Effects: Equivalent to x.swap(y).
🔗
template<class T, class... Args> any make_any(Args&&... args);
2
#
Effects: Equivalent to: return any(in_­place_­type<T>, std​::​forward<Args>(args)...);
🔗
template<class T, class U, class... Args> any make_any(initializer_list<U> il, Args&&... args);
3
#
Effects: Equivalent to: return any(in_­place_­type<T>, il, std​::​forward<Args>(args)...);
🔗
template<class T> T any_cast(const any& operand); template<class T> T any_cast(any& operand); template<class T> T any_cast(any&& operand);
4
#
Let U be the type remove_­cvref_­t<T>.
5
#
Mandates: For the first overload, is_­constructible_­v<T, const U&> is true.
For the second overload, is_­constructible_­v<T, U&> is true.
For the third overload, is_­constructible_­v<T, U> is true.
6
#
Returns: For the first and second overload, static_­cast<T>(*any_­cast<U>(&operand)).
For the third overload, static_­cast<T>(std​::​move(*any_­cast<U>(&operand))).
7
#
Throws: bad_­any_­cast if operand.type() != typeid(remove_­reference_­t<T>).
8
#
[ Example
: 
any x(5);                                   // x holds int
assert(any_cast<int>(x) == 5);              // cast to value
any_cast<int&>(x) = 10;                     // cast to reference
assert(any_cast<int>(x) == 10);

x = "Meow";                                 // x holds const char*
assert(strcmp(any_cast<const char*>(x), "Meow") == 0);
any_cast<const char*&>(x) = "Harry";
assert(strcmp(any_cast<const char*>(x), "Harry") == 0);

x = string("Meow");                         // x holds string
string s, s2("Jane");
s = move(any_cast<string&>(x));             // move from any
assert(s == "Meow");
any_cast<string&>(x) = move(s2);            // move to any
assert(any_cast<const string&>(x) == "Jane");

string cat("Meow");
const any y(cat);                           // const y holds string
assert(any_cast<const string&>(y) == cat);

any_cast<string&>(y);                       // error: cannot any_­cast away const
— end example
 ]
🔗
template<class T> const T* any_cast(const any* operand) noexcept; template<class T> T* any_cast(any* operand) noexcept;
9
#
Returns: If operand != nullptr && operand->type() == typeid(T), a pointer to the object contained by operand; otherwise, nullptr.
10
#
[ Example
: 
bool is_string(const any& operand) {
  return any_cast<string>(&operand) != nullptr;
}
— end example
 ]