Comment imprimer les valeurs C Enum sous forme de texte sans utiliser les instructions if/switch ?-C++-php.cn

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

Patricia Arquette

Libérer： 2024-11-29 22:55:12

original

523 Les gens l'ont consulté

How to Print C Enum Values as Text Without Using if/switch Statements?

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

Copier après la connexion

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

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

Copier après la connexion

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

Copier après la connexion

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

Copier après la connexion

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

Copier après la connexion

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

Copier après la connexion

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