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的整数倍地址开始存储）

 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 

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

原则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

原则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;

有关不完整类型的字节对齐

使用位域的主要目的是压缩存储，其大致规则为：

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 

 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