Comment vérifier si la structure typedef interne d'une structure typedef est NULL?

Question

typedef struct 
{ 
    uint32 item1; 
    uint32 item2; 
    uint32 item3; 
    uint32 item4; 

    <some_other_typedef struct> *table; 

} Inner_t; 

typedef struct 
{ 
    Inner_t tableA; 

    Inner_t tableB; 

} Outer_t; 

Outer_t outer_instance = 
{ 
    {NULL}, 
    { 
    0, 
    1, 
    2, 
    3, 

    table_defined_somewhere_else, 
    } 
}; 

Ma question est de savoir si tableA est NULL exactement comme dans le cas de outer_instance. Il a essayé: if (tmp->tableA == NULL). Je reçois "erreur: opérandes invalides à == binaire"

/**************************** EDIT: Mise à jour du code est ci-dessous *****************************/

J'ai changé le code selon la suggestion de bta mais maintenant je suis obtenir une autre erreur "erreur: élément initialiseur est pas constante" à la ligne juste sous la valeur NULL (à items_instance)

typedef struct 
{ 
    uint32 item1; 
    uint32 item2; 
    uint32 item3; 
    uint32 item4; 

} Items_t; 

typedef struct 
{ 
    Items_t *itemsA; 

    Items_t *itemsB; 

} Outer_t; 


Items_t items_instance= 
{ 
    1, 
    2, 
    3, 
    4 
}; 

Outer_t outer_instance= 
{ 
    NULL, 
    items_instance 

}; 

Answer 1

Dans le code révisé, vous définissez le premier champ de outer_instance sur NULL, mais en essayant de définir le deuxième champ directement sur items_instance. Depuis le champ a le type Items_t* mais items_instance a le type Items_t, vous obtenez une erreur de type.

Vous souhaitez définir le champ sur l'adresse de items_instance, utilisez &items_instance.

Answer 2

Essayez if (tmp->tableA.table== NULL)

Answer 3

Dans votre code, l'initialisation

Outer_t outer_instance = { 
    {NULL}, 
    { 
    0, 
    1, 
    2, 
    3, 
    table_defined_somewhere_else, 
    } 
}; 

est invalide. Vous essayez d'affecter NULL à Outer_t.tableA qui est de type non-pointeur Inner_t. NULL ne peut être affecté qu'à des pointeurs. La plupart des compilateurs C définissent NULL comme 0 ou ((void*)0). En fonction de votre compilateur, cette syntaxe peut être autorisée mais sera étendue à 0, définissant ainsi tous les champs de la première structure Inner_t à zéro. En tout cas, ce code ne fera pas ce que je crois que vous croyez.

Votre notion de tableA étant indéfinie ou inexistante est erronée. Comme vos structures sont actuellement définies, la déclaration d'un objet de type Outer_t créera automatiquement deux objets Inner_t en tant que membres de structure (et ces structures Inner_t créeront automatiquement les objets dont ils sont composés, etc.). Si outer_instance existe, alors outer_instance.tableA et outer_instance.tableB sont garantis d'exister. Ils ne peuvent pas être "indéfinis" (ils sont définis lorsque vous avez défini le type de données Outer_t) ou "NULL" (n'a aucune signification sauf pour les pointeurs). Une structure qui a des membres définis n'est jamais "vide".

Maintenant, il est un problème valide si oui ou non tableA ou tableB ont été initialisés. Il n'y a pas de manière universellement appropriée de le faire. Une méthode consiste à remplir toute la structure avec une valeur prédéfinie lorsqu'elle est déclarée, et de vérifier la présence de cette valeur comme un signe que la structure n'a pas été initialisée. Cela suppose toutefois qu'il existe une valeur que vous ne devriez jamais considérer comme des données valides dans cette structure; plusieurs fois, une telle valeur n'existe pas.

Si vous voulez construire votre code de telle sorte que les membres de Outer_t peuvent ou non exister, alors vous devez utiliser des pointeurs (tels que Inner_t* tableA) en tant que membres de Outer_t au lieu des structures. De cette façon, vous pouvez NULL le pointeur pour indiquer une table inexistante. Cependant, vous ne seriez pas capable de déclarer le contenu des structures internes en même temps que la structure externe comme vous le faites actuellement.

Edit: En regardant votre code mis à jour, il semble que vous obtenez cette erreur particulière parce que vous essayez d'assigner un objet de type Items_t à un champ de type Items_t*. Utilisez &items_instance ici et votre erreur devrait disparaître (à condition que items_instance est défini avantouter_instance, et tous les éléments de items_instance peuvent être déterminés au moment de la compilation).