Instruction Switch à l'aide de corde sur un tableau

Instructions de commutation de travail sur int valeurs (ou enum), mais pas sur char tableaux.

Vous pourriez faire

if (strcmp(name, "kevin")==0) {
    printf("hello");
}
else if (strcmp(name, "Laura")==0) {
    printf("Allo");
}
else if (strcmp(name, "Mike")==0) {
    printf("Good day");
}
else  {
    printf("Help!");
}

Non, vous ne pouvez pas utiliser le switch déclaration en C avec la valeur d'une chaîne ou un tableau de caractères. Le plus proche de l'alternative est d'utiliser une sorte de structure de données de la cartographie des chaînes à des pointeurs de fonction. Le pointeur de fonction peut être appelée après qu'une chaîne est utilisée pour le regarder.

Vous pouvez utiliser le "hachage-chaîne.h" de la bibliothèque qui convertit les chaînes de caractères dans le code de hachage entier.
Créer un fichier d'en-tête et de coller ce code:
http://www.opensource.apple.com/source/gcc/gcc-5484/intl/hash-string.h

#include <stdio.h>
#include <stdlib.h>
#include "hash-string.h"

int main(){

  char name[20];

  printf("Enter a name: ");
  scanf("%s",name);

  unsigned long nameInt = hash_string(name);

  switch(nameInt){
    case 7458046 /* "kevin" */: { printf("Hello %s", name); break; }
    default: { printf("You are not kevin"); }
  }

  printf("\n");
  return 0;
}

Si vous êtes après l'exécution d'actions spécifiques en faveur des chaînes de caractères spécifiques, cela implique que vous connaissez les cordes à l'avance. Cela implique à son tour leur nombre est limité, est dénombrable, comme par exemple un ensemble de N commandes:

const char * commands[] = {
 "command-1",
 "command-2",
 ...
 "command-N"

}

Pour répondre à ces commandes à l'intérieur du tableau ci-dessus à partir de votre code à l'aide d'un swtich vous besoin de connaître leur index, qui est sujette aux erreurs. Si le numéro de leur, de leur donner une ID:

enum Command_id {
  NO_COMMAND,
  COMMAND_1,
  COMMAND_2,
  //...
  COMMAND_N,
};

Maintenant mettre les deux ci-dessus à l'aide d'une struct:

struct Command_info {
  const char * command;
  enum Command_id id;
} command_infos[] = {
  {"", NO_COMMAND},
  {"command-1", COMMAND_1},
  {"command-2", COMMAND_2},
  //...
  {"command-N", COMMAND_N},
};

Maintenant vous avez les bons cartographie des chaînes et de leurs Identifiants. Pour être en mesure de carte de la chaîne d'ID au cours de l'exécution de la cartographie ci-dessus doit être recherché. Pour ce faire, dans une de manière efficace, vous voulez nous binaire de recherche. La bibliothèque C proveids bsearch() pour cela. La seule condition sine qua non est que la matrice cherchée besoin de trier.

Pour trier utilisation qsort() aussi proveid par la bibliothèque C. Pour qsort() de travail que nous vous avez besoin d'une comparaison de la fonction:

int cmp_command_infos(const void * pvCI1, const void* pvCI2)
{
  const struct Command_info * pCI1 = pvCI1;
  const struct Command_info * pCI2 = pvCI2;

  return strcmp(pCI1->command, pCI2->command);
}

Appel qsort() comme ce

qsort(command_infos, sizeof command_infos / sizeof *command_infos, sizeof *command_infos, cmp_command_infos);

Maintenant que le tableau est trié, on peut rechercher à l'aide de bsearch(). Pour la COMMANDE "-2" ce serait ressembler à ceci:

    ... = bsearch(&(struct Command_info){"COMMAND-2", NO_COMMAND}, command_infos, sizeof command_infos / sizeof *command_infos, sizeof *command_infos, cmp_command_infos);

Mettant tout cela ensemble, pourrait entraîner:

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
enum Command_id {
NO_COMMAND,
COMMAND_1,
COMMAND_2,
//...
COMMAND_N,
};
struct Command_info {
const char * command;
enum Command_id id;
} command_infos[] = {
{"", NO_COMMAND},
{"command-1", COMMAND_1},
{"command-2", COMMAND_2},
//...
{"command-N", COMMAND_N},
};
int cmp_command_infos(const void * pvCI1, const void* pvCI2)
{
const struct Command_info * pCI1 = pvCI1;
const struct Command_info * pCI2 = pvCI2;
return strcmp(pCI1->command, pCI2->command);
}
int main(int argc, char ** argv)
{
qsort(command_infos, sizeof command_infos / sizeof *command_infos, sizeof *command_infos, cmp_command_infos);
{
enum Command_id command_id = NO_COMMAND;
struct Command_info * pCI = bsearch(&(struct Command_info){argv[1], NO_COMMAND}, command_infos, sizeof command_infos / sizeof *command_infos, sizeof *command_infos, cmp_command_infos);
if (NULL == pCI)
{
printf("Command = '%s' is unknown\n", argv[1]);
}
else
{
printf("Command = '%s' --> ID = %d\n", pCI->command, pCI->id);
switch(command_id)
{
case COMMAND_1:
/* perform action on COMMAND 1 here */
break;
case COMMAND_2:
/* perform action on COMMAND 1 here */
break;
default:
/* unknow command, do nothing */
break;
}
}
}
}

L'appeler comme:

./a.out command-1

donner:

Command = 'command-1' --> ID = 1

ou:

./a.out command-bla

donner:

Command = 'command-bla' is unknown

ou même

./a.out ""

donner:

Command = '' --> ID = 0