enum CommandKind{
   APP_INIT
  ,APP_CLOSE
  ..
};
struct Command{
  ComandKind kind;
};

void OnCommand(Command& cmd)
{
switch( cmd.kind ){
 case APP_INIT:  /*логируем "APP_INIT"*/  break; 
 case APP_CLOSE: /*логируем "APP_CLOSE"*/ break; 
};
}

struct Command {
  ComandKind kind;
  const char* text;
  ComandK(ComandKind kind,const char* msg):kind(kind),msg(msg){}
}   AppInit(APP_INIT,"APP_INIT")    //можно макросом
   ,AppClose(APP_CLOSE,"APP_CLOSE")
   ..
   ;

class CommandKind
{
  public:

  enum Id
  {
     APP_INIT,
     APP_CLOSE
  };

  std::string toString( Id id )
  {
     switch( id )
     {
     case APP_INIT:  return std::string("APP_INIT"); 
     case APP_CLOSE:  return std::string("APP_CLOSE"); 
     }
     return std::string("Undefind id")
  }

  Id fromString( const std::string& idAsString );
}

А>struct Command {
А>  ComandKind kind;
А>  const char* text;
А>  ComandK(ComandKind kind,const char* msg):kind(kind),msg(msg){}
А>}   AppInit(APP_INIT,"APP_INIT")    //можно макросом
А>   ,AppClose(APP_CLOSE,"APP_CLOSE")
А>   ..
А>   ;
А>

// file commands.inc
COMMAND( APP_INIT )
COMMAND( APP_CLOSE )
/*...*/

enum CommandKind
{
#define COMMAND( NAME ) NAME ,
#include "commands.inc"
#undef COMMAND
};
const char* CommandNames[] =
{
#define COMMAND( NAME ) #NAME ,
#include "commands.inc"
#undef COMMAND
};

N>гм... может это поможет

enum E{ ENUM1, ENUM2 };
E id = ENUM1;
cout << E2S( id );

А>Пиши на шарпе или управляемом С++. Там это все на шару будет

switch( id )
     {
     case APP_INIT:  return std::string("APP_INIT"); 
     case APP_CLOSE:  return std::string("APP_CLOSE"); 
     }

S>Хотя, конечно, варварски.

#include "boost/preprocessor.hpp"

//Declaring our enum
#define ENUM_SEQ_COMMAND_KIND\
  (((APP_INIT)        (1) )   ("APP_INIT_BLA_BLA"))\
  (((APP_CLOSE)       (10)))\
  (((APP_ABRACADABRA)     )   ("Strange message"))\
  (((APP_TERMINATE)       ))

//Decryption:
//<Enum>          ->  <EnumIntValue>  -> <EnumStringValue>
//APP_INIT        ->              1   -> "APP_INIT_BLA_BLA"
//APP_CLOSE       ->             10   -> "APP_CLOSE"
//APP_ABRACADABRA ->             11   -> "Strange message"
//APP_TERMINATE   ->             12   -> "APP_TERMINATE"
//
//Format:
//(((<Enum>) [(<EnumIntValue>)]) [(<EnumStringValue>)])
//  Where,
//  [] - optional sequence argument.
//
//Features:
// 1. Both <EnumIntValue> and <EnumStringValue> - are optional.
// 2. If <EnumIntValue> in first enum doesn't typed, then it would be - 0 (zero).
// 3. If <EnumIntValue> in non first enum doesn't typed, then it would be previous enum value plus 1 (<EnumIntValue>+1).
//

// Generate single enumeration
#define _GENERATE_ENUM_FROM_SEQ(z,n,enums_seq)\
  BOOST_PP_IF(n,BOOST_PP_COMMA,BOOST_PP_EMPTY)() BOOST_PP_SEQ_ELEM(0,BOOST_PP_SEQ_ELEM(0,BOOST_PP_SEQ_ELEM(n,enums_seq)))\
  BOOST_PP_IF(BOOST_PP_GREATER_EQUAL(BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_ELEM(0,BOOST_PP_SEQ_ELEM(n,enums_seq))),2),\
    = BOOST_PP_SEQ_ELEM(1,BOOST_PP_SEQ_ELEM(0,BOOST_PP_SEQ_ELEM(n,enums_seq))),\
    BOOST_PP_IF(n,\
      = BOOST_PP_SEQ_ELEM(0,BOOST_PP_SEQ_ELEM(0,BOOST_PP_SEQ_ELEM(BOOST_PP_DEC(n),enums_seq)))+1 BOOST_PP_EMPTY,\
      BOOST_PP_EMPTY)())

// Generate multiple enumeration
#define GENERATE_ENUMS_FROM_SEQ(enums_seq)\
  BOOST_PP_REPEAT(BOOST_PP_SEQ_SIZE(enums_seq),_GENERATE_ENUM_FROM_SEQ,enums_seq)

// Generate single case
#define _GENERATE_ENUM_TO_STRING_CASE_2(z,n,enum_seq)\
  case BOOST_PP_SEQ_ELEM(0,BOOST_PP_SEQ_ELEM(0,enum_seq)): return \
  BOOST_PP_MACRO_IF(BOOST_PP_GREATER_EQUAL(BOOST_PP_SEQ_SIZE(enum_seq),2),\
    (1,enum_seq),\
    (BOOST_PP_SEQ_ELEM(0,BOOST_PP_SEQ_ELEM(0,enum_seq))),\
    BOOST_PP_SEQ_ELEM,\
    BOOST_PP_STRINGIZE);

#define _GENERATE_ENUM_TO_STRING_CASE_1(z,n,enums_seq)\
  _GENERATE_ENUM_TO_STRING_CASE_2(z,n,BOOST_PP_SEQ_ELEM(n,enums_seq))

// Generate multiple cases
#define GENERATE_ENUMS_TO_STRING_CASES(enums_seq)\
  BOOST_PP_REPEAT(BOOST_PP_SEQ_SIZE(enums_seq),_GENERATE_ENUM_TO_STRING_CASE_1,enums_seq)

// Begin of usage
enum CommandKind {
  GENERATE_ENUMS_FROM_SEQ(ENUM_SEQ_COMMAND_KIND)
};

const char* GetString(CommandKind e) {
  switch(e) {
    GENERATE_ENUMS_TO_STRING_CASES(ENUM_SEQ_COMMAND_KIND)
  }
  return 0;
}

enum CommandKind {
   APP_INIT  = 1 ,
   APP_CLOSE  = 10 ,
   APP_ABRACADABRA  = APP_CLOSE +1 ,
   APP_TERMINATE  = APP_ABRACADABRA +1
};

const char* GetString(CommandKind e) {
  switch(e) {
    case APP_INIT : return "APP_INIT_BLA_BLA";
    case APP_CLOSE : return "APP_CLOSE";
    case APP_ABRACADABRA : return "Strange message";
    case APP_TERMINATE : return "APP_TERMINATE";
  }
  return 0;
}

//Declaring our enum
#define ENUM_SEQ_COMMAND_KIND\
  (((APP_INIT)        (1) )   ("APP_INIT_BLA_BLA"))\
  (((APP_CLOSE)       (10)))\
  (((APP_ABRACADABRA)     )   ("Strange message"))\
  (((APP_TERMINATE)       ))

// Begin of usage
enum CommandKind {
  GENERATE_ENUMS_FROM_SEQ(ENUM_SEQ_COMMAND_KIND)
};

const char* GetString(CommandKind e) {
  switch(e) {
    GENERATE_ENUMS_TO_STRING_CASES(ENUM_SEQ_COMMAND_KIND)
  }
  return 0;
}

А>enum CommandKind{
А>   APP_INIT
А>  ,APP_CLOSE
А>  ..
А>};
А>

enum CommandKind {
    CK_INIT, 
    CK_CLOSE, 
    CK_COUNT
};

extern const char* EnumStr( CommandKind );

#define ENUM_STR_ENTRY( name ) case name: return #name;
const char* EnumToStr( CommandKind id )
{
    StaticAssert( CK_COUNT == 2 );
    switch( id ) {
        ENUM_STR_ENTRY( CK_INIT );
        ENUM_STR_ENTRY( CK_CLOSE );
        ENUM_STR_ENTRY( CK_COUNT );
    }
    assert( false );
    return "BadValue";
}

AB>// file commands.inc
AB>COMMAND( APP_INIT )
AB>COMMAND( APP_CLOSE )
AB>/*...*/

AB>

AB>enum CommandKind
AB>{
AB>#define COMMAND( NAME ) NAME ,
AB>#include "commands.inc"
AB>#undef COMMAND
AB>};
AB>const char* CommandNames[] =
AB>{
AB>#define COMMAND( NAME ) #NAME ,
AB>#include "commands.inc"
AB>#undef COMMAND
AB>};
AB>

#define COMMAND_LIST     \
    COMMAND( APP_INIT )  \
    COMMAND( APP_CLOSE )

enum CommandKind
{
#define COMMAND( NAME ) NAME ,
COMMAND_LIST
#undef COMMAND
};
const char* CommandNames[] =
{
#define COMMAND( NAME ) #NAME ,
COMMAND_LIST
#undef COMMAND
};

#ifndef ENUMERATION_H_
#define ENUMERATION_H_

class Enumeration {
private:
    static int count;
    const char *name;
    int value;

public:
    Enumeration() : value(0), name(0) {
    }
    
    Enumeration(const char *name) :    value(count) {
        this->name = name;
        count++;
    }

    Enumeration(const Enumeration &obj) :
        value(obj.value) {
        name = obj.name;
    }

    int getValue() const {
        return value;
    }

    const char *getName() const {
        return name;
    }
    
    bool operator ==(const Enumeration &obj) const {
        return (name == obj.name && value == obj.value);
    }

    bool operator !=(const Enumeration &obj) const {
        return (name != obj.name && value != obj.value );
    }
};

#endif /*ENUMERATION_H_*/

//cpp

#include "Enumeration.h"


int Enumeration::count = 0;



#ifndef MYENUM_H_
#define MYENUM_H_

#include "Enumeration.h"

class MyEnum : public Enumeration
{
public:
public:
    MyEnum(const char *name) : Enumeration(name) {}
  
    static const MyEnum ACTIVE;
    static const MyEnum SUSPEND;
    static const MyEnum OFF;
};

#endif /*MYENUM_H_*/

//cpp

#include "MyEnum.h"

const MyEnum MyEnum::ACTIVE("ACTIVE");
const MyEnum MyEnum::SUSPEND("SUSPEND");
const MyEnum MyEnum::OFF("OFF");


// use

#include <iostream>
#include "MyEnum.h"
using namespace std;



int main() 
{
    const Enumeration enumeration =  MyEnum::ACTIVE;

    cout << "Type : " << enumeration.getName() << endl; 
    
    return 0;
}

enum CommandKind{
   APP_INIT = 0
  ,APP_CLOSE = 1
  .. = 2
};

const char* command_names[] =
{
"APP_INIT"
, "APP_CLOSE"
,
};

...

CommandKind cmd = APP_INIT;

W>enum CommandKind{
W>   APP_INIT = 0
W>  ,APP_CLOSE = 1
W>  .. = 2
W>};
W>const char* command_names[] =
W>{
W>"APP_INIT"
W>, "APP_CLOSE"
W>,
W>};
W>

enum CommandKind{
   APP_INIT
  // 3 страницы текста
  TOTAL
};
const char* command_names[] =
{
"APP_INIT"
//3 страницы текста
};