std::any (3) - Linux Manuals

std::any: std::any

NAME

std::any - std::any

Synopsis

Defined in header <any>
class any; (since C++17)

The class any describes a type-safe container for single values of any type.
1) An object of class any stores an instance of any type that satisfies the constructor requirements or is empty, and this is referred to as the state of the class any object. The stored instance is called the contained object. Two states are equivalent if they are either both empty or if both are not empty and if the contained objects are equivalent.
2) The non-member any_cast functions provide type-safe access to the contained object.
Implementations are encouraged to avoid dynamic allocations for small objects, but such an optimization may only be applied to types for which std::is_nothrow_move_constructible returns true.

Member functions

              constructs an any object
constructor (public member function)
              assigns an any object
operator= (public member function)
              destroys an any object
destructor (public member function)

Modifiers

              change the contained object, constructing the new object directly
emplace (public member function)
              destroys contained object
reset (public member function)
              swaps two any objects
swap (public member function)

Observers

              checks if object holds a value
has_value (public member function)
              returns the typeid of the contained value
type (public member function)

Non-member functions

std::swap(std::any) specializes the std::swap algorithm
                    (function)
(C++17)

any_cast type-safe access to the contained object
                    (function template)
(C++17)

make_any creates an any object
                    (function template)
(C++17)

Helper classes

bad_any_cast exception thrown by the value-returning forms of any_cast on a type mismatch
             (class)
(C++17)

Example

// Run this code

  #include <any>
  #include <iostream>

  int main()
  {
      std::cout << std::boolalpha;

      // any type
      std::any a = 1;
      std::cout << a.type().name() << ": " << std::any_cast<int>(a) << '\n';
      a = 3.14;
      std::cout << a.type().name() << ": " << std::any_cast<double>(a) << '\n';
      a = true;
      std::cout << a.type().name() << ": " << std::any_cast<bool>(a) << '\n';

      // bad cast
      try
      {
          a = 1;
          std::cout << std::any_cast<float>(a) << '\n';
      }
      catch (const std::bad_any_cast& e)
      {
          std::cout << e.what() << '\n';
      }

      // has value
      a = 1;
      if (a.has_value())
      {
          std::cout << a.type().name() << '\n';
      }

      // reset
      a.reset();
      if (!a.has_value())
      {
          std::cout << "no value\n";
      }

      // pointer to contained data
      a = 1;
      int* i = std::any_cast<int>(&a);
      std::cout << *i << "\n";
  }

Possible output:

  i: 1
  d: 3.14
  b: true
  bad any_cast
  i
  no value
  1