C列挙型の値の代わりにテキストを出力する


87
int main()
{

  enum Days{Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday};

  Days TheDay;

  int j = 0;

  printf("Please enter the day of the week (0 to 6)\n");

  scanf("%d",&j);

  TheDay = Days(j);

  //how to PRINT THE VALUES stored in TheDay

  printf("%s",TheDay);  //   isnt working

  return 0;
}

期待される出力は、文字列「Sunday」などを出力することです。
GalacticCowboy

回答:


104

Cの列挙型は、コード内で便利な名前を持つ数値です。これらは文字列ではなく、ソースコードで割り当てられた名前はプログラムにコンパイルされないため、実行時にアクセスできません。

必要なものを取得する唯一の方法は、列挙値を文字列に変換する関数を自分で作成することです。例(ここでは、宣言をenum Days外側に移動すると仮定しますmain):

const char* getDayName(enum Days day) 
{
   switch (day) 
   {
      case Sunday: return "Sunday";
      case Monday: return "Monday";
      /* etc... */
   }
}

/* Then, later in main: */
printf("%s", getDayName(TheDay));

または、配列をマップとして使用することもできます。

const char* dayNames[] = {"Sunday", "Monday", "Tuesday", /* ... etc ... */ };

/* ... */

printf("%s", dayNames[TheDay]);

しかし、ここではおそらくSunday = 0安全のために列挙で割り当てたいと思うでしょう... C標準では、コンパイラが0から列挙を開始する必要があるかどうかはわかりませんが、ほとんどの場合はそうです(誰かがコメントしてこれを確認または拒否すると確信しています) )。


3
ああ、あなたは私をアレイソリューションに打ち負かしました。:Pただし、別の値を指定しない限り、列挙型は常に0から始まります。
casablanca 2010

1
列挙型をインデックスとして使用することに依存している場合、実際には、それぞれに明示的に番号を付けることをお勧めします。標準では不要ですが、グループとして、コンパイラは私の経験では標準に従うのに最適ではありませんでした。
jdmichal 2010

3
C標準では、「最初の列挙型に=がない場合、その列挙型定数の値は0です。しかし、それを明示的にしても何も害はありません。
Michael Burr 2010

17
C99でできることを忘れないでくださいconst char* dayNames[] = {[Sunday] = "Sunday", [Monday] = "Monday", [Tuesday] = "Tuesday", /* ... etc ... */ };。曜日が並べ替えられた場合、または月曜日が週の最初の日であると判断した場合に備えて、ご存知のとおりです。
Tim Schaeffer 2010

2
@ user3467349それ(プリプロセッサの文字列化)は、#に続く記号を文字列に変換するだけです。つまり、はい、#Mondayは「Monday」に変わりますが、Days TheDay = Monday; printf("%s", #TheDay);「TheDay」と出力されます。
タイラーマクヘンリー

29

私はこのようなものを使用します:

ファイル「EnumToString.h」内:

#undef DECL_ENUM_ELEMENT
#undef DECL_ENUM_ELEMENT_VAL
#undef DECL_ENUM_ELEMENT_STR
#undef DECL_ENUM_ELEMENT_VAL_STR
#undef BEGIN_ENUM
#undef END_ENUM

#ifndef GENERATE_ENUM_STRINGS
    #define DECL_ENUM_ELEMENT( element ) element,
    #define DECL_ENUM_ELEMENT_VAL( element, value ) element = value,
    #define DECL_ENUM_ELEMENT_STR( element, descr ) DECL_ENUM_ELEMENT( element )
    #define DECL_ENUM_ELEMENT_VAL_STR( element, value, descr ) DECL_ENUM_ELEMENT_VAL( element, value )
    #define BEGIN_ENUM( ENUM_NAME ) typedef enum tag##ENUM_NAME
    #define END_ENUM( ENUM_NAME ) ENUM_NAME; \
            const char* GetString##ENUM_NAME(enum tag##ENUM_NAME index);
#else
    #define BEGIN_ENUM( ENUM_NAME) const char * GetString##ENUM_NAME( enum tag##ENUM_NAME index ) {\
        switch( index ) { 
    #define DECL_ENUM_ELEMENT( element ) case element: return #element; break;
    #define DECL_ENUM_ELEMENT_VAL( element, value ) DECL_ENUM_ELEMENT( element )
    #define DECL_ENUM_ELEMENT_STR( element, descr ) case element: return descr; break;
    #define DECL_ENUM_ELEMENT_VAL_STR( element, value, descr ) DECL_ENUM_ELEMENT_STR( element, descr )

    #define END_ENUM( ENUM_NAME ) default: return "Unknown value"; } } ;

#endif

次に、ヘッダーファイルでenum宣言を行います。dayenum.h

#include "EnumToString.h"

BEGIN_ENUM(Days)
{
    DECL_ENUM_ELEMENT(Sunday) //will render "Sunday"
    DECL_ENUM_ELEMENT(Monday) //will render "Monday"
    DECL_ENUM_ELEMENT_STR(Tuesday, "Tuesday string") //will render "Tuesday string"
    DECL_ENUM_ELEMENT(Wednesday) //will render "Wednesday"
    DECL_ENUM_ELEMENT_VAL_STR(Thursday, 500, "Thursday string") // will render "Thursday string" and the enum will have 500 as value
    /* ... and so on */
}
END_ENUM(MyEnum)

次に、EnumToString.cというファイルで:

#include "enum.h"

#define GENERATE_ENUM_STRINGS  // Start string generation

#include "enum.h"             

#undef GENERATE_ENUM_STRINGS   // Stop string generation

次にmain.cで:

int main(int argc, char* argv[])
{
    Days TheDay = Monday;
    printf( "%d - %s\n", TheDay, GetStringDay(TheDay) ); //will print "1 - Monday"

    TheDay = Thursday;
    printf( "%d - %s\n", TheDay, GetStringDay(TheDay) ); //will print "500 - Thursday string"

    return 0;
}

これにより、この方法で宣言され、「EnumToString.c」に含まれる列挙型の文字列が「自動的に」生成されます。


4
読み通すのは醜いですが、データの重複はありません。(他のみんなとは違って。)私はこれが好きかどうかに悩まされています。
キムリース2010

1
データの重複がなく、おそらく最高の保守性/柔軟性を備えた、非常にクリエイティブなソリューションの+1ですが、そうです!私はまだむしろconstchar * []ルートに行きたいと思います。
マニフェスト

4
ええ、保守性は素晴らしいです!曜日が変わっても更新はとても簡単です!</ sarcasm>ちなみに、英語の文字列とプログラム内の名前の間のマッピングは、重複を避けるためにハードコーディングされているため、これはローカリゼーションの目的にも役立ちません。少なくとも他のアプローチでは、ソースファイル内のすべての出現箇所を変更せずに文字列を翻訳することが可能です。
R .. GitHub STOP HELPING ICE 2010

1
おそらく、returnステートメントをに変更するなどして(gettextのようなもので)それを国際化することができreturn _(#element)ます。
バルガス2010

Cプリプロセッサがこれほど便利であるが、これは醜い場合、私は通常、スクリプト言語の単純なコードジェネレータまたはカスタムプリプロセッサに置き換えます。実際、私は複数のプロジェクトでまさにこの目的のために使用したPythonスクリプトを持っています。しかし、最近はあまり使用していません。多くのユースケースでは、文字列を使用するだけで、列挙型を気にする必要はありません(C ++やObjCではさらにそうです)。
abarnert 2012年

6

私が通常これを行う方法は、文字列表現を同じ順序で別の配列に格納し、列挙値で配列にインデックスを付けることです。

const char *DayNames[] = { "Sunday", "Monday", "Tuesday", /* etc */ };
printf("%s", DayNames[Sunday]); // prints "Sunday"

4

enumCのsは、期待どおりに機能しません。それらは栄光の定数のようなものと考えることができ(そのような定数のコレクションであることに関連するいくつかの追加の利点があります)、「日曜日」のために書いたテキストは実際にコンパイル中に数値に解決されます、テキストは最終的に破棄されます。

つまり、本当にやりたいことを行うには、文字列の配列を保持するか、列挙型の値から印刷したいテキストにマップする関数を作成する必要があります。


4

Cの列挙は、基本的に、自動的にシーケンスされる整数値の名前付きリストの構文上の糖衣です。つまり、次のコードがある場合:

int main()
{
    enum Days{Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday};

    Days TheDay = Monday;
}

あなたのコンパイラは実際にこれを吐き出します:

int main()
{
    int TheDay = 1; // Monday is the second enumeration, hence 1. Sunday would be 0.
}

したがって、C列挙型を文字列として出力することは、コンパイラーにとって意味のある操作ではありません。これらに人間が読める文字列が必要な場合は、列挙型から文字列に変換する関数を定義する必要があります。


4

マクロを使用してこれを行うためのよりクリーンな方法は次のとおりです。

#include <stdio.h>
#include <stdlib.h>

#define DOW(X, S)                                                         \
    X(Sunday) S X(Monday) S X(Tuesday) S X(Wednesday) S X(Thursday) S X(Friday) S X(Saturday)

#define COMMA ,

/* declare the enum */
#define DOW_ENUM(DOW) DOW
enum dow {
    DOW(DOW_ENUM, COMMA)
};

/* create an array of strings with the enum names... */
#define DOW_ARR(DOW ) [DOW] = #DOW
const char * const dow_str[] = {
    DOW(DOW_ARR, COMMA)
};

/* ...or create a switchy function. */
static const char * dowstr(int i)
{
#define DOW_CASE(D) case D: return #D

    switch(i) {
        DOW(DOW_CASE, ;);
    default: return NULL;
    }
}


int main(void)
{
    for(int i = 0; i < 7; i++)
        printf("[%d] = «%s»\n", i, dow_str[i]);
    printf("\n");
    for(int i = 0; i < 7; i++)
        printf("[%d] = «%s»\n", i, dowstr(i));
    return 0;
}

これが完全にポータブルな白黒プリプロセッサかどうかはわかりませんが、gccで動作します。

これはc99btwなので、(オンラインコンパイラ)ideoneにc99 strictプラグインする場合に使用します。


「クリーンな」マクロがいかに優れているかが大好きです:-)。
mk12 2012年

3

パーティーに遅れているのは知っていますが、これはどうですか?

const char* dayNames[] = { [Sunday] = "Sunday", [Monday] = "Monday", /*and so on*/ };
printf("%s", dayNames[Sunday]); // prints "Sunday"

このように、手動でenumchar*アレイの同期を維持する必要はありません。あなたが私のようであれば、後で変更する可能性がenumあり、char*配列は無効な文字列を出力します。これは、普遍的にサポートされている機能ではない可能性があります。しかし、afaik、ほとんどのmordern day Cコンパイラは、この指定された初期スタイルをサポートしています。

指定された初期化子について詳しくは、こちらをご覧ください


1

問題は、名前を1回だけ書きたいということです。
私はこのようなライダーを持っています:

#define __ENUM(situation,num) \
    int situation = num;        const char * __##situation##_name = #situation;

    const struct {
        __ENUM(get_other_string, -203);//using a __ENUM Mirco make it ease to write, 
        __ENUM(get_negative_to_unsigned, -204);
        __ENUM(overflow,-205);
//The following two line showing the expanding for __ENUM
        int get_no_num = -201;      const char * __get_no_num_name = "get_no_num";
        int get_float_to_int = -202;        const char * get_float_to_int_name = "float_to_int_name";

    }eRevJson;
#undef __ENUM
    struct sIntCharPtr { int value; const char * p_name; };
//This function transform it to string.
    inline const char * enumRevJsonGetString(int num) {
        sIntCharPtr * ptr = (sIntCharPtr *)(&eRevJson);
        for (int i = 0;i < sizeof(eRevJson) / sizeof(sIntCharPtr);i++) {
            if (ptr[i].value == num) {
                return ptr[i].p_name;
            }
        }
        return "bad_enum_value";
    }

構造体を使用して列挙型を挿入し、文字列へのプリンターが各列挙型値の定義に従うことができるようにします。

int main(int argc, char *argv[]) {  
    int enum_test = eRevJson.get_other_string;
    printf("error is %s, number is %d\n", enumRevJsonGetString(enum_test), enum_test);

>error is get_other_string, number is -203

列挙型との違いは、数値が繰り返された場合、ビルダーはエラーを報告できないことです。書き込み番号が気に入らない場合は、次のように__LINE__置き換えることができます。

#define ____LINE__ __LINE__
#define __ENUM(situation) \
    int situation = (____LINE__ - __BASELINE -2);       const char * __##situation##_name = #situation;
constexpr int __BASELINE = __LINE__;
constexpr struct {
    __ENUM(Sunday);
    __ENUM(Monday);
    __ENUM(Tuesday);
    __ENUM(Wednesday);
    __ENUM(Thursday);
    __ENUM(Friday);
    __ENUM(Saturday);
}eDays;
#undef __ENUM
inline const char * enumDaysGetString(int num) {
    sIntCharPtr * ptr = (sIntCharPtr *)(&eDays);
    for (int i = 0;i < sizeof(eDays) / sizeof(sIntCharPtr);i++) {
        if (ptr[i].value == num) {
            return ptr[i].p_name;
        }
    }
    return "bad_enum_value";
}
int main(int argc, char *argv[]) {  
    int d = eDays.Wednesday;
    printf("day %s, number is %d\n", enumDaysGetString(d), d);
    d = 1;
    printf("day %s, number is %d\n", enumDaysGetString(d), d);
}

>day Wednesday, number is 3 >day Monday, number is 1


0

私はこれに不慣れですが、switchステートメントは間違いなく機能します

#include <stdio.h>

enum mycolor;

int main(int argc, const char * argv[])

{
enum Days{Sunday=1,Monday=2,Tuesday=3,Wednesday=4,Thursday=5,Friday=6,Saturday=7};

enum Days TheDay;


printf("Please enter the day of the week (0 to 6)\n");

scanf("%d",&TheDay);

switch (TheDay)
 {

case Sunday:
        printf("the selected day is sunday");
        break;
    case Monday:
        printf("the selected day is monday");
        break;
    case Tuesday:
        printf("the selected day is Tuesday");
        break;
    case Wednesday:
        printf("the selected day is Wednesday");
        break;
    case Thursday:
        printf("the selected day is thursday");
        break;
    case Friday:
        printf("the selected day is friday");
        break;
    case Saturday:
        printf("the selected day is Saturaday");
        break;
    default:
        break;
}

return 0;
}

適切なフォーマット(読み取り:インデント)は、回答の逐語的なコードに
必須

0

私はこれがdayNamesに列挙型を持つのが好きです。タイピングを減らすために、次のことができます。

#define EP(x) [x] = #x  /* ENUM PRINT */

const char* dayNames[] = { EP(Sunday), EP(Monday)};

0

別の解決策があります。独自の動的列挙クラスを作成します。struct新しい列挙を作成するためのといくつかの関数があることを意味します。この列挙は、要素をaに格納し、struct各要素には名前の文字列があります。また、個々の要素を格納するためのタイプ、それらを比較するための関数なども必要です。次に例を示します。

#include <stdarg.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>


struct Enumeration_element_T
{
  size_t index;
  struct Enumeration_T *parrent;
  char *name;
};

struct Enumeration_T
{
  size_t len;
  struct Enumeration_element_T elements[];
};
  


void enumeration_delete(struct Enumeration_T *self)
{
  if(self)
  {
    while(self->len--)
    {
      free(self->elements[self->len].name);
    }
    free(self);
  }
}

struct Enumeration_T *enumeration_create(size_t len,...)
{
  //We do not check for size_t overflows, but we should.
  struct Enumeration_T *self=malloc(sizeof(self)+sizeof(self->elements[0])*len);
  if(!self)
  {
    return NULL;
  }
  self->len=0;
  va_list l; 
  va_start(l,len);
  for(size_t i=0;i<len;i++)
  {
    const char *name=va_arg(l,const char *);
    self->elements[i].name=malloc(strlen(name)+1);
    if(!self->elements[i].name)
    {
      enumeration_delete(self);
      return NULL;
    }
    strcpy(self->elements[i].name,name);
    self->len++;
  }
  return self;
}


bool enumeration_isEqual(struct Enumeration_element_T *a,struct Enumeration_element_T *b)
{
  return a->parrent==b->parrent && a->index==b->index;
}

bool enumeration_isName(struct Enumeration_element_T *a, const char *name)
{
  return !strcmp(a->name,name);
}

const char *enumeration_getName(struct Enumeration_element_T *a)
{
  return a->name;
}

struct Enumeration_element_T *enumeration_getFromName(struct Enumeration_T *self, const char *name)
{
  for(size_t i=0;i<self->len;i++)
  {
    if(enumeration_isName(&self->elements[i],name))
    {
      return &self->elements[i];
    }
  }
  return NULL;
}
  
struct Enumeration_element_T *enumeration_get(struct Enumeration_T *self, size_t index)
{
  return &self->elements[index];
}

size_t enumeration_getCount(struct Enumeration_T *self)
{
  return self->len;
}

bool enumeration_isInRange(struct Enumeration_T *self, size_t index)
{
  return index<self->len;
}



int main(void)
{
  struct Enumeration_T *weekdays=enumeration_create(7,"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday");
  if(!weekdays)
  {
    return 1;
  }
    
  printf("Please enter the day of the week (0 to 6)\n");
  size_t j = 0;
  if(scanf("%zu",&j)!=1)
  {
    enumeration_delete(weekdays);
    return 1;
  }
  // j=j%enumeration_getCount(weekdays); //alternative way to make sure j is in range
  if(!enumeration_isInRange(weekdays,j))
  {
    enumeration_delete(weekdays);
    return 1;
  }

  struct Enumeration_element_T *day=enumeration_get(weekdays,j);
  

  printf("%s\n",enumeration_getName(day));
  
  enumeration_delete(weekdays);

  return 0;
}

列挙の機能は独自の翻訳単位にある必要がありますが、ここでは簡単にするためにそれらを組み合わせました。

利点は、このソリューションが柔軟で、DRYの原則に従い、各要素とともに情報を格納でき、実行時に新しい列挙を作成でき、実行時に新しい要素を追加できることです。欠点は、これが複雑であることである動的なメモリ割り当てを必要とし、使用することはできませんswitch- case、より多くのメモリを必要と遅いです。問題は、これが必要な場合に高級言語を使用すべきではないかどうかです。


-3

TheDayはある整数型にマップバックします。そう:

printf("%s", TheDay);

TheDayを文字列として解析しようとすると、ガベージが出力されるか、クラッシュします。

printfはタイプセーフではなく、正しい値を渡すことを信頼しています。値の名前を出力するには、列挙値を文字列にマッピングするためのメソッドを作成する必要があります-ルックアップテーブル、巨大なswitchステートメントなど。

弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.