In C esiste un switchcostrutto che consente di eseguire diversi rami condizionali di codice in base a un valore intero di prova, ad es.
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;
}
Come è possibile ottenere lo stesso comportamento (cioè evitare il cosiddetto " if- elseladder") per un valore stringa, cioè a char *?
Risposte:
Se intendi, come scrivere qualcosa di simile a questo:
// switch statement
switch (string) {
case "B1":
// do something
break;
/* more case "xxx" parts */
}
Quindi la soluzione canonica in C è usare una scala if-else:
if (strcmp(string, "B1") == 0)
{
// do something
}
else if (strcmp(string, "xxx") == 0)
{
// do something else
}
/* more else if clauses */
else /* default: */
{
}
switch (something) { case A: /*...*/ break; case B: /*...*/ break; }.
Se hai molti casi e non vuoi scrivere un sacco di strcmp()chiamate, potresti fare qualcosa del tipo:
switch(my_hash_function(the_string)) {
case HASH_B1: ...
/* ...etc... */
}
Devi solo assicurarti che la tua funzione hash non abbia collisioni all'interno del set di possibili valori per la stringa.
[a-zA-Z0-9_]? Qualche esempio?
uinti cui bit sono trattati come 8 ASCII da 1 byte char. L'ho implementato qualche tempo fa, per confronti chiave all'interno di una tabella hash in C. In questo modo sradichi la necessità di qualsiasi hashing o bucket. Il problema si presenta quando è necessario superare i 64 bit; quindi paghi il costo per i condizionali mentre ripeti ogni serie di 8 chars nella stringa completa. A meno che non srotoli il ciclo, se conosci la dimensione massima delle chiavi. È un ottimo atto di bilanciamento.
Non c'è modo di farlo in C. Ci sono molti approcci diversi. In genere il più semplice è definire un insieme di costanti che rappresentano le tue stringhe ed eseguire una ricerca per stringa per ottenere la costante:
#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 */
}
Ovviamente ci sono modi più efficienti per farlo. Se mantieni ordinate le chiavi, puoi utilizzare una ricerca binaria. Potresti usare anche una tabella hash. Queste cose cambiano le tue prestazioni a scapito della manutenzione.
Il mio metodo preferito per farlo è tramite una funzione hash (presa in prestito da qui ). Ciò consente di utilizzare l'efficienza di un'istruzione switch anche quando si lavora con 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);
}
}
Naturalmente, questo approccio richiede che i valori hash per tutti i possibili caratteri * accettati siano calcolati in anticipo. Non penso che questo sia un grosso problema; tuttavia, poiché l'istruzione switch opera su valori fissi indipendentemente. È possibile creare un semplice programma per passare char * attraverso la funzione hash e visualizzare i risultati. Questi risultati possono quindi essere definiti tramite macro come ho fatto sopra.
Penso che il modo migliore per farlo sia separare il 'riconoscimento' dalla funzionalità:
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;
}
}
}
Ho pubblicato un file di intestazione per eseguire lo switch sulle stringhe in C. Contiene un insieme di macro che nascondono la chiamata a strcmp () (o simile) per imitare un comportamento simile a uno switch. L'ho testato solo con GCC in Linux, ma sono abbastanza sicuro che possa essere adattato per supportare altri ambienti.
EDIT: aggiunto il codice qui, come richiesto
Questo è il file di intestazione che dovresti includere:
#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__
Ed è così che lo usi:
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;
C'è un modo per eseguire la ricerca di stringhe più velocemente. Presupposti: dato che stiamo parlando di un'istruzione switch, posso presumere che i valori non cambieranno durante il runtime.
L'idea è di usare qsort e bsearch di C stdlib.
Lavorerò sul codice di 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;
}
Per aggiungere alla risposta di Phimueme sopra, se la tua stringa è sempre di due caratteri, puoi creare un int a 16 bit dai due caratteri a 8 bit e attivarlo (per evitare istruzioni switch / case nidificate).
To add to Phimueme's answer above, sentiti libero di usare la funzione di commento. :)
Non possiamo sfuggire alla scala if-else per confrontare una stringa con altre. Anche il caso switch regolare è internamente anche un ladder if-else (per interi). Potremmo voler simulare solo il caso dello switch per string, ma non possiamo mai sostituire il ladder if-else. Il migliore degli algoritmi per il confronto delle stringhe non può sfuggire all'utilizzo della funzione strcmp. Significa confrontare carattere per carattere finché non viene trovata una non corrispondenza. Quindi l'uso di if-else ladder e strcmp è inevitabile.
E qui ci sono le macro più semplici per simulare il caso dello switch per le stringhe.
#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
E puoi usarli come file
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
Produzione:
in def
in ghi
in DEFAULT
Di seguito è riportato l'utilizzo nidificato di 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
Produzione:
in def
in def => xyz
in ghi
in DEFAULT
Ecco la stringa inversa SWITCH, dove puoi usare una variabile (piuttosto che una costante) nella clausola 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
Produzione:
in str3
Questo è generalmente il modo in cui lo faccio.
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";
}
}
}
case 'B'<<8+'1':lo renderebbe più chiaro, credo, di 0x4231.
#define twochar(a) (((uint16_t)a[1]<<8)|a[0])
Ecco come lo fai. No, non proprio.
#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;
}
Se è una stringa di 2 byte puoi fare qualcosa come in questo esempio concreto in cui accendo i codici lingua 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_ * è un numero intero costante utilizzato per l'indicizzazione negli array.
Assumendo poca endianness e sizeof (char) == 1, potresti farlo (qualcosa del genere è stato suggerito da MikeBrom).
char* txt = "B1";
int tst = *(int*)txt;
if ((tst & 0x00FFFFFF) == '1B')
printf("B1!\n");
Potrebbe essere generalizzato per il caso BE.
I puntatori a funzione sono un ottimo modo per farlo, ad es
result = switchFunction(someStringKey); //result is an optional return value
... questo chiama una funzione che hai impostato con il tasto stringa (una funzione per caso):
setSwitchFunction("foo", fooFunc);
setSwitchFunction("bar", barFunc);
Usa un'implementazione hashmap / tabella / dizionario preesistente come khash, restituisci quel puntatore a una funzione all'interno di switchFunction()ed eseguilo (o semplicemente restituiscilo da switchFunction()ed eseguilo tu stesso). Se l'implementazione della mappa non lo memorizza, usa semplicemente un uint64_tinvece che lanci di conseguenza a un puntatore.
Ciao, questo è il modo facile e veloce se hai questo caso:
[Modalità RAPIDA]
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
[Modalità SPIEGAZIONE]
ad esempio: ho molti menu, ogni scelta nel 1 ° menu ti porta al 2 ° menu, la stessa cosa con il 2 ° menu e il 3 ° menu. ma le Opzioni sono diverse in modo da sapere che l'utente ha scelto definitivamente. esempio:
menu 1: 1 ==> menu 2: 4 ==> menu 3: 2 (...) la scelta è 142. altri casi: 111,141,131,122 ...
soluzione: memorizzare il primo 1 ° in a, 2 ° in b, 3 ° in c. a = 1, b = 4, c = 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)