Problème de boucle de table de hachage GLib

Je vais utiliser la mise en oeuvre de la table de hachage de GLib dans un programme C et, pour l’instant, je l’expérimente juste. J’ai écrit le code suivant pour le test:

#include  #include  #include  #include  #include  int main(){ // Some codes and declerations here GHashTable *g_hash_table; uint32_t *a; a=(uint32_t *)malloc(sizeof(uint32_t)); if(a==NULL){ printf("Not Enough Mem For a\n"); return 1; } *a=1123231; uint32_t* key; key=(uint32_t *)malloc(sizeof(uint32_t)); if(key==NULL){ printf("Not Enough Mem For key\n"); return 1; } *key=122312312; int i; g_hash_table=g_hash_table_new(g_int_hash, g_int_equal); for(i=0;i<TABLE_SIZE;i++){ *key+=1; *a+=1; g_hash_table_insert(g_hash_table,(gpointer)key,(gpointer)a); uint32_t *x=(uint32_t *)g_hash_table_lookup(g_hash_table,key); printf("Counter:%d, %u\n",i,*x); } GHashTableIter iter; g_hash_table_iter_init(&iter,g_hash_table); int size=g_hash_table_size(g_hash_table); printf("First size: %d\n",size); uint32_t *val; uint32_t *key_; int counter=0; // My problem is in the following loop it // always returns the same and the last key value pair while(g_hash_table_iter_next(&iter,(gpointer*)(void*)&key_,(gpointer*)(void*)&val)){ counter++; printf("%u %u\n",(uint32_t)*key_,(uint32_t)*val); printf("Counter: %d\n",counter); } //Some more code here return 0; } 

En quelque sorte, mon code de test itère correctement mais dans la boucle, il retourne toujours la dernière paire de clés et la dernière paire de valeurs et il est toujours identique. Quel est le problème ici? Le code ci-dessus ne peut pas être exécuté avec son format. Je viens de copier et coller certaines parties pour donner une idée claire de ce que j’essaie de faire.

Il y a une erreur dans la key , a déclaration. Vous mettez toujours le même pointeur dans la table de hachage. Essayer:

 #include  #include  #include  #include  #include  #define TABLE_SIZE 12 int main() { // Some codes and declarations here GHashTable *g_hash_table; int i; g_hash_table = g_hash_table_new(g_int_hash, g_int_equal); for (i=0; i %u\n", *key ,*x); } GHashTableIter iter; int size=g_hash_table_size(g_hash_table); printf("First size: %d\n", size); uint32_t *val; uint32_t *key_; // My problem is in the following loop // it always returns the same and the last key value pair g_hash_table_iter_init (&iter, g_hash_table); while (g_hash_table_iter_next (&iter, (gpointer) &key_, (gpointer) &val)) { printf("key %u ---> %u\n", (uint32_t)*key_, (uint32_t)*val); } // TODO: free keys return 0; } 

Je pense que votre code d’insertion est cassé. Vous n’allouez la mémoire qu’une seule fois, mais vous effectuez ensuite de nombreuses insertions, en incrémentant la valeur stockée dans l’emplacement atsortingbué unique entre chacune.

La table de hachage stocke votre pointeur. Ainsi, chaque clé sera associée au même pointeur.

En outre, vous devriez probablement utiliser g_malloc() avec glib, par g_malloc() de cohérence.

Et je recommande toujours d’utiliser sizeof sur des objects plutôt que sur leurs types; De cette façon, vous ne vous répétez pas d’une manière tout aussi dangereuse. Donc, au lieu de

  guint32 *a; a = g_malloc(sizeof (guint32)); 

utilisation

  a = g_malloc(sizeof *a); 

De cette façon, vous “verrouillez” la dépendance, de sorte que vous allouiez toujours assez d’espace pour stocker n’importe quel point, même si vous modifiez le type ultérieurement.

De plus, vous devriez jeter un regard critique sur chaque casting que vous faites. Lancer un pointeur non constant sur gpointer est le signe d’un programmeur hésitant. Avec gpointer , gpointer n’est qu’un synonyme de void * , ce qui gpointer que la dissortingbution n’est jamais nécessaire. Cela ne fait qu’append cruellement à votre code, ce qui le rend plus difficile à lire.