Peut chaînes être utilisé comme un index de tableau?

Il peut compiler, mais il ne fonctionne pas.

Ce n'est pas tout à fait clair ce que vous essayez d'atteindre. Je pense que vous voulez un tableau associatif, dans ce cas, vous devriez trouver une bibliothèque de leur mise en œuvre.

Si vous êtes à la recherche de quelque chose de plus comme un type énuméré, et vous pouvez compter sur C89, regardez quelque chose comme:

enum cardsuit {
   CLUBS,
   DIAMONDS,
   HEARTS,
   SPADES
};

Si vous ne pouvez pas compter sur C89, alors vous devriez essayer quelques typedef la ruse.

OriginalL'auteur Hank Gay

Vous devez écrire une fonction qui mappe des chaînes de nombres entiers, ou encore utiliser les énumérations dans l'ensemble (et puis peut-être une fonction que les cartes de valeurs énumérées à cordes).

En général, il est plus agréable de faire la dernière: pour passer des entiers, de sorte que la mise en œuvre ne dépend pas de l'détails de chaînes de caractères qui peuvent être utilisés dans la représentation. Par exemple, pensez à comment vous allez gérer la localisation (traduction) si jamais vous avez besoin de faire ces chaînes acceptable pour quelqu'un parlant une langue différente.

OriginalL'auteur Martin Carpenter

Ce que vous cherchez est probablement l'équivalent d'un tableau associatif qui ne peuvent pas être fournis avec le même sucre syntaxique en C malheureusement sans certains idiot résultats.

Cependant, ce que vous pouvez offrir est un hashmap si vos données est conforme à la clé -> valeur des paires. Ce que vous aurez besoin est un idéal de fonction de hachage.

Il y a un décent exemple simple d'une table de hachage ici:

http://www.cl.cam.ac.uk/~cwc22/hashtable/

OriginalL'auteur Philip Reynolds

C'est un vieux thread, mais j'ai pensé que cela pourrait encore être utile pour ceux qui sont à la recherche pour une mise en œuvre. Il ne prend pas trop de code; j'ai fait le mien en ~100 lignes de sans supplément de la bibliothèque comme Hank Gay suggéré. Je l'ai appelé un dictionnaire car elle est parallèle à (un peu) le python de type de données. Voici le code:

#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
typedef struct hollow_list hollow_list;
struct hollow_list{
unsigned int size;
void *value;
bool *written;
hollow_list *children;
};
//Creates a hollow list and allocates all of the needed memory
hollow_list hollow_list_create(unsigned int size){
hollow_list output;
output = (hollow_list) {.size = size, .value = (void *) 0, .written = calloc(size, sizeof(bool)), .children = calloc(size, sizeof(hollow_list))};
return output;
}
//Frees all memory of associated with a hollow list and its children
void hollow_list_free(hollow_list *l, bool free_values){
int i;
for(i = 0; i < l->size; i++){
hollow_list_free(l->children + i, free_values);
}
if(free_values){
free(l->value);
}
free(l);
}
//Reads from the hollow list and returns a pointer to the item's data
void *hollow_list_read(hollow_list *l, unsigned int index){
if(index == 0){
return l->value;
}
unsigned int bit_checker;
bit_checker = 1<<(l->size - 1);
int i;
for(i = 0; i < l->size; i++){
if(bit_checker & index){
if(l->written[i] == true){
return hollow_list_read(l->children + i, bit_checker ^ index);
} else {
return (void *) 0;
}
}
bit_checker >>= 1;
}
}
//Writes to the hollow list, allocating memory only as it needs
void hollow_list_write(hollow_list *l, unsigned int index, void *value){
if(index == 0){
l->value = value;
} else {
unsigned int bit_checker;
bit_checker = 1<<(l->size - 1);
int i;
for(i = 0; i < l->size; i++){
if(bit_checker & index){
if(!l->written[i]){
l->children[i] = hollow_list_create(l->size - i - 1);
l->written[i] = true;
}
hollow_list_write(l->children + i, bit_checker ^ index, value);
break;
}
bit_checker >>= 1;
}
}
}
typedef struct dictionary dictionary;
struct dictionary{
void *value;
hollow_list *child;
};
dictionary dictionary_create(){
dictionary output;
output.child = malloc(sizeof(hollow_list));
*output.child = hollow_list_create(8);
output.value = (void *) 0;
return output;
}
void dictionary_write(dictionary *dict, char *index, unsigned int strlen, void *value){
void *hollow_list_value;
dictionary *new_dict;
int i;
for(i = 0; i < strlen; i++){
hollow_list_value = hollow_list_read(dict->child, (int) index[i]);
if(hollow_list_value == (void *) 0){
new_dict = malloc(sizeof(dictionary));
*new_dict = dictionary_create();
hollow_list_write(dict->child, (int) index[i], new_dict);
dict = new_dict;
} else {
dict = (dictionary *) hollow_list_value;
}
}
dict->value = value;
}
void *dictionary_read(dictionary *dict, char *index, unsigned int strlen){
void *hollow_list_value;
dictionary *new_dict;
int i;
for(i = 0; i < strlen; i++){
hollow_list_value = hollow_list_read(dict->child, (int) index[i]);
if(hollow_list_value == (void *) 0){
return hollow_list_value;
} else {
dict = (dictionary *) hollow_list_value;
}
}
return dict->value;
}
int main(){
char index0[] = "hello, this is a test";
char index1[] = "hello, this is also a test";
char index2[] = "hello world";
char index3[] = "hi there!";
char index4[] = "this is something";
char index5[] = "hi there";
int item0 = 0;
int item1 = 1;
int item2 = 2;
int item3 = 3;
int item4 = 4;
dictionary d;
d = dictionary_create();
dictionary_write(&d, index0, 21, &item0);
dictionary_write(&d, index1, 26, &item1);
dictionary_write(&d, index2, 11, &item2);
dictionary_write(&d, index3, 13, &item3);
dictionary_write(&d, index4, 17, &item4);
printf("%d\n", *((int *) dictionary_read(&d, index0, 21)));
printf("%d\n", *((int *) dictionary_read(&d, index1, 26)));
printf("%d\n", *((int *) dictionary_read(&d, index2, 11)));
printf("%d\n", *((int *) dictionary_read(&d, index3, 13)));
printf("%d\n", *((int *) dictionary_read(&d, index4, 17)));
printf("%d\n", ((int) dictionary_read(&d, index5, 8)));
}

Malheureusement, vous ne pouvez pas reproduire la liste[x] la syntaxe, mais c'est la meilleure alternative que j'ai trouvé.

OriginalL'auteur 2.71828-asy