Tout ce que vous devez savoir sur std :: any

Les bases

class MyAny
{
    void* _value;
    TypeInfo _typeInfo;
};

std::any a(12);

//    :
a = std::string("Hello!");
a = 16;
//   :

//    a  
std::cout << std::any_cast<int>(a) << '\n'; 

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

//        - :
a.reset();
if (!a.has_value())
{
    std::cout << "a is empty!" << "\n";
}

//    any  :
std::map<std::string, std::any> m;
m["integer"] = 10;
m["string"] = std::string("Hello World");
m["float"] = 1.0f;

for (auto &[key, val] : m)
{
    if (val.type() == typeid(int))
        std::cout << "int: " << std::any_cast<int>(val) << "\n";
    else if (val.type() == typeid(std::string))
        std::cout << "string: " << std::any_cast<std::string>(val) << "\n";
    else if (val.type() == typeid(float))
        std::cout << "float: " << std::any_cast<float>(val) << "\n";
}

16
bad any_cast
a is empty!
float: 1
int: 10
string: Hello World

• std::any — std::optional std::variant
• , .has_value()
• .reset()
• std::decay
• ,
• std::any_cast, bad_any_cast, «T»
• .type(), std::type_info

Quand utiliser?

• Dans les bibliothèques - lorsque votre bibliothèque doit stocker ou transférer des données et que vous ne savez pas de quel type ces données peuvent être
• Lors de l'analyse des fichiers - si vous ne pouvez vraiment pas déterminer quels types sont pris en charge
• Messagerie
• Interaction avec le langage de script
• Création d'un interprète pour un langage de script
• Interface utilisateur - Les champs peuvent stocker n'importe quoi

Créer std :: any

• initialisation standard - l'objet est vide
• initialisation directe avec valeur / objet
• indiquant directement le type d'objet - std::in_place_type
• via std::make_any

//  :
std::any a;
assert(!a.has_value());

//   :
std::any a2(10); // int
std::any a3(MyType(10, 11));

// in_place:
std::any a4(std::in_place_type<MyType>, 10, 11);
std::any a5{std::in_place_type<std::string>, "Hello World"};

// make_any
std::any a6 = std::make_any<std::string>("Hello World");

Changer la valeur

std::any a;

a = MyType(10, 11);
a = std::string("Hello");

a.emplace<float>(100.5f);
a.emplace<std::vector<int>>({10, 11, 12, 13});
a.emplace<MyType>(10, 11);

Cycle de vie des objets

std::any var = std::make_any<MyType>();
var = 100.0f;
std::cout << std::any_cast<float>(var) << "\n";

MyType::MyType
MyType::~MyType
100

Accéder à une valeur

• retourner une copie de la valeur et quitter std::bad_any_casten cas d'erreur
• retourner un lien vers la valeur et quitter std::bad_any_cast en cas d'erreur
• retourne un pointeur sur une valeur (constante ou non) ou nullptr en cas d'erreur

struct MyType
{
    int a, b;

    MyType(int x, int y) : a(x), b(y) { }

    void Print() { std::cout << a << ", " << b << "\n"; }
};

int main()
{
    std::any var = std::make_any<MyType>(10, 10);
    try
    {
        std::any_cast<MyType&>(var).Print();
        std::any_cast<MyType&>(var).a = 11; // /
        std::any_cast<MyType&>(var).Print();
        std::any_cast<int>(var); // throw!
    }
    catch(const std::bad_any_cast& e) 
    {
        std::cout << e.what() << '\n';
    }

    int* p = std::any_cast<int>(&var);
    std::cout << (p ? "contains int... \n" : "doesn't contain an int...\n");

    MyType* pt = std::any_cast<MyType>(&var);
    if (pt)
    {
        pt->a = 12;
        std::any_cast<MyType&>(var).Print();
    }
}

Performances et utilisation de la mémoire

Les implémentations doivent éviter l'utilisation de mémoire allouée dynamiquement pour une petite valeur contenue. Exemple: où l'objet construit ne contient qu'un int. Cette optimisation de petit objet ne doit être appliquée qu'aux types T pour lesquels is_nothrow_move_constructible_v est vrai

Une implémentation doit éviter d'utiliser la mémoire dynamique pour les données stockées de petite taille. Par exemple, lorsqu'un objet est créé en stockant uniquement int. Cette optimisation pour les petits objets ne doit être appliquée qu'aux types T pour lesquels is_nothrow_move_constructible_v est vrai.

Migration depuis boost :: any

Exemples d'utilisation de std :: any

Analyse de fichiers

Messagerie

LRESULT CALLBACK WindowProc(
  _In_ HWND   hwnd,
  _In_ UINT   uMsg,
  _In_ WPARAM wParam,
  _In_ LPARAM lParam
);

class Message
{
public:
    enum class Type 
    {
        Init,
        Closing,
        ShowWindow,        
        DrawWindow
    };

public:
    explicit Message(Type type, std::any param) :
        mType(type),
        mParam(param)
    {   }
    explicit Message(Type type) :
        mType(type)
    {   }

    Type mType;
    std::any mParam;
};

class Window
{
public:
    virtual void HandleMessage(const Message& msg) = 0;
};

Message m(Message::Type::ShowWindow, std::make_pair(10, 11));
yourWindow.HandleMessage(m);

switch (msg.mType) {
// ...
case Message::Type::ShowWindow:
    {
    auto pos = std::any_cast<std::pair<int, int>>(msg.mParam);
    std::cout << "ShowWidow: "
              << pos.first << ", " 
              << pos.second << "\n";
    break;
    }
}

Propriétés

struct property
{
    property();
    property(const std::string &, const std::any &);

    std::string name;
    std::any value;
};

typedef std::vector<property> properties;

Nous traversons les frontières

L'essentiel est que std :: any vous permet de transférer des droits sur des données arbitraires à travers les frontières qui ne connaissent pas son type.

• dans la bibliothèque de l'interface: vous ne savez pas quels types le client veut y utiliser
• messagerie: la même idée - donner au client la flexibilité
• analyse de fichiers: pour prendre en charge tout type

Total

• std::any pas une classe modèle
• std::any utilise l'optimisation des petits objets, donc il n'allouera pas dynamiquement de la mémoire pour les types simples tels que int ou double, et pour les types plus grands, une mémoire supplémentaire sera utilisée
• std::any peut être appelé "lourd", mais il offre une sécurité et une plus grande flexibilité
• L'accès aux données std::anypeut être obtenu à l'aide de any_cast, qui propose plusieurs "modes". Par exemple, en cas d'erreur, il peut lever une exception ou simplement retourner nullptr
• utilisez-le lorsque vous ne savez pas exactement quels types de données sont possibles, sinon envisagez d'utiliser std::variant