C 语言结构体(struct)

C 语言结构体(struct)

在本教程中，您将学习C语言编程中的结构类型。您将借助示例学习定义和使用结构。

在C语言编程中，有时需要存储实体的多个属性。 实体不必仅具有一种类型的所有信息。 它可以具有不同数据类型的不同属性。

C 数组允许定义可存储相同类型数据项的变量，结构是 C 编程中另一种用户自定义的可用的数据类型，它允许您存储不同类型的数据项。

结构用于表示一条记录，假设您想要跟踪图书馆中书本的动态，您可能需要跟踪每本书的下列属性：

• Title
• Author
• Subject
• Book ID

定义结构

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

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

tag 是结构体标签。

member-list 是标准的变量定义，比如 int i; 或者 float f，或者其他有效的变量定义。

variable-list 结构变量，定义在结构的末尾，最后一个分号之前，您可以指定一个或多个结构变量。下面是声明 Book 结构的方式：

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

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

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

在上面的声明中，第一个和第二声明被编译器当作两个完全不同的类型，即使他们的成员列表是一样的，如果令 t3=&s1，则是非法的。

结构体的成员可以包含其他结构体，也可以包含指向自己结构体类型的指针，而通常这种指针的应用是为了实现一些更高级的数据结构如链表和树等。

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

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

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

结构体变量的初始化

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

示例

#include 
 
struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
} book = {"C 语言", "nhooo", "编程语言", 123456};
 
int main()
{
    printf("书名： %s\n作者： %s\n主题： %s\nBookID %d\n", book.title, book.author, book.subject, book.book_id);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

执行输出结果为：

书名： C 语言
作者： nhooo
主题： 编程语言
BookID 123456
1
2
3
4

访问结构成员

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

示例

#include 
#include 
 
struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
};
 
int main( )
{
   struct Books Book1;        /* 声明 Book1，类型为 Books */
   struct Books Book2;        /* 声明 Book2，类型为 Books */
 
   /* Book1 详述 */
   strcpy( Book1.title, "C 编程语言");
   strcpy( Book1.author, "Nuha Ali"); 
   strcpy( Book1.subject, "C 编程语言教程");
   Book1.book_id = 6495407;
 
   /* Book2 详述 */
   strcpy( Book2.title, "JAVA编程语言");
   strcpy( Book2.author, "Seagull Ali");
   strcpy( Book2.subject, "JAVA编程语言教程");
   Book2.book_id = 6495700;
 
   /* 输出 Book1 信息 */
   printf( "Book 1 书名： %s\n", Book1.title);
   printf( "Book 1 作者： %s\n", Book1.author);
   printf( "Book 1 主题： %s\n", Book1.subject);
   printf( "Book 1 编号： %d\n", Book1.book_id);
 
   /* 输出 Book2 信息 */
   printf( "Book 2 书名： %s\n", Book2.title);
   printf( "Book 2 作者： %s\n", Book2.author);
   printf( "Book 2 主题： %s\n", Book2.subject);
   printf( "Book 2 编号： %d\n", Book2.book_id);
 
   return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

当上面的代码被编译和执行时，它会产生下列结果：

Book 1 书名： C 编程语言
Book 1 作者： Nuha Ali
Book 1 主题： C 编程语言教程
Book 1 编号： 6495407
Book 2 书名： JAVA编程语言
Book 2 作者： Seagull Ali
Book 2 主题： JAVA编程语言教程
Book 2 编号： 6495700
1
2
3
4
5
6
7
8

结构作为函数参数

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

示例

#include 
#include 
 
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，类型为 Books */
   struct Books Book2;        /* 声明 Book2，类型为 Books */
 
   /* Book1 详述 */
   strcpy( Book1.title, "C 编程语言");
   strcpy( Book1.author, "Nuha Ali"); 
   strcpy( Book1.subject, "C 编程语言教程");
   Book1.book_id = 6495407;
 
   /* Book2 详述 */
   strcpy( Book2.title, "JAVA编程语言");
   strcpy( Book2.author, "Seagull Ali");
   strcpy( Book2.subject, "JAVA编程语言教程");
   Book2.book_id = 6495700;
 
   /* 输出 Book1 信息 */
   printBook( Book1 );
 
   /* 输出 Book2 信息 */
   printBook( Book2 );
 
   return 0;
}
void printBook( struct Books book )
{
   printf( "Book 书名： %s\n", book.title);
   printf( "Book 作者： %s\n", book.author);
   printf( "Book 主题： %s\n", book.subject);
   printf( "Book 编号： %d\n", book.book_id);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

当上面的代码被编译和执行时，它会产生下列结果：

Book 书名： C 编程语言
Book 作者： Nuha Ali
Book 主题： C 编程语言教程
Book 编号： 6495407
Book 书名： JAVA编程语言
Book 作者： Seagull Ali
Book 主题： JAVA编程语言教程
Book 编号： 6495700
1
2
3
4
5
6
7
8

指向结构的指针

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

struct Books *struct_pointer;
1

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

struct_pointer = &Book1;
1

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

struct_pointer->title;
1

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

示例

#include 
#include 
 
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，类型为 Books */
   struct Books Book2;        /* 声明 Book2，类型为 Books */
 
   /* Book1 详述 */
   strcpy( Book1.title, "C 编程语言");
   strcpy( Book1.author, "Nuha Ali"); 
   strcpy( Book1.subject, "C 编程语言教程");
   Book1.book_id = 6495407;
 
   /* Book2 详述 */
   strcpy( Book2.title, "JAVA编程语言");
   strcpy( Book2.author, "Seagull Ali");
   strcpy( Book2.subject, "JAVA编程语言教程");
   Book2.book_id = 6495700;
 
   /* 通过传 Book1 的地址来输出 Book1 信息 */
   printBook( &Book1 );
 
   /* 通过传 Book2 的地址来输出 Book2 信息 */
   printBook( &Book2 );
 
   return 0;
}
void printBook( struct Books *book )
{
   printf( "Book 书名： %s\n", book->title);
   printf( "Book 作者： %s\n", book->author);
   printf( "Book 主题： %s\n", book->subject);
   printf( "Book 编号： %d\n", book->book_id);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

当上面的代码被编译和执行时，它会产生下列结果：

Book 书名： C 编程语言
Book 作者： Nuha Ali
Book 主题： C 编程语言教程
Book 编号： 6495407
Book 书名： JAVA编程语言
Book 作者： Seagull Ali
Book 主题： JAVA编程语言教程
Book 编号： 6495700
1
2
3
4
5
6
7
8

位域

有些信息在存储时，并不需要占用一个完整的字节，而只需占几个或一个二进制位。例如在存放一个开关量时，只有 0 和 1 两种状态，用 1 位二进位即可。为了节省存储空间，并使处理简便，C 语言又提供了一种数据结构，称为"位域"或"位段"。

所谓"位域"是把一个字节中的二进位划分为几个不同的区域，并说明每个区域的位数。每个域有一个域名，允许在程序中按域名进行操作。这样就可以把几个不同的对象用一个字节的二进制位域来表示。

典型的示例：

• 用 1 位二进位存放一个开关量时，只有 0 和 1 两种状态。
• 读取外部文件格式——可以读取非标准的文件格式。例如：9 位的整数。

位域的定义和位域变量的说明

位域定义与结构定义相仿，其形式为：

struct 位域结构名 
{
 位域列表
};
1
2
3
4

其中位域列表的形式为：

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

例如：

struct bs{
    int a:8;
    int b:2;
    int c:6;
}data;
1
2
3
4
5

说明 data 为 bs 变量，共占两个字节。其中位域 a 占 8 位，位域 b 占 2 位，位域 c 占 6 位。

让我们再来看一个示例：

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;
1
2
3
4
5
6
7
8

在这里，packed_struct 包含了 6 个成员：四个 1 位的标识符 f1…f4、一个 4 位的 type 和一个 9 位的 my_int。

对于位域的定义尚有以下几点说明：

• 一个位域存储在同一个字节中，如一个字节所剩空间不够存放另一位域时，则会从下一单元起存放该位域。也可以有意使某位域从下一单元开始。例如：

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

  在这个位域定义中，a 占第一字节的 4 位，后 4 位填 0 表示不使用，b 从第二字节开始，占用 4 位，c 占用 4 位。

• 由于位域不允许跨两个字节，因此位域的长度不能大于一个字节的长度，也就是说不能超过8位二进位。如果最大长度大于计算机的整数字长，一些编译器可能会允许域的内存重叠，另外一些编译器可能会把大于一个域的部分存储在下一个字中。

• 位域可以是无名位域，这时它只用来作填充或调整位置。无名的位域是不能使用的。例如：

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

从以上分析可以看出，位域在本质上就是一种结构类型，不过其成员是按二进位分配的。

位域的使用

位域的使用和结构成员的使用相同，其一般形式为：

位域变量名.位域名
位域变量名->位域名
1
2

位域允许用各种格式输出。

请看下面的示例：

示例

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);    /* 用指针方式输出了这三个域的值 */
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

上例程序中定义了位域结构 bs，三个位域为 a、b、c。说明了 bs 类型的变量 bit 和指向 bs 类型的指针变量 pbit。这表示位域也是可以使用指针的。

typedef 关键字

我们使用typedef关键字为数据类型创建别名。它通常与结构一起使用，以简化声明变量的语法。

此代码

struct Distance{
    int feet;
    float inch;
};

int main() {
    struct Distance d1, d2;
}
1
2
3
4
5
6
7
8

等同于

typedef struct Distance{
    int feet;
    float inch;
} distances;

int main() {
    distances d1, d2;
}
1
2
3
4
5
6
7
8

嵌套结构

您可以在C语言编程中的结构内创建结构。例如，

struct complex
{
 int imag;
 float real;
};

struct number
{
   struct complex comp;
   int integers;
} num1, num2;
1
2
3
4
5
6
7
8
9
10
11

假设，你要设置num2的变量imag值为11，怎么做呢？看下面示例：

num2.comp.imag = 11;
1

为什么在C中使用结构？

假设您要存储有关一个人的信息：他/她的姓名，身份证号和薪水。您可以创建不同的变量name，citNo和salary存储此信息。

如果您需要存储多个人的信息怎么办？现在，你需要为每个人每个信息创建不同的变量：name1，citNo1，salary1，name2，citNo2，salary2, 等。

更好的方法是在单个名称Person结构下收集所有相关信息，并将其用于每个人。