Как я могу сравнить строки в C с помощью оператора switch?

Question 1

В C есть switchконструкция, которая позволяет выполнять различные условные ветви кода на основе тестового целочисленного значения, например,

int a;
/* Read the value of "a" from some source, e.g. user input */
switch (a) {
  case 100:
    // Code
    break;
  case 200:
    // Code
    break;
  default:
    // Code
    break;
}

Как можно получить такое же поведение (т.е. избежать так называемого « if- elseлестница») для значения строки, то есть char *?

Question 2

Если вы имеете в виду, как написать что-то подобное:

// switch statement
switch (string) {
  case "B1": 
    // do something
    break;
  /* more case "xxx" parts */
}

Тогда каноническим решением в C является использование лестницы if-else:

if (strcmp(string, "B1") == 0) 
{
  // do something
} 
else if (strcmp(string, "xxx") == 0)
{
  // do something else
}
/* more else if clauses */
else /* default: */
{
}

Question 3

Если у вас много дел и вы не хотите писать много strcmp()звонков, вы можете сделать что-то вроде:

switch(my_hash_function(the_string)) {
    case HASH_B1: ...
    /* ...etc... */
}

Вам просто нужно убедиться, что ваша хеш-функция не имеет конфликтов внутри набора возможных значений для строки.

Question 4

В Си нет возможности сделать это. Есть много разных подходов. Обычно самым простым является определение набора констант, представляющих ваши строки, и поиск по строке для получения константы:

#define BADKEY -1
#define A1 1
#define A2 2
#define B1 3
#define B2 4

typedef struct { char *key; int val; } t_symstruct;

static t_symstruct lookuptable[] = {
    { "A1", A1 }, { "A2", A2 }, { "B1", B1 }, { "B2", B2 }
};

#define NKEYS (sizeof(lookuptable)/sizeof(t_symstruct))

int keyfromstring(char *key)
{
    int i;
    for (i=0; i < NKEYS; i++) {
        t_symstruct *sym = lookuptable[i];
        if (strcmp(sym->key, key) == 0)
            return sym->val;
    }
    return BADKEY;
}

/* ... */
switch (keyfromstring(somestring)) {
case A1: /* ... */ break;
case A2: /* ... */ break;
case B1: /* ... */ break;
case B2: /* ... */ break;
case BADKEY: /* handle failed lookup */
}

Конечно, есть более эффективные способы сделать это. Если вы сохраните свои ключи отсортированными, вы можете использовать двоичный поиск. Вы также можете использовать хеш-таблицу. Эти вещи влияют на вашу производительность за счет технического обслуживания.

Question 5

Я предпочитаю сделать это с помощью хеш-функции (заимствованной отсюда ). Это позволяет вам использовать эффективность оператора switch даже при работе с char *:

#include "stdio.h"

#define LS 5863588
#define CD 5863276
#define MKDIR 210720772860
#define PWD 193502992

const unsigned long hash(const char *str) {
    unsigned long hash = 5381;  
    int c;

    while ((c = *str++))
        hash = ((hash << 5) + hash) + c;
    return hash;
}

int main(int argc, char *argv[]) {
    char *p_command = argv[1];
    switch(hash(p_command)) {
    case LS:
        printf("Running ls...\n");
        break;
    case CD:
        printf("Running cd...\n");
        break;
    case MKDIR:
        printf("Running mkdir...\n");
        break;
    case PWD:
        printf("Running pwd...\n");
        break;
    default:
        printf("[ERROR] '%s' is not a valid command.\n", p_command);
    }
}

Конечно, этот подход требует, чтобы хеш-значения для всех возможных принятых char * были рассчитаны заранее. Я не думаю, что это слишком большая проблема; однако, поскольку оператор switch работает независимо от фиксированных значений. Можно создать простую программу для передачи символов * через хэш-функцию и вывода их результатов. Затем эти результаты можно определить с помощью макросов, как я сделал выше.

Question 6

Я думаю, что лучший способ сделать это - отделить «узнаваемость» от функциональности:

struct stringcase { char* string; void (*func)(void); };

void funcB1();
void funcAzA();

stringcase cases [] = 
{ { "B1", funcB1 }
, { "AzA", funcAzA }
};

void myswitch( char* token ) {
  for( stringcases* pCase = cases
     ; pCase != cases + sizeof( cases ) / sizeof( cases[0] )
     ; pCase++ )
  {
    if( 0 == strcmp( pCase->string, token ) ) {
       (*pCase->func)();
       break;
    }
  }

}

Question 7

Я опубликовал файл заголовка для переключения строк в C. Он содержит набор макросов, которые скрывают вызов strcmp () (или аналогичный), чтобы имитировать поведение, подобное переключателю. Я тестировал его только с GCC в Linux, но уверен, что его можно адаптировать для поддержки других сред.

РЕДАКТИРОВАТЬ: добавил код здесь, как просили

Это заголовочный файл, который вы должны включить:

#ifndef __SWITCHS_H__
#define __SWITCHS_H__

#include <string.h>
#include <regex.h>
#include <stdbool.h>

/** Begin a switch for the string x */
#define switchs(x) \
    { char *__sw = (x); bool __done = false; bool __cont = false; \
        regex_t __regex; regcomp(&__regex, ".*", 0); do {

/** Check if the string matches the cases argument (case sensitive) */
#define cases(x)    } if ( __cont || !strcmp ( __sw, x ) ) \
                        { __done = true; __cont = true;

/** Check if the string matches the icases argument (case insensitive) */
#define icases(x)    } if ( __cont || !strcasecmp ( __sw, x ) ) { \
                        __done = true; __cont = true;

/** Check if the string matches the specified regular expression using regcomp(3) */
#define cases_re(x,flags) } regfree ( &__regex ); if ( __cont || ( \
                              0 == regcomp ( &__regex, x, flags ) && \
                              0 == regexec ( &__regex, __sw, 0, NULL, 0 ) ) ) { \
                                __done = true; __cont = true;

/** Default behaviour */
#define defaults    } if ( !__done || __cont ) {

/** Close the switchs */
#define switchs_end } while ( 0 ); regfree(&__regex); }

#endif // __SWITCHS_H__

И вот как вы его используете:

switchs(argv[1]) {
    cases("foo")
    cases("bar")
        printf("foo or bar (case sensitive)\n");
        break;

    icases("pi")
        printf("pi or Pi or pI or PI (case insensitive)\n");
        break;

    cases_re("^D.*",0)
        printf("Something that start with D (case sensitive)\n");
        break;

    cases_re("^E.*",REG_ICASE)
        printf("Something that start with E (case insensitive)\n");
        break;

    cases("1")
        printf("1\n");
        // break omitted on purpose

    cases("2")
        printf("2 (or 1)\n");
        break;

    defaults
        printf("No match\n");
        break;
} switchs_end;

Question 8

Есть способ выполнить поиск строки быстрее. Предположения: поскольку мы говорим об операторе switch, я могу предположить, что значения не будут меняться во время выполнения.

Идея состоит в том, чтобы использовать qsort и bsearch из C stdlib.

Я буду работать над кодом xtofl.

struct stringcase { char* string; void (*func)(void); };

void funcB1();
void funcAzA();

struct stringcase cases [] = 
{ { "B1", funcB1 }
, { "AzA", funcAzA }
};

struct stringcase work_cases* = NULL;
int work_cases_cnt = 0;

// prepare the data for searching
void prepare() {
  // allocate the work_cases and copy cases values from it to work_cases
  qsort( cases, i, sizeof( struct stringcase ), stringcase_cmp );
}

// comparator function
int stringcase_cmp( const void *p1, const void *p2 )
{
  return strcasecmp( ((struct stringcase*)p1)->string, ((struct stringcase*)p2)->string);
}

// perform the switching
void myswitch( char* token ) {
  struct stringcase val;
  val.string=token;
  void* strptr = bsearch( &val, work_cases, work_cases_cnt, sizeof( struct stringcase), stringcase_cmp );
  if (strptr) {
    struct stringcase* foundVal = (struct stringcase*)strptr;
    (*foundVal->func)();
    return OK;
  }
  return NOT_FOUND;
}

Question 9

Чтобы добавить к ответу Phimueme выше, если ваша строка всегда состоит из двух символов, вы можете построить 16-битное int из двух 8-битных символов - и включить его (чтобы избежать вложенных операторов switch / case).

Question 10

Мы не можем избежать лестницы if-else, чтобы сравнить строку с другими. Даже обычный switch-case внутри также является лестницей if-else (для целых чисел). Мы могли бы захотеть смоделировать только switch-case для строки, но никогда не сможем заменить лестницу if-else. Лучший из алгоритмов сравнения строк не может избежать использования функции strcmp. Средство сравнения символа за символом, пока не будет найдено несоответствие. Поэтому использование лестницы if-else и strcmp неизбежно.

ДЕМО

А вот простейшие макросы для имитации switch-case для строк.

#ifndef SWITCH_CASE_INIT
#define SWITCH_CASE_INIT
    #define SWITCH(X)   for (char* __switch_p__ = X, int __switch_next__=1 ; __switch_p__ ; __switch_p__=0, __switch_next__=1) { {
    #define CASE(X)         } if (!__switch_next__ || !(__switch_next__ = strcmp(__switch_p__, X))) {
    #define DEFAULT         } {
    #define END         }}
#endif

И вы можете использовать их как

char* str = "def";

SWITCH (str)
    CASE ("abc")
        printf ("in abc\n");
        break;
    CASE ("def")              // Notice: 'break;' statement missing so the control rolls through subsequent CASE's until DEFAULT 
        printf("in def\n");
    CASE ("ghi")
        printf ("in ghi\n");
    DEFAULT
        printf("in DEFAULT\n");
END

Вывод:

in def
in ghi
in DEFAULT

Ниже показано использование вложенного SWITCH:

char* str = "def";
char* str1 = "xyz";

SWITCH (str)
    CASE ("abc")
        printf ("in abc\n");
        break;
    CASE ("def")                                
        printf("in def\n");
        SWITCH (str1)                           // <== Notice: Nested SWITCH
            CASE ("uvw")
                printf("in def => uvw\n");
                break;
            CASE ("xyz")
                printf("in def => xyz\n");
                break;
            DEFAULT
                printf("in def => DEFAULT\n");
        END
    CASE ("ghi")
        printf ("in ghi\n");
    DEFAULT
        printf("in DEFAULT\n");
END

Вывод:

in def
in def => xyz
in ghi
in DEFAULT

Вот обратная строка SWITCH, где вы можете использовать переменную (а не константу) в предложении CASE:

char* str2 = "def";
char* str3 = "ghi";

SWITCH ("ghi")                      // <== Notice: Use of variables and reverse string SWITCH.
    CASE (str1)
        printf ("in str1\n");
        break;
    CASE (str2)                     
        printf ("in str2\n");
        break;
    CASE (str3)                     
        printf ("in str3\n");
        break;
    DEFAULT
        printf("in DEFAULT\n");
END

Вывод:

in str3

Question 11

Я обычно так делаю.

void order_plane(const char *p)
{
    switch ((*p) * 256 + *(p+1))
    {
        case 0x4231 : /* B1 */
        {
           printf("Yes, order this bomber.  It's a blast.\n");
           break;
        }

        case 0x5354 : /* ST */
        {
            printf("Nah.  I just can't see this one.\n");
            break;
        }

        default :
        {
            printf("Not today.  Can I interest you in a crate of SAMs?\n";
        }
    }
}

Question 12

Вот как вы это делаете. Нет, не совсем.

#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <stdint.h>


 #define p_ntohl(u) ({const uint32_t Q=0xFF000000;       \
                     uint32_t S=(uint32_t)(u);           \
                   (*(uint8_t*)&Q)?S:                    \
                   ( (S<<24)|                            \
                     ((S<<8)&0x00FF0000)|                \
                     ((S>>8)&0x0000FF00)|                \
                     ((S>>24)&0xFF) );  })

main (void)
{
    uint32_t s[0x40]; 
    assert((unsigned char)1 == (unsigned char)(257));
    memset(s, 0, sizeof(s));
    fgets((char*)s, sizeof(s), stdin);

    switch (p_ntohl(s[0])) {
        case 'open':
        case 'read':
        case 'seek':
            puts("ok");
            break;
        case 'rm\n\0':
            puts("not authorized");
            break;
        default:
            puts("unrecognized command");  
    }
    return 0;
}

Question 13

Если это двухбайтовая строка, вы можете сделать что-то вроде этого конкретного примера, где я включаю языковые коды ISO639-2.

    LANIDX_TYPE LanCodeToIdx(const char* Lan)
    {
      if(Lan)
        switch(Lan[0]) {
          case 'A':   switch(Lan[1]) {
                        case 'N': return LANIDX_AN;
                        case 'R': return LANIDX_AR;
                      }
                      break;
          case 'B':   switch(Lan[1]) {
                        case 'E': return LANIDX_BE;
                        case 'G': return LANIDX_BG;
                        case 'N': return LANIDX_BN;
                        case 'R': return LANIDX_BR;
                        case 'S': return LANIDX_BS;
                      }
                      break;
          case 'C':   switch(Lan[1]) {
                        case 'A': return LANIDX_CA;
                        case 'C': return LANIDX_CO;
                        case 'S': return LANIDX_CS;
                        case 'Y': return LANIDX_CY;
                      }
                      break;
          case 'D':   switch(Lan[1]) {
                        case 'A': return LANIDX_DA;
                        case 'E': return LANIDX_DE;
                      }
                      break;
          case 'E':   switch(Lan[1]) {
                        case 'L': return LANIDX_EL;
                        case 'N': return LANIDX_EN;
                        case 'O': return LANIDX_EO;
                        case 'S': return LANIDX_ES;
                        case 'T': return LANIDX_ET;
                        case 'U': return LANIDX_EU;
                      }
                      break;
          case 'F':   switch(Lan[1]) {
                        case 'A': return LANIDX_FA;
                        case 'I': return LANIDX_FI;
                        case 'O': return LANIDX_FO;
                        case 'R': return LANIDX_FR;
                        case 'Y': return LANIDX_FY;
                      }
                      break;
          case 'G':   switch(Lan[1]) {
                        case 'A': return LANIDX_GA;
                        case 'D': return LANIDX_GD;
                        case 'L': return LANIDX_GL;
                        case 'V': return LANIDX_GV;
                      }
                      break;
          case 'H':   switch(Lan[1]) {
                        case 'E': return LANIDX_HE;
                        case 'I': return LANIDX_HI;
                        case 'R': return LANIDX_HR;
                        case 'U': return LANIDX_HU;
                      }
                      break;
          case 'I':   switch(Lan[1]) {
                        case 'S': return LANIDX_IS;
                        case 'T': return LANIDX_IT;
                      }
                      break;
          case 'J':   switch(Lan[1]) {
                        case 'A': return LANIDX_JA;
                      }
                      break;
          case 'K':   switch(Lan[1]) {
                        case 'O': return LANIDX_KO;
                      }
                      break;
          case 'L':   switch(Lan[1]) {
                        case 'A': return LANIDX_LA;
                        case 'B': return LANIDX_LB;
                        case 'I': return LANIDX_LI;
                        case 'T': return LANIDX_LT;
                        case 'V': return LANIDX_LV;
                      }
                      break;
          case 'M':   switch(Lan[1]) {
                        case 'K': return LANIDX_MK;
                        case 'T': return LANIDX_MT;
                      }
                      break;
          case 'N':   switch(Lan[1]) {
                        case 'L': return LANIDX_NL;
                        case 'O': return LANIDX_NO;
                      }
                      break;
          case 'O':   switch(Lan[1]) {
                        case 'C': return LANIDX_OC;
                      }
                      break;
          case 'P':   switch(Lan[1]) {
                        case 'L': return LANIDX_PL;
                        case 'T': return LANIDX_PT;
                      }
                      break;
          case 'R':   switch(Lan[1]) {
                        case 'M': return LANIDX_RM;
                        case 'O': return LANIDX_RO;
                        case 'U': return LANIDX_RU;
                      }
                      break;
          case 'S':   switch(Lan[1]) {
                        case 'C': return LANIDX_SC;
                        case 'K': return LANIDX_SK;
                        case 'L': return LANIDX_SL;
                        case 'Q': return LANIDX_SQ;
                        case 'R': return LANIDX_SR;
                        case 'V': return LANIDX_SV;
                        case 'W': return LANIDX_SW;
                      }
                      break;
          case 'T':   switch(Lan[1]) {
                        case 'R': return LANIDX_TR;
                      }
                      break;
          case 'U':   switch(Lan[1]) {
                        case 'K': return LANIDX_UK;
                        case 'N': return LANIDX_UN;
                      }
                      break;
          case 'W':   switch(Lan[1]) {
                        case 'A': return LANIDX_WA;
                      }
                      break;
          case 'Z':   switch(Lan[1]) {
                        case 'H': return LANIDX_ZH;
                      }
                      break;
        }
      return LANIDX_UNDEFINED;
    }

LANIDX_ * - постоянные целые числа, используемые для индексации в массивах.

Question 14

Предполагая небольшой порядок байтов и sizeof (char) == 1, вы могли бы это сделать (что-то вроде этого было предложено MikeBrom).

char* txt = "B1";
int tst = *(int*)txt;
if ((tst & 0x00FFFFFF) == '1B')
    printf("B1!\n");

Его можно было бы обобщить на случай BE.

Question 15

Указатели функций - отличный способ сделать это, например

result = switchFunction(someStringKey); //result is an optional return value

... это вызывает функцию, которую вы установили с помощью строкового ключа (одна функция на случай):

setSwitchFunction("foo", fooFunc);
setSwitchFunction("bar", barFunc);

Используйте уже существующую реализацию hashmap / table / dictionary, такую как khash, верните этот указатель на функцию внутри switchFunction()и выполните ее (или просто верните ее switchFunction()и выполните самостоятельно). Если реализация карты этого не хранит, просто используйте uint64_tвместо этого, которое вы приводите соответственно к указателю.

Question 16

Привет, это простой и быстрый способ, если у вас есть этот случай:

[БЫСТРЫЙ режим]

int concated;
char ABC[4]="";int a=1,b=4,c=2;            //char[] Initializing
ABC<-sprintf(ABC,"%d%d%d",a,b,c);          //without space between %d%d%d
printf("%s",ABC);                          //value as char[] is =142
concated=atoi(ABC);                        //result is 142 as int, not 1,4,2 (separeted)

//now use switch case on 142 as an integer and all possible cases

[РАЗЪЯСНЕННЫЙ режим]

Например: у меня много меню, каждый выбор в 1-м меню переводит вас во 2-е меню, то же самое со 2-м меню и 3-м меню. Но параметры разные, поэтому вы знаете, что пользователь окончательно выбрал. пример:

меню 1: 1 ==> меню 2: 4 ==> меню 3: 2 (...) выбор - 142. другие случаи: 111,141,131,122 ...

Решение: сохраните первый 1-й в a, 2-й в b, 3-й в c. а = 1, б = 4, с = 2

 char ABC[4]="";
 ABC<-sprintf(ABC,"%d%d%d",a,b,c);              //without space between %d%d%d
 printf("%s",ABC);                              //value as char[]=142

      //now you want to recover your value(142) from char[] to int as  int value 142

 concated=atoi(ABC);                            //result is 142 as int, not 1,4,2 (separeted)

Answer 1

85

В C есть switchконструкция, которая позволяет выполнять различные условные ветви кода на основе тестового целочисленного значения, например,

int a;
/* Read the value of "a" from some source, e.g. user input */
switch (a) {
  case 100:
    // Code
    break;
  case 200:
    // Code
    break;
  default:
    // Code
    break;
}

Как можно получить такое же поведение (т.е. избежать так называемого « if- elseлестница») для значения строки, то есть char *?

c string switch-statement string-comparison Никлас
источник

Что вы имеете в виду под «включением»?

kennytm

Пожалуйста, переформулируйте вопрос, чтобы прояснить, что вы на самом деле пытаетесь сделать (или просите).

Шимон Тот

9

OP, вероятно, хочет использовать строку в качестве параметра оператора switch. Насколько я знаю, это невозможно.

dandan78

Answer 2

Что вы имеете в виду под «включением»?

kennytm

Answer 3

Пожалуйста, переформулируйте вопрос, чтобы прояснить, что вы на самом деле пытаетесь сделать (или просите).

Шимон Тот

Answer 4

9

OP, вероятно, хочет использовать строку в качестве параметра оператора switch. Насколько я знаю, это невозможно.

dandan78

Answer 5

104

Если вы имеете в виду, как написать что-то подобное:

// switch statement
switch (string) {
  case "B1": 
    // do something
    break;
  /* more case "xxx" parts */
}

Тогда каноническим решением в C является использование лестницы if-else:

if (strcmp(string, "B1") == 0) 
{
  // do something
} 
else if (strcmp(string, "xxx") == 0)
{
  // do something else
}
/* more else if clauses */
else /* default: */
{
}

Барт ван Инген Шенау
источник

1

На самом деле проблема в том, что у меня уже есть переключатель на int, и в особом случае у меня есть значения «B1» и «B2», которые я хочу использовать в том же переключателе. Единственный способ - как-то преобразовать значения "B1" и "B2" и использовать их как int !!?

Никлас

2

@Niklas: Это важная информация для вашего вопроса. Можете ли вы обновить свой вопрос и объяснить (если возможно, с помощью некоторого (псевдо) кода), что вы пытаетесь сделать?

Барт ван Инген Шенау

5

@Niklas: Вы должны прояснить свой вопрос: как вообще «B1» и «B2» могут быть частным случаем int?

Эдгар Боне

1

#define A 1 #define B 2 #define C S1 #define D S2, и эти значения я хочу использовать в своем коммутаторе. Так просто :-)

Niklas

5

@Niklas: Определения - это не строки. Если определение предназначено для числа, вы можете использовать его прямо в своем переключателе следующим образом switch (something) { case A: /*...*/ break; case B: /*...*/ break; }.

Барт ван Инген Шенау,

Answer 6

1

На самом деле проблема в том, что у меня уже есть переключатель на int, и в особом случае у меня есть значения «B1» и «B2», которые я хочу использовать в том же переключателе. Единственный способ - как-то преобразовать значения "B1" и "B2" и использовать их как int !!?

Никлас

Answer 7

2

@Niklas: Это важная информация для вашего вопроса. Можете ли вы обновить свой вопрос и объяснить (если возможно, с помощью некоторого (псевдо) кода), что вы пытаетесь сделать?

Барт ван Инген Шенау

Answer 8

5

@Niklas: Вы должны прояснить свой вопрос: как вообще «B1» и «B2» могут быть частным случаем int?

Эдгар Боне

Answer 9

1

#define A 1 #define B 2 #define C S1 #define D S2, и эти значения я хочу использовать в своем коммутаторе. Так просто :-)

Niklas

Answer 10

5

@Niklas: Определения - это не строки. Если определение предназначено для числа, вы можете использовать его прямо в своем переключателе следующим образом switch (something) { case A: /*...*/ break; case B: /*...*/ break; }.

Барт ван Инген Шенау,

Answer 11

46

Если у вас много дел и вы не хотите писать много strcmp()звонков, вы можете сделать что-то вроде:

switch(my_hash_function(the_string)) {
    case HASH_B1: ...
    /* ...etc... */
}

Вам просто нужно убедиться, что ваша хеш-функция не имеет конфликтов внутри набора возможных значений для строки.

Эдгар Боне
источник

9

«убедитесь, что ваша хеш-функция не имеет конфликтов внутри набора возможных значений строки». - Существует ли такая хеш-функция для алфавита [a-zA-Z0-9_]? Любой пример?

Арун,

8

@ArunSaha: Очевидно, не для произвольных комбинаций таких символов.

Эдгар Боне,

3

Если вы используете строковые ключи фиксированной длины, вы можете преобразовать каждый из них в уникальные целые числа; столкновения невозможны.

Инженер

@ArcaneEngineer Эм ... разве это не та проблема, которую пытается решить вопрос? Как, учитывая только строку, выбрать целое число? "используйте переключатель или лестницу if / else" Или, может быть, вы имеете в виду что-то очень короткое, например, 4 символа?

ebyrob 02

@ebyrob Я имел в виду все, что сравнимо в быстрой операции, например, 2 64-битных uint, биты которых обрабатываются как 8 однобайтовых ASCII char. Я реализовал это некоторое время назад для ключевых сравнений в хэш-таблице на C. Таким образом, вы устраняете необходимость в хешировании или ведрах. Проблема возникает тогда, когда вам нужно превышать 64 бита; затем вы оплачиваете стоимость условных операторов, перебирая каждый набор из 8 charсекунд в полной строке. Если вы не развернете цикл, если вы знаете максимальный размер ключей. Это прекрасный баланс.

Инженер

Answer 12

9

«убедитесь, что ваша хеш-функция не имеет конфликтов внутри набора возможных значений строки». - Существует ли такая хеш-функция для алфавита [a-zA-Z0-9_]? Любой пример?

Арун,

Answer 13

8

@ArunSaha: Очевидно, не для произвольных комбинаций таких символов.

Эдгар Боне,

Answer 14

3

Если вы используете строковые ключи фиксированной длины, вы можете преобразовать каждый из них в уникальные целые числа; столкновения невозможны.

Инженер

Answer 15

@ArcaneEngineer Эм ... разве это не та проблема, которую пытается решить вопрос? Как, учитывая только строку, выбрать целое число? "используйте переключатель или лестницу if / else" Или, может быть, вы имеете в виду что-то очень короткое, например, 4 символа?

ebyrob 02

Answer 16

@ebyrob Я имел в виду все, что сравнимо в быстрой операции, например, 2 64-битных uint, биты которых обрабатываются как 8 однобайтовых ASCII char. Я реализовал это некоторое время назад для ключевых сравнений в хэш-таблице на C. Таким образом, вы устраняете необходимость в хешировании или ведрах. Проблема возникает тогда, когда вам нужно превышать 64 бита; затем вы оплачиваете стоимость условных операторов, перебирая каждый набор из 8 charсекунд в полной строке. Если вы не развернете цикл, если вы знаете максимальный размер ключей. Это прекрасный баланс.

Инженер

Answer 17

В Си нет возможности сделать это. Есть много разных подходов. Обычно самым простым является определение набора констант, представляющих ваши строки, и поиск по строке для получения константы:

#define BADKEY -1
#define A1 1
#define A2 2
#define B1 3
#define B2 4

typedef struct { char *key; int val; } t_symstruct;

static t_symstruct lookuptable[] = {
    { "A1", A1 }, { "A2", A2 }, { "B1", B1 }, { "B2", B2 }
};

#define NKEYS (sizeof(lookuptable)/sizeof(t_symstruct))

int keyfromstring(char *key)
{
    int i;
    for (i=0; i < NKEYS; i++) {
        t_symstruct *sym = lookuptable[i];
        if (strcmp(sym->key, key) == 0)
            return sym->val;
    }
    return BADKEY;
}

/* ... */
switch (keyfromstring(somestring)) {
case A1: /* ... */ break;
case A2: /* ... */ break;
case B1: /* ... */ break;
case B2: /* ... */ break;
case BADKEY: /* handle failed lookup */
}

Конечно, есть более эффективные способы сделать это. Если вы сохраните свои ключи отсортированными, вы можете использовать двоичный поиск. Вы также можете использовать хеш-таблицу. Эти вещи влияют на вашу производительность за счет технического обслуживания.

Answer 18

7

Намного удобнее использовать перечисление вместо набора #defines для ключей, но в остальном это лучшее, что вы можете сделать.

Крейг Рингер,

Answer 19

инкремент неправильный. lookuptable + i * sizeof (t_symstruct) не равно lookuptable [i].

asdf

Answer 20

@asdf Вот как работает арифметика указателей в c. Sizeof неявно.

ijustlovemath

Answer 21

Я предпочитаю сделать это с помощью хеш-функции (заимствованной отсюда ). Это позволяет вам использовать эффективность оператора switch даже при работе с char *:

#include "stdio.h"

#define LS 5863588
#define CD 5863276
#define MKDIR 210720772860
#define PWD 193502992

const unsigned long hash(const char *str) {
    unsigned long hash = 5381;  
    int c;

    while ((c = *str++))
        hash = ((hash << 5) + hash) + c;
    return hash;
}

int main(int argc, char *argv[]) {
    char *p_command = argv[1];
    switch(hash(p_command)) {
    case LS:
        printf("Running ls...\n");
        break;
    case CD:
        printf("Running cd...\n");
        break;
    case MKDIR:
        printf("Running mkdir...\n");
        break;
    case PWD:
        printf("Running pwd...\n");
        break;
    default:
        printf("[ERROR] '%s' is not a valid command.\n", p_command);
    }
}

Конечно, этот подход требует, чтобы хеш-значения для всех возможных принятых char * были рассчитаны заранее. Я не думаю, что это слишком большая проблема; однако, поскольку оператор switch работает независимо от фиксированных значений. Можно создать простую программу для передачи символов * через хэш-функцию и вывода их результатов. Затем эти результаты можно определить с помощью макросов, как я сделал выше.

Answer 22

Добро пожаловать в Stack Overflow. То, что вы показали, красиво представлено и является хорошей идеей, но ... но это не так уж сильно отличается от некоторых других ответов - есть несколько, в которых используются незначительные варианты этой идеи. Если вы добавите новый ответ на старый стабильный вопрос, вы должны быть уверены, что у вас есть хорошая новая информация. Это в основном предупреждение; Я, конечно, не собираюсь голосовать против вас за это.

Джонатан Леффлер,

Answer 23

Я думаю, что лучший способ сделать это - отделить «узнаваемость» от функциональности:

struct stringcase { char* string; void (*func)(void); };

void funcB1();
void funcAzA();

stringcase cases [] = 
{ { "B1", funcB1 }
, { "AzA", funcAzA }
};

void myswitch( char* token ) {
  for( stringcases* pCase = cases
     ; pCase != cases + sizeof( cases ) / sizeof( cases[0] )
     ; pCase++ )
  {
    if( 0 == strcmp( pCase->string, token ) ) {
       (*pCase->func)();
       break;
    }
  }

}

Answer 24

Я опубликовал файл заголовка для переключения строк в C. Он содержит набор макросов, которые скрывают вызов strcmp () (или аналогичный), чтобы имитировать поведение, подобное переключателю. Я тестировал его только с GCC в Linux, но уверен, что его можно адаптировать для поддержки других сред.

РЕДАКТИРОВАТЬ: добавил код здесь, как просили

Это заголовочный файл, который вы должны включить:

#ifndef __SWITCHS_H__
#define __SWITCHS_H__

#include <string.h>
#include <regex.h>
#include <stdbool.h>

/** Begin a switch for the string x */
#define switchs(x) \
    { char *__sw = (x); bool __done = false; bool __cont = false; \
        regex_t __regex; regcomp(&__regex, ".*", 0); do {

/** Check if the string matches the cases argument (case sensitive) */
#define cases(x)    } if ( __cont || !strcmp ( __sw, x ) ) \
                        { __done = true; __cont = true;

/** Check if the string matches the icases argument (case insensitive) */
#define icases(x)    } if ( __cont || !strcasecmp ( __sw, x ) ) { \
                        __done = true; __cont = true;

/** Check if the string matches the specified regular expression using regcomp(3) */
#define cases_re(x,flags) } regfree ( &__regex ); if ( __cont || ( \
                              0 == regcomp ( &__regex, x, flags ) && \
                              0 == regexec ( &__regex, __sw, 0, NULL, 0 ) ) ) { \
                                __done = true; __cont = true;

/** Default behaviour */
#define defaults    } if ( !__done || __cont ) {

/** Close the switchs */
#define switchs_end } while ( 0 ); regfree(&__regex); }

#endif // __SWITCHS_H__

И вот как вы его используете:

switchs(argv[1]) {
    cases("foo")
    cases("bar")
        printf("foo or bar (case sensitive)\n");
        break;

    icases("pi")
        printf("pi or Pi or pI or PI (case insensitive)\n");
        break;

    cases_re("^D.*",0)
        printf("Something that start with D (case sensitive)\n");
        break;

    cases_re("^E.*",REG_ICASE)
        printf("Something that start with E (case insensitive)\n");
        break;

    cases("1")
        printf("1\n");
        // break omitted on purpose

    cases("2")
        printf("2 (or 1)\n");
        break;

    defaults
        printf("No match\n");
        break;
} switchs_end;

Answer 25

Я отредактировал пример, не добавив «перерыв», а подчеркнув тот факт, что вы можете его опустить

Андреа Каррон

Answer 26

1

это лучше! Прежде чем использовать "sscanf" для сопоставления, я выучил "regex.h", который отлично подходит для строковых случаев :)

LinconFive

Answer 27

Какое красивое решение, хорошая читаемость и гораздо больше функциональности по сравнению с переключателем / корпусом - Спасибо! Не забывайте "switchs_end:" после закрывающей скобки.

Ахим,

Answer 28

Есть способ выполнить поиск строки быстрее. Предположения: поскольку мы говорим об операторе switch, я могу предположить, что значения не будут меняться во время выполнения.

Идея состоит в том, чтобы использовать qsort и bsearch из C stdlib.

Я буду работать над кодом xtofl.

struct stringcase { char* string; void (*func)(void); };

void funcB1();
void funcAzA();

struct stringcase cases [] = 
{ { "B1", funcB1 }
, { "AzA", funcAzA }
};

struct stringcase work_cases* = NULL;
int work_cases_cnt = 0;

// prepare the data for searching
void prepare() {
  // allocate the work_cases and copy cases values from it to work_cases
  qsort( cases, i, sizeof( struct stringcase ), stringcase_cmp );
}

// comparator function
int stringcase_cmp( const void *p1, const void *p2 )
{
  return strcasecmp( ((struct stringcase*)p1)->string, ((struct stringcase*)p2)->string);
}

// perform the switching
void myswitch( char* token ) {
  struct stringcase val;
  val.string=token;
  void* strptr = bsearch( &val, work_cases, work_cases_cnt, sizeof( struct stringcase), stringcase_cmp );
  if (strptr) {
    struct stringcase* foundVal = (struct stringcase*)strptr;
    (*foundVal->func)();
    return OK;
  }
  return NOT_FOUND;
}

Answer 29

6

Чтобы добавить к ответу Phimueme выше, если ваша строка всегда состоит из двух символов, вы можете построить 16-битное int из двух 8-битных символов - и включить его (чтобы избежать вложенных операторов switch / case).

Майк Бром
источник

Если действительно хотите To add to Phimueme's answer above, то смело используйте функцию комментариев. :)

Onion-Knight

3

@Onion: Вы заметите, что у Майка Брома в настоящее время нет репутации, чтобы комментировать посты, кроме его собственных, и ответов на свои вопросы. Тем не менее, @Mike "выше" скользкий в SO, потому что нет надежного порядка сортировки. Лучше дать ссылку на ответ типа «... в ответе Phimueme ...» (хотя этот ответ сейчас удален, и ссылка годна только для пользователя с репутацией 10k +).

dmckee --- котенок экс-модератора

Answer 30

Если действительно хотите To add to Phimueme's answer above, то смело используйте функцию комментариев. :)

Onion-Knight

Answer 31

3

@Onion: Вы заметите, что у Майка Брома в настоящее время нет репутации, чтобы комментировать посты, кроме его собственных, и ответов на свои вопросы. Тем не менее, @Mike "выше" скользкий в SO, потому что нет надежного порядка сортировки. Лучше дать ссылку на ответ типа «... в ответе Phimueme ...» (хотя этот ответ сейчас удален, и ссылка годна только для пользователя с репутацией 10k +).

dmckee --- котенок экс-модератора

Answer 32

Мы не можем избежать лестницы if-else, чтобы сравнить строку с другими. Даже обычный switch-case внутри также является лестницей if-else (для целых чисел). Мы могли бы захотеть смоделировать только switch-case для строки, но никогда не сможем заменить лестницу if-else. Лучший из алгоритмов сравнения строк не может избежать использования функции strcmp. Средство сравнения символа за символом, пока не будет найдено несоответствие. Поэтому использование лестницы if-else и strcmp неизбежно.

ДЕМО

А вот простейшие макросы для имитации switch-case для строк.

#ifndef SWITCH_CASE_INIT
#define SWITCH_CASE_INIT
    #define SWITCH(X)   for (char* __switch_p__ = X, int __switch_next__=1 ; __switch_p__ ; __switch_p__=0, __switch_next__=1) { {
    #define CASE(X)         } if (!__switch_next__ || !(__switch_next__ = strcmp(__switch_p__, X))) {
    #define DEFAULT         } {
    #define END         }}
#endif

И вы можете использовать их как

char* str = "def";

SWITCH (str)
    CASE ("abc")
        printf ("in abc\n");
        break;
    CASE ("def")              // Notice: 'break;' statement missing so the control rolls through subsequent CASE's until DEFAULT 
        printf("in def\n");
    CASE ("ghi")
        printf ("in ghi\n");
    DEFAULT
        printf("in DEFAULT\n");
END

Вывод:

in def
in ghi
in DEFAULT

Ниже показано использование вложенного SWITCH:

char* str = "def";
char* str1 = "xyz";

SWITCH (str)
    CASE ("abc")
        printf ("in abc\n");
        break;
    CASE ("def")                                
        printf("in def\n");
        SWITCH (str1)                           // <== Notice: Nested SWITCH
            CASE ("uvw")
                printf("in def => uvw\n");
                break;
            CASE ("xyz")
                printf("in def => xyz\n");
                break;
            DEFAULT
                printf("in def => DEFAULT\n");
        END
    CASE ("ghi")
        printf ("in ghi\n");
    DEFAULT
        printf("in DEFAULT\n");
END

Вывод:

in def
in def => xyz
in ghi
in DEFAULT

Вот обратная строка SWITCH, где вы можете использовать переменную (а не константу) в предложении CASE:

char* str2 = "def";
char* str3 = "ghi";

SWITCH ("ghi")                      // <== Notice: Use of variables and reverse string SWITCH.
    CASE (str1)
        printf ("in str1\n");
        break;
    CASE (str2)                     
        printf ("in str2\n");
        break;
    CASE (str3)                     
        printf ("in str3\n");
        break;
    DEFAULT
        printf("in DEFAULT\n");
END

Вывод:

in str3

Answer 33

«Даже обычный switch-case внутренне также является лестницей if-else (для целых чисел)», что неверно. Если возможно, компилятор сгенерирует таблицу переходов, что будет намного эффективнее. См. Stackoverflow.com/a/14067661/4990392

Дада,

Answer 34

2

Я обычно так делаю.

void order_plane(const char *p)
{
    switch ((*p) * 256 + *(p+1))
    {
        case 0x4231 : /* B1 */
        {
           printf("Yes, order this bomber.  It's a blast.\n");
           break;
        }

        case 0x5354 : /* ST */
        {
            printf("Nah.  I just can't see this one.\n");
            break;
        }

        default :
        {
            printf("Not today.  Can I interest you in a crate of SAMs?\n";
        }
    }
}

EvilTeach
источник

Интересно. Отсутствует (вероятно, по выбору) защитное кодирование. И я восхищаюсь дополнительными подтяжками на всякий случай. Делает код более читаемым (хотя я предпочитаю египетские скобки для регистра).

Дариуш

1

Кстати, вы можете использовать постоянные выражения в метках case. case 'B'<<8+'1':Я думаю, это проясняет это, чем 0x4231.

Йенс

Я бы использовал макрос. #define twochar(a) (((uint16_t)a[1]<<8)|a[0])

v7d8dpo4 09

Answer 35

Интересно. Отсутствует (вероятно, по выбору) защитное кодирование. И я восхищаюсь дополнительными подтяжками на всякий случай. Делает код более читаемым (хотя я предпочитаю египетские скобки для регистра).

Дариуш

Answer 36

1

Кстати, вы можете использовать постоянные выражения в метках case. case 'B'<<8+'1':Я думаю, это проясняет это, чем 0x4231.

Йенс

Answer 37

Я бы использовал макрос. #define twochar(a) (((uint16_t)a[1]<<8)|a[0])

v7d8dpo4 09

Answer 38

1

Вот как вы это делаете. Нет, не совсем.

#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <stdint.h>


 #define p_ntohl(u) ({const uint32_t Q=0xFF000000;       \
                     uint32_t S=(uint32_t)(u);           \
                   (*(uint8_t*)&Q)?S:                    \
                   ( (S<<24)|                            \
                     ((S<<8)&0x00FF0000)|                \
                     ((S>>8)&0x0000FF00)|                \
                     ((S>>24)&0xFF) );  })

main (void)
{
    uint32_t s[0x40]; 
    assert((unsigned char)1 == (unsigned char)(257));
    memset(s, 0, sizeof(s));
    fgets((char*)s, sizeof(s), stdin);

    switch (p_ntohl(s[0])) {
        case 'open':
        case 'read':
        case 'seek':
            puts("ok");
            break;
        case 'rm\n\0':
            puts("not authorized");
            break;
        default:
            puts("unrecognized command");  
    }
    return 0;
}

пользователь14554
источник

3

Я не думаю, что это стандартная C.

Йохан Котлински

2

Сделать макрос, поддерживающий смешанный порядок байтов, или функцию, оставим читателю в качестве упражнения.

2

Это стандартный C, но не переносимый. Порядок байтов многобайтовых char является «зависимым от реализации» и не обязательно должен отражать порядок байтов машины. Я использовал это однажды и обгорел: в Solaris SPARC (big endian) GNU-C 3.4 использует другой порядок байтов, чем Sunstudio 12.

Патрик Шлютер

@tristopia Вы, конечно, правы (настолько правы, насколько это возможно после попытки сделать что-то подобное по-настоящему). Вот почему мы все должны использовать вместо этого B.

Почему вы убили свой аккаунт?

Answer 39

3

Я не думаю, что это стандартная C.

Йохан Котлински

Answer 40

2

Сделать макрос, поддерживающий смешанный порядок байтов, или функцию, оставим читателю в качестве упражнения.

Answer 41

2

Это стандартный C, но не переносимый. Порядок байтов многобайтовых char является «зависимым от реализации» и не обязательно должен отражать порядок байтов машины. Я использовал это однажды и обгорел: в Solaris SPARC (big endian) GNU-C 3.4 использует другой порядок байтов, чем Sunstudio 12.

Патрик Шлютер

Answer 42

@tristopia Вы, конечно, правы (настолько правы, насколько это возможно после попытки сделать что-то подобное по-настоящему). Вот почему мы все должны использовать вместо этого B.

Answer 43

Почему вы убили свой аккаунт?

Answer 44

Если это двухбайтовая строка, вы можете сделать что-то вроде этого конкретного примера, где я включаю языковые коды ISO639-2.

    LANIDX_TYPE LanCodeToIdx(const char* Lan)
    {
      if(Lan)
        switch(Lan[0]) {
          case 'A':   switch(Lan[1]) {
                        case 'N': return LANIDX_AN;
                        case 'R': return LANIDX_AR;
                      }
                      break;
          case 'B':   switch(Lan[1]) {
                        case 'E': return LANIDX_BE;
                        case 'G': return LANIDX_BG;
                        case 'N': return LANIDX_BN;
                        case 'R': return LANIDX_BR;
                        case 'S': return LANIDX_BS;
                      }
                      break;
          case 'C':   switch(Lan[1]) {
                        case 'A': return LANIDX_CA;
                        case 'C': return LANIDX_CO;
                        case 'S': return LANIDX_CS;
                        case 'Y': return LANIDX_CY;
                      }
                      break;
          case 'D':   switch(Lan[1]) {
                        case 'A': return LANIDX_DA;
                        case 'E': return LANIDX_DE;
                      }
                      break;
          case 'E':   switch(Lan[1]) {
                        case 'L': return LANIDX_EL;
                        case 'N': return LANIDX_EN;
                        case 'O': return LANIDX_EO;
                        case 'S': return LANIDX_ES;
                        case 'T': return LANIDX_ET;
                        case 'U': return LANIDX_EU;
                      }
                      break;
          case 'F':   switch(Lan[1]) {
                        case 'A': return LANIDX_FA;
                        case 'I': return LANIDX_FI;
                        case 'O': return LANIDX_FO;
                        case 'R': return LANIDX_FR;
                        case 'Y': return LANIDX_FY;
                      }
                      break;
          case 'G':   switch(Lan[1]) {
                        case 'A': return LANIDX_GA;
                        case 'D': return LANIDX_GD;
                        case 'L': return LANIDX_GL;
                        case 'V': return LANIDX_GV;
                      }
                      break;
          case 'H':   switch(Lan[1]) {
                        case 'E': return LANIDX_HE;
                        case 'I': return LANIDX_HI;
                        case 'R': return LANIDX_HR;
                        case 'U': return LANIDX_HU;
                      }
                      break;
          case 'I':   switch(Lan[1]) {
                        case 'S': return LANIDX_IS;
                        case 'T': return LANIDX_IT;
                      }
                      break;
          case 'J':   switch(Lan[1]) {
                        case 'A': return LANIDX_JA;
                      }
                      break;
          case 'K':   switch(Lan[1]) {
                        case 'O': return LANIDX_KO;
                      }
                      break;
          case 'L':   switch(Lan[1]) {
                        case 'A': return LANIDX_LA;
                        case 'B': return LANIDX_LB;
                        case 'I': return LANIDX_LI;
                        case 'T': return LANIDX_LT;
                        case 'V': return LANIDX_LV;
                      }
                      break;
          case 'M':   switch(Lan[1]) {
                        case 'K': return LANIDX_MK;
                        case 'T': return LANIDX_MT;
                      }
                      break;
          case 'N':   switch(Lan[1]) {
                        case 'L': return LANIDX_NL;
                        case 'O': return LANIDX_NO;
                      }
                      break;
          case 'O':   switch(Lan[1]) {
                        case 'C': return LANIDX_OC;
                      }
                      break;
          case 'P':   switch(Lan[1]) {
                        case 'L': return LANIDX_PL;
                        case 'T': return LANIDX_PT;
                      }
                      break;
          case 'R':   switch(Lan[1]) {
                        case 'M': return LANIDX_RM;
                        case 'O': return LANIDX_RO;
                        case 'U': return LANIDX_RU;
                      }
                      break;
          case 'S':   switch(Lan[1]) {
                        case 'C': return LANIDX_SC;
                        case 'K': return LANIDX_SK;
                        case 'L': return LANIDX_SL;
                        case 'Q': return LANIDX_SQ;
                        case 'R': return LANIDX_SR;
                        case 'V': return LANIDX_SV;
                        case 'W': return LANIDX_SW;
                      }
                      break;
          case 'T':   switch(Lan[1]) {
                        case 'R': return LANIDX_TR;
                      }
                      break;
          case 'U':   switch(Lan[1]) {
                        case 'K': return LANIDX_UK;
                        case 'N': return LANIDX_UN;
                      }
                      break;
          case 'W':   switch(Lan[1]) {
                        case 'A': return LANIDX_WA;
                      }
                      break;
          case 'Z':   switch(Lan[1]) {
                        case 'H': return LANIDX_ZH;
                      }
                      break;
        }
      return LANIDX_UNDEFINED;
    }

LANIDX_ * - постоянные целые числа, используемые для индексации в массивах.

Answer 45

0

Предполагая небольшой порядок байтов и sizeof (char) == 1, вы могли бы это сделать (что-то вроде этого было предложено MikeBrom).

char* txt = "B1";
int tst = *(int*)txt;
if ((tst & 0x00FFFFFF) == '1B')
    printf("B1!\n");

Его можно было бы обобщить на случай BE.

руслик
источник

2

Не делай этого! Это может вызвать исключение «выравнивания данных». Не гарантируется, что char * txt указывает на адрес, который соответствует требованиям выравнивания int.

harper

@R он просил об этом. @harper это не относится к x86.

Ruslik

Никлас не просил x86. И поскольку вы упомянули случай с прямым порядком байтов, вы не рассматриваете исключительно среду x86. Так что '

harper

Более того, многобайтовые символы не обязательно располагаются в машинном порядке байтов. См. Мой комментарий к ответу jbcreix.

Патрик Шлютер,

Answer 46

2

Не делай этого! Это может вызвать исключение «выравнивания данных». Не гарантируется, что char * txt указывает на адрес, который соответствует требованиям выравнивания int.

harper

Answer 47

@R он просил об этом. @harper это не относится к x86.

Ruslik

Answer 48

Никлас не просил x86. И поскольку вы упомянули случай с прямым порядком байтов, вы не рассматриваете исключительно среду x86. Так что '

harper

Answer 49

Более того, многобайтовые символы не обязательно располагаются в машинном порядке байтов. См. Мой комментарий к ответу jbcreix.

Патрик Шлютер,

Answer 50

Указатели функций - отличный способ сделать это, например

result = switchFunction(someStringKey); //result is an optional return value

... это вызывает функцию, которую вы установили с помощью строкового ключа (одна функция на случай):

setSwitchFunction("foo", fooFunc);
setSwitchFunction("bar", barFunc);

Используйте уже существующую реализацию hashmap / table / dictionary, такую как khash, верните этот указатель на функцию внутри switchFunction()и выполните ее (или просто верните ее switchFunction()и выполните самостоятельно). Если реализация карты этого не хранит, просто используйте uint64_tвместо этого, которое вы приводите соответственно к указателю.

Answer 51

@ eri0o Если вы думали, что это прилично, почему бы не проголосовать за него? Первого отрицателя уже давно нет.

Инженер

Answer 52

Привет, это простой и быстрый способ, если у вас есть этот случай:

[БЫСТРЫЙ режим]

int concated;
char ABC[4]="";int a=1,b=4,c=2;            //char[] Initializing
ABC<-sprintf(ABC,"%d%d%d",a,b,c);          //without space between %d%d%d
printf("%s",ABC);                          //value as char[] is =142
concated=atoi(ABC);                        //result is 142 as int, not 1,4,2 (separeted)

//now use switch case on 142 as an integer and all possible cases

[РАЗЪЯСНЕННЫЙ режим]

Например: у меня много меню, каждый выбор в 1-м меню переводит вас во 2-е меню, то же самое со 2-м меню и 3-м меню. Но параметры разные, поэтому вы знаете, что пользователь окончательно выбрал. пример:

меню 1: 1 ==> меню 2: 4 ==> меню 3: 2 (...) выбор - 142. другие случаи: 111,141,131,122 ...

Решение: сохраните первый 1-й в a, 2-й в b, 3-й в c. а = 1, б = 4, с = 2

 char ABC[4]="";
 ABC<-sprintf(ABC,"%d%d%d",a,b,c);              //without space between %d%d%d
 printf("%s",ABC);                              //value as char[]=142

      //now you want to recover your value(142) from char[] to int as  int value 142

 concated=atoi(ABC);                            //result is 142 as int, not 1,4,2 (separeted)

Как я могу сравнить строки в C с помощью оператора switch?

Ответы: