C 数组允许定义可存储相同类型数据项的变量，结构是 C 编程中另一种用户自定义的可用的数据类型，它允许您存储不同类型的数据项。 结构用于表示一条记录，假设您想要跟踪图书馆中书本的动态，您可能需要跟踪每本书的下列属性：

  • Title
  • Author
  • Subject
  • Book ID

定义结构

为了定义结构，您必须使用struct语句。struct 语句定义了一个包含多个成员的新的数据类型，struct 语句的格式如下：

  1. struct tag { 
  2.     member-list
  3.     member-list 
  4.     member-list  
  5.     ...
  6. } variable-list ;

tag 是结构体标签。
member-list是标准的变量定义，比如 int i; 或者 float f，或者其他有效的变量定义。
variable-list 结构变量，定义在结构的末尾，最后一个分号之前，您可以指定一个或多个结构变量。下面是声明 Book 结构的方式：

  1. struct Books
  2. {
  3.    char  title[50];
  4.    char  author[50];
  5.    char  subject[100];
  6.    int   book_id;
  7. } book;

在一般情况下，tag、member-list、variable-list这 3 部分至少要出现 2 个。以下为实例：

  1. //此声明声明了拥有3个成员的结构体，分别为整型的a，字符型的b和双精度的c
  2. //同时又声明了结构体变量 s1,s2,s3
  3. //这个结构体并没有标明其标签
  4. struct
  5. {
  6.   int a;
  7.   char b;
  8.   double c;
  9. } s1,s2,s3;
  14. //此声明声明了拥有3个成员的结构体，分别为整型的a，字符型的b和双精度的c
  15. //结构体的标签被命名为SIMPLE,没有声明变量
  16. struct SIMPLE
  17. {
  18.   int a;
  19.   char b;
  20.   double c;
  21. };
  22. //用SIMPLE标签的结构体，另外声明了变量t1、t2、t3
  23. struct SIMPLE t1, t2[20], *t3;
  28. //也可以用typedef创建新类型
  29. typedef struct
  30. {
  31.   int a;
  32.   char b;
  33.   double c;
  34. } Simple2;
  35. //现在可以用Simple2作为类型声明新的结构体变量
  36. Simple2 u1, u2[20], *u3;

在上面的声明中，第一个和第二声明被编译器当作两个完全不同的类型，即使他们的成员列表是一样的，如果令 t3=&s1，则是非法的。
结构体的成员可以包含其他结构体，也可以包含指向自己结构体类型的指针，而通常这种指针的应用是为了实现一些更高级的数据结构如链表和树等。

  1. //此结构体的声明包含了其他的结构体
  2. struct COMPLEX
  3. {
  4.     char string[100];
  5.     struct SIMPLE a;
  6. };
  11. //此结构体的声明包含了指向自己类型的指针
  12. struct NODE
  13. {
  14.     char string[100];
  15.     struct NODE *next_node;
  16. };

如果两个结构体互相包含，则需要对其中一个结构体先进行不完整声明，如下所示：

  1. struct B; //对结构体B进行不完整声明
  3. //结构体A中包含指向结构体B的指针
  4. struct A
  5. {
  6.   struct B *partner;
  7.   //other members;
  8. };
  10. //结构体B中包含指向结构体A的指针，在A声明完后，B也随之进行声明
  11. struct B
  12. {
  13.   struct A *partner;
  14.   //other members;
  15. };

结构体变量的初始化

和其它类型变量一样，对结构体变量可以在定义时指定初始值。

  1. #include <stdio.h>
  3. struct Books
  4. {
  5.   char title[50];
  6.   char author[50];
  7.   char subject[100];
  8.   int book_id;
  9. } book = {"C 语言", "Ken", "编程语言", 123456};
  11. int main()
  12. {
  13.   printf("title : %s\nauthor: %s\nsubject: %s\nbook_id: %d\n", book.title, book.author, book.subject, book.book_id);
  14. }
  16. /*
  17. title : C 语言
  18. author: Ken
  19. subject: 编程语言
  20. book_id: 123456
  21. */

访问结构成员

为了访问结构的成员，我们使用成员访问运算符（.）。成员访问运算符是结构变量名称和我们要访问的结构成员之间的一个句号。您可以使用struct关键字来定义结构类型的变量。下面的实例演示了结构的用法：

  1. #include <stdio.h>
  2. #include <string.h>
  4. struct Books
  5. {
  6.    char  title[50];
  7.    char  author[50];
  8.    char  subject[100];
  9.    int   book_id;
  10. };
  12. int main( )
  13. {
  14.    struct Books Book1;        // 声明 Book1，类型为 Books
  15.    struct Books Book2;        // 声明 Book2，类型为 Books
  17.    // Book1 详述
  18.    strcpy( Book1.title, "C Programming");
  19.    strcpy( Book1.author, "Nuha Ali"); 
  20.    strcpy( Book1.subject, "C Programming Tutorial");
  21.    Book1.book_id = 6495407;
  23.    // Book2 详述
  24.    strcpy( Book2.title, "Telecom Billing");
  25.    strcpy( Book2.author, "Zara Ali");
  26.    strcpy( Book2.subject, "Telecom Billing Tutorial");
  27.    Book2.book_id = 6495700;
  29.    // 输出 Book1 信息
  30.    printf( "Book 1 title : %s\n", Book1.title);
  31.    printf( "Book 1 author : %s\n", Book1.author);
  32.    printf( "Book 1 subject : %s\n", Book1.subject);
  33.    printf( "Book 1 book_id : %d\n", Book1.book_id);
  35.    // 输出 Book2 信息
  36.    printf( "Book 2 title : %s\n", Book2.title);
  37.    printf( "Book 2 author : %s\n", Book2.author);
  38.    printf( "Book 2 subject : %s\n", Book2.subject);
  39.    printf( "Book 2 book_id : %d\n", Book2.book_id);
  41.    return 0;
  42. }
  45. /*
  46. Book 1 title : C Programming
  47. Book 1 author : Nuha Ali
  48. Book 1 subject : C Programming Tutorial
  49. Book 1 book_id : 6495407
  51. Book 2 title : Telecom Billing
  52. Book 2 author : Zara Ali
  53. Book 2 subject : Telecom Billing Tutorial
  54. Book 2 book_id : 6495700
  55. */

结构作为函数参数

您可以把结构作为函数参数，传参方式与其他类型的变量或指针类似。您可以使用上面实例中的方式来访问结构变量：

  1. #include <stdio.h>
  2. #include <string.h>
  4. struct Books
  5. {
  6.    char  title[50];
  7.    char  author[50];
  8.    char  subject[100];
  9.    int   book_id;
  10. };
  12. // 函数声明
  13. void printBook( struct Books book );
  14. int main( )
  15. {
  16.    struct Books Book1;        // 声明 Book1，类型为 Books
  17.    struct Books Book2;        // 声明 Book2，类型为 Books
  19.    // Book1 详述
  20.    strcpy( Book1.title, "C Programming");
  21.    strcpy( Book1.author, "Nuha Ali"); 
  22.    strcpy( Book1.subject, "C Programming Tutorial");
  23.    Book1.book_id = 6495407;
  25.    // Book2 详述
  26.    strcpy( Book2.title, "Telecom Billing");
  27.    strcpy( Book2.author, "Zara Ali");
  28.    strcpy( Book2.subject, "Telecom Billing Tutorial");
  29.    Book2.book_id = 6495700;
  32.    printBook( Book1 );  // 输出 Book1 信息
  33.    printBook( Book2 ); // 输出 Book2 信息
  35.    return 0;
  36. }
  38. void printBook( struct Books book )
  39. {
  40.    printf( "Book title : %s\n", book.title);
  41.    printf( "Book author : %s\n", book.author);
  42.    printf( "Book subject : %s\n", book.subject);
  43.    printf( "Book book_id : %d\n", book.book_id);
  44. }
  46. /*
  47. Book title : C Programming
  48. Book author : Nuha Ali
  49. Book subject : C Programming Tutorial
  50. Book book_id : 6495407
  52. Book title : Telecom Billing
  53. Book author : Zara Ali
  54. Book subject : Telecom Billing Tutorial
  55. Book book_id : 6495700
  56. */

指向结构的指针

您可以定义指向结构的指针，方式与定义指向其他类型变量的指针相似，如下所示：

  1. struct Books *struct_pointer;

现在，您可以在上述定义的指针变量中存储结构变量的地址。为了查找结构变量的地址，请把 & 运算符放在结构名称的前面，如下所示：

  1. struct_pointer = &Book1;

为了使用指向该结构的指针访问结构的成员，您必须使用 -> 运算符，如下所示：

  1. struct_pointer->title;

让我们使用结构指针来重写上面的实例，这将有助于您理解结构指针的概念：

  1. #include <stdio.h>
  2. #include <string.h>
  4. struct Books
  5. {
  6.    char  title[50];
  7.    char  author[50];
  8.    char  subject[100];
  9.    int   book_id;
  10. };
  12. // 函数声明 
  13. void printBook( struct Books *book );
  14. int main( )
  15. {
  16.    struct Books Book1;        // 声明 Book1，类型为 Books 
  17.    struct Books Book2;        // 声明 Book2，类型为 Books 
  19.    // Book1 详述 
  20.    strcpy( Book1.title, "C Programming");
  21.    strcpy( Book1.author, "Nuha Ali"); 
  22.    strcpy( Book1.subject, "C Programming Tutorial");
  23.    Book1.book_id = 6495407;
  25.    // Book2 详述 
  26.    strcpy( Book2.title, "Telecom Billing");
  27.    strcpy( Book2.author, "Zara Ali");
  28.    strcpy( Book2.subject, "Telecom Billing Tutorial");
  29.    Book2.book_id = 6495700;
  31.    printBook( &Book1 ); // 通过传 Book1 的地址来输出 Book1 信息 
  32.    printBook( &Book2 ); // 通过传 Book2 的地址来输出 Book2 信息 
  34.    return 0;
  35. }
  36. void printBook( struct Books *book )
  37. {
  38.    printf( "Book title : %s\n", book->title);
  39.    printf( "Book author : %s\n", book->author);
  40.    printf( "Book subject : %s\n", book->subject);
  41.    printf( "Book book_id : %d\n", book->book_id);
  42. }
  45. /*
  46. Book title : C Programming
  47. Book author : Nuha Ali
  48. Book subject : C Programming Tutorial
  49. Book book_id : 6495407
  50. Book title : Telecom Billing
  51. Book author : Zara Ali
  52. Book subject : Telecom Billing Tutorial
  53. Book book_id : 6495700
  54. */

结构体列表

  1. #include <stdio.h>
  3. struct Books
  4. {
  5.   char title[50];
  6.   char author[50];
  7.   char subject[100];
  8.   int book_id;
  9. } book = {"C 语言", "一缕清风", "编程语言", 123456};
  12. struct Books book2[2] =
  13.     {
  14.         {"C", "Ken", "编程语言", 666666},
  15.         {"C", "Ken", "编程语言", 888888},
  16. };
  19. int main()
  20. {
  21.   printf("title : %s\nauthor: %s\nsubject: %s\nbook_id: %d\n", book.title, book.author, book.subject, book.book_id);
  22.   printf("\n");
  23.   printf("title : %s\nauthor: %s\nsubject: %s\nbook_id: %d\n", book2[0].title, book2[0].author, book2[0].subject, book2[0].book_id);
  24. }
  26. /*
  27. title : C 语言
  28. author: 一缕清风
  29. subject: 编程语言
  30. book_id: 123456
  32. title : C
  33. author: Ken
  34. subject: 编程语言
  35. book_id: 666666
  36. */