Alles, was Sie über std :: any wissen müssen

Die Grundlagen

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

Wann verwenden?

• In Bibliotheken - wenn Ihre Bibliothek einige Daten speichern oder übertragen muss und Sie nicht wissen, welcher Typ diese Daten sein können
• Beim Parsen von Dateien - wenn Sie wirklich nicht feststellen können, welche Typen unterstützt werden
• Messaging
• Interaktion mit der Skriptsprache
• Erstellen eines Interpreters für eine Skriptsprache
• Benutzeroberfläche - Felder können alles speichern

Erstellen Sie std :: any

• Standardinitialisierung - Objekt ist leer
• direkte Initialisierung mit Wert / Objekt
• direkte Angabe des Objekttyps - std::in_place_type
• mit der Hilfe 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");

Wert ändern

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);

Objektlebenszyklus

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

MyType::MyType
MyType::~MyType
100

Zugriff auf einen Wert erhalten

• Geben Sie eine Kopie des Werts zurück und beenden Sie den Vorgang std::bad_any_castbei einem Fehler
• Geben Sie einen Link zum Wert zurück und beenden Sie ihn std::bad_any_cast bei einem Fehler
• Geben Sie im Fehlerfall einen Zeiger auf einen Wert (konstant oder nicht) oder nullptr zurück

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();
    }
}

Leistung und Speichernutzung

Implementierungen sollten die Verwendung von dynamisch zugewiesenem Speicher für einen kleinen enthaltenen Wert vermeiden. Beispiel: Wenn das erstellte Objekt nur ein int enthält. Eine solche Kleinobjektoptimierung darf nur auf Typen T angewendet werden, für die is_nothrow_move_constructible_v wahr ist

Eine Implementierung sollte die Verwendung von dynamischem Speicher für kleine gespeicherte Daten vermeiden. Wenn beispielsweise ein Objekt erstellt wird, in dem nur int gespeichert wird. Eine solche Optimierung für kleine Objekte sollte nur auf Typen T angewendet werden, für die is_nothrow_move_constructible_v wahr ist.

Migration von boost :: any

Beispiele für die Verwendung von std :: any

Dateianalyse

Messaging

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;
    }
}

Eigenschaften

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

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

typedef std::vector<property> properties;

Wir gehen durch die Grenzen

Unter dem Strich können Sie mit std :: any Rechte an beliebigen Daten über Grenzen hinweg übertragen, die ihren Typ nicht kennen.

• in der Bibliothek für die Schnittstelle: Sie wissen nicht, welche Typen der Client dort verwenden möchte
• Messaging: die gleiche Idee - geben Sie dem Kunden Flexibilität
• Dateianalyse: Zur Unterstützung eines beliebigen Typs

Gesamt

• std::any keine Vorlagenklasse
• std::any Verwendet die Optimierung kleiner Objekte, sodass für solche einfachen Typen wie int oder double kein Speicher dynamisch zugewiesen wird. Für größere Typen wird zusätzlicher Speicher verwendet
• std::any kann als "schwer" bezeichnet werden, bietet aber Sicherheit und größere Flexibilität
• Der Zugriff auf die Daten std::anykann mit Hilfe von erfolgen any_cast, das mehrere "Modi" bietet. Im Fehlerfall kann beispielsweise eine Ausnahme ausgelöst oder nur nullptr zurückgegeben werden
• Verwenden Sie es, wenn Sie nicht genau wissen, welche Datentypen möglich sind. Andernfalls sollten Sie es verwenden std::variant