结构体与共用体 结构体 结构体是一种构造数据类型 用途：把不同类型的数据组合成一个整体 自定义数据类型 结构体类型定义

Presentation on theme: "结构体与共用体 结构体 结构体是一种构造数据类型 用途：把不同类型的数据组合成一个整体 自定义数据类型 结构体类型定义"— Presentation transcript:

1 结构体与共用体 结构体 结构体是一种构造数据类型 用途：把不同类型的数据组合成一个整体-------自定义数据类型 结构体类型定义
合法标识符 可省:无名结构体 struct [结构体名] { 类型标识符 成员名； ……………. }； 成员类型可以是 基本型或构造型 struct是关键字, 不能省略

2 … ….. 例 struct student { int num; char name[20]; char sex; int age;
score addr 2字节 20字节 1字节 4字节 30字节 … ….. 例 struct student { int num; char name[20]; char sex; int age; float score; char addr[30]; }; 结构体类型定义描述结构 的组织形式,不分配内存 结构体类型定义的作用域

3 结构体变量的定义 先定义结构体类型，再定义结构体变量 一般形式： 例 #define STUDENT struct student
{ 类型标识符 成员名； ……………. }； struct 结构体名 变量名表列； 例 #define STUDENT struct student STUDENT { int num; char name[20]; char sex; int age; float score; char addr[30]; }; STUDENT stu1,stu2; 例 struct student { int num; char name[20]; char sex; int age; float score; char addr[30]; }; struct student stu1,stu2;

4 定义结构体类型的同时定义结构体变量 一般形式： 例 struct student { int num; char name[20];
类型标识符 成员名； ……………. }变量名表列； 例 struct student { int num; char name[20]; char sex; int age; float score; char addr[30]; }stu1,stu2;

5 直接定义结构体变量 一般形式： 例 struct { int num; char name[20]; char sex; int age;
类型标识符 成员名； ……………. }变量名表列； 例 struct { int num; char name[20]; char sex; int age; float score; char addr[30]; }stu1,stu2; 用无名结构体直接定义 变量只能一次

6 说明 结构体类型与结构体变量概念不同 结构体可嵌套 结构体成员名与程序中变量名可相同，不会混淆 结构体类型及变量的作用域与生存期
类型:不分配内存； 变量:分配内存 类型:不能赋值、存取、运算; 变量:可以 结构体可嵌套 结构体成员名与程序中变量名可相同，不会混淆 结构体类型及变量的作用域与生存期 例 struct date { int month; int day; int year; }; struct student { int num; char name[20]; struct date birthday; }stu; num name birthday month day year 例 struct student { int num; char name[20]; struct date { int month; int day; int year; }birthday; }stu; num name birthday month day year

7 结构体变量的引用 引用规则 引用方式： 结构体变量名.成员名 结构体变量不能整体引用,只能引用变量成员 例 struct student
引用方式： 结构体变量名.成员名 例 struct student { int num; char name[20]; char sex; int age; float score; char addr[30]; }stu1,stu2; stu1.num=10; stu1.score=85.5; stu1.score+=stu2.score; stu1.age++; 可以将一个结构体变量赋值给另一个结构体变量 结构体嵌套时逐级引用 成员(分量)运算符 优先级: 1 结合性:从左向右 例 struct student { int num; char name[20]; char sex; int age; float score; char addr[30]; }stu1,stu2; printf(“%d,%s,%c,%d,%f,%s\n”,stu1); () stu1={101,“Wan Lin”,‘M’,19,87.5,“DaLian”}; () 例 struct student { int num; char name[20]; char sex; int age; float score; char addr[30]; }stu1,stu2; if(stu1==stu2) …… () 例 struct student { int num; char name[20]; struct date { int month; int day; int year; }birthday; }stu1,stu2; num name birthday month day year stu1.birthday.month=12; 例 struct student { int num; char name[20]; char sex; int age; float score; char addr[30]; }stu1,stu2; stu2=stu1; ( )

8 结构体变量的初始化 形式一： 例 struct student { int num; char name[20]; char sex;
类型标识符 成员名； ……………. }； struct 结构体名 结构体变量={初始数据}； 例 struct student { int num; char name[20]; char sex; int age; char addr[30]; }; struct student stu1={112,“Wang Lin”,‘M’,19, “200 Beijing Road”};

9 形式二： 例 struct student { int num; char name[20]; char sex; int age;
类型标识符 成员名； ……………. }结构体变量={初始数据}； 例 struct student { int num; char name[20]; char sex; int age; char addr[30]; }stu1={112,“Wang Lin”,‘M’,19, “200 Beijing Road”};

10 形式三： 例 struct { int num; char name[20]; char sex; int age;
类型标识符 成员名； ……………. }结构体变量={初始数据}； 例 struct { int num; char name[20]; char sex; int age; char addr[30]; }stu1={112,“Wang Lin”,‘M’,19, “200 Beijing Road”};

11 结构体数组 结构体数组的定义 三种形式： 形式一: struct student { int num; 形式二:
name sex age stu[0] stu[1] 25B 形式一: struct student { int num; char name[20]; char sex; int age; }; struct student stu[2]; 形式二: struct student { int num; char name[20]; char sex; int age; }stu[2]; 形式三: struct { int num; char name[20]; char sex; int age; }stu[2];

12 strcpy(stu[0].name,”ZhaoDa”);
结构体数组初始化 结构体数组引用 分行初始化: struct student { int num; char name[20]; char sex; int age; }; struct student stu[ ]={{100,“Wang Lin”,‘M’,20}, {101,“Li Gang”,‘M’,19}, {110,“Liu Yan”,‘F’,19}}; 全部初始化时维数可省 顺序初始化: struct student { int num; char name[20]; char sex; int age; }; struct student stu[ ]={100,“Wang Lin”,‘M’,20, 101,“Li Gang”,‘M’,19, 110,“Liu Yan”,‘F’,19}; 引用方式： 结构体数组名[下标].成员名 例 struct student { int num; char name[20]; char sex; int age; }stu[ ]={{……},{……},{……}}; 例 struct { int num; char name[20]; char sex; int age; }stu[ ]={{……},{……},{……}}; struct student { int num; char name[20]; char sex; int age; }str[3]; stu[1].age++; strcpy(stu[0].name,”ZhaoDa”);

13 }leader[3]={“Li”,0,“Zhang”,0,”Wang“,0}; main()
例 统计后选人选票 struct person { char name[20]; int count; }leader[3]={“Li”,0,“Zhang”,0,”Wang“,0}; main() { int i,j; char leader_name[20]; for(i=1;i<=10;i++) { scanf("%s",leader_name); for(j=0;j<3;j++) if(strcmp(leader_name,leader[j].name)==0) leader[j].count++; } for(i=0;i<3;i++) printf("%5s:%d\n",leader[i].name,leader[i].count); name count Li Zhang Wang

14 结构体和指针 指向结构体变量的指针 定义形式：struct 结构体名 *结构体指针名; main() { struct student
例 struct student *p; main() { struct student { long int num; char name[20]; char sex; float score; }stu_1,*p; p=&stu_1; stu_1.num=89101; strcpy(stu_1.name,"Li Lin"); p->sex='M'; p->score=89.5; printf("\nNo:%ld\nname:%s\nsex:%c\nscore:%f\n", (*p).num,p->name,stu_1.sex,p->score); } 使用结构体指针变量引用成员形式 num name sex age stu p struct student { int num; char name[20]; char sex; int age; }stu; struct student *p=&stu; 存放结构体变量在内存的起始地址 struct student stu1; struct student *p=&stu1; stu1.num=101;  (*p).num=101 (*结构体指针名).成员名 结构体指针名->成员名 结构体变量名.成员名 例 int n; int *p=&n; *p=10;  n=10 例 指向结构体的指针变量 指向运算符 优先级: 1 结合方向：从左向右

15 指向结构体数组的指针 例 指向结构体数组的指针 struct student { int num; char name[20];
例 指向结构体数组的指针 struct student { int num; char name[20]; char sex; int age; }stu[3]={{10101,"Li Lin",'M',18}, {10102,"Zhang Fun",'M',19}, {10104,"Wang Min",'F',20}}; main() { struct student *p; for(p=stu;p<stu+3;p++) printf("%d%s%c%d\n",p->num,p->name,p->sex,p->age); } num name sex age stu[0] p stu[1] stu[2] p+1

16 用指向结构体的指针作函数参数 用结构体变量的成员作参数----值传递 用指向结构体变量或数组的指针作参数----地址传递
用结构体变量作参数----多值传递，效率低

17 例 用结构体变量作函数参数 (main) a :27 arg b: 3 c :30 struct data
(func) parm 例 用结构体变量作函数参数 struct data { int a, b, c; }; main() { void func(struct data); struct data arg; arg.a=27; arg.b=3; arg.c=arg.a+arg.b; printf("arg.a=%d arg.b=%d arg.c=%d\n",arg.a,arg.b,arg.c); printf("Call Func()....\n"); func(arg); } void func(struct data parm) { printf("parm.a=%d parm.b=%d parm.c=%d\n",parm.a,parm.b,parm.c); printf("Process...\n"); parm.a=18; parm.b=5; parm.c=parm.a*parm.b; printf("parm.a=%d parm.b=%d parm.c=%d\n",parm.a,parm.b,parm.c); printf("Return...\n"); arg a :27 b: 3 c :30 (main) (func) parm a :18 b: 5 c :90

18 例 用结构体指针变量作函数参数 arg a :27 b: 3 c :30 (main) (func) parm **** arg a :18
例 用结构体指针变量作函数参数 arg a :27 b: 3 c :30 (main) (func) parm **** arg a :18 b: 5 c :90 (main) (func) parm **** arg a :18 b: 5 c :90 (main) arg a :27 b: 3 c :30 (main) struct data { int a, b, c; }; main() { void func(struct data *parm); struct data arg; arg.a=27; arg.b=3; arg.c=arg.a+arg.b; printf("arg.a=%d arg.b=%d arg.c=%d\n",arg.a,arg.b,arg.c); printf("Call Func()....\n"); func(&arg); } void func(struct data *parm) { printf("parm->a=%d parm->b=%d parm->c=%d\n",parm->a,parm->b,parm->c); printf("Process...\n"); parm->a=18; parm->b=5; parm->c=parm->a*parm->b; printf("parm->a=%d parm->b=%d parm->c=%d\n",parm->a,parm->b,parm->c); printf("Return...\n");

19 共用体 共用体类型定义 构造数据类型,也叫联合体 用途：使几个不同类型的变量共占一段内存(相互覆盖) 定义形式： 例 union data
{ 类型标识符 成员名； ……………. }； 例 union data { int i; char ch; float f; }; f ch i 类型定义不分配内存

20 共用体变量的定义 形式一: union data { int i; char ch; float f; }a,b; 形式二:
}; union data a,b,c,*p,d[3]; 形式三: union { int i; char ch; float f; }a,b,c; f ch i a b 共用体变量任何时刻 只有一个成员存在 共用体变量定义分配内存, 长度=最长成员所占字节数

21 p->i p->ch p->f
共用体变量引用 引用方式： 共用体指针名->成员名 共用体变量名.成员名 (*共用体指针名).成员名 引用规则 不能引用共用体变量，只能引用其成员 union data { int i; char ch; float f; }; union data a,b,c,*p,d[3]; a.i a.ch a.f p->i p->ch p->f (*p).i (*p).ch (*p).f d[0].i d[0].ch d[0].f 共用体变量中起作用的成员是最后一次存放的成员 不能在定义共用体变量时初始化 例 union { int i; char ch; float f; }a; a=1; () 例 a.i=1; a.ch=‘a’; a.f=1.5; printf(“%d”,a.i); (编译通过，运行结果不对) 可以用一个共用体变量为另一个变量赋值 例 union { int i; char ch; float f; }a={1,’a’,1.5}; () 例 float x; union { int i; char ch; float f; }a,b; a.i=1; a.ch=‘a’; a.f=1.5; b=a; () x=a.f; ()

22 x.ch[0],x.ch[1],x.ch[0],x.ch[1]); }
例 将一个整数按字节输出 main() { union int_char { int i; char ch[2]; }x; x.i=24897; printf("i=%o\n",x.i); printf("ch0=%o,ch1=%o\n ch0=%c,ch1=%c\n", x.ch[0],x.ch[1],x.ch[0],x.ch[1]); } 低字节 高字节 ch[0] ch[1] 运行结果： i=60501 ch0=101,ch1=141 ch0=A,ch1=a

23 结构体与共用体 区别: 存储方式不同 联系: 两者可相互嵌套 struct node { char ch[2]; ch int k; a
union node }b; a ch k b 变量的各成员同时存在 任一时刻只有一个成员存在

24 例 结构体中嵌套共用体 struct { int num; char name[10]; char sex; char job; union
class position Li Wang 1011 2086 F M S T 501 prof 例 结构体中嵌套共用体 struct { int num; char name[10]; char sex; char job; union { int class; char position[10]; }category; }person[2]; 循环n次 读入姓名、号码、性别、职务 job==‘s’ 真 假 读入class 读入 position 输出 “输入错” 输出:姓名,号码, 性别,职业,班级 性别,职业,职务 job==‘t’

25 用typedef定义类型 功能：用自定义名字为已有数据类型命名 类型定义简单形式： typedef type name;
例 typedef int INTEGER; 例 INTEGER a,b,c; REAL f1,f2; 类型定义语句关键字 已有数据类型名 用户定义的类型名 例 typedef float REAL; int a,b,c; float f1,f2; 类型定义后,与已有类型一样使用 说明: 1.typedef 没有创造新数据类型 2.typedef 是定义类型,不能定义变量 3.typedef 与 define 不同 define typedef 预编译时处理 编译时处理 简单字符置换 为已有类型命名

26 typedef定义类型步骤 按定义变量方法先写出定义体 如 int i; 将变量名换成新类型名 如 int INTEGER;
最前面加typedef 如 typedef int INTEGER; 用新类型名定义变量 如 INTEGER i,j; 例 定义结构体类型 struct date { int month; int day; int year; }d; 例 定义结构体类型 struct date { int month; int day; int year; }DATE; 例 定义结构体类型 typedef struct date { int month; int day; int year; }DATE; 例 定义结构体类型 DATE birthday, *p;  struct date { int month; int day; int year; }birthday, *p;

27 例 定义数组类型 int a[100]; int ARRAY[100]; typedef int ARRAY[100]; ARRAY a,b,c;  int a[100],b[100],c[100];

28 例 定义指针类型 char *str; char *STRING; typedef char *STRING; STRING p,s[10];  char *p; char *s[10];

29 例 定义函数指针类型 int (*p)(); int (*POWER)(); typedef int (*POWER)(); POWER p1,p2;  int (*p1)(),(*p2)();

30 例 typedef struct club { char name[20]; int size; int year; }GROUP; typedef GROUP *PG; PG pclub; GROUP为结构体类型 PG为指向GROUP的指针类型  GROUP *pclub;  struct club *pclub;

31 sizeof应用在结构上的情况 struct MyStruct { double dda1; char dda; int type };
sizeof(MyStruct)=？ 13？ Or 16？

32 VC对变量存储的一个特殊处理。为了提高CPU的存储速度，VC对一些变量的起始地址做了“对齐”处理。在默认情况下，VC规定各成员变量存放的 起始地址相对于结构的起始地址的偏移量必须为该变量的类型所占用的字节数的倍数。

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

34 { double dda1; char dda; int type }；
struct MyStruct { double dda1; char dda; int type }； 先为第一个成员dda1分配空间，其起始地址跟结构的起始地址相同（刚好偏移量0刚好 为sizeof(double)的倍数），该成员变量占用sizeof(double)=8个字节；接下来为第二个成员dda分配空间，这时下一个可以分 配的地址对于结构的起始地址的偏移量为8，是sizeof(char)的倍数，所以把dda存放在偏移量为8的地方满足对齐方式，该成员变量占用 sizeof(char)=1个字节；接下来为第三个成员type分配空间，这时下一个可以分配的地址对于结构的起始地址的偏移量为9，不是sizeof (int)=4的倍数，为了满足对齐方式对偏移量的约束问题，VC自动填充3个字节（这三个字节没有放什么东西），这时下一个可以分配的地址对于结构的起 始地址的偏移量为12，刚好是sizeof(int)=4的倍数，所以把type存放在偏移量为12的地方，该成员变量占用sizeof(int)=4个 字节；这时整个结构的成员变量已经都分配了空间，总的占用的空间大小为： =16，刚好为结构的字节边界数（即结构中占用最大空间的类型所占用的字节数sizeof(double)=8）的倍数，所以没有空缺的字节需要填充。 所以整个结构的大小为：sizeof(MyStruct)= =16，其中有3个字节是VC自动填充的，没有放任何有意义的东西。

35 struct MyStruct {char dda; double dda1; int type }；

36 //偏移量为0，满足对齐方式，dda占用1个字节； double dda1;
struct MyStruct { char dda; //偏移量为0，满足对齐方式，dda占用1个字节； double dda1; //下一个可用的地址的偏移量为1，不是sizeof(double)=8 //的倍数，需要补足7个字节才能使偏移量变为8（满足对齐 //方式），因此VC自动填充7个字节，dda1存放在偏移量为8 //的地址上，它占用8个字节。 int type； //下一个可用的地址的偏移量为16，是sizeof(int)=4的倍 //数，满足int的对齐方式，所以不需要VC自动填充，type存 //放在偏移量为16的地址上，它占用4个字节。 }； 所有成员变量都分配了空间，空间总的大小为 =20，不是结构的节边界数（即结构中占用最大空间的类型所占用的字节数sizeof 字串2(double)=8）的倍数，所以需要填充4个字节，以满足结构的大小为sizeof(double)=8的倍数。 sizeof(MyStruc)为 =24。其中总的有7 4=11个字节是VC自动填充的

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

38 #pragma pack(push) //保存对齐状态 #pragma pack(4)//设定为4字节对齐 struct test { char m1; double m4;
//字串3 int m3; }; #pragma pack(pop)//恢复对齐状态

39 以上结构的大小为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。