Namespaces
Variants

std::any:: any

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

explicit any ( std:: in_place_type_t < ValueType > , std:: initializer_list < U > il,

Args && ... args ) ;
(6) (seit C++17)

Konstruiert ein neues any -Objekt.

1) Konstruiert ein leeres Objekt.
2,3) Kopiert (2) oder verschiebt (3) den Inhalt von other in eine neue Instanz, sodass jeder Inhalt sowohl im Typ als auch im Wert dem von other vor dem Konstruktoraufruf entspricht, oder leer ist, falls other leer ist. Formal,
2) Wenn other leer ist, ist das konstruierte Objekt leer. Andernfalls entspricht es any ( std:: in_place_type < T > , std:: any_cast < const T & > ( other ) ) , wobei T der Typ des in other enthaltenen Objekts ist.
3) Wenn other leer ist, ist das konstruierte Objekt leer. Andernfalls enthält das konstruierte Objekt entweder das in other enthaltene Objekt oder ein Objekt desselben Typs, das aus dem in other enthaltenen Objekt konstruiert wurde, wobei dieses Objekt als Rvalue betrachtet wird.
4) Konstruiert ein Objekt mit anfänglichem Inhalt als Objekt vom Typ std:: decay_t < ValueType > , direkt initialisiert von std:: forward < ValueType > ( value ) .
5) Konstruiert ein Objekt mit anfänglichem Inhalt als Objekt vom Typ std:: decay_t < ValueType > , direkt-nicht-Listen-initialisiert aus std:: forward < Args > ( args ) ... .
6) Konstruiert ein Objekt mit anfänglichem Inhalt als Objekt vom Typ std:: decay_t < ValueType > , direkt-nicht-List-initialisiert aus il, std:: forward < Args > ( args ) ... .

Inhaltsverzeichnis

Template-Parameter

ValueType - enthaltene Wertart
Typanforderungen
-
std::decay_t<ValueType> muss die Anforderungen von CopyConstructible erfüllen.

Parameter

other - ein anderes any Objekt, von dem kopiert oder verschoben wird
value - Wert zur Initialisierung des enthaltenen Werts
il, args - Argumente, die an den Konstruktor des enthaltenen Objekts übergeben werden

Ausnahmen

2,4-6) Wirft jede Ausnahme, die vom Konstruktor des enthaltenen Typs ausgelöst wird.

Hinweise

Da der Standardkonstruktor constexpr ist, werden statische std::any s als Teil der statischen Nicht-Lokal-Initialisierung initialisiert, bevor jegliche dynamische Nicht-Lokal-Initialisierung beginnt. Dies macht es sicher, ein Objekt vom Typ std::any im Konstruktor eines beliebigen statischen Objekts zu verwenden.

Beispiel

Diesen Code ausführen 
#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
    // Erforderlich vor C++20 für In-Place-Konstruktion
    A(int age, std::string name, double salary)
        : age(age), name(std::move(name)), salary(salary) {}
#endif
};
// Verwendung von abi demangle zur Ausgabe lesbarer Typnamen von any-Instanzen
void printType(const std::any& a)
{
    std::cout << boost::core::demangle(a.type().name()) << '\n';
}
int main()
{
    // Konstruktor #4: std::any enthält int
    std::any a1{7};
    // Konstruktor #5: std::any enthält A, direkt konstruiert
    std::any a2(std::in_place_type<A>, 30, "Ada", 1000.25);
    // Konstruktor #6: std::any enthält eine Menge von A mit benutzerdefiniertem Vergleich
    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);
}

Mögliche Ausgabe: 

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

Siehe auch

weist ein any Objekt zu
(öffentliche Elementfunktion)