C 结构体、共用体、枚举
1、结构体
结构体是一种构造类型的数据结构,是一种或多种基本类型或构造类型的数据的集合。
1.1、结构体类型定义
1.1.1、法1:先定义结构体类型,再去定义结构体变量。
struct 结构体类型名 {
成员列表
};
================================
struct stu {
int num;
char name[20];
char sex;
};
// 定义三个 struct stu 类型的变量,每个变量都有三个成员,分别是num name sex
struct stu michael, michelle, liMing;
1.1.2、法2:在定义结构体类型的时定义结构体变量,以后还可以定义结构体变量。
struct 结构体类型名 {
成员列表;
} 变量1, 变量2;
struct 结构体类型名 变量3, 变量4;
================================
struct stu {
int num;
char name[20];
char sex;
} lucy, bob, lilei;
struct stu lingHuChong, liBai;
1.1.3、法3:定义结构体类型的时,没有结构体类型名,直接定义结构体变量(之后不能再定义相关类型的数据)。
struct {
成员列表;
} 变量1, 变量2;
================================
struct {
int num;
char name[20];
char sex;
} michael, michelle;
1.1.4、常用的定义结构体的方法:
typedef struct stu {
int num;
char name[20];
char sex;
} STU;
以后 STU
就相当于 struct stu
STU michael;
等价于 struct stu lucy;
1.2、结构体变量的定义初始化及使用
1、结构体变量的定义和初始化
结构体变量,是个变量,这个变量是若干个相同或不同数据构成的集合
注:
(1):在定义结构体变量之前首先得有结构体类型,然后再定义变量
(2):在定义结构体变量的时候,可以顺便给结构体变量赋初值,被称为结构体的初始化
(3):结构体变量初始化的时候,各个成员顺序初始化
struct stu{
int num;
char name[20];
char sex;
};
struct stu boy;
struct stu lucy = {
101, "michael", 'f'};
2、结构体变量的使用
定义了结构体变量后,要使用变量
(1).结构体变量成员的引用方法
结构体变量.成员名
struct stu{
int num;
char name[20];
char sex;
};
struct stu bob;
bob.num = 101;//bob 是个结构体变量,但是bob.num 是个int 类型的变量
bob.name 是个字符数组,是个字符数组的名字,代表字符数组的地址,是个常量
bob.name = "bob";//是不可行,是个常量
strcpy(bob.name, "bob");
#include <stdio.h>
struct stu{
int num;
char name[20];
int score;
char *addr;
};
int main(int argc, char *argv[]) {
struct stu bob;
printf("%d\n", sizeof(bob));
printf("%d\n", sizeof(bob.name));
printf("%d\n", sizeof(bob.addr));
return 0;
}
(2).结构体成员多级引用
#include <stdio.h>
struct date {
int year;
int month;
int day;
};
struct stu{
int num;
char name[20];
char sex;
struct date birthday;
};
int main(int argc, char *argv[]) {
struct stu lilei={
101,"lilei",'m'};
lilei.birthday.year=1986;
lilei.birthday.month=1;
lilei.birthday.day=8;
printf("%d %s %c\n",lilei.num,lilei.name,lilei.sex);
printf("%d %d %d\n",lilei.birthday.year,lilei.birthday.month,lilei.birthday.day);
return 0;
}
3、相同类型的结构体变量可以相互赋值
注意:必须是相同类型的结构体变量,才能相互赋值。
#include <stdio.h>
struct stu {
int num;
char name[20];
char sex;
};
int main(int argc, char *argv[]) {
struct stu bob = {
101, "bob", 'm'};
struct stu lilei;
lilei = bob;
printf("%d %s %c\n", lilei.num, lilei.name, lilei.sex);
return 0;
}
1.3、结构体数组
结构体数组是个数组,由若干个相同类型的结构体变量构成的集合
1、结构体数组的定义方法
struct 结构体类型名数组名[元素个数];
struct stu {
int num;
char name[20];
char sex;
};
struct stu edu[3];//定义了一个struct stu 类型的结构体数组edu,
这个数组有3 个元素分别是edu[0] 、edu[1]、edu[2]
1、结构体数组元素的引用数组名[下标]
2、数组元素的使用
edu[0].num =101; //用101 给edu 数组的第0 个结构体变量的num 赋值
strcpy(edu[1].name, “lucy”);
#include <stdio.h>
typedef struct student {
int num;
char name[20];
float score;
}STU;
STU edu[3] = {
{
101,"Lucy",78},
{
102,"Bob",59.5},
{
103,"Tom",85}
};
int main() {
int i;
float sum=0;
for(i=0; i<3; i++) {
sum += edu[i].score;
}
printf("平均成绩为%f\n", sum/3);
return 0;
}
1.4、结构体指针
即结构体的地址,结构体变量存放内存中,也有起始地址
咱们定义一个变量来存放这个地址,那这个变量就是结构体指针变量。
结构体指针变量也是个指针,既然是指针在32 位环境下,指针变量的占4 个字节,存放一个地址编号。
1、结构体指针变量的定义方法:
struct 结构体类型名* 结构体指针变量名;
struct stu {
int num;
char name[20];
};
==定义一个 【struct stu *】 类型的指针变量;变量名是p,p占4个字节,用来保存结构体变量的地址编号。==
struct stu * p;
struct stu michael;
p = &michael;
==访问结构体变量的成员的方法==
michael.num = 101; // 可以用【 结构体变量名.成员名 】
(*p).num = 101; // 可以用【 *p.成员名 】( *p 相当于 p 指向的变量 boy )
p->num = 101; // 可以用 【 指针变量名->成员名 】
通过结构体指针来引用指针指向的结构体的成员,前提是
指针必须先指向一个结构体变量。
结构体指针应用场景:
(1):保存结构体变量的地址
typedef struct stu {
int num;
char name[20];
float score;
} STU;
int main() {
STU *p, lucy;
p=&lucy;
p->num = 101;
strcpy(p->name, "baby");
//p->name="baby";//错误,因为p->name 相当于lucy.name 是个字符数组的名字,是个常量
}
(2):传结构体变量的地址
#include<stdio.h>
#include<string.h>
typedef struct stu {
int num;
char name[20];
float score;
} STU;
void fun(STU *p) {
p->num = 101;
(*p).score = 87.6;
strcpy(p->name, "lucy");
}
int main() {
STU girl;
fun(&girl);
printf("%d %s %f\n", girl.num, girl.name, girl.score);
return 0;
}
(3):传结构体数组的地址
结构体数组,是由若干个相同类型的结构体变量构成的集合。存放在内存里,
也有起始地址,其实就是第0 个结构体变量的地址。
#include<stdio.h>
#include<string.h>
typedef struct stu{
int num;
char name[20];
float score;
} STU;
void fun(STU *p) {
p[1].num=101;
(*(p+1)).score=88.6;
}
int main() {
STU edu[3];
fun(edu);
printf("%d %f\n",edu[1].num,edu[1].score);
return 0;
}
(1):结构体变量的地址编号和结构体第一个成员的地址编号相同,但指针的类型不同
#include <stdio.h>
struct stu {
int num;
char name[20];
int score;
};
int main(int argc, char *argv[]) {
struct stu bob;
printf("%p\n",&bob);
printf("%p\n",&(bob.num));
return 0;
}
(2):结构体数组的地址就是结构体数组中第0 个元素的地址
#include <stdio.h>
struct stu{
int num;
char name[20];
int score;
};
int main(int argc, char *argv[]) {
struct stu edu[3];
printf("%p\n",edu);//struct stu *
printf("%p\n",&(edu[0]));//struct stu *
printf("%p\n",&(edu[0].num));//int *
return 0;
}
1.5、结构体内存分配
1、结构体内存分配
结构体变量是所有成员的集合,结构体变量占用内存的大小是所有成员的大小之和。
#include<stdio.h>
struct stu{
int num;
int age;
} lucy;
int main() {
printf("%d\n", sizeof(lucy)); //结果为8
return 0;
}
但是在实际给结构体变量分配内存的时候,是规则的
#include<stdio.h>
struct stu {
char sex;
int age;
} lucy;
int main() {
printf("%d\n", sizeof(lucy)); //结果为8???
return 0;
}
规则1:以多少个字节为单位开辟内存
给结构体变量分配内存的时候,会去结构体变量中找基本类型的成员
哪个基本类型的成员占字节数多,就以它大大小为单位开辟内存,
在gcc 中出现了double 类型的,例外
(1):成员中只有char 型数据,以1 字节为单位开辟内存。
(2):成员中出现了short int 类型数据,没有更大字节数的基本类型数据。
以2 字节为单位开辟内存
(3):出现了int float 没有更大字节的基本类型数据的时候以4 字节为单位开辟内存。
(4):出现了double 类型的数据
情况1:
在vc6.0 和Visual Studio 中里,以8 字节为单位开辟内存。
情况2:
在Linux 环境gcc 里,以4 字节为单位开辟内存。
无论是那种环境,double 型变量,占8 字节。
注意:
如果在结构体中出现了数组,数组可以看成多个变量的集合。
如果出现指针的话,没有占字节数更大的类型的,以4 字节为单位开辟内存。
在内存中存储结构体成员的时候,按定义的结构体成员的顺序存储。
struct stu {
char sex;
int age;
} lucy;
lucy 的大小是 4 的倍数。
规则2:字节对齐
(1):char 1 字节对齐,即存放char 型的变量,内存单元的编号是1 的倍数即可。
(2):short int 2 字节对齐,即存放short int 型的变量,起始内存单元的编号是2 的倍数即可。
(3):int 4 字节对齐,即存放int 型的变量,起始内存单元的编号是4 的倍数即可
(4):long int 在32 位平台下,4 字节对齐,即存放long int 型的变量,起始内存单元的编号是4
的倍数即可
(5):float 4 字节对齐,即存放float 型的变量,起始内存单元的编号是4 的倍数即可
(6):double
a.vc6.0 和Visual Studio 环境下
8 字节对齐,即存放double 型变量的起始地址,必须是8 的倍数,double 变量占8 字节
b.gcc 环境下
4 字节对齐,即存放double 型变量的起始地址,必须是4 的倍数,double 变量占8 字节。
注意3:当结构体成员中出现数组的时候,可以看成多个变量。
注意4:开辟内存的时候,从上向下依次按成员在结构体中的位置顺序开辟空间
例20://temp 8 个字节
#include<stdio.h>
struct stu{
char a;
short int b;
int c;
}temp;
int main()
{
printf("%d\n",sizeof(temp));
printf("%p\n",&(temp.a));
printf("%p\n",&(temp.b));
printf("%p\n",&(temp.c));
return 0;
}
结果分析:
a 的地址和b 的地址差2 个字节
b 的地址和c 的地址差2 个字节
例21:temp 的大小为12 个字节
#include<stdio.h>
struct stu{
char a;
int c;
short int b;
}temp;
int main()
{
printf("%d\n",sizeof(temp));
printf("%p\n",&(temp.a));
printf("%p\n",&(temp.b));
printf("%p\n",&(temp.c));
return 0;
}
结果分析:
a 和c 的地址差4 个字节
c 和b 的地址差4 个字节
例22:
struct stu{
char buf[10];
int a;
}temp;
//temp 占16 个字节
例23:
在vc 和Visual Studio 中占16 个字节a 和b 的地址差8 个字节
在gcc 中占12 个字节a 和b 的地址差4 个字节
#include<stdio.h>
struct stu{
char a;
double b;
}temp;
int main()
{
printf(“%d\n”,sizeof(temp));
printf(“%p\n”,&(temp.a));
printf(“%p\n”,&(temp.b));
return 0;
}
为什么要有字节对齐?
用空间来换时间,提高cpu 读取数据的效率
struct stu{
char a;
int b;
}boy;
指定对齐原则:
使用#pragma pack改变默认对齐原则
格式:
#pragma pack (value)时的指定对齐值value。
注意:
1.value只能是:1 2 4 8等
2.指定对齐值与数据类型对齐值相比取较小值
说明:咱们指定一个value
(1):以多少个字节为单位开辟内存
结构体成员中,占字节数最大的类型长度和value比较,
取较小值,为单位开辟内存
例24:
#pragma pack(2)
struct stu{
char a;
int b;
} ;
以2个字节为单位开辟内存
#include<stdio.h>
#pragma pack(2)
struct stu{
char a;
int b;
}temp;
int main()
{
printf("%d\n",sizeof(temp));
printf("%p\n",&(temp.a));
printf("%p\n",&(temp.b));
return 0;
}
temp的大小为6个字节
a和b的地址差2个字节
例25:
#pragma pack(8)
struct stu{
char a;
int b;
} ;
以4个字节为单位开辟内存
#include<stdio.h>
#pragma pack(8)
struct stu{
char a;
int b;
}temp;
int main()
{
printf("%d\n",sizeof(temp));
printf("%p\n",&(temp.a));
printf("%p\n",&(temp.b));
return 0;
}
temp的大小为8个字节
a和b的地址差4个字节
(2):字节对齐
结构体成员中成员的对齐方法,各个默认的对齐字节数和value相比,
取较小值
例26:
#include<stdio.h>
#pragma pack(2)
struct stu{
char a;
int b;
}temp;
int main()
{
printf("%d\n",sizeof(temp));
printf("%p\n",&(temp.a));
printf("%p\n",&(temp.b));
return 0;
}
b成员是2字节对齐,a和b的地址差2个字节
例27:
#include<stdio.h>
#pragma pack(8)
struct stu{
char a;
int b;
}temp;
int main()
{
printf("%d\n",sizeof(temp));
printf("%p\n",&(temp.a));
printf("%p\n",&(temp.b));
return 0;
}
a和b都按原先的对齐方式存储
如:如果指定对齐值:
设为1:则short、int、float等均为1
设为2:则char 仍为1,short 为2,int 变为2
1.6、位段
一、位段
在结构体中,以位为单位的成员,咱们称之为位段(位域)。
struct stu{
unsigned int a:2;
unsigned int b:6;
unsigned int c:4;
unsigned int d:4;
unsigned int i;
} data;
注意:不能对位段成员取地址
例28:
#include<stdio.h>
struct stu{
unsigned int a:2;
unsigned int b:6;
unsigned int c:4;
unsigned int d:4;
unsigned int i;
} data;
int main()
{
printf("%d\n",sizeof(data));
printf("%p\n",&data);
printf("%p\n",&(data.i));
return 0;
}
位段注意:
1、对于位段成员的引用如下:
data.a =2
赋值时,不要超出位段定义的范围;
如段成员a定义为2位,最大值为3,即(11)2
所以data.a =5,就会取5的低两位进行赋值101
2、位段成员的类型必须指定为整型或字符型
3、一个位段必须存放在一个存储单元中,不能跨两个单元
第一个单元空间不能容纳下一个位段,则该空间不用,
而从下一个单元起存放该位段
位段的存储单元:
(1):char 型位段存储单元是1 个字节
(2):short int 型的位段存储单元是2 个字节
(3):int 的位段,存储单元是4 字节
(4):long int 的位段,存储单元是4 字节
struct stu {
char a:7;
char b:7;
char c:2;
} temp;//占3 字节,b 不能跨存储单元存储
#include<stdio.h>
struct stu{
char a:7;
char b:7;
char c:2;
}temp;
int main()
{
printf("%d\n",sizeof(temp));
return 0;
}
结果为:3 ,证明位段不能跨其存储单元存储
注意:不能取temp.b 的地址,因为b 可能不够1 字节,不能取地址。
4、位段的长度不能大于存储单元的长度
(1):char 型位段不能大于8 位
(2):short int 型位段不能大于16 位
(3):int 的位段,位段不能大于32 位
(4):long int 的位段,位段不能大于32 位
例30:
#include<stdio.h>
struct stu{
char a:9;
char b:7;
char c:2;
}temp;
int main()
{
printf("%d\n",sizeof(temp));
return 0;
}
分析:
编译出错,位段a 不能大于其存储单元的大小
5、如一个段要从另一个存储单元开始,可以定义:
unsigned char a:1;
unsigned char b:2;
unsigned char :0;
unsigned char c:3;(另一个单元)
由于用了长度为0 的位段,其作用是使下一个位段从
下一个存储单元开始存放
将a、b 存储在一个存储单元中,c 另存在下一个单元
例:31
#include<stdio.h>
struct stu{
unsigned char a:1;
unsigned char b:2;
unsigned char :0;
unsigned char c:3;
};
int main()
{
struct m_type temp;
printf("%d\n",sizeof(temp));
return 0;
}
6、可以定义无意义位段,如:
unsigned a: 1;
unsigned : 2;
unsigned b: 3;
2、共用体
2.1、共用体的定义
共用体和结构体类似,也是一种构造类型的数据结构。
定义共用体类型的方法和结构体非常相似,把 struct 改成 union 就可以了。
在进行某些算法的时候,需要使几种不同类型的变量存到同一段内存单元中,几个变量所使用空间相互重叠,这种几个不同的变量共同占用一段内存的结构,在C语言中,被称作“共用体”类型结构。
共用体所有成员占有同一段地址空间。
共用体的大小是其占内存长度最大的成员的大小。
typedef struct CustomData {
// 结构体
short int i;
char ch;
float f;
} DATA;
DATA temp1;
结构体变量 temp1 最小占 7 个字节(不考虑字节对齐)。
typedef union CustomData {
// 共用体
short int i;
char ch;
float f;
} DATA;
DATA temp2;
共用体变量 temp2 占 4 个字节,即i、ch、f 共用 4 个字节。
#include<stdio.h>
typedef union MyUnionType {
short int i;
char ch;
float f;
} DATA;
int main() {
DATA temp2;
printf("%d\n",sizeof(temp2));
printf("%p\n",&temp2);
printf("%p\n",&(temp2.i));
printf("%p\n",&(temp2.ch));
printf("%p\n",&(temp2.f));
return 0;
}
结果:temp2 的大小为4 个字节,下面几个地址都是相同的,证明了共用体的各个成员占用同一块内存。
2.2、共用体的特点
1、同一内存段可以用来存放几种不同类型的成员,但每一瞬时只有一种起作用。
2、共用体变量中起作用的成员是最后一次存放的成员,在存入一个新的成员后原有的成员的值会被覆盖。
3、共用体变量的地址和它的各成员的地址都是同一地址。
4、共用体变量的初始化 union MyUnionType v1 = { 123 };
初始化共用体只能为第一个成员赋值,不能给所有成员都赋初值。
#include<stdio.h>
typedef union data {
unsigned char a;
unsigned int b;
} DATA;
int main() {
DATA temp;
temp.b = 0xffffffff;
printf("temp.b = %x\n", temp.b);
temp.a = 0x0d;
printf("temp.a = %x\n", temp.a);
printf("temp.b = %x\n", temp.b);
return 0;
}
结果:
temp.b = ffffffff
temp.a = d
temp.b = ffffff0d
3、枚举
将变量的值逐个列举出来,变量的值只限于列举出来的值的范围内。
枚举类型也是个构造类型,类型定义类似结构体类型的定义。
3.1、枚举类型的定义方法
enum 枚举类型名 {
枚举值列表;
};
在枚举值列表中需列出所有枚举元素。
枚举元素是常量,默认是从0开始编号的。枚举变量仅能取枚举值列表所列元素。
3.2、枚举变量的定义方法
星期日:
enum 枚举类型名 枚举变量名;
enum week {
// 枚举类型
Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday
};
enum week workday, weekday;//枚举变量
weekend 与 weekday 只能取 Sunday...Saturday 中的值。
-
枚举值是常量,不能在程序中用赋值语句再对它赋值。
例如:sun=5; mon=2; sun=mon; 都是错误的. -
枚举元素本身由系统定义了一个表示序号的数值。
默认是从0开始顺序定义为0,1,2…
如在week中,mon值为0,tue值为1, …,sun值为6 -
可以改变枚举值的默认值
enum week {
// 枚举类型
mon=3, tue, wed, thu, fri=4, sat, sun
};
说明:mon = 3 tue = 4,以此类推
说明:fri=4 以此类推
注意:
在定义枚举类型的时候枚举元素可以用等号给它赋值,用来代表元素从几开始编号。在程序中,不能再次对枚举元素赋值,因为枚举元素是常量。