C语言杂谈
C语言程序处理过程
预处理:宏定义展开、头文件展开、条件编译,这里并不会检查语法
编译:检查语法,将预处理后文件编译生成汇编文件
汇编:将汇编文件生成目标文件(二进制文件)
链接:将目标文件链接为可执行程序
程序只有在运行才加载到内存(由系统完成),但是某个变量具体分配多大,是在编译阶段就已经确定了,换句话说,在编译阶段做完处理后,程序运行时系统才知道分配多大的空间,所以,很多时候说,这个变量的空间在编译时就分配(确定)了。
字符串操作
1、字符串基本操作
1)字符串初始化
/* C语言没有字符串类型,用字符数组模拟
C语言字符串以数字0,或字符 '\0' 结尾,数字 0 和字符 '\0' 等价 */
char str1[100] = { 'a', 'b', 'c', 'd' }; //没赋值的自动以数字0填充
char str2[] = { 'a', 'b', 'c', 'd' }; //数组长度为4,结尾没有数字0
char str4[] = "abcdef"; //常用赋值方式,栈区
char *p = "abcdef"; //文字常量区,内容不允许被修改
char *buf = (char *)malloc(100); //堆区
strcpy(buf, "abcd"); //"abcd"拷贝到buf指向的内存区域中
2)sizeof和strlen区别
//使用字符串初始化,常用
char buf8[] = "abc";
//strlen: 测字符串长度,不包含数字0,字符'\0'
//sizeof:测数组长度,包含数字0,字符'\0'
printf("strlen = %d, sizeof = %d\n", strlen(buf8), sizeof(buf8));
char buf9[100] = "abc";
printf("strlen = %d, sizeof = %d\n", strlen(buf9), sizeof(buf9));
3)'\0' 后面最好别跟数字,因为几个数字合起来有可能是一个转义字符
//\012相当于\n
char str[] = "\0129";
printf("%s aaaa\n", str);
4)字符'\0', 数字0, 字符'0', NULL的区别
a) 字符'\0' ASCII码值为 0 的字符
字符'\0' 和 数字 0 是等级的,'\0'中'\'是转义字符
char buf[100];
//下面是等级,在数组第10个位置设置字符串结束符
buf[10] = 0;
buf[10] = '\0';
b) 字符'0'是字符串的某个字符内容为'0', ASCII码值为 48 的字符
char buf[100];
buf[0] = '0'; //第0个字符为字符 '0'
c) NULL 标准头文件(stdio.h)的宏 其值为数字 0
const的使用
1)const声明变量为只读(不可更改)
const int a = 10;
a = 100; //error
技巧:去掉指针类型看constant修饰谁
//修饰*,指针指向能变,指针指向的内存不能变
//修饰指针变量,指针指向的内存,指针指向不能变
char buf[100] = "abcdef";
const char *p = buf; //类似于文字常量区 char *p = "123445";
char const *p = buf; //修饰*,指针指向能变,指针指向的内存不能变
//p[0] = '1'; //error
p = "123456"; //ok
char * const p1 = buf; //修饰指针变量,指针指向的内存,指针指向不能变
//p1 = "123456"; //error
p1[0] = '1'; //ok
const char * const p2 = buf; //p2, 只读
数组类型
int a[] = { 1, 3, 5 }; //3个元素
a: 数组首行首元素地址,一级指针
&a: 整个数组的首地址,二级指针
首行首元素地址和首行(整个一维数组)地址值虽然是一样,但是它们的步长不一样
a+1: 跳过1元素,一元素为4字节,步长4个字节
&a+1: 跳过整个数组,整个数组长度为 3*4 = 12,步长 3 * 4 = 12
sizeof(a): 传参为:数组首行首元素地址,测数组(int [3])的长度,3 * 4 = 12
sizeof(a[0]): 传参为:数组首元素(不是地址),每个元素为int类, 4字节
sizeof(&a):传参为:一维数组整个数组的地址(首行地址),编译器当做指针类型,4字节
(重要)首行地址 --> 首行首元素地址(加*)
&a:首行地址
*&a -> a : 首行首元素地址
//数组也是一种数据类型,类型本质:固定大小内存块别名
//由元素类型和内存大小(元素个数)共同决定 int a[5] int[5]
//可以通过typedef定义数组类型
//有typedef:类型
//没有typedef:变量
typedef int ARRARY[5]; //定义了一个名字为ARRARY的数组类型(int[5]类型)
//等价于typedef int (ARRARY)[5];
//根据数组类型,定义变量
//ARRARY的位置替代为d,去掉typedef,int d[5]
ARRARY d; //相当于int d[5];
结构体字节对齐规则
内存对齐的原则
默认情况下,数据成员的对齐规则(以最大的类型字节为单位)。
当然,字节对齐可以通过程序控制,采用指令:
#pragma pack(xx)
#pragma pack(1) //1字节对齐
#pragma pack(2) //2字节对齐
#pragma pack(4) //4字节对齐
#pragma pack(8) //8字节对齐
#pragma pack(16) //16字节对齐
原则1:数据成员的对齐规则(以最大的类型字节为单位)。
结构体(struct)的数据成员,第一个数据成员放在offset为0的地方,以后每个数据成员存放在offset为该数据成员大小的整数倍的地方(比如int在32位机为4字节,则要从4的整数倍地址开始存储)
1 struct
2 {
3 int a;
4 short b;
5 }A;
6 //对齐单位为 4 个字节(结构体A中最大的类型为int(4个字节))
7 //偏移量:
8 a: 4*0 = 0
9 b: 2*2 = 4
10 ![](https://img2020.cnblogs.com/blog/1959382/202009/1959382-20200908215432612-1889782235.png)
11 sizeof(A) = 8;
1 struct
2 {
3 int a;
4 char b;
5 short c;
6 }A;
7 //对齐单位 4 个字节
8 sizeof(A) = 8;
9 a: 4*0 = 0 //偏移0个字节
10 b: 1*4 = 4 //偏移4个字节
11 c: 2*3 = 6
![](https://img2020.cnblogs.com/blog/1959382/202009/1959382-20200908215610859-192962893.png)
原则2:结构体作为成员的对齐规则。
如果一个结构体B里嵌套另一个结构体A,则结构体A应从offset为A内部最大成员的整数倍的地方开始存储。
(struct B里存有struct A,A里有char,int,double等成员,那A应该从8的整数倍开始存储。),结构体A中的成员的对齐规则仍满足原则1、原则2。
注意:
1. 结构体A所占的大小为该结构体成员内部最大元素的整数倍,不足补齐。
2. 不是直接将结构体A的成员直接移动到结构体B中
1 struct A
2 {
3 int a;
4 double b;
5 float c;
6 };
7
8 struct
9 {
10 char e[2];
11 int f;
12 double g;
13 short h;
14 struct A i;
15 }B;
16 //对齐单位 8 个字节
17 sizeof(B) = 48;
18 //普通成员偏移量
19 e: 1*0 = 0
20 f: 4*1 = 4
21 g: 8*1 = 8
22 h: 2*8 = 16
23 结构体起点坐标:
24 8*3 = 24
25 //结构体成员偏移量
26 a: 24 + 4*0 = 24
27 b: 24 + 8*1 = 32
28 c: 24 + 4*4 = 40
![](https://img2020.cnblogs.com/blog/1959382/202009/1959382-20200908215824811-960930083.png)
原则3:收尾工作
结构体的总大小,也就是sizeof的结果,必须是其内部最大成员的整数倍,不足的要补齐。
原则4:指定对齐单位
1 #pragma pack(2) //指定对齐单位为2个字节
2 typedef struct
3 {
4 int a;
5 char b;
6 short c;
7 char d;
8 }A;
9 a: 2*0 = 0
10 b: 1*4 = 4
11 c: 2*3 = 6
12 d: 1*8 = 8
13 sizeof(A) = 10;
![](https://img2020.cnblogs.com/blog/1959382/202009/1959382-20200908220026861-2040129611.png)
有关不完整类型的字节对齐
使用位域的主要目的是压缩存储,其大致规则为:
1) 一个位域必须存储在同一个字节中,不能跨两个字节。如一个字节所剩空间不够存放另一位域时,应从下一单元起存放该位域。
2) 如果相邻位域字段的类型相同,且其位宽之和小于类型的sizeof大小,则后面的字段将紧邻前一个字段存储,直到不能容纳为止;
3) 如果相邻位域字段的类型相同,但其位宽之和大于类型的sizeof大小,则后面的字段将从新的存储单元开始,其偏移量为其类型大小的整数倍;
4) 如果相邻的位域字段的类型不同,则各编译器的具体实现有差异,VC6采取不压缩方式,Dev-C++和gcc采取压缩方式;
5) 如果位域字段之间穿插着非位域字段,则不进行压缩;
6) 整个结构体的总大小为最宽基本类型成员大小的整数倍。
1 //以 4 字节对齐
2 struct A
3 {
4 int a1:5;
5 int a2:9;
6 char c;
7 int b:4;
8 short s;
9 }B;
10
11 sizeof(B) = 16
12
13 a1 + a2 = 14 位,少于 32位,4字节
14 a1+a2存放在一起:4*0 = 0
15 c: 1 * 4 = 4
16 b: 4 * 2 = 8 //所占的大小为该结构体成员内部最大元素的整数倍(4对齐),不足补齐。
17 s: 2 * 6 = 12
![](https://img2020.cnblogs.com/blog/1959382/202009/1959382-20200908220224888-1099938876.png)
1 struct A
2 {
3 int a1 : 5;
4 int a2 : 9;
5 char c;
6 int b : 4;
7 short s;
8 }B;
9 sizeof(B) = 12;
10
11 a1+a2 = 14 (小于32位,4字节)
12 a1+a2: 2 * 0 =0;
13 c: 1 * 4 = 4;
14 b: 2 * 3 = 6; //4超过2字节,以2字节为单位
15 s:2 * 5 = 10
![](https://img2020.cnblogs.com/blog/1959382/202009/1959382-20200908220313656-489931941.png)