STD :: ENDLICH ist ein in C 17 eingeführter Typ-sicherer willkürlicher Typ-Speicherwerkzeug. Es kann zum Speichern und Abrufen von Replementtypen verwendet werden. Es ist für Szenarien wie Konfigurieren von Systemen, Plug-in-Schnittstellen usw. geeignet, für die heterogene Datenbeh?lter erforderlich sind. Bei der Verwendung muss eine

Durch die Arbeit mit std::any in C k?nnen Sie Werte jeder Art sicher speichern und abrufen, solange Sie Typ -überprüfungen verwalten und ordnungsgem?? zugreifen. Es ist Teil der Standardbibliothek C 17 und nützlich, wenn Sie heterogene Datencontainer ben?tigen - wie beim Erstellen von Konfigurationssystemen, Plugin -Schnittstellen oder generischen Dateninhabern.

Hier erfahren Sie, wie Sie std::any Effektiv verwenden:

1. und grundlegende Nutzung

std::any zu verwenden, geben Sie den <any></any> Header an:

 #Include <Nod>
#include <iostream>
#include <string>

int main () {
    std :: beliebiger Wert = 42; // einen int speichern
    value = std :: string ("Hallo"); // Jetzt eine Zeichenfolge speichern
}

Sie k?nnen einem std::any Objekt Werte eines kopierbaren Typs zuweisen.

2. Rufen Sie Werte mit std :: Any_cast ab

Verwenden Sie std::any_cast , um den gespeicherten Wert zu erhalten. Dies ist der einzige sichere Weg, um Daten zu extrahieren.

Mit dem richtigen Typ (Erfolg) abrufen

 std :: irgendwelche Daten = 3.14;
if (auto* ptr = std :: Any_Cast <Double> (& data)) {
    std :: cout << *ptr << &#39;\ n&#39;;
}

Oder direkt (l?st std::bad_any_access auf Typfehlanpassung):

 versuchen {
    double d = std :: Any_Cast <Double> (Daten);
    std :: cout << d << &#39;\ n&#39;;
} catch (const std :: bad_any_access &) {
    std :: cout << "Falscher Typ! \ n";
}

Sicheres Abruf mit Zeigerguss

Durch die Verwendung einer Zeigerversion von any_cast wird Ausnahmen vermieden:

 if (const auto* str = std :: Any_Cast <Std :: String> (& Daten)) {
    std :: cout << "String:" << *str << &#39;\ n&#39;;
} else if (const auto* num = std :: Any_Cast <int> (& data)) {
    std :: cout << "Integer:" << *num << &#39;\ n&#39;;
}

Dieses Muster ist nützlich, wenn mehrere m?gliche Typen behandelt werden.

3.. überprüfen und Verwalten von Typen

Sie k?nnen überprüfen, welcher Typ mit .type() gespeichert und mit typeid verglichen wird.

 #include <Typinfo>

if (data.type () == typeId (std :: string)) {
    std :: cout << "Es ist eine Zeichenfolge! \ n";
} else if (data.type () == typeId (int)) {
    std :: cout << "Es ist eine Ganzzahl! \ n";
}

Dies funktioniert gut in Kombination mit any_cast für einen sicheren Versand.

4.. L?schen oder Zurücksetzen std :: Any

Um ein std::any leer zu machen, zuweisen Sie {} oder verwenden Sie .reset() :

 Data.Reset (); // jetzt data.has_value () gibt false zurück

if (! data.has_value ()) {
    std :: cout << "Kein Wert gespeichert. \ n";
}

Sie k?nnen auch die Leere überprüfen:

 if (data.has_value ()) {
    // sicher zu besetzen
}

5. Speichern benutzerdefinierte Typen

Sie k?nnen benutzerdefinierte Typen speichern, solange sie urheberrechtlich geschützt sind.

 Struktur Person {
    std :: string name;
    int Alter;
};

std :: irgendwelche p = Person {"Alice", 30};

if (const auto* person = std :: Any_Cast <Person> (& p)) {
    std :: cout << Person-> Name << "," << Person-> Alter << &#39;\ n&#39;;
}

HINWEIS: std::any erfordert, dass der Typ kopierenkonstruktierbar ist. Move-Nur-Move-Typen (wie std::unique_ptr ) funktioniert nicht, es sei denn, eingewickelt (siehe unten).

6. Einschr?nkungen und Problemumgehungen

• KEINE MOVE-Nur-Move-Typen direkt : std::any Bedürfnisse Urheberrecht. Sie k?nnen jedoch nur Bewegungstypen in einem std::unique_ptr einwickeln:

 std :: Any Wrapper = std :: Unique_ptr <int> (New int (42));
if (auto* ptr = std :: Any_Cast <std :: Unique_ptr <int >> (& wradeper)) {
    std :: cout << "Wert:" << ** ptr << &#39;\ n&#39;;
}

• Leistungskosten : Typl?re und dynamische Zuordnung (für gr??ere Typen) k?nnen Overhead hinzufügen. Vermeiden Sie std::any Wenn m?glich, leistungskritische Wege.

• Keine impliziten Konvertierungen : Auch int zu double fehlschl?gen. Sie müssen den genauen gespeicherten Typ extrahieren.

7. Praktisches Beispiel: Heterogener Beh?lter

 #include <Vector>
#Include <Nod>
#include <string>
#include <iostream>

int main () {
    std :: vector <std :: any> values ??= {1, "text", 3.14, std :: string ("Hallo")};

    für (const auto & v: Werte) {
        if (v.type () == typeId (int)) {
            std :: cout << "int:" << std :: Any_Cast <int> (v) << &#39;\ n&#39;;
        } else if (v.type () == typeId (const char*)) {
            std :: cout << "char*:" << std :: Any_Cast <const char*> (v) << &#39;\ n&#39;;
        } else if (v.type () == typeId (doppelt)) {
            std :: cout << "double:" << std :: Any_Cast <Double> (v) << &#39;\ n&#39;;
        } else if (v.type () == Typid (std :: string)) {
            std :: cout << "String:" << std :: Any_Cast <Std :: String> (v) << &#39;\ n&#39;;
        }
    }
}

Hinweis: String -Literale sind const char* , nicht std::string , also sei vorsichtig.

Grunds?tzlich ist std::any eine Typ-Sicherheit-Gewerkschaft, wenn Sie Flexibilit?t ben?tigen. Verwenden Sie es, wenn Sie verschiedene Typen in derselben Variablen oder im gleichen Container speichern müssen, aber immer die Typen vor dem Gie?en überprüfen. Es ist kein Ersatz für Vorlagen oder Polymorphismus, sondern ein Werkzeug für bestimmte dynamische Szenarien.

Das obige ist der detaillierte Inhalt vonWie man mit std :: any in c arbeitet. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!