C语言程序设计笔记---020
C语言进阶之自定义类型
前言：
通过C语言进阶的字符串函数和内存函数的知识，这篇就继续学习C语言的自定义类型的相关内容。
/知识点汇总/
C语言的自定义类型
1.结构体
2.枚举
3.联合体
1、结构体
结构体：是一些值的集合，这些值称为成员变量，结构体的每个成员可以是不同类型的变量
数组：是一组相同类型的元素集合
1.1、结构体的声明
格式：
struct tag
{
member list; //成员列表
}variable list; //结构体变量
#include <stdio.h>
struct Student
{
char name[20];
int age;
char sex[5];
float score;
}s1,s2,s3;//三个结构体变量 --- 全局变量
struct Book
{
char name[20];
char author[12];
float price;
};
struct Book
{
char name[20];
char author[12];
float price;
}b1;
int main()
{
struct Student s4, s5, s6;//三个结构体变量 ---局部变量
return 0;
}
结构体的一种特殊声明：结构体匿名
#include <stdio.h>
struct Student
{
char name[20];
int age;
char sex[5];
float score;
}s1,s2,s3;//三个结构体变量 --- 全局变量
//一种特殊声明，匿名声明，只会执行一次。一次性
struct
{
char name[20];
char author[12];
float price;
}b1;
struct
{
char name[20];
char author[12];
float price;
}*p;
int main()
{
struct Student s4, s5, s6;//三个结构体变量 ---局部变量
//不建议使用匿名写法
p = &b1;
return 0;
}
1.2、结构体的自引用
结构体的自引用：就是在结构体内部,包含指向自身类型结构体的指针
错误的写法示例：
struct Node
{
int data;//数据
struct Node n;//下一个节点
};
正确的引用方法：
//正确自引用写法1：
struct Node
{
int data;//数据
struct Node* n;//下一个节点
};
//正确写法2：
typedef struct Node
{
int data;//数据
struct Node* n;//下一个节点
}Node;
小结：
结构体里包含一个同类型的结构体不可行，但可以包含一个同类型的指针结构体可行
1.3、结构体变量的定义和初始化
#include <stdio.h>
struct Point
{
int x;
int y;
}p1 = {
1,2 };//初始化方式一
struct Point p3 = {
4,5 };//初始化方式二
struct Stu
{
char name[15];
int age;
};
struct Node
{
int data;
struct Point p;
struct NOde* next;
};
int main()
{
int a = 3;
int b = 4;
struct Point p2 = {
a,b };//初始化方式三
struct Stu s = {
"lisi",20 };//顺序初始化
struct Stu s1 = {
.age = 18,.name = "zhangsan" };//指定顺序或指定成员初始化
printf("%s %d\n", s.name, s.age);
printf("%s %d\n", s1.name, s1.age);
struct Node n = {
100,{
3,4},NULL };
printf("%d x=%d y=%d\n", n.data, n.p.x, n.p.y);
return 0;
}
1.4、结构体内存对齐
#include <stdio.h>
struct S1
{
char c1;
int i;
char c2;
};
struct S2
{
char c1;
char c2;
int i;
};
int main()
{
printf("%d\n", sizeof(struct S1));//12
printf("%d\n", sizeof(struct S2));//8
return 0;
}
offsetof – 宏 — 可直接使用
原型：size_t offsetof( structName, memberName );
头文件：<stddef.h>
功能：计算结构体成员相较于起始位置的偏移量
#include <stdio.h>
#include <stddef.h>
struct S1
{
char c1;
int i;
char c2;
};
struct S2
{
char c1;
char c2;
int i;
};
int main()
{
//offsetof -- 计算起始位置的偏移量
printf("%d\n", offsetof(struct S1, c1));//0
printf("%d\n", offsetof(struct S1, c2));//8
printf("%d\n", offsetof(struct S1, i));//4
printf("%d\n", offsetof(struct S2, c1));//0
printf("%d\n", offsetof(struct S2, c2));//1
printf("%d\n", offsetof(struct S2, i));//4
return 0;
}
小结：
观看可知，结构体定义的所开辟的内容完全相同，但是所在的字节大小却不同
原理：结构体内存对齐
1.5、探究结构体内存对齐
1.怎么对齐？
2.为什么要对齐？
标准规定：
结构体对齐的规则：
1.结构体的成员在与结构体变量偏移量为0的地址处开始存储
2.结构体其它成员变量要对齐到某个数字(对齐数)的整数倍的地址处存储
对齐数 = 编译器默认的一个对齐数与该成员大小的较小值其中，VS编译器默认为8 Linux中默认为没有对齐数，对齐数就是成员自身的大小（gcc编译器下）
3.结构体总大小为最大对齐数(每个成员变量都有一个对齐数)的整数倍
4.如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数(含嵌套结构体的对齐数)的整数倍
1.怎么对齐？
根据规则可知，对齐偏移量与变量的类型相关，先根据变量类型的得到偏移量再和当前VS编译器的默认对齐数8作比较，选择最小的为该变量的对齐数，也就是存储空间所开辟的空间大小。
最后，结构体的总大小，必须是所有结构体成员的最大的对齐数的整数倍，如果不是整数倍，则继续开辟空间直到成为整数倍。
#include <stdio.h>
struct S1
{
char c1;
char c2;
int i;
};
struct S2
{
char c1;
int i;
char c2;
};
struct S3
{
double d;
char c;
int i;
};
struct S4
{
char c1;
struct S3 s3;
double d;
};
int main()
{
printf("%d\n", sizeof(struct S1));//8
printf("%d\n", sizeof(struct S2));//12
printf("%d\n", sizeof(struct S3));//16
printf("%d\n", sizeof(struct S4));//32
return 0;
}
2.为什么要对齐？
(1).平台原因：
不是所有的硬件平台都能访问任意地址上的任意数据的：
某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常
(2).性能原因：
数据结构(尤其是栈)应该尽可能地在自然边界上对齐
原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。
3.总体来说：结构体的内存对齐是针对于拿空间来换取时间的做法。
那么如果在设计结构体时，既要满足对齐，又要节省空间，如何做到呢？
(1)、让占用空间小的成员变量尽量集中在一起。
比如：
struct S1
{
char c1;
char c2;
int i;
};
struct S2
{
char c1;
int i;
char c2;
};
(2)、引用#pragma，预处理指令，修改默认对齐数
#include <stdio.h>
struct S1
{
char c1;
char c2;
int i;
};
#pragma pack(1)//设置默认对齐数为1
struct S2
{
char c1;
int i;
char c2;
};
#pragma pack()//取消设置的默认对齐数，还原为编译器默认值
int main()
{
printf("%d\n", sizeof(struct S1));//8
printf("%d\n", sizeof(struct S2));//6
return 0;
}
小结：
所以遇见结构体对齐方式不合适时，也可以通过#pragma预处理指令修改默认对齐数（通常为偶数）
1.6、结构体传参
结构体传参分类：结构体传值调用和传址调用
#include <stdio.h>
struct S
{
int data[1000];
int num;
};
void print(struct S t)
{
printf("%d %d %d %d\n", t.data[0], t.data[1], t.data[2], t.num);
}
void print2(struct S* ps)
{
printf("%d %d %d %d\n", ps->data[0], ps->data[1], ps->data[2], ps->num);
}
int main()
{
struct S s = {
{
1,2,3},100 };
print(s);//传值调用
print2(&s);//传值调用
return 0;
}
小结：
1.函数传参时，参数是需要压栈的，会有时间和空间上的系统开销
2.如果传递一个结构体对象的时候，结构体过大，参数压栈的系统开销比较大，所以会导致性能的下降
2、枚举
顾名思义就是一一列举数据
把可能的值一一列举出来
比如生活中一些可以一一列举出来的数据：
1.一周有七天，可以从周一到周日一一列举
2.性别有男有女，可以一一列举
3.月份有12个月，可以一一列举
2.1、枚举类型的定义、使用和初始化
#include <stdio.h>
//宏定义常量
#define MALE 1
#define FEMALE 2
#define SECRET 3
enum Sex
{
//枚举的可能取值
MALE,//注意，枚举常量以逗号隔开
FEMALE,
SECRET
};
enum Color
{
//枚举的可能取值
RED,
GREEN,
BLUE
};
enum Week
{
Mon = 1,//赋初始值
Tues = 2,
wed = 3,
Thur = 4,
Fri = 5,
sat = 6,
Sun = 7
};
int main()
{
//MALE = 5; ---- Error,因为枚举常量属于常量，不可以给常量赋值，常量是不可更改的
printf("%d\n", MALE);//0
printf("%d\n", FEMALE);//1
printf("%d\n", SECRET);//2
//枚举成员常量不赋予初值时，默认从0开始递增的
//枚举类型的使用：
enum Sex sex = SECRET;//相当于将一个常量赋值给变量sex
//也类似于宏定义常量的使用
printf("%d\n", sizeof(sex));//4,打印查看枚举常量的大小，整型4个字节
return 0;
}
小结：
我们可以使用#define定义常量，那么为什么使用枚举？
枚举的优点：
1.增加代码的可读性和维护性
2.和#define定义的标识符比较，枚举有类型检查，更加严谨
3.便于调试
4.使用方便，一次可定义多个常量
枚举类型的使用差异
#include <stdio.h>
enum Sex
{
MALE,
FEMALE,
SECRET
};
int main()
{
//枚举类型的使用：
enum Sex sex = SECRET;
//只能拿枚举常量给枚举变量赋值，才不会出现类型的差异
sex = 5;//会有类型的差异，比如在cpp条件下就会报错（enum类型 与 int类型不匹配，类型差异）
return 0;
}
3、联合(共用体)
定义：联合也是一种特殊的自定义类型；这种类型定义的变量也包含一系列的成员，特征是这些成员公用同一块空间(所以联合也叫共同体)。
联合体的关键字：union
联合体成员与结构体成员类型类似可是多种类型
联合体的特点：
联合体的成员是共用一块内存空间的，这样一个联合变量的大小，至少是最大成员的大小(因为联合至少得有能力保存最大的那个成员)
#include <stdio.h>
union Un
{
char c;//联合体成员跟结构体成员一样用分号隔开
int i;
};
int main()
{
union Un un;
printf("%d\n", sizeof(un));//4
//共用一块地址
printf("%p\n", &un);//0073F6EC
printf("%p\n", &(un.c));//0073F6EC
printf("%p\n", &(un.i));//0073F6EC
//所以当联合体成员被修改，可能导致其他的成员也跟着相应变化
//所以在使用联合体成员时，不建议同时操作数据。
return 0;
}
3.1、回顾大端小端的判断 — 联合体的应用
小端存储：低地址数据存放在低地址处，高地址数据存放在高地址处
大端存储：低地址数据存放在高地址处，高地址数据存放在低地址处
写法一：
#include <stdio.h>
int check_sys()
{
int a = 1;
//if (*(char*)&a == 1)//&a类型是int*
// return 1;
//else
// return 0;
return *(char*)&a;
}
int main()
{
int ret = check_sys();
if (ret == 1)
printf("小端\n");
else
printf("大端\n");
return 0;
}
写法二： 联合体应用
#include <stdio.h>
int check_sys()
{
union Un//当Un省略就是匿名联合体，此时可以使用，因为这里联合体只需要执行一次与匿名结构体、匿名联合体的性质吻合，只执行一次
{
char c;
int i;
}u;
u.i = 1;
//因为i和c是联合体变量，所以共用一块内存空间
//并且当给i赋值给1，以十六进制表示为：0x00 00 00 01
//所以我们返回c的值，如果c等于0，则高地址数据存放在低地址处，
//否则c为1，低地址处数据存放在低地址处
return u.c;
}
int main()
{
int ret = check_sys();
if (ret == 1)
printf("小端\n");
else
printf("大端\n");
return 0;
}
3.2、联合体的大小计算
1.联合体的大小至少是最大成员的大小
2.当最大成员大小不是最大对齐数的整数倍时，就要对齐到最大对齐数的整数倍
#include <stdio.h>
union Un
{
char c[5];//5
int i;//4
};
int main()
{
printf("%zd\n", sizeof(union Un));//8
return 0;
}
#include <stdio.h>
union Un
{
short c[7];//14
int i;//4
};
int main()
{
printf("%zd\n", sizeof(union Un));//16,共用一块地址且是4的倍数，对齐后16
return 0;
}
小结：
联合体的使用场景，常见于，某些成员不会在同一时间使用。
使用联合体也是可以节省空间的。
4、结语
熟悉以上内容以后对C语言的使用更利于程序的可读性和效率，此篇笔记有误的地方请多多指教。
半亩方糖一鉴开，天光云影共徘徊。
问渠哪得清如许?为有源头活水来。–朱熹（观书有感）