【C语言学习笔记 --- 自定义类型】

C语言程序设计笔记---020

  • C语言进阶之自定义类型
    • 1、结构体
      • 1.1、结构体的声明
      • 1.2、结构体的自引用
      • 1.3、结构体变量的定义和初始化
      • 1.4、结构体内存对齐
      • 1.5、探究结构体内存对齐
      • 1.6、结构体传参
    • 2、枚举
      • 2.1、枚举类型的定义、使用和初始化
    • 3、联合(共用体)
      • 3.1、回顾大端小端的判断 --- 联合体的应用
      • 3.2、联合体的大小计算
    • 4、结语

C语言进阶之自定义类型

前言:
通过C语言进阶的字符串函数和内存函数的知识,这篇就继续学习C语言的自定义类型的相关内容。

/知识点汇总/
C语言的自定义类型
1.结构体
2.枚举
3.联合体

1、结构体

结构体:是一些值的集合,这些值称为成员变量,结构体的每个成员可以是不同类型的变量
数组:是一组相同类型的元素集合

1.1、结构体的声明

格式

struct tag
{
	member list; //成员列表
}variable list; //结构体变量
#include 

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 
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 
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 
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 );
头文件:
功能:计算结构体成员相较于起始位置的偏移量

#include 
#include 
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 
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 
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 
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 
//宏定义常量
#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 
enum Sex
{
	MALE,
	FEMALE,
	SECRET
};
int main()
{
	//枚举类型的使用:
	enum Sex sex = SECRET;
	//只能拿枚举常量给枚举变量赋值,才不会出现类型的差异
	sex = 5;//会有类型的差异,比如在cpp条件下就会报错(enum类型 与 int类型不匹配,类型差异)
	return 0;
}

3、联合(共用体)

定义:联合也是一种特殊的自定义类型;这种类型定义的变量也包含一系列的成员,特征是这些成员公用同一块空间(所以联合也叫共同体)。
联合体的关键字:union
联合体成员与结构体成员类型类似可是多种类型
联合体的特点
联合体的成员是共用一块内存空间的,这样一个联合变量的大小,至少是最大成员的大小(因为联合至少得有能力保存最大的那个成员)

#include 
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 
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 
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 
union Un
{
	char c[5];//5
	int i;//4
};
int main()
{
	printf("%zd\n", sizeof(union Un));//8
	return 0;
}
#include 
union Un
{
	short c[7];//14
	int i;//4
};
int main()
{
	printf("%zd\n", sizeof(union Un));//16,共用一块地址且是4的倍数,对齐后16
	return 0;
}

小结
联合体的使用场景,常见于,某些成员不会在同一时间使用。
使用联合体也是可以节省空间的。

4、结语

熟悉以上内容以后对C语言的使用更利于程序的可读性和效率,此篇笔记有误的地方请多多指教。
半亩方糖一鉴开,天光云影共徘徊。
问渠哪得清如许?为有源头活水来。–朱熹(观书有感)

你可能感兴趣的:(C语言基础,c语言,学习,笔记,结构体,枚举,联合体,内存对齐)