C ++: टेक्स्ट के रूप में enum मान प्रिंट करें

Question 1

अगर मेरे पास इस तरह की कोई एनम है

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

फिर मैं सांत्वना के लिए प्रिंट आउट लेना चाहता हूं

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

लेकिन मैं जो चाहता हूं वह पाठ "एररएवा" है, क्या मैं इसे बिना / स्विच का उपयोग किए बिना कर सकता हूं?
और इसके लिए आपका समाधान क्या है?

Question 2

मानचित्र का उपयोग करना:

#include <iostream>
#include <map>
#include <string>

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

std::ostream& operator<<(std::ostream& out, const Errors value){
    static std::map<Errors, std::string> strings;
    if (strings.size() == 0){
#define INSERT_ELEMENT(p) strings[p] = #p
        INSERT_ELEMENT(ErrorA);     
        INSERT_ELEMENT(ErrorB);     
        INSERT_ELEMENT(ErrorC);             
#undef INSERT_ELEMENT
    }   

    return out << strings[value];
}

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

रैखिक खोज के साथ संरचनाओं की सरणी का उपयोग करना:

#include <iostream>
#include <string>

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

std::ostream& operator<<(std::ostream& out, const Errors value){
#define MAPENTRY(p) {p, #p}
    const struct MapEntry{
        Errors value;
        const char* 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;
}

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

स्विच / केस का उपयोग करना:

#include <iostream>
#include <string>

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

std::ostream& operator<<(std::ostream& out, const Errors value){
    const char* s = 0;
#define PROCESS_VAL(p) case(p): s = #p; break;
    switch(value){
        PROCESS_VAL(ErrorA);     
        PROCESS_VAL(ErrorB);     
        PROCESS_VAL(ErrorC);
    }
#undef PROCESS_VAL

    return out << s;
}

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

Question 3

मिलान मूल्यों के साथ तार की एक सरणी या वेक्टर का उपयोग करें:

char *ErrorTypes[] =
{
    "errorA",
    "errorB",
    "errorC"
};

cout << ErrorTypes[anError];

EDIT: उपरोक्त समाधान तब लागू होता है जब Enum सन्निहित होता है, अर्थात 0 से शुरू होता है और कोई असाइन किए गए मान नहीं होते हैं। यह सवाल में एनम के साथ पूरी तरह से काम करेगा।

इस मामले के लिए आगे प्रमाण के लिए कि एनम 0 से शुरू नहीं होता है, उपयोग करें:

cout << ErrorTypes[anError - ErrorA];

Question 4

यहाँ Boost.Preprocessor पर आधारित एक उदाहरण दिया गया है:

#include <iostream>

#include <boost/preprocessor/punctuation/comma.hpp>
#include <boost/preprocessor/control/iif.hpp>
#include <boost/preprocessor/comparison/equal.hpp>
#include <boost/preprocessor/stringize.hpp>
#include <boost/preprocessor/seq/for_each.hpp>
#include <boost/preprocessor/seq/size.hpp>
#include <boost/preprocessor/seq/seq.hpp>


#define DEFINE_ENUM(name, values)                               \
  enum name {                                                   \
    BOOST_PP_SEQ_FOR_EACH(DEFINE_ENUM_VALUE, , values)          \
  };                                                            \
  inline const char* format_##name(name val) {                  \
    switch (val) {                                              \
      BOOST_PP_SEQ_FOR_EACH(DEFINE_ENUM_FORMAT, , values)       \
    default:                                                    \
        return 0;                                               \
    }                                                           \
  }

#define DEFINE_ENUM_VALUE(r, data, elem)                        \
  BOOST_PP_SEQ_HEAD(elem)                                       \
  BOOST_PP_IIF(BOOST_PP_EQUAL(BOOST_PP_SEQ_SIZE(elem), 2),      \
               = BOOST_PP_SEQ_TAIL(elem), )                     \
  BOOST_PP_COMMA()

#define DEFINE_ENUM_FORMAT(r, data, elem)             \
  case BOOST_PP_SEQ_HEAD(elem):                       \
  return BOOST_PP_STRINGIZE(BOOST_PP_SEQ_HEAD(elem));


DEFINE_ENUM(Errors,
            ((ErrorA)(0))
            ((ErrorB))
            ((ErrorC)))

int main() {
  std::cout << format_Errors(ErrorB) << std::endl;
}

Question 5

यदि आप enumकिसी बाहरी फ़ाइल में अपनी प्रविष्टियों को सूचीबद्ध करने के इच्छुक हैं तो आप एक सरल प्री-प्रोसेसर ट्रिक का उपयोग कर सकते हैं ।

/* file: errors.def */
/* syntax: ERROR_DEF(name, value) */
ERROR_DEF(ErrorA, 0x1)
ERROR_DEF(ErrorB, 0x2)
ERROR_DEF(ErrorC, 0x4)

फिर एक स्रोत फ़ाइल में, आप फ़ाइल को एक सम्मिलित फ़ाइल की तरह मानते हैं, लेकिन आप परिभाषित करते हैं कि आप क्या करना चाहते ERROR_DEFहैं।

enum Errors {
#define ERROR_DEF(x,y) x = y,
#include "errors.def"
#undef ERROR_DEF
};

static inline std::ostream & operator << (std::ostream &o, Errors e) {
    switch (e) {
    #define ERROR_DEF(x,y) case y: return o << #x"[" << y << "]";
    #include "errors.def"
    #undef ERROR_DEF
    default: return o << "unknown[" << e << "]";
    }
}

यदि आप कुछ सोर्स ब्राउजिंग टूल (जैसे cscope) का उपयोग करते हैं, तो आपको बाहरी फाइल के बारे में बताना होगा।

Question 6

यहाँ एक चर्चा हुई है जो मदद कर सकती है: क्या C ++ एनम को स्ट्रिंग में बदलने का एक सरल तरीका है?

अद्यतन: यहाँ # एक स्क्रिप्ट Lua के लिए जो एक ऑपरेटर बनाता है << प्रत्येक नाम के लिए यह मुठभेड़ों। इसे कम सरल मामलों के लिए काम करने के लिए कुछ काम की आवश्यकता हो सकती है [1]:

function make_enum_printers(s)
    for n,body in string.gmatch(s,'enum%s+([%w_]+)%s*(%b{})') do
    print('ostream& operator<<(ostream &o,'..n..' n) { switch(n){') 
    for k in string.gmatch(body,"([%w_]+)[^,]*") do
    print('  case '..k..': return o<<"'..k..'";')
    end
    print('  default: return o<<"(invalid value)"; }}')
    end
end

local f=io.open(arg[1],"r")
local s=f:read('*a')
make_enum_printers(s)

इस इनपुट को देखते हुए:

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

enum Sec {
    X=1,Y=X,foo_bar=X+1,Z
};

यह उत्तपन करता है:

ostream& operator<<(ostream &o,Errors n) { switch(n){
  case ErrorA: return o<<"ErrorA";
  case ErrorB: return o<<"ErrorB";
  case ErrorC: return o<<"ErrorC";
  default: return o<<"(invalid value)"; }}
ostream& operator<<(ostream &o,Sec n) { switch(n){
  case X: return o<<"X";
  case Y: return o<<"Y";
  case foo_bar: return o<<"foo_bar";
  case Z: return o<<"Z";
  default: return o<<"(invalid value)"; }}

तो यह शायद आपके लिए एक शुरुआत है।

[१] अलग-अलग या गैर-नाम स्थान के स्कोपों में एनम, इनिशियल एक्सप्रेशंस वाले एनाम्स जिनमें एक कोमा होता है, आदि।

Question 7

जब भी मैं किसी एनम को परिभाषित करता हूं तो मैं एक स्ट्रिंग ऐरे का उपयोग करता हूं:

Profile.h

#pragma once

struct Profile
{
    enum Value
    {
        Profile1,
        Profile2,
    };

    struct StringValueImplementation
    {
        const wchar_t* operator[](const Profile::Value profile)
        {
            switch (profile)
            {
            case Profile::Profile1: return L"Profile1";
            case Profile::Profile2: return L"Profile2";
            default: ASSERT(false); return NULL;
            }
        }
    };

    static StringValueImplementation StringValue;
};

Profile.cpp

#include "Profile.h"

Profile::StringValueImplementation Profile::StringValue;

Question 8

यह एक अच्छा तरीका है,

enum Rank { ACE = 1, DEUCE, TREY, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE, TEN, JACK, QUEEN, KING };

वर्ण सरणियों की एक सरणी के साथ इसे प्रिंट करें

const char* rank_txt[] = {"Ace", "Deuce", "Trey", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten", "Jack", "Four", "King" } ;

इस कदर

std::cout << rank_txt[m_rank - 1]

Question 9

#include <iostream>
using std::cout;
using std::endl;

enum TEnum
{ 
  EOne,
  ETwo,
  EThree,
  ELast
};

#define VAR_NAME_HELPER(name) #name
#define VAR_NAME(x) VAR_NAME_HELPER(x)

#define CHECK_STATE_STR(x) case(x):return VAR_NAME(x);

const char *State2Str(const TEnum state)
{
  switch(state)
  {
    CHECK_STATE_STR(EOne);
    CHECK_STATE_STR(ETwo);
    CHECK_STATE_STR(EThree);
    CHECK_STATE_STR(ELast);
    default:
      return "Invalid";
  }
}

int main()
{
  int myInt=12345;
  cout << VAR_NAME(EOne) " " << VAR_NAME(myInt) << endl;

  for(int i = -1; i < 5;   i)
    cout << i << " " << State2Str((TEnum)i) << endl;
  return 0;
}

Question 10

आप एक stl मानचित्र कंटेनर का उपयोग कर सकते हैं ....

typedef map<Errors, string> ErrorMap;

ErrorMap m;
m.insert(ErrorMap::value_type(ErrorA, "ErrorA"));
m.insert(ErrorMap::value_type(ErrorB, "ErrorB"));
m.insert(ErrorMap::value_type(ErrorC, "ErrorC"));

Errors error = ErrorA;

cout << m[error] << endl;

Question 11

इस समस्या के लिए, मैं इस तरह से एक सहायता कार्य करता हूं:

const char* name(Id id) {
    struct Entry {
        Id id;
        const char* name;
    };
    static const Entry entries[] = {
        { ErrorA, "ErrorA" },
        { ErrorB, "ErrorB" },
        { 0, 0 }
    }
    for (int it = 0; it < gui::SiCount; ++it) {
        if (entries[it].id == id) {
            return entries[it].name;
        }
    }
   return 0;
}

std::mapइस तरह के छोटे संग्रह की तुलना में रैखिक खोज आमतौर पर अधिक कुशल होती है ।

Question 12

इस समाधान के लिए आपको किसी भी डेटा संरचना का उपयोग करने या एक अलग फ़ाइल बनाने की आवश्यकता नहीं है।

मूल रूप से, आप अपने सभी Enum मानों को एक #define में परिभाषित करते हैं, फिर उन्हें ऑपरेटर << में उपयोग करते हैं। @ Jxh के उत्तर के समान।

अंतिम पुनरावृत्ति के लिए ideone लिंक: http://ideone.com/hQTKQp

पूर्ण कोड:

#include <iostream>

#define ERROR_VALUES ERROR_VALUE(NO_ERROR)\
ERROR_VALUE(FILE_NOT_FOUND)\
ERROR_VALUE(LABEL_UNINITIALISED)

enum class Error
{
#define ERROR_VALUE(NAME) NAME,
    ERROR_VALUES
#undef ERROR_VALUE
};

inline std::ostream& operator<<(std::ostream& os, Error err)
{
    int errVal = static_cast<int>(err);
    switch (err)
    {
#define ERROR_VALUE(NAME) case Error::NAME: return os << "[" << errVal << "]" #NAME;
    ERROR_VALUES
#undef ERROR_VALUE
    default:
        // If the error value isn't found (shouldn't happen)
        return os << errVal;
    }
}

int main() {
    std::cout << "Error: " << Error::NO_ERROR << std::endl;
    std::cout << "Error: " << Error::FILE_NOT_FOUND << std::endl;
    std::cout << "Error: " << Error::LABEL_UNINITIALISED << std::endl;
    return 0;
}

आउटपुट:

Error: [0]NO_ERROR
Error: [1]FILE_NOT_FOUND
Error: [2]LABEL_UNINITIALISED

इस तरह से करने के बारे में एक अच्छी बात यह है कि आप प्रत्येक त्रुटि के लिए अपने स्वयं के कस्टम संदेश भी निर्दिष्ट कर सकते हैं यदि आपको लगता है कि आपको उनकी आवश्यकता है:

#include <iostream>

#define ERROR_VALUES ERROR_VALUE(NO_ERROR, "Everything is fine")\
ERROR_VALUE(FILE_NOT_FOUND, "File is not found")\
ERROR_VALUE(LABEL_UNINITIALISED, "A component tried to the label before it was initialised")

enum class Error
{
#define ERROR_VALUE(NAME,DESCR) NAME,
    ERROR_VALUES
#undef ERROR_VALUE
};

inline std::ostream& operator<<(std::ostream& os, Error err)
{
    int errVal = static_cast<int>(err);
    switch (err)
    {
#define ERROR_VALUE(NAME,DESCR) case Error::NAME: return os << "[" << errVal << "]" #NAME <<"; " << DESCR;
    ERROR_VALUES
#undef ERROR_VALUE
    default:
        return os << errVal;
    }
}

int main() {
    std::cout << "Error: " << Error::NO_ERROR << std::endl;
    std::cout << "Error: " << Error::FILE_NOT_FOUND << std::endl;
    std::cout << "Error: " << Error::LABEL_UNINITIALISED << std::endl;
    return 0;
}

आउटपुट:

Error: [0]NO_ERROR; Everything is fine
Error: [1]FILE_NOT_FOUND; File is not found
Error: [2]LABEL_UNINITIALISED; A component tried to the label before it was initialised

यदि आप अपने त्रुटि कोड / विवरण को बहुत वर्णनात्मक बनाना पसंद करते हैं, तो हो सकता है कि आप उन्हें प्रोडक्शन बिल्ड में न चाहें। उन्हें बंद करना केवल मूल्य मुद्रित करना आसान है:

inline std::ostream& operator<<(std::ostream& os, Error err)
{
    int errVal = static_cast<int>(err);
    switch (err)
    {
    #ifndef PRODUCTION_BUILD // Don't print out names in production builds
    #define ERROR_VALUE(NAME,DESCR) case Error::NAME: return os << "[" << errVal << "]" #NAME <<"; " << DESCR;
        ERROR_VALUES
    #undef ERROR_VALUE
    #endif
    default:
        return os << errVal;
    }
}

आउटपुट:

Error: 0
Error: 1
Error: 2

यदि ऐसा है, तो त्रुटि संख्या 525 का पता लगाना PITA होगा। हम मैन्युअल रूप से इस तरह प्रारंभिक संख्या में संख्या निर्दिष्ट कर सकते हैं:

#define ERROR_VALUES ERROR_VALUE(NO_ERROR, 0, "Everything is fine")\
ERROR_VALUE(FILE_NOT_FOUND, 1, "File is not found")\
ERROR_VALUE(LABEL_UNINITIALISED, 2, "A component tried to the label before it was initialised")\
ERROR_VALUE(UKNOWN_ERROR, -1, "Uh oh")

enum class Error
{
#define ERROR_VALUE(NAME,VALUE,DESCR) NAME=VALUE,
    ERROR_VALUES
#undef ERROR_VALUE
};

inline std::ostream& operator<<(std::ostream& os, Error err)
{
    int errVal = static_cast<int>(err);
    switch (err)
    {
#ifndef PRODUCTION_BUILD // Don't print out names in production builds
#define ERROR_VALUE(NAME,VALUE,DESCR) case Error::NAME: return os << "[" #VALUE  "]" #NAME <<"; " << DESCR;
    ERROR_VALUES
#undef ERROR_VALUE
#endif
    default:
        return os <<errVal;
    }
}
    ERROR_VALUES
#undef ERROR_VALUE
#endif
    default:
    {
        // If the error value isn't found (shouldn't happen)
        return os << static_cast<int>(err);
        break;
    }
    }
}

आउटपुट:

Error: [0]NO_ERROR; Everything is fine
Error: [1]FILE_NOT_FOUND; File is not found
Error: [2]LABEL_UNINITIALISED; A component tried to the label before it was initialised
Error: [-1]UKNOWN_ERROR; Uh oh

Question 13

इस बारे में कैसा है?

    enum class ErrorCodes : int{
          InvalidInput = 0
    };

    std::cout << ((int)error == 0 ? "InvalidInput" : "") << std::endl;

आदि ... मुझे पता है कि यह एक बहुत ही विपरीत उदाहरण है, लेकिन मुझे लगता है कि इसमें ऐसा अनुप्रयोग है जहां लागू और आवश्यक है और निश्चित रूप से इसके लिए स्क्रिप्ट लिखने से कम है।

Question 14

प्रीप्रोसेसर का उपयोग करें:

#define VISIT_ERROR(FIRST, MIDDLE, LAST) \
    FIRST(ErrorA) MIDDLE(ErrorB) /* MIDDLE(ErrorB2) */ LAST(ErrorC)

enum Errors
{
    #define ENUMFIRST_ERROR(E)  E=0,
    #define ENUMMIDDLE_ERROR(E) E,
    #define ENUMLAST_ERROR(E)   E
    VISIT_ERROR(ENUMFIRST_ERROR, ENUMMIDDLE_ERROR, ENUMLAST_ERROR)
    // you might undefine the 3 macros defined above
};

std::string toString(Error e)
{
    switch(e)
    {
    #define CASERETURN_ERROR(E)  case E: return #E;
    VISIT_ERROR(CASERETURN_ERROR, CASERETURN_ERROR, CASERETURN_ERROR)
    // you might undefine the above macro.
    // note that this will produce compile-time error for synonyms in enum;
    // handle those, if you have any, in a distinct macro

    default:
        throw my_favourite_exception();
    }
}

इस दृष्टिकोण का लाभ यह है कि: - यह समझना अभी भी सरल है, फिर भी - यह विभिन्न मुलाकातों (न केवल स्ट्रिंग) के लिए अनुमति देता है

यदि आप पहले ड्रॉप करने के लिए तैयार हैं, तो अपने आप को एक फॉर्च्यूनर () मैक्रो को क्राफ्ट करें, #define ERROR_VALUES() (ErrorA, ErrorB, ErrorC)और फिर फॉरएच () के संदर्भ में अपने आगंतुकों को लिखें। फिर कोड समीक्षा पास करने का प्रयास करें :)।

Question 15

कृपया इस पोस्ट पर एक नज़र डालें:

आधुनिक सी ++ 11 / सी ++ 14 / सी ++ 17 और भविष्य सी ++ 20 में स्ट्रिंग करने के लिए enum

DRZ