struct (langage de programmation C) - struct (C programming language)

Une structure dans le langage de programmation C (et de nombreux dérivés) est une déclaration de type de données composite (ou enregistrement ) qui définit une liste physiquement groupée de variables sous un nom dans un bloc de mémoire, permettant d'accéder aux différentes variables via un seul pointeur ou par la structure déclarée nom qui renvoie la même adresse. Le type de données struct peut contenir d'autres types de données et est donc utilisé pour les enregistrements de type mixte tels qu'une entrée de répertoire de disque dur (longueur de fichier, nom, extension, adresse physique, etc.), ou d'autres enregistrements de type mixte (nom , adresse, téléphone, solde, etc.).

La structure C fait directement référence à un bloc contigu de mémoire physique, généralement délimité (dimensionné) par des limites de longueur de mot. Cela correspond à la fonctionnalité de nom similaire disponible dans certains assembleurs pour processeurs Intel. Étant un bloc de mémoire contiguë, chaque champ dans une structure est situé à un certain décalage fixe par rapport au début.

Étant donné que le contenu d'une structure est stocké dans une mémoire contiguë, l' opérateur sizeof doit être utilisé pour obtenir le nombre d'octets nécessaires pour stocker un type particulier de structure, tout comme il peut être utilisé pour les primitives . L'alignement de champs particuliers dans la structure (par rapport aux limites des mots ) est spécifique à l'implémentation et peut inclure un remplissage, bien que les compilateurs modernes prennent généralement en charge la #pragma pack directive, qui modifie la taille en octets utilisés pour l'alignement.

Dans le langage C ++ , une structure est identique à une classe C ++ mais a une visibilité par défaut différente: les membres de la classe sont privés par défaut, tandis que les membres de la structure sont publics par défaut.

Dans d'autres langues

Le type de données struct en C est dérivé du type de données struct ALGOL 68 .

Comme son homologue C, le type de données struct en C # ( Structure en Visual Basic .NET ) est similaire à une classe . La plus grande différence entre une structure et une classe dans ces langages est que lorsqu'une structure est passée en tant qu'argument à une fonction, toute modification apportée à la structure dans cette fonction ne sera pas reflétée dans la variable d'origine (sauf si le passage par référence est utilisé).

Cela diffère du C ++, où les classes ou les structures peuvent être allouées statiquement ou dynamiquement soit sur la pile (similaire à C #), soit sur le tas, avec un pointeur explicite. En C ++ , la seule différence entre une structure et une classe est que les membres et les classes de base d'une structure sont publics par défaut. (Une classe définie avec le class mot - clé a des membres privés et des classes de base par défaut.)

Déclaration

La syntaxe générale d'une déclaration struct en C est: 

struct tag_name {
   type member1;
   type member2;
   /* declare as many members as desired, but the entire structure size must be known to the compiler. */
};

Voici tag_name facultatif dans certains contextes.

Une telle struct déclaration peut également apparaître dans le contexte d'une déclaration typedef d'un alias de type ou de la déclaration ou de la définition d'une variable: 

typedef struct tag_name {
   type member1;
   type member2;
} struct_alias;

Initialisation

Il existe trois manières d'initialiser une structure. Pour le struct type 

/* Declare the struct with integer members x, y */
struct point {
   int    x;
   int    y;
};

Les initialiseurs de style C89 sont utilisés lorsque des membres contigus peuvent être donnés. 

/* Define a variable p of type point, and initialize its first two members in place */
struct point p = { 1, 2 };

Pour la liste des membres non contigus ou dans le désordre, le style d' initialisation désigné peut être utilisé 

/* Define a variable p of type point, and set members using designated initializers*/
struct point p = { .y = 2, .x = 1 };

Si un initialiseur est donné ou si l'objet est alloué statiquement , les éléments omis sont initialisés à 0.

Une troisième manière d'initialiser une structure est de copier la valeur d'un objet existant du même type 

/* Define a variable q of type point, and set members to the same values as those of p */
struct point q = p;

Mission

Une structure peut être affectée à une autre structure. Un compilateur peut utiliser memcpy() pour effectuer une telle affectation. 

struct point {
    int x;
    int y;
};

int main(void)
{
    struct point p = { 1, 3 };        /* initialized variable */
    struct point q;                   /* uninitialized */
    q = p;                     /* copy member values from p into q */
    return 0;
}

Pointeurs vers struct

Les pointeurs peuvent être utilisés pour faire référence à un struct par son adresse. Ceci est utile pour passer des structures à une fonction. Le pointeur peut être déréférencé à l'aide de l' * opérateur. L' -> opérateur déréférence le pointeur vers struct (opérande de gauche), puis accède à la valeur d'un membre de la structure (opérande de droite). 

struct point {
   int x;
   int y;
};
struct point my_point = { 3, 7 };
struct point *p = &my_point;  /* p is a pointer to my_point */
(*p).x = 8;                   /* set the first member of the struct */
p->x = 8;                     /* equivalent method to set the first member of the struct */

Voir également

Les références