¿Por qué este código no asigna memoria en C?

La pregunta actualizada está aquí

Problema de asignación de memoria en HashTable

Estoy trabajando en hacer un HashTable en C. Esto es lo que he hecho. Creo que voy por el camino correcto, pero cuando bash

C Principal

HashTablePtr hash; hash = createHashTable(10); insert(hash, "hello"); insert(hash, "world"); 

HashTable.c

  HashTablePtr createHashTable(unsigned int capacity){ HashTablePtr hash; hash = (HashTablePtr) malloc(sizeof(HashTablePtr)); hash->size = 0; hash->capacity = capacity; ListPtr mylist = (ListPtr)calloc(capacity, sizeof(ListPtr)); /* WHY IT DOESN'T ALLOCATE MEMORY FOR mylist HERE?? */ mylist->head = NULL; mylist->size = 0; mylist->tail = NULL; hash->list = mylist; return hash; 

ListPtr es una lista de pst de LinkedList

Lista.h

 typedef struct list List; typedef struct list * ListPtr; struct list { int size; NodePtr head; NodePtr tail; }; ... ... 

HashTable.h

  typedef struct hashtable * HashTablePtr; typedef struct hashtable HashTable; struct hashtable { unsigned int capacity; unsigned int size; ListPtr *list; unsigned int (*makeHash)(unsigned int, void *); }; ... ... 

Cuando ejecuto mi depurador, no veo ninguna memoria asignada a myList. En el ejemplo anterior, mi bash es convertirlo en un conjunto de 10 listas.

Por favor ayúdame a solucionar esto.

No soy ese experto en C, si eso ayuda.

 calloc(capacity, sizeof(ListPtr) 

debiera ser

 calloc(capacity, sizeof(List) 

Creo que hay toda una serie de problemas aquí. No has incluido el error que recibiste, así que enumeraré un par:

  • hash = (HashTablePtr) malloc (sizeof (HashTablePtr *)); – Está asignando el tamaño de una tabla hash **, que es de cuatro bytes, debe asignar el tamaño del objeto subyacente.
  • ListPtr mylist = (ListPtr *) calloc (capacity, sizeof (ListPtr)); – Nuevamente, está asignando el tamaño del puntero en lugar del objeto de lista subyacente.
  • HashTablePtr createHashTable (unsigned int capacity)) {- Probablemente esté obteniendo un error de comstackción aquí con los parámetros adicionales y el número inconsistente de parámetros.

Personalmente, no soy un gran fan de usar typedefs, especialmente cuando eres un principiante. Creo que eso puede ser en parte lo que te confunde. Eres mejor evitando cosas como:

 typedef struct hashtable * HashTablePtr; 

El uso de muchas definiciones de tipo hará que su código sea más difícil de leer, ya que también tendrá que buscar constantemente lo que están refiriendo.

El problema principal es que estaba asignando la memoria para el tamaño de un puntero de tabla hashtable y no para el tamaño de sus estructuras respetadas. Creo que el siguiente código muestra esto bien. También querrá comprobar si las asignaciones funcionaron. Si malloc, calloc, realloc. etc. fallan ellos vuelven NULL. Si esto sucede y no verifica este caso, obtendrá un error de seguridad y su progtwig se bloqueará.

También siga el estándar c99 y ponga todas sus declaraciones de variables al inicio de la función.

c99 std

página de manual de malloc

 struct hashtable * createHashTable(unsigned int capacity){ struct hashtable *hash; struct list *mylist; /* You want to allocate size of the hash structure not the size of a pointer. */ hash = malloc(sizeof(struct hashtable)); // always make sure if the allocation worked. if(hash == NULL){ fprintf(stderr, "Could not allocate hashtable\n"); return NULL; } hash->size = 0; hash->capacity = capacity; /* Unless you need the memory to be zero'd I would just use malloc here * mylist = calloc(capacity, sizeof(struct list)); */ mylist = malloc(capacity * sizeof(struct list)); if(mylist == NULL){ fprintf(stderr, "Could not allocate list\n"); free(hash); /* free our memory and handle the error*/ return NULL; } mylist->head = NULL; mylist->size = 0; mylist->tail = NULL; hash->list = mylist; return hash; } 

También recuerda liberar tu lista antes de liberar tu tabla hash:

 free(myhash->list); free(myhash); 

Está asignando un bloque contiguo de ListPtr, pero realmente desea asignar espacio para todas las estructuras en lugar de solo punteros (ListPtr) a esas estructuras:

 calloc(capacity, sizeof(List)); 

Estoy de acuerdo con el comentario de gman acerca de no ocultar los punteros. Al codificar en C, nunca tipeo una List * como ListPtr . Hace que el código sea más difícil de entender.