Comment imprimer les valeurs C Enum sous forme de texte sans utiliser les instructions if/switch ?

Impression de valeurs d'énumération sous forme de texte en C sans if/switch

En C , les énumérations fournissent un moyen pratique de représenter un ensemble de constantes nommées. Cependant, lors de l'impression d'une valeur d'énumération, le comportement par défaut est d'afficher sa représentation numérique.

Supposons que nous ayons une énumération comme celle-ci :

enum Errors {
    ErrorA = 0,
    ErrorB,
    ErrorC,
};

Si nous essayons d'imprimer une valeur d'énumération en utilisant std::cout:

Errors anError = ErrorA;
std::cout << anError; // 0 will be printed

Nous obtiendrons la valeur numérique 0 au lieu de la représentation textuelle "ErrorA". Ce problème se pose car std::cout ne prend pas en charge la conversion des énumérations en chaînes.

Solutions

1. Utiliser une carte

Une approche consiste à créer une carte qui associe chaque valeur d'énumération à sa représentation textuelle :

#include <map>
#include <string_view>

std::ostream& operator<<(std::ostream& out, const Errors value) {
    static const auto strings = [] {
        std::map<Errors, std::string_view> result;
        #define INSERT_ELEMENT(p) result.emplace(p, #p);
        INSERT_ELEMENT(ErrorA);     
        INSERT_ELEMENT(ErrorB);     
        INSERT_ELEMENT(ErrorC);             
        #undef INSERT_ELEMENT
        return result;
    };

    return out << strings[value];
}

2. Utiliser un tableau de structures avec une recherche linéaire

Une autre option consiste à utiliser un tableau de structures, chacune contenant une valeur enum et sa représentation textuelle, puis à effectuer une recherche linéaire :

#include <string_view>

std::ostream& operator<<(std::ostream& out, const Errors value) {
#define MAPENTRY(p) {p, #p}
    const struct MapEntry {
        Errors value;
        std::string_view str;
    } entries[] = {
        MAPENTRY(ErrorA),
        MAPENTRY(ErrorB),
        MAPENTRY(ErrorC),
        {ErrorA, 0} //doesn't matter what is used instead of ErrorA here...
    };
#undef MAPENTRY
    const char* s = 0;
    for (const MapEntry* i = entries; i->str; i++) {
        if (i->value == value) {
            s = i->str;
            break;
        }
    }

    return out << s;
}

3. Utiliser switch/case

Enfin, nous pouvons également utiliser une instruction switch/case :

#include <string>

std::ostream& operator<<(std::ostream& out, const Errors value) {
    return out << [value] {
    #define PROCESS_VAL(p) case(p): return #p;
        switch(value) {
            PROCESS_VAL(ErrorA);     
            PROCESS_VAL(ErrorB);     
            PROCESS_VAL(ErrorC);
        }
    #undef PROCESS_VAL
    };
}

Tester les solutions :

Pour tester ces solutions, nous pouvons créer un exécutable en utilisant le code suivant :

#include <iostream>

int main(int argc, char** argv) {
    std::cout << ErrorA << std::endl << ErrorB << std::endl << ErrorC << std::endl;
    return 0;   
}

L'exécution de cet exécutable devrait afficher les représentations textuelles des valeurs enum :

ErrorA
ErrorB
ErrorC

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!