C Structure

Les tableaux en C permettent de définir des variables qui peuvent stocker des éléments de données du même type,Structureet sont un autre type de données défini par l'utilisateur disponible en programmation C, qui vous permet de stocker des éléments de données de types différents.

Les membres de données d'une structure peuvent être des types de données de base (tels que int, float, char, etc.), ou d'autres types de structure, des types pointeur, etc.

Les structures sont utilisées pour représenter un enregistrement. Supposons que vous souhaitiez suivre les mouvements des livres dans une bibliothèque ; vous devrez peut-être suivre les attributs suivants pour chaque livre :

Title
Auteur
Sujet
ID du livre

Définir une structure

La définition de structure se compose du mot-cléstructet du nom de structure. Le nom de structure peut être défini selon les besoins.

L'instruction struct définit un nouveau type de données contenant plusieurs membres. Le format de l'instruction struct est le suivant :

struct tag {
liste-de membres
liste-de membres
liste-de membres
...
} liste-de variables ;

tagEst une étiquette de structure.

member-listest une définition de variable standard, telle queint i;oufloat f;, ou d'autres définitions de variables valides.

variable-listVariables de structure, définies à la fin de la structure, avant le point-virgule final, vous pouvez spécifier une ou plusieurs variables de structure. Voici comment déclarer une structure Book :

struct Books
{
char title[50];
char author[50];
char subject[100];
int book_id;
} book;

En général,étiquette、liste-de-membres、liste-de-variablesAu moins 2 de ces 3 parties doivent apparaître. Voici un exemple :

// Cette déclaration déclare une structure avec 3 membres, à savoir l'entier a, le caractère b et le double c
// Elle déclare également la variable de structure s1
// Cette structure ne spécifie pas son étiquette
struct
{
int a;
char b;
double c;
} s1;

// Cette déclaration déclare une structure avec 3 membres, à savoir l'entier a, le caractère b et le double c
// L'étiquette de la structure est nommée SIMPLE, et aucune variable n'est déclarée
struct SIMPLE
{
int a;
char b;
double c;
};
// En utilisant la structure avec l'étiquette SIMPLE, des variables supplémentaires t1, t2, t3 sont déclarées
struct SIMPLE t1, t2[20], *t3;

// Vous pouvez également utiliser typedef pour créer un nouveau type
typedef struct
{
int a;
char b;
double c;
} Simple2;
// Maintenant, Simple2 peut être utilisé comme type pour déclarer de nouvelles variables de structure
Simple2 u1, u2[20], *u3;

Dans les déclarations ci-dessus, la première et la deuxième déclaration sont traitées par le compilateur comme deux types complètement différents, même si leurs listes de membres sont identiques. Si vous affectez t3=&s1, c'est illégal.

Les membres d'une structure peuvent contenir d'autres structures, et peuvent aussi contenir des pointeurs vers leur propre type de structure. Habituellement, ces pointeurs sont utilisés pour implémenter des structures de données plus avancées telles que les listes chaînées et les arbres.

// Cette déclaration de structure inclut d'autres structures
struct COMPLEX
{
char string[100];
struct SIMPLE a;
};

// Cette déclaration de structure contient un pointeur vers son propre type
struct NODE
{
char string[100];
struct NODE *next_node;
};

Si deux structures se contiennent mutuellement, l'une des structures nécessite une déclaration incomplète, comme indiqué ci-dessous :

struct B; // Faire une déclaration incomplète de la structure B

// struct A contient un pointeur vers struct B
struct A
{
struct B *partner;
//autres membres;
};

// struct B contient un pointeur vers struct A; après la déclaration de A, B est également déclaré.
struct B
{
struct A *partner;
//autres membres;
};

Initialisation des variables de structure

Comme les variables d'autres types, les variables de structure peuvent recevoir des valeurs initiales au moment de la définition.

Exemple

#include <stdio.h>

struct Books
{
char title[50];
char author[50];
char subject[100];
int book_id;
} book = {"C language", "EXAMPLE", "programming language", 123456};

int main()
{
printf("title : %s\nauthor: %s\nsubject: %s\nbook_id: %d\n", book.title, book.author, book.subject, book.book_id);
}

La sortie après exécution est :

title : C 语言
author: EXAMPLE
subject: 编程语言
book_id: 123456

Accès aux membres de la structure

Pour accéder aux membres d'une structure, nous utilisonsOpérateur d'accès aux membres (.)L'opérateur d'accès aux membres est un point entre le nom de la variable de structure et le membre de structure auquel nous voulons accéder. Vous pouvez utiliserstructle mot-clé pour définir des variables de type structure. L'exemple suivant illustre l'utilisation des structures :

Exemple

#include <stdio.h>
#include <string.h>

struct Books
{
char title[50];
char author[50];
char subject[100];
int book_id;
};

int main( )
{
struct Books Book1; /* Déclarer Book1 de type Books */
struct Books Book2; /* Déclarer Book2 de type Books */

/* Détails de Book1 */
strcpy( Book1.title, "C Programming");
strcpy( Book1.author, "Nuha Ali");
strcpy( Book1.subject, "C Programming Tutorial");
Book1.book_id = 6495407;

/* Détails de Book2 */
strcpy( Book2.title, "Telecom Billing");
strcpy( Book2.author, "Zara Ali");
strcpy( Book2.subject, "Telecom Billing Tutorial");
Book2.book_id = 6495700;

/* Afficher les informations de Book1 */
printf( "Titre du livre 1 : %s\n", Book1.title);
printf( "Auteur du livre 1 : %s\n", Book1.author);
printf( "Sujet du livre 1 : %s\n", Book1.subject);
printf( "book_id du livre 1 : %d\n", Book1.book_id);

/* Afficher les informations de Book2 */
printf( "Titre du livre 2 : %s\n", Book2.title);
printf( "Auteur du livre 2 : %s\n", Book2.author);
printf( "Sujet du livre 2 : %s\n", Book2.subject);
printf( "book_id du livre 2 : %d\n", Book2.book_id);

return 0;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

Book 1 title : C Programming
Book 1 author : Nuha Ali
Book 1 subject : C Programming Tutorial
Book 1 book_id : 6495407
Book 2 title : Telecom Billing
Book 2 author : Zara Ali
Book 2 subject : Telecom Billing Tutorial
Book 2 book_id : 6495700

Structures comme paramètres de fonction

Vous pouvez passer des structures comme paramètres de fonction, et la méthode de passage est similaire à celle des variables ou des pointeurs d'autres types. Vous pouvez utiliser la méthode de l'exemple ci-dessus pour accéder aux variables de structure :

Exemple

#include <stdio.h>
#include <string.h>

struct Books
{
char title[50];
char author[50];
char subject[100];
int book_id;
};

/* Déclaration de fonction */
void printBook( struct Books book );
int main( )
{
struct Books Book1; /* Déclarer Book1 de type Books */
struct Books Book2; /* Déclarer Book2 de type Books */

/* Détails de Book1 */
strcpy( Book1.title, "C Programming");
strcpy( Book1.author, "Nuha Ali");
strcpy( Book1.subject, "C Programming Tutorial");
Book1.book_id = 6495407;

/* Détails de Book2 */
strcpy( Book2.title, "Telecom Billing");
strcpy( Book2.author, "Zara Ali");
strcpy( Book2.subject, "Telecom Billing Tutorial");
Book2.book_id = 6495700;

/* Afficher les informations de Book1 */
printBook( Book1 );

/* Afficher les informations de Book2 */
printBook( Book2 );

return 0;
}
void printBook( struct Books book )
{
printf( "Titre du livre : %s\n", book.title);
printf( "Auteur du livre : %s\n", book.author);
printf( "Sujet du livre : %s\n", book.subject);
printf( "Livre book_id : %d\n", book.book_id);
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

Book title : C Programming
Book author : Nuha Ali
Book subject : C Programming Tutorial
Book book_id : 6495407
Book title : Telecom Billing
Book author : Zara Ali
Book subject : Telecom Billing Tutorial
Book book_id : 6495700

Pointeur vers une structure

Vous pouvez définir un pointeur vers une structure de manière similaire à la définition de pointeurs vers des variables d'autres types, comme indiqué ci-dessous :

struct Books *struct_pointer;

Maintenant, vous pouvez stocker l'adresse d'une variable de structure dans la variable pointeur définie ci-dessus. Pour trouver l'adresse d'une variable de structure, placez l'opérateur & avant le nom de la structure, comme indiqué ci-dessous :

struct_pointer = &Book1;

Pour accéder aux membres de la structure à l'aide d'un pointeur vers la structure, vous devez utiliser l'opérateur ->, comme indiqué ci-dessous :

struct_pointer->title;

Réécrivons l'exemple ci-dessus en utilisant des pointeurs de structure, ce qui vous aidera à comprendre le concept de pointeurs de structure :

Exemple

#include <stdio.h>
#include <string.h>

struct Books
{
char title[50];
char author[50];
char subject[100];
int book_id;
};

/* Déclaration de fonction */
void printBook( struct Books *book );
int main( )
{
struct Books Book1; /* Déclarer Book1 de type Books */
struct Books Book2; /* Déclarer Book2 de type Books */

/* Détails de Book1 */
strcpy( Book1.title, "C Programming");
strcpy( Book1.author, "Nuha Ali");
strcpy( Book1.subject, "C Programming Tutorial");
Book1.book_id = 6495407;

/* Détails de Book2 */
strcpy( Book2.title, "Telecom Billing");
strcpy( Book2.author, "Zara Ali");
strcpy( Book2.subject, "Telecom Billing Tutorial");
Book2.book_id = 6495700;

/* Afficher les informations de Book1 en passant l'adresse de Book1 */
printBook( &Book1 );

/* Afficher les informations de Book2 en passant l'adresse de Book2 */
printBook( &Book2 );

return 0;
}
void printBook( struct Books *book )
{
printf( "Titre du livre : %s\n", book->title);
printf( "Auteur du livre : %s\n", book->author);
printf( "Sujet du livre : %s\n", book->subject);
printf( "Livre book_id : %d\n", book->book_id);
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

Book title : C Programming
Book author : Nuha Ali
Book subject : C Programming Tutorial
Book book_id : 6495407
Book title : Telecom Billing
Book author : Zara Ali
Book subject : Telecom Billing Tutorial
Book book_id : 6495700

Calcul de la taille de la structure

En langage C, nous pouvons utilisersizeofl'opérateur pour calculer la taille d'une structure,sizeofIl renvoie la taille en octets du type ou de la variable donnée.

Pour les structures,sizeofIl renverra le nombre total d'octets de la structure, y compris les tailles de toutes les variables membres et les éventuels octets de remplissage.

L'exemple suivant montre comment calculer la taille d'une structure :

Exemple

#include <stdio.h>

struct Person {
char name[20];
int age;
float height;
};

int main() {
struct Person person;
printf("Taille de struct Person : %zu octets\n", sizeof(person));
return 0;
}

Dans l'exemple ci-dessus, nous avons défini une structure nomméePersonUne structure qui contient un tableau de caractèresname, un entierageet un nombre à virgule flottanteheight。

DansmainDans la fonction, nous avons déclaré unePersonvariable de typeperson, puis utilisezsizeofl'opérateur pour obtenirpersonla taille de la structure.

Enfin, nous utilisonsprintfLa fonction affiche la taille de la structure, et la sortie est la suivante :

结构体 Person 大小为: 28 字节

Remarque, la taille d'une structure peut être affectée par les règles d'optimisation et d'alignement du compilateur. Le compilateur peut insérer des octets de remplissage supplémentaires dans la structure pour aligner les variables membres de la structure, améliorant ainsi l'efficacité d'accès à la mémoire. Par conséquent, la taille réelle de la structure peut être supérieure à la somme des tailles des variables membres. Si vous avez besoin de connaître exactement la disposition et l'alignement de la mémoire de la structure, vous pouvez utiliseroffsetofmacro et__attribute__((packed))attributs, etc. pour contrôler et interroger davantage la taille et l'alignement de la structure.

autres extensions

C Bibliothèque standard

C Structure

Définir une structure

Initialisation des variables de structure

Exemple

Accès aux membres de la structure

Exemple

Structures comme paramètres de fonction

Exemple

Pointeur vers une structure

Exemple

Calcul de la taille de la structure

Exemple