web-dev-qa-db-fra.com

Pourquoi laisse-t-on certaines variables de structure en dehors des accolades?

J'essaie de comprendre struct en C. Je ne pouvais pas comprendre l'idée de cette définition ci-dessous. Pourquoi laisse-t-on aCard, deck[ ] et *cardPtr dehors? Quelle est la différence entre les inclure dans et les laisser de côté? 

 struct card {
    char *face;
    char *suit;
 } aCard, deck[52], *cardPtr;
c
38
Belverus

Bien que, cette question ait déjà répondu, je publie ma réponse car je pense que le PO a des doutes dans la déclaration de structure et la définition de variable d'un type de structure.

Si vous ne savez pas ce qu'est une structure en C, jetez un œil à 1) au dessous de.

Le mot clé struct introduit une déclaration de structure, qui est une liste de déclarations entre accolades . Un nom facultatif appelé balise de structure peut Suivre le Word struct. Il s'agit donc d'une déclaration de structure:

struct card {
    char *face;
    char *suit;
 };

ici face et suit sont variables de membre . Notez qu'une déclaration de structure ne réserve aucun stockage; il décrit simplement un modèle de structure.

Une déclaration de structure définit un type. L'accolade de droite qui termine la liste des membres peut être suivie d'une liste de variables. Donc, dans votre cas:

....
} aCard, deck[52], *cardPtr;

aCard, deck[52] et *cardPtr sont les variables de type struct card.

Étant donné que votre déclaration de structure porte le nom card, la balise card peut être utilisée ultérieurement dans les définitions des instances de la structure. par exemple. étant donné la déclaration de structure card ci-dessus,

struct card someCard;

définit une variable someCard qui est une structure de type struct card.

Vous pouvez également typedef une déclaration de structure et l'utiliser pour définir des variables de son type.

1)

Par définition - Une structure est un ensemble d’une ou de plusieurs variables, éventuellement de types différents, regroupées sous un même nom.

Selon la norme C 6.2.5 [Types]:

Un type de structure décrit un ensemble d'objets membres non vides alloués séquentiellement (et, dans certaines circonstances, un tableau incomplet), chacun d'eux ayant un nom éventuellement spécifié et un type éventuellement distinct. 

.....
.....
Les types arithmétiques et les types de pointeur sont collectivement appelés types scalaires. Les types de tableau et de structure sont collectivement appelés types d'agrégats.46) 

18
H.S.

Vous mélangez les choses. Un struct card a les membres face et suit. Mais il existe trois variables utilisant le type struct card, à savoir aCard, deck, cardPtr.

Sinon, on aurait pu écrire:

typedef struct {
    char *face;
    char *suit;
} Card;

Card aCard, deck[52], *cardPtr;
// or even
Card aCard;
Card deck[52];
Card *cardPtr;

Pour la typedef, regardez: Pourquoi devrions-nous dactylographier une structure aussi souvent en C? (Il entre dans le débat typedef struct { ... } Foo; vs struct Foo {...}).

73
Micha Wiedenmann

Votre morceau de code pourrait être écrit comme ceci ce qui le rend plus clair:

struct card {          // define the struct card
    char *face;
    char *suit;
 };

struct card aCard;     // declare a variable "aCard" of type "struct card "
struct card deck[52]   // declare an array of 52 variables of type "struct card"
struct card *cardPtr;  // declare a variable "cardPtr" of type "pointer to struct card"
28
Jabberwocky

UNE

struct card {
    char *face;
    char *suit;
 }

est comme int, mais il est défini par l'utilisateur, et

aCard, deck[52], *cardPtr;

sont des noms de variables, par exemple,

int aCard, deck[41], *cardPtr;
7
BladeMight

Vous avez déclaré trois variables. aCard est de type struct card, deck est de type struct card[52] et cardPtr est de type struct card *

1
Broman

aCard et le reste que vous avez mentionné sont des variables de type struct card et chacune de ces variables contient char *face et char *suit. Alors, comment une variable peut-elle se contenir, c'est-à-dire que aCard se trouve à l'intérieur du noeud struct.

0
Observer