La structure en C est un type de données défini par l'utilisateur qui peut être utilisé pour regrouper des éléments de types éventuellement différents en un seul type. Le mot-clé de structure est utilisé pour définir la structure dans le langage de programmation C. Les éléments de la structure sont appelés ses membre et ils peuvent être de n’importe quel type de données valide.
Déclaration de structure C
Nous devons déclarer la structure en C avant de l'utiliser dans notre programme. Dans la déclaration de structure, nous spécifions ses variables membres ainsi que leur type de données. Nous pouvons utiliser le mot-clé struct pour déclarer la structure en C en utilisant la syntaxe suivante :
Syntaxe
struct structure_name { data_type member_name1; data_type member_name1; .... .... };> La syntaxe ci-dessus est également appelée modèle de structure ou prototype de structure et aucune mémoire n'est allouée à la structure dans la déclaration.
Définition de la structure C
Pour utiliser la structure dans notre programme, nous devons définir son instance. Nous pouvons le faire en créant des variables de type structure. Nous pouvons définir des variables de structure en utilisant deux méthodes :
formater la date en java
1. Déclaration de variable de structure avec modèle de structure
struct structure_name { data_type member_name1; data_type member_name1; .... .... } variable1, varaible2, ... ;> 2. Déclaration de variable de structure après le modèle de structure
// structure declared beforehand struct structure_name variable1, variable2 , .......;>
Accéder aux membres de la structure
Nous pouvons accéder aux membres de la structure en utilisant le ( . ) opérateur point.
Syntaxe
structure_name.member1; strcuture_name.member2;>
Dans le cas où l'on dispose d'un pointeur vers la structure, on peut également utiliser l'opérateur flèche pour accéder aux membres.
Initialiser les membres de la structure
Membres de la structure c'est pas possible initialisé avec la déclaration. Par exemple, le programme C suivant échoue lors de la compilation.
struct Point { int x = 0; // COMPILER ERROR: cannot initialize members here int y = 0; // COMPILER ERROR: cannot initialize members here };> La raison de l’erreur ci-dessus est simple. Lorsqu'un type de données est déclaré, aucune mémoire ne lui est allouée. La mémoire est allouée uniquement lorsque les variables sont créées.
Nous pouvons initialiser les membres de la structure de 3 manières qui sont les suivantes :
- Utilisation de l'opérateur d'affectation.
- Utilisation de la liste d'initialisation.
- Utilisation de la liste d'initialiseurs désignés.
1. Initialisation à l'aide de l'opérateur d'affectation
struct structure_name str; str.member1 = value1; str.member2 = value2; str.member3 = value3; . . .>
2. Initialisation à l'aide de la liste d'initialisation
struct structure_name str = { value1, value2, value3 };> Dans ce type d'initialisation, les valeurs sont affectées dans un ordre séquentiel au fur et à mesure qu'elles sont déclarées dans le modèle de structure.
3. Initialisation à l'aide de la liste d'initialiseurs désignée
L'initialisation désignée permet aux membres de la structure d'être initialisés dans n'importe quel ordre. Cette fonctionnalité a été ajoutée dans la norme C99.
struct structure_name str = { .member1 = value1, .member2 = value2, .member3 = value3 };> L'initialisation désignée n'est prise en charge qu'en C mais pas en C++.
Exemple de structure en C
Le programme C suivant montre comment utiliser les structures
C
// C program to illustrate the use of structures> #include> > // declaring structure with name str1> struct> str1 {> >int> i;> >char> c;> >float> f;> >char> s[30];> };> > // declaring structure with name str2> struct> str2 {> >int> ii;> >char> cc;> >float> ff;> } var;>// variable declaration with structure template> > // Driver code> int> main()> {> >// variable declaration after structure template> >// initialization with initializer list and designated> >// initializer list> >struct> str1 var1 = { 1,>'A'>, 1.00,>'techcodeview.com'> },> >var2;> >struct> str2 var3 = { .ff = 5.00, .ii = 5, .cc =>'a'> };> > >// copying structure using assignment operator> >var2 = var1;> > >printf>(>'Struct 1:
i = %d, c = %c, f = %f, s = %s
'>,> >var1.i, var1.c, var1.f, var1.s);> >printf>(>'Struct 2:
i = %d, c = %c, f = %f, s = %s
'>,> >var2.i, var2.c, var2.f, var2.s);> >printf>(>'Struct 3
i = %d, c = %c, f = %f
'>, var3.ii,> >var3.cc, var3.ff);> > >return> 0;> }> |
>
>Sortir
Struct 1: i = 1, c = A, f = 1.000000, s = techcodeview.com Struct 2: i = 1, c = A, f = 1.000000, s = techcodeview.com Struct 3 i = 5, c = a, f = 5.000000>
typedef pour les structures
Le typedef Le mot-clé est utilisé pour définir un alias pour le type de données déjà existant. Dans les structures, nous devons utiliser le mot-clé struct avec le nom de la structure pour définir les variables. Parfois, cela augmente la longueur et la complexité du code. Nous pouvons utiliser le typedef pour définir un nouveau nom plus court pour la structure.
Exemple
C
quelle est la taille de l'écran de mon ordinateur
// C Program to illustrate the use of typedef with> // structures> #include> > // defining structure> struct> str1 {> >int> a;> };> > // defining new name for str1> typedef> struct> str1 str1;> > // another way of using typedef with structures> typedef> struct> str2 {> >int> x;> } str2;> > int> main()> {> >// creating structure variables using new names> >str1 var1 = { 20 };> >str2 var2 = { 314 };> > >printf>(>'var1.a = %d
'>, var1.a);> >printf>(>'var2.x = %d'>, var2.x);> > >return> 0;> }> |
>
>Sortir
var1.a = 20 var2.x = 314>
Structures imbriquées
Le langage C nous permet d'insérer une structure dans une autre en tant que membre. Ce processus est appelé imbrication et ces structures sont appelées structures imbriquées. Il existe deux manières d’imbriquer une structure dans une autre :
1. Imbrication de structures intégrées
Dans cette méthode, la structure imbriquée est également déclarée à l'intérieur de la structure parent.
Exemple
struct parent { int member1; struct member_str member2 { int member_str1; char member_str2; ... } ... }> 2. Nidification de structure séparée
Dans cette méthode, deux structures sont déclarées séparément, puis la structure membre est imbriquée dans la structure parent.
Exemple
struct member_str { int member_str1; char member_str2; ... } struct parent { int member1; struct member_str member2; ... }> Une chose à noter ici est que la déclaration de la structure doit toujours être présente avant sa définition en tant que membre de la structure. Par exemple, le la déclaration ci-dessous est invalide car la struct mem n'est pas définie lorsqu'elle est déclarée à l'intérieur de la structure parent.
struct parent { struct mem a; }; struct mem { int var; };> Accès aux membres imbriqués
Nous pouvons accéder aux membres imbriqués en utilisant le même opérateur point ( . ) deux fois, comme indiqué :
str_parent.str_child .member;>
Exemple d'imbrication de structure
C
essayer la structure des données
// C Program to illustrate structure nesting along with> // forward declaration> #include> > // child structure declaration> struct> child {> >int> x;> >char> c;> };> > // parent structure declaration> struct> parent {> >int> a;> >struct> child b;> };> > // driver code> int> main()> {> >struct> parent var1 = { 25, 195,>'A'> };> > >// accessing and printing nested members> >printf>(>'var1.a = %d
'>, var1.a);> >printf>(>'var1.b.x = %d
'>, var1.b.x);> >printf>(>'var1.b.c = %c'>, var1.b.c);> > >return> 0;> }> |
>
>Sortir
var1.a = 25 var1.b.x = 195 var1.b.c = A>
Pointeur de structure en C
Nous pouvons définir un pointeur qui pointe vers la structure comme n'importe quelle autre variable. De tels pointeurs sont généralement appelés Pointeurs de structure . Nous pouvons accéder aux membres de la structure pointés par le pointeur de structure en utilisant le ( -> ) opérateur de flèche.
Exemple de pointeur de structure
C
// C program to illustrate the structure pointer> #include> > // structure declaration> struct> Point {> >int> x, y;> };> > int> main()> {> >struct> Point str = { 1, 2 };> > >// p2 is a pointer to structure p1> >struct> Point* ptr = &str;> > >// Accessing structure members using structure pointer> >printf>(>'%d %d'>, ptr->x, ptr->y);> > >return> 0;> }> |
>
>Sortir
1 2>
Structures autoréférentielles
Les structures autoréférentielles en C sont les structures qui contiennent des références au même type qu'elles-mêmes, c'est-à-dire qu'elles contiennent un membre du pointeur de type pointant vers le même type de structure.
Exemple de structures autoréférentielles
struct structure_name { data_type member1; data_type member2; struct structure_name* str; }> C
collections java java
// C program to illustrate the self referential structures> #include> > // structure template> typedef> struct> str {> >int> mem1;> >int> mem2;> >struct> str* next;> }str;> > // driver code> int> main()> {> >str var1 = { 1, 2, NULL };> >str var2 = { 10, 20, NULL };> > >// assigning the address of var2 to var1.next> >var1.next = &var2;> > >// pointer to var1> >str *ptr1 = &var1;> > >// accessing var2 members using var1> >printf>(>'var2.mem1: %d
var2.mem2: %d'>, ptr1->suivant->mem1,> >ptr1->suivant->mem2);> > >return> 0;> }> |
>
>Sortir
var2.mem1: 10 var2.mem2: 20>
De tels types de structures sont utilisés dans différentes structures de données, par exemple pour définir les nœuds des listes chaînées, des arbres, etc.
Rembourrage et emballage de la structure C
Techniquement, la taille de la structure en C devrait être la somme des tailles de ses membres. Mais cela n’est peut-être pas vrai dans la plupart des cas. La raison en est le remplissage de la structure.
Rembourrage de la structure est le concept consistant à ajouter plusieurs octets vides dans la structure pour aligner naturellement les données membres dans la mémoire. Cela vise à minimiser les cycles de lecture du processeur pour récupérer différents membres de données dans la structure.
Il existe certaines situations dans lesquelles nous devons étroitement emballer la structure en supprimant les octets vides. Dans de tels cas, nous utilisons Emballage de structure. Le langage C propose deux méthodes de compression de structure :
- Utilisation du pack #pragma(1)
- Utilisation de __attribute((packed))__
Exemple de rembourrage et de garnissage de structure
C
// C program to illustrate structure padding and packing> #include> > // structure with padding> struct> str1 {> >char> c;> >int> i;> };> > struct> str2 {> >char> c;> >int> i;> } __attribute((packed)) __;>// using structure packing> > // driver code> int> main()> {> > >printf>(>'Size of str1: %d
'>,>sizeof>(>struct> str1));> >printf>(>'Size of str2: %d
'>,>sizeof>(>struct> str2));> >return> 0;> }> |
>
>Sortir
Size of str1: 8 Size of str2: 5>
Comme nous pouvons le voir, la taille de la structure varie lorsque le compactage de la structure est effectué.
Pour en savoir plus sur le remplissage et le compactage de la structure, reportez-vous à cet article – Les champs de bits sont utilisés pour spécifier la longueur des membres de la structure en bits. Lorsque nous connaissons la longueur maximale du membre, nous pouvons utiliser des champs de bits pour spécifier la taille et réduire la consommation de mémoire.
Syntaxe des champs de bits
struct structure_name { data_type member_name : width_of_bit-field; };> Exemple de champs de bits
C
123film
// C Program to illustrate bit fields in structures> #include> > // declaring structure for reference> struct> str1 {> >int> a;> >char> c;> };> > // structure with bit fields> struct> str2 {> >int> a : 24;>// size of 'a' is 3 bytes = 24 bits> >char> c;> };> > // driver code> int> main()> {> >printf>(>'Size of Str1: %d
Size of Str2: %d'>,> >sizeof>(>struct> str1),>sizeof>(>struct> str2));> >return> 0;> }> |
>
>Sortir
Size of Str1: 8 Size of Str2: 4>
Comme nous pouvons le voir, la taille de la structure est réduite lors de l'utilisation du champ de bits pour définir la taille maximale du membre « a ».
Utilisations de la structure en C
Les structures C sont utilisées pour les éléments suivants :
- La structure peut être utilisée pour définir les types de données personnalisés pouvant être utilisés pour créer certains types de données complexes tels que les dates, l'heure, les nombres complexes, etc. qui ne sont pas présents dans le langage.
- Il peut également être utilisé dans l’organisation des données où une grande quantité de données peut être stockée dans différents champs.
- Les structures sont utilisées pour créer des structures de données telles que des arbres, des listes chaînées, etc.
- Ils peuvent également être utilisés pour renvoyer plusieurs valeurs à partir d’une fonction.
Limites des structures C
En langage C, les structures fournissent une méthode pour regrouper des données de différents types. Une structure est un outil utile pour gérer un groupe d’éléments de données logiquement liés. Cependant, les structures C présentent également certaines limites.
- Consommation de mémoire plus élevée : cela est dû au rembourrage de la structure. Pas de masquage de données : les structures C ne permettent pas de masquage de données. Les membres de la structure sont accessibles par n'importe quelle fonction, n'importe où dans la portée de la structure. Fonctions à l'intérieur de la structure : les structures C n'autorisent pas les fonctions à l'intérieur de la structure, nous ne pouvons donc pas fournir les fonctions associées. Membres statiques : la structure C ne peut pas avoir de membres statiques à l'intérieur de son corps. Création de construction dans Structure : les structures en C ne peuvent pas avoir de constructeur à l'intérieur de Structures.
Articles Liés
- Structures C vs Structure C++