Namespaces
Variants

std::any:: any

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

Construit un nouvel objet any .

1) Construit un objet vide.
2,3) Copie (2) ou déplace (3) le contenu de other dans une nouvelle instance, de sorte que tout contenu soit équivalent en type et en valeur à celui de other avant l'appel du constructeur, ou vide si other est vide. Formellement,
2) Si other est vide, l'objet construit est vide. Sinon, équivalent à any ( std:: in_place_type < T > , std:: any_cast < const T & > ( other ) ) , où T est le type de l'objet contenu dans other .
3) Si other est vide, l'objet construit est vide. Sinon, l'objet construit contient soit l'objet contenu dans other , soit un objet du même type construit à partir de l'objet contenu dans other , en considérant cet objet comme une rvalue.
4) Construit un objet dont le contenu initial est un objet de type std:: decay_t < ValueType > , initialisé directement à partir de std:: forward < ValueType > ( value ) .
5) Construit un objet dont le contenu initial est un objet de type std:: decay_t < ValueType > , initialisé directement (non par liste) à partir de std:: forward < Args > ( args ) ... .
6) Construit un objet dont le contenu initial est un objet de type std:: decay_t < ValueType > , initialisé directement (non par liste) à partir de il, std:: forward < Args > ( args ) ... .

Table des matières

Paramètres du modèle

ValueType - type de valeur contenu
Exigences de type
-
std::decay_t<ValueType> doit satisfaire aux exigences de CopyConstructible .

Paramètres

other - autre any objet à copier ou déplacer
value - valeur pour initialiser la valeur contenue
il, args - arguments à transmettre au constructeur de l'objet contenu

Exceptions

2,4-6) Lance toute exception levée par le constructeur du type contenu.

Notes

Parce que le constructeur par défaut est constexpr , les std::any statiques sont initialisés dans le cadre de l'initialisation non-locale statique , avant que toute initialisation non-locale dynamique ne commence. Cela rend sûr d'utiliser un objet de type std::any dans le constructeur de tout objet statique.

Exemple

Exécuter ce 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
    // Requis avant C++20 pour la construction en place
    A(int age, std::string name, double salary)
        : age(age), name(std::move(name)), salary(salary) {}
#endif
};
// Utilisation de abi demangle pour afficher le nom de type lisible de l'instance de any
void printType(const std::any& a)
{
    std::cout << boost::core::demangle(a.type().name()) << '\n';
}
int main()
{
    // Constructeur #4 : std::any contenant un int
    std::any a1{7};
    // Constructeur #5 : std::any contenant A, construit en place
    std::any a2(std::in_place_type<A>, 30, "Ada", 1000.25);
    // Constructeur #6 : std::any contenant un set de A avec comparaison personnalisée
    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);
}

Sortie possible : 

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

Voir aussi

assigne un objet any
(fonction membre publique)