Structure en C


Le tableau C vous permet de définir des variables pouvant stocker des éléments de données du même type. Structure est un autre type de données défini par l'utilisateur disponible dans la programmation C, qui vous permet de stocker. différents types d'éléments de données. La structure

est utilisée pour représenter un enregistrement. Supposons que vous souhaitiez suivre la dynamique des livres dans la bibliothèque. Vous devrez peut-être suivre les attributs suivants de chaque livre :

  • <. 🎜>Titre

  • Auteur

  • Sujet

  • ID du livre

Définir une structure

Afin de définir une structure, vous devez utiliser l'instruction struct. L'instruction struct définit un nouveau type de données contenant plusieurs membres. Le format de l'instruction struct est le suivant : 

struct [structure tag]{
   member definition;
   member definition;   ...
   member definition;} [one or more structure variables];

balise de structure est facultatif et chaque définition de membre est une définition de variable standard. , comme int i; ou float f; ou d'autres définitions de variables valides. A la fin de la définition de la structure, avant le dernier point-virgule, vous pouvez éventuellement 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;

Accès aux membres de la structure

Pour accéder aux membres d'une structure, nous utilisons l'opé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 utiliser le mot-clé struct pour définir des variables de type structure. L'exemple suivant démontre l'utilisation de structures : 

#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;        /* 声明 Book1，类型为 Book */   struct Books Book2;        /* 声明 Book2，类型为 Book */ 
   /* Book1 详述 */
   strcpy( Book1.title, "C Programming");
   strcpy( Book1.author, "Nuha Ali"); 
   strcpy( Book1.subject, "C Programming Tutorial");   Book1.book_id = 6495407;   /* Book2 详述 */
   strcpy( Book2.title, "Telecom Billing");
   strcpy( Book2.author, "Zara Ali");
   strcpy( Book2.subject, "Telecom Billing Tutorial");   Book2.book_id = 6495700; 
   /* 输出 Book1 信息 */
   printf( "Book 1 title : %s\n", Book1.title);
   printf( "Book 1 author : %s\n", Book1.author);
   printf( "Book 1 subject : %s\n", Book1.subject);
   printf( "Book 1 book_id : %d\n", Book1.book_id);   /* 输出 Book2 信息 */
   printf( "Book 2 title : %s\n", Book2.title);
   printf( "Book 2 author : %s\n", Book2.author);
   printf( "Book 2 subject : %s\n", Book2.subject);
   printf( "Book 2 book_id : %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 ProgrammingBook 1 author : Nuha AliBook 1 subject : C Programming TutorialBook 1 book_id : 6495407Book 2 title : Telecom BillingBook 2 author : Zara AliBook 2 subject : Telecom Billing TutorialBook 2 book_id : 6495700

Structure en tant que paramètre de fonction

Vous Structures peuvent être utilisés comme paramètres de fonction, et la méthode de transmission des paramètres est similaire à d'autres types de variables ou de pointeurs. Vous pouvez accéder aux variables de structure en utilisant la même méthode que dans l'exemple ci-dessus : 

#include <stdio.h>#include <string.h> struct Books{   char  title[50];   char  author[50];   char  subject[100];   int   book_id;};/* 函数声明 */void printBook( struct Books book );int main( ){   struct Books Book1;        /* 声明 Book1，类型为 Book */   struct Books Book2;        /* 声明 Book2，类型为 Book */ 
   /* Book1 详述 */
   strcpy( Book1.title, "C Programming");
   strcpy( Book1.author, "Nuha Ali"); 
   strcpy( Book1.subject, "C Programming Tutorial");   Book1.book_id = 6495407;   /* Book2 详述 */
   strcpy( Book2.title, "Telecom Billing");
   strcpy( Book2.author, "Zara Ali");
   strcpy( Book2.subject, "Telecom Billing Tutorial");   Book2.book_id = 6495700; 
   /* 输出 Book1 信息 */
   printBook( Book1 );   /* 输出 Book2 信息 */
   printBook( Book2 );   return 0;}void printBook( struct Books book ){
   printf( "Book title : %s\n", book.title);
   printf( "Book author : %s\n", book.author);
   printf( "Book subject : %s\n", book.subject);
   printf( "Book 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 ProgrammingBook author : Nuha AliBook subject : C Programming TutorialBook book_id : 6495407Book title : Telecom BillingBook author : Zara AliBook subject : Telecom Billing TutorialBook book_id : 6495700

Pointeur vers la structure

Vous pouvez définir un pointeur vers une structure de la même manière que vous définissez un pointeur vers d'autres types de variables, comme indiqué ci-dessous : 

struct Books *struct_pointer;

Vous pouvez maintenant stocker l'adresse de la variable de structure dans le pointeur variable définie ci-dessus. Pour trouver l'adresse d'une variable de structure, placez l'opérateur & devant le nom de la structure, comme ceci : 

struct_pointer = &Book1;

Afin d'accéder à un membre d'une structure à l'aide d'un pointeur vers la structure, vous devez utiliser le ->, comme indiqué ci-dessous : 

struct_pointer->title;

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

#include <stdio.h>#include <string.h> struct Books{   char  title[50];   char  author[50];   char  subject[100];   int   book_id;};/* 函数声明 */void printBook( struct Books *book );int main( ){   struct Books Book1;        /* 声明 Book1，类型为 Book */   struct Books Book2;        /* 声明 Book2，类型为 Book */ 
   /* Book1 详述 */
   strcpy( Book1.title, "C Programming");
   strcpy( Book1.author, "Nuha Ali"); 
   strcpy( Book1.subject, "C Programming Tutorial");   Book1.book_id = 6495407;   /* Book2 详述 */
   strcpy( Book2.title, "Telecom Billing");
   strcpy( Book2.author, "Zara Ali");
   strcpy( Book2.subject, "Telecom Billing Tutorial");   Book2.book_id = 6495700; 
   /* 通过传 Book1 的地址来输出 Book1 信息 */
   printBook( &Book1 );   /* 通过传 Book2 的地址来输出 Book2 信息 */
   printBook( &Book2 );   return 0;}void printBook( struct Books *book ){
   printf( "Book title : %s\n", book->title);
   printf( "Book author : %s\n", book->author);
   printf( "Book subject : %s\n", book->subject);
   printf( "Book book_id : %d\n", book->book_id);}

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

Book title : C ProgrammingBook author : Nuha AliBook subject : C Programming TutorialBook book_id : 6495407Book title : Telecom BillingBook author : Zara AliBook subject : Telecom Billing TutorialBook book_id : 6495700

champ de bits

Lorsque certaines informations sont stockées, elles n'ont pas besoin d'occuper un octet complet, mais seulement quelques ou un bits binaires . Par exemple, lors du stockage d'une valeur de commutateur, il n'y a que deux états : 0 et 1, donc un binaire de 1 bit peut être utilisé. Afin d'économiser de l'espace de stockage et de faciliter le traitement, le langage C fournit une structure de données appelée « champ de bits » ou « segment de bits ».

Le soi-disant « champ de bits » consiste à diviser les bits binaires d'un octet en plusieurs zones différentes et à spécifier le nombre de bits dans chaque zone. Chaque domaine possède un nom de domaine qui permet des opérations par nom de domaine dans le programme. De cette manière, plusieurs objets différents peuvent être représentés par un champ de bits binaires d'un octet.

Exemple typique :

  • Lorsqu'un binaire de 1 bit est utilisé pour stocker une valeur de commutateur, il n'y a que deux états : 0 et 1.

  • Lire les formats de fichiers externes - peut lire les formats de fichiers non standard. Par exemple : entier à 9 chiffres.

Définition des champs de bits et description des variables du champ de bits

La définition du champ de bits est similaire à la définition de la structure, sa forme est : 

    struct 位域结构名        { 位域列表 };

La forme du champ de bits list Par exemple : 

    类型说明符 位域名: 位域长度

Par exemple : 

struct bs{    int a:8;    int b:2;    int c:6;};

Les variables de champ de bits sont déclarées de la même manière que les variables de structure. Vous pouvez définir d'abord puis expliquer, définir et expliquer en même temps, ou expliquer directement. Par exemple : 

struct bs{    int a:8;    int b:2;    int c:6;}data;

indique que data est une variable bs, occupant deux octets au total. Le champ de bits a occupe 8 bits, le champ de bits b occupe 2 bits et le champ de bits c occupe 6 bits.

Regardons un autre exemple : 

struct packed_struct {  unsigned int f1:1;  unsigned int f2:1;  unsigned int f3:1;  unsigned int f4:1;  unsigned int type:4;  unsigned int my_int:9;} pack;

Ici, packed_struct contient 6 membres : quatre identifiants à 1 chiffre f1..f4, un type à 4 chiffres et 9 bits de my_int.

Il existe plusieurs explications pour la définition des champs de bits :

  • Un champ de bits doit être stocké dans le même octet et ne peut pas s'étendre sur deux octets . Si l'espace restant d'un octet n'est pas suffisant pour stocker un autre champ binaire, le champ binaire doit être stocké à partir de l'unité suivante. Vous pouvez également démarrer intentionnellement un champ de bits à partir de l'unité suivante. Par exemple : 

    struct bs{    unsigned a:4;    unsigned  :4;    /* 空域 */    unsigned b:4;    /* 从下一单元开始存放 */    unsigned c:4}

    Dans cette définition de champ de bits, a occupe 4 bits du premier octet, remplissez les 4 derniers bits avec 0 pour indiquer que vous ne l'utilisez pas, b commence à partir du deuxième octet, occupant 4 bits, c occupe 4 bits.

  • Étant donné que le champ de bits n'est pas autorisé à s'étendre sur deux octets, la longueur du champ de bits ne peut pas être supérieure à la longueur d'un octet, ce qui signifie qu'elle ne peut pas dépasser 8 bits binaires. Certains compilateurs peuvent autoriser le chevauchement de la mémoire des champs si la longueur maximale est supérieure à la longueur entière de l'ordinateur, et d'autres compilateurs peuvent stocker de plus grandes parties d'un champ dans le mot suivant. Le champ de bits

  • peut être un champ de bits sans nom, auquel cas il n'est utilisé que pour le remplissage ou l'ajustement de position. Les champs de bits sans nom ne peuvent pas être utilisés. Par exemple : 

    struct k{    int a:1;    int  :2;    /* 该 2 位不能使用 */    int b:3;    int c:2;};

Comme le montre l'analyse ci-dessus, le champ de bits est essentiellement un type de structure, mais ses membres sont alloués en termes binaires. L'utilisation de

champs de bits

L'utilisation de

champs de bits est la même que l'utilisation des membres de la structure. Sa forme générale est : 

    位域变量名·位域名

Les champs de bits permettent une sortie dans divers. formats.

Veuillez consulter l'exemple suivant : 

main(){    struct bs{        unsigned a:1;        unsigned b:3;        unsigned c:4;    } bit,*pbit;
    bit.a=1;/* 给位域赋值（应注意赋值不能超过该位域的允许范围） */
    bit.b=7;/* 给位域赋值（应注意赋值不能超过该位域的允许范围） */
    bit.c=15;/* 给位域赋值（应注意赋值不能超过该位域的允许范围） */
    printf("%d,%d,%d\n",bit.a,bit.b,bit.c);/* 以整型量格式输出三个域的内容 */
    pbit=&bit;/* 把位域变量 bit 的地址送给指针变量 pbit */
    pbit->a=0;/* 用指针方式给位域 a 重新赋值，赋为 0 */
    pbit->b&=3;/* 使用了复合的位运算符 "&="，相当于：pbit->b=pbit->b&3，位域 b 中原有值为 7，与 3 作按位与运算的结果为 3（111&011=011，十进制值为 3） */
    pbit->c|=1;/* 使用了复合位运算符"|="，相当于：pbit->c=pbit->c|1，其结果为 15 */
    printf("%d,%d,%d\n",pbit->a,pbit->b,pbit->c);/* 用指针方式输出了这三个域的值 */}

L'exemple de programme ci-dessus définit la structure du champ de bits bs, et les trois champs de bits sont a, b et c. Décrit la variable bit de type bs et la variable de pointeur pbit pointant vers le type bs. Cela signifie que les champs de bits peuvent également utiliser des pointeurs.

←
→