Pourquoi laisser certaines variables de structure en dehors des accolades ?

Question

J'essaie de comprendre struct en C. Je n'ai pas pu saisir l'idée de cette définition ci-dessous. Pourquoi laissons-nous aCard , deck[ ] y *cardPtr dehors ? Quelle est la différence entre les inclure et les laisser de côté ?

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

Answer 1

Vous mélangez les choses. A struct card a les membres face y suit . Mais il y a trois variables qui utilisent le struct card à savoir aCard, deck, cardPtr .

On aurait pu aussi écrire :

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

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

Pour le typedef Jetez un coup d'œil : Pourquoi devrions-nous typedef un struct si souvent en C ? (Il va dans le typedef struct { ... } Foo; vs struct Foo {...} débat).

Answer 2

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"

Answer 3

Bien que cette question ait déjà reçu une réponse, je poste ma réponse car je pense que le PO a des doutes sur la déclaration de la structure et la définition de la variable d'un type de structure.

Si vous ne savez pas ce qu'est une structure en C, jetez un coup d'œil sur le site suivant 1) ci-dessous.

Le mot-clé struct introduit une déclaration de structure, qui est une liste de déclarations entre parenthèses . Un nom facultatif appelé balise de structure peut suivre le mot struct . Il s'agit donc d'une déclaration de structure :

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

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

Une déclaration struct définit un type. L'accolade 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] y *cardPtr sont les variables de type struct card .

Puisque votre déclaration de structure est étiquetée avec le nom card l'étiquette card peut être utilisé ultérieurement dans les définitions des instances de la structure. Par exemple, étant donné la déclaration de la 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 une collection d'une ou plusieurs variables, éventuellement de types différents, regroupées sous un seul nom.

Conformément à la norme C#6.2.5 [Types] :

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

.....
.....
Les types arithmétiques et les types pointeurs sont collectivement appelés types scalaires. Les types de tableaux et de structures sont collectivement appelés types agrégés.46)

Answer 4

A

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

c'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;

Answer 5

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