C la structure

structure Définition

Afin de définir la structure, vous devez utiliser l'instructionstruct.déclaration de struct définit un nouveau type de données qui contient une pluralité de membres, la déclaration format struct est la suivante:

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

lastructure tag est facultative, chaque définition de membre est la définition standard d'une variable, comme int i; ou float f; ou d' autres définitions de variables valides.A la fin de la structure définie, la dernière avant le point-virgule, vous pouvez spécifier une ou plusieurs variables structurelles, ce qui est en option. Voici la structure de déclaration Réservez avant le:

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

Accès à un membre de la structure

Afin d'accéder à des membres de la structure, nous utilisonsl'opérateur d'accès membre (.).opérateur d'accès membre est une structure de période noms et structures de nos membres variables veulent accéder entre. Vous pouvez définir le type d'une structure variable à l' aidedu mot - clé struct.L'exemple suivant illustre l'utilisation de la structure:

#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 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

Structure en tant que paramètre de fonction

Vous pouvez mettre la structure en tant que paramètre de la fonction, la manière Sénat semblable à d'autres types de variables ou des pointeurs. Vous pouvez utiliser l'exemple ci-dessus le moyen d'accéder à des variables 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 信息 */
   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 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 sur la structure, la façon dont la définition des liens vers d'autres types de variable pointeur similaires, comme suit:

struct Books *struct_pointer;

Maintenant, vous pouvez répondre à des variables de structure de stockage dans la définition ci-dessus d'une variable de pointeur. Pour trouver l'adresse de la variable de la structure, l'opérateur & devant le nom de la structure, comme suit:

struct_pointer = &Book1;

Pour utiliser le pointeur pour accéder aux points de structure de membre à la structure, vous devez utiliser l'opérateur ->, comme suit:

struct_pointer->title;

Nous allons utiliser le pointeur de la structure pour réécrire l'exemple ci-dessus, il vous aidera à comprendre le concept de la structure des pointeurs:

#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 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

Champ de bits

Certaines informations sont stockées et n'a pas besoin de prendre un octet complet, tout en tenant compte que pour un seul ou quelques bits. Par exemple, lors du stockage d'un commutateur, seuls deux états 0 et 1, avec un bit binaire. Pour économiser de l'espace de stockage, et le processus est simple, le langage C et fournit une structure de données appelée "champ de bits" ou "segment de bits."

Le soi-disant "champ de bit" est un octet dans le binaire divisé en plusieurs domaines, et d'indiquer le nombre de bits dans chaque région. Chaque domaine a un nom de domaine, ce qui permet au programme de fonctionner en fonction du nom de domaine. Nous pouvons donc mettre plusieurs objets différents avec un champ octet binaire pour représenter.

Des exemples typiques:

• Lorsque le stockage d'un commutateur avec un binaire, seuls deux états 0 et 1.
• Lire les formats de fichiers externes - peut être lu formats de fichiers non standard. Par exemple: nombre entier de 9 bits.

Description Définit les variables de champ de bits et un champ de bits

définitions de champ de bits et des définitions de structure similaire à la forme:

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

Qui forment la liste de champ de bits est:

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

Par exemple:

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

De la même manière que décrit les variables BITFIELD et les variables de structure décrite. Peut être utilisé après la première définition décrit et définit des instructions soit illustrent directement de trois façons. Par exemple:

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

Description pour les données variables bs, un total de deux octets. Ce qui représentait champ de 8 bits d'un champ de bits b représentait deux, représentant le champ 6 bits c.

Regardons un 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 comprend six membres: quatre 1-bit identifiant f1..f4, un type 4-bit et un my_int 9 bits.

Pour la définition du champ de bits , il y a les instructions suivantes:

• Un champ de bits doit être stocké dans un seul octet, pas étendre sur deux octets. Tels que quand un octet est pas assez d'espace laissé pour enregistrer un autre domaine, devrait être l'unité de stockage à côté du champ de bits. Il peut également Commenté intentionnellement domaine 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, un quatre bits du premier octet après quatre ont déclaré ne pas utiliser pour remplir 0, b du deuxième octet, occupant 4, c occupe quatre.

• Étant donné que le champ de bits ne sont pas autorisés à traverser les deux octets, de sorte que la longueur du champ de bits ne peut pas être supérieure à une longueur d'octet, soit pas plus de 8 binaires. Si la longueur maximale est supérieure à la totalité de la longueur du mot de l'ordinateur, certains compilateurs peuvent permettre région de chevauchement de mémoire, et certains compilateurs peuvent mettre plus d'une partie du domaine de stockage du mot suivant.

• Les champs de bits peuvent être champ de bits sans nom, alors il est seulement utilisé comme remplissage ou de la position de réglage. champ de bits anonyme ne peut pas être utilisé. Par exemple:

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

Comme on peut le voir d'après l'analyse ci-dessus, le champ de bits est essentiellement un type de structure, mais ses membres sont par la distribution binaire.

Utilisez les champs de bits

Les membres qui utilisent la même structure et champ de bits, sa forme générale:

    位域变量名·位域名

Champ de bits permet une variété de formats.

Prenons les exemples suivants:

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);	/* 用指针方式输出了这三个域的值 */
}

Le programme d'exemple définit le champ de bits la structure bs, champ de trois bits est a, b, c. Description du type de bs binaires variables et bs pointant le type pointeur de BAII variable. Cela représente un champ de bits peut également être pointeurs utilisés.