Question

I’m using a malloc’d string as a key to a GLib hash table. I then have several updates to make. Each update uses a newly malloced string that is identical in the actual sequence of characters. If I do an an insert, will the old string be overwritten? How can I make sure to free it so I don’t keep extra copies around? If it’s not overwritten, how can I make sure to implement an update without it being too slow?

Answer 1

If you supply the correct comparator and key/value destructors to g_hash_table_new_full when creating the hash table, you don’t have to do anything extra. The table will understand that the key strings are the same even if they are separate copies, and it will automatically free repeated copies of the same key as well.

Here is an example (the ugly printfs are only there to show whats happening):

First you write a destructor:

void
free_data (gpointer data)
{
  printf ("freeing: %s %p\n", (char *) data, data);
  free (data);
}

Then you instantiate and play around with the GHashTable:

int main (void)
{
  char *key, *val;
  GHashTable *hash_table
  = g_hash_table_new_full (g_str_hash,  /* Hash function  */
                           g_str_equal, /* Comparator     */
                           free_data,   /* Key destructor */
                           free_data);  /* Val destructor */
  /* Insert 'k_1' */
  key = strdup ("k_1");
  printf ("%s %p\n", key, key);
  val = strdup ("v_1");
  printf ("%s %p\n", val, val);

  printf ("inserting\n");
  g_hash_table_insert (hash_table, key, val);
  printf ("insert finished\n");

  /* Insert 'k_1' again using new strings */
  key = strdup ("k_1");
  printf ("%s %p\n", key, key);
  val = strdup ("new_v_1");
  printf ("%s %p\n", val, val);

  printf ("inserting\n");
  g_hash_table_insert (hash_table, key, val);
  printf ("insert finished\n");

  g_hash_table_unref (hash_table);

  return 0;
}

Here is what a test run looks like:

k_1 0x80cce70
v_1 0x80cce80
inserting
insert finished
k_1 0x80cce90
new_v_1 0x80ccea0
inserting
freeing: k_1 0x80cce90
freeing: v_1 0x80cce80
insert finished
freeing: k_1 0x80cce70
freeing: new_v_1 0x80ccea0

You will see that if you create a ‘new’ key identical to an existing key, and try to insert a corresponding ‘new’ value, then the ‘insert’ operation automatically destroys the ‘new’ key (because it is the same as the existing one), as well as the old value (because it has to be replaced with the new one).