motor - La mejor manera de encender una cuerda en C

como prender un carro automatico descargado

Question

En C hay una construcción de switch , que permite ejecutar diferentes ramas condicionales de código basadas en un valor entero de prueba, por ejemplo,

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;
}

¿Cómo es posible obtener el mismo comportamiento (es decir, evitar la llamada " if - else ladder") para un valor de cadena, es decir, un char * ?

Answer 1

Así es como lo haces. No en realidad no.

#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;
}

Answer 2

Asumiendo poca endianness y sizeof (char) == 1, podrías hacer eso (algo como esto fue sugerido por MikeBrom).

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

Podría ser generalizado para el caso de BE.

Answer 3

Creo que la mejor manera de hacerlo es separar el ''reconocimiento'' de la funcionalidad:

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 4

Hay una forma de realizar la búsqueda de cadenas más rápido. Suposiciones: dado que estamos hablando de una instrucción switch, puedo suponer que los valores no cambiarán durante el tiempo de ejecución.

La idea es usar el qsort y bsearch de C stdlib.

Estaré trabajando en el código de 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 5

He publicado un archivo de cabecera para realizar el cambio de las cadenas en C. Contiene un conjunto de macro que oculta la llamada a strcmp () (o similar) para imitar un comportamiento similar a un conmutador. Lo he probado solo con GCC en Linux, pero estoy bastante seguro de que se puede adaptar para soportar otro entorno.

EDITAR: agregó el código aquí, según lo solicitado

Este es el archivo de encabezado que debe incluir:

#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__

Y así es como lo usas:

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");
cases("2")
printf("2/n");
break;
defaults
printf("No match/n");
break;
} switchs_end;

Answer 6

Hola, esta es la manera fácil y rápida si tienes este caso:

[Modo rápido]

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

[Modo EXPLICADO]

por ejemplo: tengo muchos menús, cada elección en el primer menú lo lleva al segundo menú, lo mismo con el segundo menú y el tercer menú. Pero las opciones son diferentes para que sepa que el usuario ha finalizado definitivamente. ejemplo:

menú 1: 1 ==> menú 2: 4 ==> menú 3: 2 (...) la opción es 142. otros casos: 111,141,131,122 ...

solución: almacene la primera 1ra en a, 2da en b, 3ra en 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)

Answer 7

Los punteros de función son una excelente manera de hacerlo, p. Ej.

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

... esto llama a una función que ha establecido por la clave de cadena (una función por caso):

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

Utilice una implementación preexistente de hashmap / tabla / diccionario como khash, devuelva ese puntero a una función dentro de switchFunction() , y ejecútelo (o simplemente devuélvalo desde switchFunction() y ejecútelo usted mismo). Si la implementación del mapa no almacena eso, simplemente use un uint64_t en uint64_t lugar, y uint64_t según un puntero.

Answer 8

Mi método preferido para hacer esto es a través de una función hash (prestada desde here ). Esto le permite utilizar la eficiencia de una instrucción switch incluso cuando se trabaja 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);
}
}

Por supuesto, este enfoque requiere que los valores hash para todos los caracteres aceptados posibles se calculen de antemano. No creo que esto sea demasiado problema; sin embargo, dado que la instrucción switch funciona en valores fijos independientemente. Se puede hacer un programa simple para pasar char * a través de la función hash y dar salida a sus resultados. Estos resultados se pueden definir a través de macros como lo he hecho anteriormente.

Answer 9

No hay forma de hacer esto en C. Hay muchos enfoques diferentes. Por lo general, lo más simple es definir un conjunto de constantes que representan sus cadenas y hacer una búsqueda por cadena para obtener la constante:

#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*sizeof(t_symstruct);
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 */
}

Hay, por supuesto, formas más eficientes de hacer esto. Si mantiene las claves ordenadas, puede usar una búsqueda binaria. También puedes usar una tabla hash. Estas cosas cambian su desempeño a expensas del mantenimiento.

Answer 10

Para agregar a la respuesta anterior de Phimueme, si su cadena tiene siempre dos caracteres, entonces puede construir un int entero de 16 bits de los dos caracteres de 8 bits, y encender eso (para evitar declaraciones de cambio / caso anidados).

Answer 11

Por lo general, así es como lo hago.

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";
}
}
}

Answer 12

Si se trata de una cadena de 2 bytes, puede hacer algo como en este ejemplo concreto en el que enciendo los códigos de idioma 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_ * son enteros constantes utilizados para indexar en matrices.

Answer 13

Si te refieres a cómo escribir algo similar a esto:

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

Entonces la solución canónica en C es usar una escalera if-else:

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

Answer 14

Si tiene muchos casos y no desea escribir strcmp() llamadas strcmp() , podría hacer algo como:

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

Solo tienes que asegurarte de que tu función hash no tenga colisiones dentro del conjunto de valores posibles para la cadena.