À l'aide de malloc en C pour allouer de l'espace pour un typedef serais type
Je ne suis pas sûr exactement ce dont j'ai besoin pour l'utiliser comme un argument à la fonction malloc pour allouer de l'espace dans le table_allocate(int) de la fonction. Je pensais juste count_table* cTable = malloc(sizeof(count_table*)) , mais ce n'est pas faire n'importe quoi avec le paramètre de taille. Suis-je censé pour allouer de l'espace pour la list_node_t aussi? Ci-dessous est ce que je suis en train de travailler avec.
dans le .h fichier je suis donné cette signature:
//créer un compte tableau de struct et allouer de l'espace pour cela //retourne comme un pointeur count_table_t* table_allocate(int);
Voici les structs que je suis censé utiliser:
typedef struct list_node list_node_t; struct list_node { char *clé; int valeur; //le nœud suivant dans la liste list_node_t *suivant; }; typedef struct count_table count_table_t; struct count_table { int taille; //un tableau de pointeurs list_node list_node_t **list_array; };
Merci!
Vous avez tout à fait un peu de bonnes réponses, mais personne n'a encore noter un point important:
int
est un type signé, et, sauf si vous souhaitez avoir des tailles, vous devez utiliser size_t
, qui est le type retourné par la sizeof
opérateur et passé à malloc
et les amis, et est destiné à être en mesure de stocker l'index de tableau pour les tableaux de taille autorisée par le compilateur. Vous voulez probablement size_t size
au lieu de int size
.OriginalL'auteur user516888 | 2010-11-23
Vous devez vous connecter pour publier un commentaire.
est faux. Il devrait être
Aussi, vous devez allouer de la mémoire pour list_node_t aussi séparément.
EDIT:
En dehors de ce que Clifford a relevé à propos de l'allocation de mémoire pour la liste de noeud, je pense que l'allocation de mémoire doit aussi être pris en charge pour la
char *key
à l'intérieur de la liste de nœud.Oui. Vous êtes l'obtention de ce droit. : ) Mais, veuillez vous référer à Clifford réponse au sujet de votre double utilisation du pointeur pour list_node_t. Vous avez besoin de vérifier pourquoi est-il donné comme un double pointeur là. Merci!
+1 mais je voudrais écrire
count_table* cTable = malloc(sizeof *cTable);
personnellement.Lutz: Bon point; - une plus grande facilité de maintenance.
Lutz & Clifford, je suis d'accord avec vos idées à ce sujet. Mais, aussi beaucoup une fois j'ai vu des gens faire une faute de frappe d'erreur et de manquer le " * " causant de ce fait seulement 4 octets à allouer. Ce problème conduit à des problèmes difficiles à trouver dans un grand code. Donc, je suis un peu confus à ce sujet.
OriginalL'auteur Jay
Votre suggestion:
count_table* cTable = malloc(sizeof(count_table*))
serait seulement allouer de l'espace pour un pointeur à un count_table.Vous auriez besoin
Chaque noeud de liste serait allouée séparément et cTable->taille et cTable->list_array et le dernier
list_node_t::next
mis à jour en conséquence. Le maintien d'un pointeur vers le dernier nœud ajouté ferait d'ajouter des nœuds plus vite.Je ne suis pas sûr pourquoi
count_table::list_array
est de typelist_node_t**
plutôt que de simplementlist_node_t*
(et aussi appelélist_array
plutôt que de simplementlist
). Est-ce votre intention que c'est à la fois un tableau et une liste en même temps? Ce serait un peu redondant. Le membre doit être seulement un pointeur vers le premier nœud, les nœuds sont alors accessibles vialist_node::next
::
vous dire.
Non, je veux dire :: parce que la gauche est un type pas une instance. Je suis à l'aide de C++ champ d'application de la notation, mais il n'est pas prévu que c'est du code, je suis simplement en l'utilisant comme une mention de se référer à un membre d'une structure plutôt que de membre d'une instance d'une struct. Il n'est pas syntaxique moyen de le faire en C.
ce que vous dites fait beaucoup de sens. comme pour l' (int taille) paramètre... pensez-vous qu'il est prévu que je ajouter que le nombre de nœuds de la count_table dans cette fonction? Je ne comprends pas ce que le paramètre de taille pour.
Je pense que l'idée est qu'il y a un tableau de listes, de sorte que lorsqu'un nœud est haché, vous regardez dans le tableau d'entrée, puis accompagnés en bas une seule liste liée. Qu'au moins un sens de la structure des données.
Ohhhhh. wow. Ouais, je vois que maintenant. Merci!
OriginalL'auteur Clifford
Étant donné que la
int
est une "taille" de paramètre pour la créationcount_table_t
, il semble que vous êtes censé les deux répartir lescount_table_t
lui-même, ainsi que d'initialiser ses membres.Initialisation de la
list_array
membre implique également une allocation de mémoire, de sorte qu'il pourrait ressembler:Cependant, vous avez également besoin de vérifier certaines conditions d'erreur: la multiplication des
size
parsizeof table->list_array[0]
pourrait débordement, et l'une desmalloc()
appels pourraient échouer. Si la fonction doit effectivement ressembler à ceci:(Notez que
(size_t)-1
est une constante égale à la maximum valeur d'unsize_t
, qui est le type du paramètre demalloc()
).int count
s devrait probablement êtresize_t
s.Lutz: d'Accord (et qui permettrait d'éliminer la nécessité pour les
< 0
à vérifier), mais il semble que la signature de la fonction etstruct
définition ont été remises à des conditions.OriginalL'auteur caf
En plus des autres affiches qui indiquent que vous êtes seulement allouer suffisamment d'espace pour le pointeur, pas l'espace les données que vous voulez occuper, je vous invite fortement à faire des choses comme ça:
Cela vous aidera dans le cas où le type de
cTable
ne change jamais, vous n'aurez pas à ajuster les deux parties de cette ligne, juste le type.OriginalL'auteur jer