Comment travailler avec std :: tout en c

STD :: tout est un outil de stockage de type arbitraire de type introduit dans C 17. Il peut être utilisé pour enregistrer et récupérer tous les types reproductibles. Il convient pour des scénarios tels que la configuration des systèmes, des interfaces plug-in, etc. qui nécessitent des conteneurs de données hétérogènes. Lorsque vous l'utilisez, il doit inclure un fichier d'en-tête et utiliser std :: any_cast pour extraire les valeurs en toute sécurité et utiliser .Type () et typeId pour vérifier les types pour éviter les exceptions. Il prend en charge le stockage de types personnalisés, mais ne prend pas en charge le stockage direct des types de déplacements uniquement et peut être résolu par l'emballage STD :: UNIQUE_PTR. Il y a des surcharges de performances et aucune conversion de type implicite, qui convient aux exigences de type dynamique des chemins critiques non performances, mais ne doit pas remplacer les modèles ou les mécanismes polymorphes. Lorsque vous l'utilisez, il faut s'assurer que le type correspond avant l'extraction pour garantir la sécurité du type et réaliser finalement le traitement des données génériques flexibles et sécurisées.

Travailler avec std::any en C vous permet de stocker et de récupérer des valeurs de tout type en toute sécurité, tant que vous gérez les vérifications de type et accédez correctement. Il fait partie de la bibliothèque standard C 17 et est utile lorsque vous avez besoin de conteneurs de données hétérogènes, comme lors de la création de systèmes de configuration, d'interfaces de plugin ou de détenteurs de données génériques.

Voici comment utiliser std::any : tout:

1. y compris et utilisation de base

Pour utiliser std::any , incluez l'en-tête <any></any> :

 #include <yhy
#include <iostream>
#include <string>

int main () {
    std :: toute valeur = 42; // Stockez un int
    Value = std :: string ("Hello"); // maintenant stocker une chaîne
}

Vous pouvez attribuer des valeurs de n'importe quel type copieable à un std::any objet.

2. Récupération des valeurs avec std :: any_cast

Pour obtenir la valeur stockée, utilisez std::any_cast . C'est le seul moyen sûr d'extraire les données.

Récupération avec un type correct (succès)

 std :: toutes les données = 3,14;
if (Auto * ptr = std :: any_cast <rouble> (& data)) {
    std :: cout << * ptr << &#39;\ n&#39;;
}

Ou directement (lance std::bad_any_access sur le non-match de type):

 essayer {
    Double D = std :: any_cast <back> (données);
    std :: cout << d << &#39;\ n&#39;;
} catch (const std :: bad_any_access &) {
    std :: cout << "mauvais type! \ n";
}

Récupération sûre avec un moulage du pointeur

L'utilisation d'une version de pointeur de any_cast évite les exceptions:

 if (const auto * str = std :: any_cast <std :: string> (& data)) {
    std :: cout << "String:" << * str << &#39;\ n&#39;;
} else if (const auto * num = std :: any_cast <nt> (& data)) {
    std :: cout << "entier:" << * num << &#39;\ n&#39;;
}

Ce modèle est utile lors de la gestion de plusieurs types possibles.

3. Types de vérification et de gestion

Vous pouvez vérifier quel type est stocké en utilisant .type() et comparer avec typeid .

 #include <TypeInfo>

if (data.type () == typeId (std :: string)) {
    std :: cout << "C&#39;est une chaîne! \ n";
} else if (data.type () == typeId (int)) {
    std :: cout << "C&#39;est un entier! \ n";
}

Cela fonctionne bien en combinaison avec any_cast pour une expédition sûre.

4. Effacer ou réinitialiser Std :: tout

Pour faire un std::any vide, attribuer {} ou utiliser .reset() :

 data.reset (); // maintenant data.has_value () renvoie false

if (! data.has_value ()) {
    std :: cout << "Aucune valeur stockée. \ n";
}

Vous pouvez également vérifier le vide:

 if (data.has_value ()) {
    // sûr à lancer
}

5. Stockage des types personnalisés

Vous pouvez stocker des types définis par l'utilisateur tant qu'ils sont des droits d'auteur.

 Struct Person {
    std :: nom de chaîne;
    en âge;
};

std :: tout P = personne {"Alice", 30};

if (const Auto * personne = std :: any_cast <som> (& p)) {
    std :: cout << Person-> name << "," << personne-> Âge << &#39;\ n&#39;;
}

Remarque: std::any exige que le type soit constructible de copie. Les types de déménagement (comme std::unique_ptr ) ne fonctionneront pas à moins que ce soit emballé (voir ci-dessous).

6. Limites et solution de contournement

• Aucun type de déménagement uniquement : std::any a besoin de droits d'auteur. Mais vous pouvez envelopper des types de déplacements uniquement dans un std::unique_ptr :

 std :: tout wrapper = std :: unique_ptr <nt> (new int (42));
if (auto * ptr = std :: any_cast <std :: unique_ptr <nt>> (& wrapper)) {
    std :: cout << "valeur:" << ** ptr << &#39;\ n&#39;;
}

• Coût des performances : l'effacement de type et l'allocation dynamique (pour les plus grands types) peuvent ajouter des frais généraux. Évitez std::any dans les chemins critiques des performances si possible.

• Pas de conversions implicites : même int à double échoue. Vous devez extraire le type stocké exact.

7. Exemple pratique: conteneur hétérogène

 #include <Vector>
#include <yhy
#include <string>
#include <iostream>

int main () {
    std :: vector <std :: any> valeurs = {1, "texte", 3.14, std :: string ("bonjour")};

    pour (const auto & v: valeurs) {
        if (v.type () == typeId (int)) {
            std :: cout << "int:" << std :: any_cast <nt> (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 (double)) {
            std :: cout << "Double:" << std :: any_cast <back> (v) << &#39;\ n&#39;;
        } else if (v.type () == typeId (std :: string)) {
            std :: cout << "String:" << std :: any_cast <std :: string> (v) << &#39;\ n&#39;;
        }
    }
}

Remarque: les littéraux de chaîne sont const char* , pas std::string , alors soyez prudent.

Fondamentalement, std::any est une union de type type lorsque vous avez besoin de flexibilité. Utilisez-le lorsque vous devez stocker différents types dans la même variable ou le même conteneur, mais vérifiez toujours les types avant le casting. Ce n'est pas un remplacement pour les modèles ou le polymorphisme, mais un outil pour des scénarios de type dynamique spécifiques.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!