home | help 
std::any::any(3)	       C++ Standard Libary		std::any::any(3)

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, equiv-
     alent 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<Value-
     Type>(value).
	  * This overload participates in overload resolution only if
	    std::decay_t<ValueType> is not the same type as any nor  a	special-
     ization of
	    std::in_place_type_t,    and   std::is_copy_constructible_v<std::de-
     cay_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::initial-
     izer_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-6)	Throws	any exception thrown by the constructor of the contained
     type.

Notes
	Because the default constructor is constexpr, static std::anys are  ini-
     tialized 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  con-
     structor of any
	static object.

Example
     // Run this code

      #include <boost/core/demangle.hpp>

      #include <any>
      #include <initializer_list>
      #include <iostream>
      #include <memory>
      #include <set>
      #include <string>
      #include <utility>

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

      #if __cpp_aggregate_paren_init < 201902L
	  // Required before C++20 for in-place construction
	  A(int age, std::string name, double salary)
	      : age(age), name(std::move(name)), salary(salary) {}
      #endif
      };

      // Using abi demangle to print nice type name of instance of any holding
      void printType(const std::any& a)
      {
	  std::cout << boost::core::demangle(a.type().name()) << '\n';
      }

      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<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<std::set<A, decltype(lambda)>>,
	      {
		  A{39, std::string{"Ada"}, 100.25},
		  A{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> >

See also
	operator= assigns an any object
		  (public member function)

http://cppreference.com 	   2024.06.10			std::any::any(3)
home | help