C语言学习之关键字第十二讲

struct   声明结构体

结构(struct)转自《c语言结构体用法》

     结构是由基本数据类型构成的、并用一个标识符来命名的各种变量的组合。 

结构中可以使用不同的数据类型。 

    1. 结构说明和结构变量定义 

    在Turbo C中, 结构也是一种数据类型, 可以使用结构变量, 因此,  象其它 

类型的变量一样, 在使用结构变量时要先对其定义。 

    定义结构变量的一般格式为: 

     struct 结构名 

     { 

          类型  变量名; 

          类型  变量名; 

          ... 

     } 结构变量; 

    结构名是结构的标识符不是变量名。 

    类型为第二节中所讲述的五种数据类型(整型、浮点型、字符型、指针型和 

无值型)。 

    构成结构的每一个类型变量称为结构成员, 它象数组的元素一样, 但数组中 

元素是以下标来访问的, 而结构是按变量名字来访问成员的。 

    下面举一个例子来说明怎样定义结构变量。 

     struct string 

     { 

          char name[8]; 

          int age; 

          char sex[2]; 

          char depart[20]; 

          float wage1, wage2, wage3, wage4, wage5; 

     } person; 

    这个例子定义了一个结构名为string的结构变量person,   如果省略变量名 

person, 则变成对结构的说明。用已说明的结构名也可定义结构变量。这样定义 

时上例变成: 

     struct string 

     { 

          char name[8]; 

          int age; 

          char sex[2]; 

          char depart[20]; 

          float wage1, wage2, wage3, wage4, wage5; 

     }; 

     struct string person; 

    如果需要定义多个具有相同形式的结构变量时用这种方法比较方便, 它先作 

结构说明, 再用结构名来定义变量。 

    例如: 

     struct string Tianyr, Liuqi, ...; 

    如果省略结构名, 则称之为无名结构, 这种情况常常出现在函数内部, 用这 

种结构时前面的例子变成: 

     struct 

     { 

          char name[8]; 

          int age; 

          char sex[2]; 

          char depart[20]; 

          float wage1, wage2, wage3, wage4, wage5; 

     } Tianyr, Liuqi; 

    2. 结构变量的使用 

    结构是一个新的数据类型, 因此结构变量也可以象其它类型的变量一样赋值、 

运算, 不同的是结构变量以成员作为基本变量。 

    结构成员的表示方式为: 

          结构变量.成员名 

    如果将"结构变量.成员名"看成一个整体,  则这个整体的数据类型与结构中 

该成员的数据类型相同, 这样就可象前面所讲的变量那样使用。 

    下面这个例子定义了一个结构变量, 其中每个成员都从键盘接收数据, 然后 

对结构中的浮点数求和, 并显示运算结果, 同时将数据以文本方式存入一个名为 

wage.dat的磁盘文件中。请注意这个例子中不同结构成员的访问。 

    例3: 

     ＃i nclude <stdio.h> 

     main() 

     { 

          struct{                  /*定义一个结构变量*/ 

               char name[8]; 

               int age; 

               char sex[2]; 

               char depart[20]; 

               float wage1, wage2, wage3, wage4, 

wage5; 

          }a; 

          FILE *fp; 

          float wage; 

          char c=’Y’; 

          fp="fopen"("wage.dat", "w");    

/*创建一个文件只写*/ 

          while(c==’Y’||c==’y’)         

/*判断是否继续循环*/ 

          { 

               printf("/nName:"); 

               scanf("%s", a.name);     /*输入姓名*/ 

               printf("Age:"); 

               scanf("%d", &a.wage);    /*输入年龄*/ 

               printf("Sex:"); 

               scanf("%d", a.sex); 

               printf("Dept:"); 

               scanf("%s", a.depart); 

               printf("Wage1:"); 

               scanf("%f", &a.wage1);   /*输入工资*/ 

               printf("Wage2:"); 

               scanf("%f", &a.wage2); 

               printf("Wage3:"); 

               scanf("%f", &a.wage3); 

               printf("Wage4:"); 

               scanf("%f", &a.wage4); 

               printf("Wage5:"); 

               scanf("%f", &a.wage5); 

               

wage=a.wage1+a.wage2+a.wage3+a.wage4+a.wage5; 

               printf("The sum of wage is 

%6.2f/n", wage);/*显示结果*/ 

               fprintf(fp, 

"%10s%4d%4s%30s%10.2f/n",  /*结果写入文件*/ 

                            a.name, a.age, a.sex, 

a.depart, wage); 

               while(1) 

               { 

                    printf("Continue?<Y/N>"); 

                    c="getche"(); 

                    

if(c==’Y’||c==’y’||c==’N’||c==’n’) 

                         break; 

               } 

          } 

          fclose(fp); 

     } 

    3. 结构数组和结构指针 

    结构是一种新的数据类型, 同样可以有结构数组和结构指针。 

    一、结构数组 

    结构数组就是具有相同结构类型的变量集合。假如要定义一个班级40个同学 

的姓名、性别、年龄和住址, 可以定义成一个结构数组。如下所示: 

     struct{ 

          char name[8]; 

          char sex[2]; 

          int age; 

          char addr[40]; 

     }student[40]; 

    也可定义为: 

     struct string{ 

          char name[8]; 

          char sex[2]; 

          int age; 

          char addr[40]; 

     }; 

     struct string student[40]; 

    需要指出的是结构数组成员的访问是以数组元素为结构变量的, 其形式为: 

          结构数组元素.成员名 

    例如: 

      student[0].name 

      student[30].age 

    实际上结构数组相当于一个二维构造, 第一维是结构数组元素, 每个元素是 

一个结构变量, 第二维是结构成员。 

    注意: 

    结构数组的成员也可以是数组变量。 

    例如: 

     struct a 

     { 

          int m[3][5]; 

          float f; 

          char s[20]; 

     }y[4]; 

    为了访问结构a中结构变量y[2]的这个变量, 可写成 

       y[2].m[1][4] 

    二、结构指针 

    结构指针是指向结构的指针。它由一个加在结构变量名前的"*" 操作符来定 

义, 例如用前面已说明的结构定义一个结构指针如下: 

     struct string{ 

          char name[8]; 

          char sex[2]; 

          int age; 

          char addr[40]; 

     }*student; 

    也可省略结构指针名只作结构说明, 然后再用下面的语句定义结构指针。 

      struct string *student; 

    使用结构指针对结构成员的访问, 与结构变量对结构成员的访问在表达方式 

上有所不同。结构指针对结构成员的访问表示为: 

       结构指针名->结构成员 

    其中"->"是两个符号"-"和">"的组合, 好象一个箭头指向结构成员。例如要 

给上面定义的结构中name和age赋值, 可以用下面语句: 

     strcpy(student->name, "Lu G.C"); 

     student->age=18; 

    实际上, student->name就是(*student).name的缩写形式。 

    需要指出的是结构指针是指向结构的一个指针, 即结构中第一个成员的首地 

址, 因此在使用之前应该对结构指针初始化, 即分配整个结构长度的字节空间, 

这可用下面函数完成, 仍以上例来说明如下: 

     student=(struct string*)malloc(size of 

(struct string)); 

    size of (struct string)自动求取string结构的字节长度, 

malloc() 函数 

定义了一个大小为结构长度的内存区域, 然后将其诈地址作为结构指针返回。 

    注意: 

    1. 结构作为一种数据类型,  因此定义的结构变量或结构指针变量同样有局 

部变量和全程变量, 视定义的位置而定。 

    2. 结构变量名不是指向该结构的地址, 这与数组名的含义不同,  因此若需 

要求结构中第一个成员的首地址应该是&[结构变量名]。 

    4. 结构的复杂形式 

    一、嵌套结构 

    嵌套结构是指在一个结构成员中可以包括其它一个结构, Turbo C 允许这种 

嵌套。 

    例如: 下面是一个有嵌套的结构 

     struct string{ 

          char name[8]; 

          int age; 

          struct addr address; 

     } student; 

    其中: addr为另一个结构的结构名, 必须要先进行, 说明, 即 

     struct addr{ 

          char city[20]; 

          unsigned lon zipcode; 

          char tel[14]; 

     } 

    如果要给student结构中成员address结构中的zipcode赋值, 则可写成: 

      student.address.zipcode=200001; 

    每个结构成员名从最外层直到最内层逐个被列出, 即嵌套式结构成员的表达 

方式是: 

      结构变量名.嵌套结构变量名.结构成员名 

    其中: 嵌套结构可以有很多, 结构成员名为最内层结构中不是结构的成员名。 

    二、位结构 

    位结构是一种特殊的结构, 在需按位访问一个字节或字的多个位时, 位结构 

比按位运算符更加方便。 

    位结构定义的一般形式为: 

     struct位结构名{ 

          数据类型 变量名: 整型常数; 

          数据类型 变量名: 整型常数; 

     } 位结构变量; 

    其中: 数据类型必须是int(unsigned或signed)。 整型常数必须是非负的整 

数, 范围是0~15, 表示二进制位的个数, 即表示有多少位。 

    变量名是选择项, 可以不命名, 这样规定是为了排列需要。 

    例如: 下面定义了一个位结构。 

     struct{ 

          unsigned incon: 8;  

/*incon占用低字节的0~7共8位*/ 

          unsigned txcolor: 

4;/*txcolor占用高字节的0~3位共4位*/ 

          unsigned bgcolor: 

3;/*bgcolor占用高字节的4~6位共3位*/ 

          unsigned blink: 1;  /*blink占用高字节的第7位*/ 

     }ch; 

    位结构成员的访问与结构成员的访问相同。 

    例如: 访问上例位结构中的bgcolor成员可写成: 

      ch.bgcolor 

    注意: 

    1. 位结构中的成员可以定义为unsigned, 也可定义为signed,  但当成员长 

度为1时, 会被认为是unsigned类型。因为单个位不可能具有符号。 

    2. 位结构中的成员不能使用数组和指针, 但位结构变量可以是数组和指针, 

如果是指针, 其成员访问方式同结构指针。 

    3. 位结构总长度(位数), 是各个位成员定义的位数之和,  可以超过两个字 

节。 

    4. 位结构成员可以与其它结构成员一起使用。 

    例如: 

     struct info{ 

          char name[8]; 

          int age; 

          struct addr address; 

          float pay; 

          unsigned state: 1; 

          unsigned pay: 1; 

          }workers;’ 

    上例的结构定义了关于一个工从的信息。其中有两个位结构成员, 每个位结 

构成员只有一位, 因此只占一个字节但保存了两个信息, 该字节中第一位表示工 

人的状态, 第二位表示工资是否已发放。由此可见使用位结构可以节省存贮空间。 

以下红色部分为自己整理

1.struct成员的初始化

1.struct数据有3中初始化方法：顺序，C风格及C++风格的乱序。

1）顺序 
这种方法很常见，在一般的介绍C的书中都有介绍。顺序初始化的特点是: 按照成员定义的顺序，从前到后逐个初始化；允许只初始化部分成员；在被初始化的成员之前，不能有未初始化的成员。 
eg: 

struct User oneUser = {10, "Lucy", "/home/Lucy"}; 

2）乱序（C风格）

顺序的缺陷是必须按成员定义的顺序逐个初始化，不能间隔。而乱序的方式则很好的解决了这个问题，因为这种方式是按照成员名进行。
eg: 

struct User oneUser = { 
                        .name = "Lucy",  
                        .id = 10, 
                        .home = "/home/Lucy" 
                      }; 

3）乱序（C++风格） 
C++风格的乱序初始化方式跟C风格的一样，只是它更常用在C++代码里。 
eg: 

struct User oneUser = { 
                                 name:"Lucy",  
                                 id:10, 
                                 home:"/home/Lucy" 
                      }; 

如果想初始化结构体数组，可采用 {{ }, { }, { }} 方式，如

?

1 2 3 4 5 6 7 8 9 10 11 12 13

struct student_st stus[ 2 ] = {      {          .c = 'D' ,          .score = 94 ,          /*也可以只初始化部分成员*/      },      {          .c = 'D' ,          .score = 94 ,          .name = "Xxx"      }, };

注:

不论是哪种方式，都允许只初始化部分成员；未被初始化的成员默认为0(指针类型的成员默认为NULL)。两种乱序初始化方法，即可以用在C代码中，也可以用在C++代码中。

2 拷贝
struct有两种拷贝方式，一是直接赋值(=)，另一种是用memcpy等库函数实行内存拷贝。
eg：
        struct Temp a, b;
        //Set value to members of b
        a = b;
        memcpy(&a, &b, sizeof(a));
不管是哪种拷贝方式，都是将以&b开始的，大小为sizeof(struct Temp)的内存区域中的数据，简单地复制到以&a开始的，同样大小的内存区域。所以，这两种方式与按成员赋值是等价的：
        a.id = b.id;
        a.name = b.name;
        a.home = b.home;
        a.passwd = b.passwd;
由此，我们不难看出，上面两种拷贝方式都属于浅拷贝。
            
3 指针成员的两种使用技巧
1) 为多个指针成员同时分配内存
如果一个struct中有多个指针类型的成员，我们通常需要为每个指针逐个成员分配内存空间，并在使用完时释放它们；这样频繁调用malloc/free，难免让人生厌。如果在分配内存之前，每个指针所指向内存区域的大小是确定的，那么，我们可以为所有指针一次性分配内存区域；并在使用完后，一次性释放。
eg:
       struct Inode
       {
          int id;

          char *file;
          int fie_len;

          char *path;
          int path_len;

          char *user;
          int user_len;
       };

       struct Inode data = {
                            .file_len = X,
                            .path_len = Y,
                            .user_len = X
                            };

       //Allocate memory
       data.file = (char *)malloc(data.file_len + data.path_len + data.user_len);
       data.path = data.file + data.file_len;
       data.user = data.path + data.path_len;


       //User
       ...


       //Free memory
       free(data.file);

2）变长数组的另类实现
将下面的定义
       struct File
       {
          TypeA dataA;
          ......
          char *data;
          TypeN dataN;        
       };
改成：
       struct File
       {
          TypeA dataA;
          ......        
          TypeN dataN;  
          char data[0];     
       };
即将指针成员换成大小为0的一维数组, 作为struct的最后一个成员（数据结构的可变部分必须作为最后一个成员），有两个优点：
（1） 在紧邻struct处为data分配内存区域，这样在分配内存后无须为data赋值；
（2） 利用数组的特性，以指针的方式通过越界访问data数组外的内存区域。
eg:
       struct File *pVar = (struct File *)malloc(sizeof(struct File) + DATA_LEN);
       strncpy(pVar->data, "Source data", DATA_LEN);

2.struct的存储位置和union的区别

请看下面的结构：

struct MyStruct

{

    double dda1;

    char dda;

    int type;

};

对结构MyStruct采用sizeof会出现什么结果呢？sizeof(MyStruct)为多少呢？

也许你会这样求：sizeof(MyStruct)=sizeof(double)+sizeof(char)+sizeof(int)=13

但是当在VC中测试上面结构的大小时，你会发现sizeof(MyStruct)=16。你知道为什么在VC中会得出这样一个结果吗？

其实，这是VC对变量存储的一个特殊处理。为了提高CPU的存储速度，VC对一些变量的起始地址做了“对齐”处理。在默认情况下，VC规定各成员变量存放的起始地址相对于结构的起始地址的偏移量必须为该变量的类型所占用的字节数的倍数。下面列出常用类型的对齐方式(vs6.0&vs8.0,32位系统)。

类型	对齐方式（变量存放的起始地址相对于结构的起始地址的偏移量）
char	偏移量必须为sizeof(char)，即1的倍数
short	偏移量必须为sizeof(short)，即2的倍数
int	偏移量必须为sizeof(int)，即4的倍数
float	偏移量必须为sizeof(float)，即4的倍数
double	偏移量必须为sizeof(double)，即8的倍数

各成员变量在存放的时候根据在结构中出现的顺序依次申请空间，同时按照上面的对齐方式调整位置，空缺的字节VC会自动填充。同时VC为了确保结构的大小为结构的字节边界数（即该结构中占用最大空间的类型所占用的字节数）的倍数，所以在为最后一个成员变量申请空间后，还会根据需要自动填充空缺的字节。

下面用前面的例子来说明VC到底怎么样来存放结构的。

struct MyStruct

{

    double dda1;

    char dda;

    int type;

};

为上面的结构分配空间的时候，VC根据成员变量出现的顺序和对齐方式，依次分配。

（1）先为第一个成员dda1分配空间，其起始地址跟结构的起始地址相同，刚好偏移量0刚好为sizeof(double)的倍数，该成员变量占用sizeof(double)=8个字节；

（2）接下来为第二个成员dda分配空间，这时下一个可以分配的地址对于结构的起始地址的偏移量为8，是sizeof(char)的倍数，所以把dda存放在偏移量为8的地方满足对齐方式，该成员变量占用sizeof(char)=1个字节；

（3）接下来为第三个成员type分配空间，这时下一个可以分配的地址对于结构的起始地址的偏移量为9，不是sizeof(int)=4的倍数，为了满足对齐方式对偏移量的约束问题，VC自动填充3个字节（这三个字节没有放什么东西），这时下一个可以分配的地址对于结构的起始地址的偏移量为12，刚好是=4的倍数，所以把type存放在偏移量为12的地方，该成员变量占用sizeof(int)=4个字节；

（4）这时整个结构的成员变量已经都分配了空间，总的占用的空间大小为：8+1+3+4=16，刚好为结构的字节边界数（即结构中占用最大空间的类型所占用的字节数sizeof(double)=8）的倍数，所以没有空缺的字节需要填充。

（5）所以整个结构的大小为：sizeof(MyStruct)=8+1+3+4=16，其中有3个字节是VC自动填充的，没有放任何有意义的东西。

下面再举个例子，交换一下上面的MyStruct的成员变量的位置，使它变成下面的情况：

struct MyStruct

{

    char dda;

    double dda1;

    int type;

};

这个结构占用的空间为多大呢？在VC6.0环境下，可以得到sizeof(MyStruct)=24。结合上面提到的分配空间的一些原则，分析下VC怎么样为上面的结构分配空间的。（简单说明）

struct MyStruct

{

     /*偏移量为0，满足对齐方式，dda占用1个字节*/

    char dda;

    /*下一个可用的地址的偏移量为1，不是sizeof(double)=8的倍数，

    需要补足个字节才能使偏移量变为（满足对齐方式），因此VC自动填充7个字节，

    dda1存放在偏移量为8的地址上，它占用8个字节。*/

    double dda1;

    /*下一个可用的地址的偏移量为16，是sizeof(int)=4的倍数，满足int的对齐方式，

    所以不需要VC自动填充，type存放在偏移量为的地址上，它占用4个字节。*/

    int type; 

};

所有成员变量都分配了空间，空间总的大小为1+7+8+4=20，不是结构的节边界数（即结构中占用最大空间的类型所占用的字节数sizeof(double)=8）的倍数，所以需要填充4个字节，以满足结构的大小为sizeof(double)=8的倍数。

所以该结构总的大小为：sizeof(MyStruct)为1+7+8+4+4=24。其中总的有7+4=11个字节是VC自动填充的，没有放任何有意义的东西。

VC对结构的存储的特殊处理确实提高CPU存储变量的速度，但是有时候也带来了一些麻烦，我们也屏蔽掉变量默认的对齐方式，自己可以设定变量的对齐方式。

VC中提供了#pragma pack(n)来设定变量以n字节对齐方式。n字节对齐就是说变量存放的起始地址的偏移量有两种情况：第一、如果n大于等于该变量所占用的字节数，那么偏移量必须满足默认的对齐方式，第二、如果n小于该变量的类型所占用的字节数，那么偏移量为n的倍数，不用满足默认的对齐方式。结构的总大小也有个约束条件，分下面两种情况：如果n大于所有成员变量类型所占用的字节数，那么结构的总大小必须为占用空间最大的变量占用的空间数的倍数；否则必须为n的倍数。下面举例说明其用法。

#pragma pack(push) // 保存对齐状态

#pragma pack(4) // 设定为4字节对齐

struct test

{

    char m1;

    double m4;

    int m3;

};

#pragma pack(pop) // 恢复对齐状态

以上结构的大小为16，下面分析其存储情况，首先为m1分配空间，其偏移量为0，满足我们自己设定的对齐方式（4字节对齐），m1占用1个字节。接着开始为m4分配空间，这时其偏移量为1，需要补足3个字节，这样使偏移量满足为n=4的倍数（因为sizeof(double)大于n）,m4占用8个字节。接着为m3分配空间，这时其偏移量为12，满足为4的倍数，m3占用4个字节。这时已经为所有成员变量分配了空间，共分配了16个字节，满足为n的倍数。如果把上面的#pragma pack(4)改为#pragma pack(16)，那么我们可以得到结构的大小为24。（请读者自己分析）

    在VC6中，Project SettingsàC/C++àStruct member alignment中默认值为8Bytes *。Struct member alignment用以指定数据结构中的成员变量在内存中是按几字节对齐的，根据计算机数据总线的位数，不同的对齐方式存取数据的速度不一样。这个参数对数据包网络传输等应用尤为重要，不是存取速度问题，而是数据位的精确定义问题，一般在程序中使用#pragma pack来指定。

参考：

《The sizeof Operator》

《VC中的sizeof的用法总结》

《什么是内存对齐》

《 Struct 和 Union区别 》

3.struct的存储类型同数组的区别

数组是一组同类型的数据集合，结构体数据类型可以任意多个。

4.struct的typedef用法

详见本人博客c语言学习之关键字第十一讲