Comment vérifier si les structures sont initialisées ou non

C n'a pas null, il a NULL. Donc, essayez ceci:

dict* NewDictionary(void) {
  return calloc(sizeof(dict)); 
}

Cette version corrige quelques problèmes:

1. Tu partais value et key non initialisée, donc ils pouvaient tenir aléatoire d'ordures. À l'aide de calloc() va tout initialiser à 0, ce qui dans le pointeur de contexte est NULL. Il ne sera pas même prendre beaucoup plus de temps de traitement.
2. Vous n'avez pas de retourner quoi que ce soit. C'est un comportement indéfini. Si vous la fonction se termine sans un return déclaration, c'est que par pure chance que quoi que ce soit sera retourné.
3. Vous avez été en utilisant dict_pair au lieu de struct dict_pair. En C++, struct les noms sont dans le type ordinaire de l'espace de noms, c'est à dire t x = { 0 }; est valide en C++, mais en C, vous auriez besoin de dire struct t x = { 0 };.
4. Vous n'avez pas de vérifier la valeur de retour de malloc() (maintenant calloc() mais les mêmes règles s'appliquent). Si il n'y a pas assez de mémoire, calloc() retourne NULL. Je déteste déréférencer un NULL pointeur sur l'accident. Nous n'avons pas à vérifier la valeur de retour ici parce que j'ai fait avec toutes les étapes intermédiaires - calloc() est assez pour nous.

Noter que calloc() est un peu moins portable. Même si la norme exige que void *p = 0 définit le pointeur vers un pointeur null, il ne nécessite pas que le pointeur null "tous les bits à zéro", ce qui est calloc() techniquement n'. Si vous ne souhaitez pas utiliser calloc() pour cette raison, voici une version qui fait la même chose avec malloc():

dict* NewDictionary(void) {
  dict *dictionary = malloc(sizeof(dict)); 
  if(dictionary) {
    dictionary->head  = NULL;
    dictionary->tail  = NULL;
    dictionary->value = NULL;
    dictionary->key   = NULL;
  }
  return dictionary;
}

Ou:

dict* NewDictionary(void) {
  dict *dictionary = malloc(sizeof(dict)); 
  if(dictionary == NULL) return NULL;
  dictionary->head  = NULL;
  dictionary->tail  = NULL;
  dictionary->value = NULL;
  dictionary->key   = NULL;
  return dictionary;
}

Voir comment beaucoup plus agréable l' calloc() version est?

Quant à votre deuxième question:

Aussi, puis-je consulter de manière récursive déclarer la même structure à l'intérieur de la structure?

Non, vous ne pouvez pas faire ceci:

struct t {
  struct t x;
}

Mais vous peut ce faire (qui est ce que vous faites, et ce que vous voulez):

struct t {
  struct t *x;
}

Vous pouvez avoir un pointeur à un struct à l'intérieur de la struct lui-même, mais vous ne pouvez pas avoir la réelle struct à l'intérieur de la struct lui-même. Ce que vous faites est parfaitement légal, parce que vous êtes à l'aide de pointeurs.

OriginalL'auteur Chris Lutz

J'avais utiliser un allouée statiquement variable pour l'initialisation:

dict* NewDictionary(void) {
  static dict null_dict; //no initializer, so zero by default
  dict *dictionary = malloc(sizeof *dictionary);
  *dictionary = null_dict;
  return dictionary;
}

Cela garantit que les membres soient correctement mis à zéro, indépendamment du fait qu'ils sont des pointeurs, à virgule flottante ou les types d'entiers.

OriginalL'auteur Christoph

Je suis en utilisant une astuce qui fonctionne pour moi.

struct hello{
    ....;
    ....;
    ....;
};

struct hello *t;

t=malloc(sizeof(struct hello));
free(t);
t=NULL;

Maintenant u peut facilement vérifier si t est initialisé ou non. Et il n'y a pas de fuite de mémoire.

OriginalL'auteur RatDon