转载——嵌入式linux之高级c语言专题—数组&字符串&结构体&共用体&枚举

前言：

为了方便查看博客，特意申请了一个公众号，附上二维码，有兴趣的朋友可以关注，和我一起讨论学习，一起享受技术，一起成长。

---

本文转载自嵌入式linux之高级c语言专题—数组&字符串&结构体&共用体&枚举

---

1. 程序中内存从哪里来1

1.1 程序执行需要内存支持

对程序来说，内存就是程序的立足之地（程序是被放在内存中运行的）；程序运行时需要内存来存储一些临时变量。

1.2 内存管理最终是由操作系统完成的

（1）内存本身在物理上是一个硬件器件，由硬件系统提供；

（2）内存是由操作系统统一管理。为了内存管理方便又合理，操作系统提供了多种机制来让我们应用程序使用内存。这些机制彼此不同，各自有各自的特点，我们程序根据自己的实际情况来选择某种方式获取内存（在操作系统处登记这块内存的临时使用权限）、使用内存、释放内存（向操作系统归还这块内存的使用权限）。

1.3 三种内存来源：栈（stack）、堆（heap）、数据区（.data）

在一个C语言程序中，能够获取的内存就是三种情况：栈（stack）、堆（heap）、数据区（.data）。

1.4 栈的详解

运行时自动分配且自动回收：栈是自动管理的，程序员不需要手工干预。方便简单。

反复使用： 栈内存在程序中其实就是那一块空间，程序反复使用这一块空间；

脏内存： 栈内存由于反复使用，每次使用后程序不会去清理，因此分配到时保留原来的值；（故局部变量值是随机的）

临时性： 函数不能返回栈变量的指针，因为这个空间是临时的；

栈会溢出： 因为操作系统事先给定了栈的大小，如果在函数中无穷尽的分配栈内存总能用完。

2. 程序中内存从哪里来2

2.1 堆内存详解

操作系统堆管理器管理： 堆管理器是操作系统的一个模块，堆管理内存分配灵活，按需分配。

大块内存： 堆内存管理着总量很大的操作系统内存块，各进程可以按需申请使用，使用完释放。

程序手动申请&释放： 手工意思是需要写代码去申请 malloc 和释放 free 。

脏内存： 堆内存也是反复使用的，而且使用者用完释放前不会清除，因此也是脏的。

临时性： 堆内存只在 malloc 和 free 之间属于我这个进程，而可以访问。在 malloc 之前和 free 之后都不能再访问，否则会有不可预料的后果。

2.2 堆内存使用范例

void *malloc(size_t size);
void *calloc(size_t nmemb,size_t size);
void *realloc(void *ptr,size_t size);

（1）void * 是个指针类型，malloc 返回的是一个 void * 类型的指针，实质上 malloc 返回的是堆管理器分配给我本次申请的那段内存空间的首地址（malloc返回的值其实是一个数字，这个数字表示一个内存地址）。

（2）为什么要使用 void * 作为类型？

主要原因是 malloc 帮我们分配内存时只是分配了内存空间，至于这段空间将来用来存储什么类型的元素 malloc 是不关心的，由我们程序自己来决定。

（3）什么是 void 类型。早期被翻译成空型，这个翻译非常不好，会误导人。 void 类型不表示没有类型，而表示万能类型。 void 的意思就是说这个数据的类型当前是不确定的，在需要的时候可以再去指定它的具体类型。 void * 类型是一个指针类型，这个指针本身占 4 个字节，但是指针指向的类型是不确定的，换句话说这个指针在需要的时候可以被强制转化成其他任何一种确定类型的指针，也就是说这个指针可以指向任何类型的元素。

（4）malloc 的返回值：成功申请空间后返回这个内存空间的指针，申请失败时返回 NULL 。所以 malloc 获取的内存指针使用前一定要先检验是否为 NULL 。

（5）malloc 申请的内存时用完后要 free 释放：free§；会告诉堆管理器这段内存我用完了你可以回收了。堆管理器回收了这段内存后这段内存当前进程就不应该再使用了。因为释放后堆管理器就可能把这段内存再次分配给别的进程，所以你就不能再使用了。

 void free(void *ptr);

（6）再调用 free 归还这段内存之前，指向这段内存的指针 p 一定不能丢（也就是不能给 p 另外赋值）。因为 p 一旦丢失这段 malloc 来的内存就永远的丢失了（内存泄漏），直到当前程序结束时操作系统才会回收这段内存。

测试：

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
   
   int *p = (int *)malloc(1000*sizeof(int));//(1)申请堆内存

    if(NULL == p)                           //(2)检验分配的内存
    {
        printf("malloc is error\r\n");
    }
    
    *(p+0) = 1;                             //(3)使用申请的内存
    *(p+1) = 2;
    printf("*(p+0) = %d \r\n",*(p+0));
    printf("*(p+1) = %d \r\n",*(p+1));

    free(p);
    p = NULL;                               //(4)释放内存,free前，不能给p赋值,否则会导致内存泄漏
    //内存已经被收回了,不能再被使用
    printf("second start!\r\n");
    *(p+0) = 123;
    *(p+1) = 124;
    printf("*(p+0) = %d \r\n",*(p+0));
    printf("*(p+1) = %d \r\n",*(p+1));
    printf("all stop!\r\n");
    return 0;
}

2.3 malloc 的一些细节表现

（1）malloc(0)

malloc申请0字节内存本身就是一件无厘头事情，一般不会碰到这个需要。

如果真的malloc(0)返回的是NULL还是一个有效指针？

答案是： 实际分配了16Byte的一段内存并且返回了这段内存的地址。这个答案不是确定的，因为C语言并没有明确规定 malloc(0) 时的表现，由各 malloc 函数库的实现者来定义。

malloc(4)

gcc 中的 malloc 默认最小是以 16B 为分配单位的。如果 malloc 小于 16B 的大小时都会返回一个 16 字节的大小的内存。malloc 实现时没有实现任意自己的分配而是允许一些大小的块内存的分配。

3. 程序中内存从哪里来3

3.1 代码段、数据段、bss段

（1）编译器在编译程序的时候，将程序中的所有的元素分成了一些组成部分，各部分构成一个段，所以说段是可执行程序的组成部分。

（2）代码段：代码段就是程序中的可执行部分，直观理解代码段就是函数堆叠组成的。

（3）数据段（也被称为数据区、静态数据区、静态区）：数据段就是程序中的数据，直观理解就是 C 语言程序中的全局变量。（注意：全局变量才算是程序的数据，局部变量不算程序的数据，只能算是函数的数据）

（4）.bss段（又叫ZI(zero initial)段）：.bss 段的特点就是被初始化为 0 ，bss 段本质上也是属于数据段， bss 段就是被初始化为 0 的数据段。

注意区分：

数据段（.data）和 bss 段的区别和联系：二者本来没有本质区别，都是用来存放 C 程序中的全局变量的。区别在于把显示初始化为非零的全局变量存在 .data 段中，而把显式初始化为 0 或者并未显式初始化（C语言规定未显式初始化的全局变量值默认为 0 ）的全局变量存在 bss 段。

3.2 有些特殊数据会被放到代码段

char *p = “linux”

（1）C 语言中使用：定义字符串时，字符串 “linux” 实际被分配在代码段，也就是说这个 “linux” 字符串实际上是一个常量字符串而不是变量字符串。

（2）const 型常量：C 语言中 const 关键字用来定义常量，常量就是不能被改变的量。const 的实现方法至少有2种：

第一种就是编译将 const 修饰的变量放在代码段去以实现不能修改（普遍见于各种单片机的编译器）；

第二种就是由编译器来检查以确保 const 型的常量不会被修改，实际上 const 型的常量还是和普通变量一样放在数据段的（ gcc 中就是这样实现的）。

3.3 有些特殊数据会被放到代码段

（1）放在 .data 段的变量有 2 种：

第一种：显式初始化为非零的全局变量。

第二种：静态局部变量，也就是 static 修饰的局部变量。（普通局部变量分配在栈上，静态局部变量分配在 .data 段）

3.4 未初始化或显式初始化为 0 的全局变量放在bss段

（1） bss段和.data段并没有本质区别，几乎可以不用明确去区分这两种。

3.5 总结：C语言中所有变量和常量所使用的内存无非以上三种情况。

（1）相同点：

三种获取内存（堆、栈、数据区）的方法，都可以给程序提供可用内存，都可以用来定义变量给程序用。

（2）不同点：

栈内存对应 C 中的普通局部变量（别的变量还用不了栈，而且栈是自动的，由编译器和运行时环境共同来提供服务的，程序员无法手工控制）；

堆内存完全是独立于我们的程序存在和管理的，程序需要内存时可以去手工申请 malloc，使用完成后必须尽快 free 释放。（堆内存对程序就好象公共图书馆对于人）；

数据段对于程序来说对应 C 程序中的全局变量和静态局部变量。

如果我需要一段内存来存储数据，我究竟应该把这个数据存储在哪里？（或者说我要定义一个变量，我究竟应该定义为局部变量还是全局变量，还是用 malloc 来实现 ）。不同的存储方式有不同的特点，简单总结如下：

函数内部临时使用，出了函数不会用到，就定义局部变量；

堆内存和数据段几乎拥有完全相同的属性，大部分时候是可以完全替换的。但是生命周期不一样；

堆内存的生命周期是从 malloc 开始到 free 结束，而全局变量是从整个程序一开始执行就开始，直到整个程序结束才会消灭，伴随程序运行的一生。

启示：如果你这个变量只是在程序的一个阶段有用，用完就不用了，就适合用堆内存；如果这个变量本身和程序是一生相伴的，那就适合用全局变量。（堆内存就好象租房、数据段就好象买房）你以后会慢慢发现：买不如租，堆内存的使用比全局变量广泛。

4. C语言的字符串类型

4.1 C语言没有原生字符串类型

（1）很多高级语言像 java、C# 等就有字符串类型，有个 String 来表示字符串，用法和 int 这些很像，可以 String s1 = “linux” ;来定义字符串类型的变量。

（2）C 语言没有 String 类型，C 语言中的字符串是通过字符指针来间接实现的。

C 语言中定义字符串方法：char *p = “linux”；此时 p 就叫做字符串，但是实际上p 只是一个字符指针（本质上就是一个指针变量，只是 p 指向了一个字符串的起始地址而已）。

4.2 C 语言中字符串的本质：指针指向头、固定尾部的地址相连的一段内存

（1）字符串就是一串字符，C 语言中使用 ASCII 编码对字符进行编程，编码后可以用 char 型变量来表示一个字符。字符串就是多个字符打包在一起共同组成的。

（2）字符串在内存中其实就是多个字节连续分布构成的（类似于数组，字符串和字符数组非常像）

（3）C语言中字符串有3个核心要点：

第一是：用一个指针指向字符串头
第二是：固定尾部（字符串总是以’\0’来结尾）
第三是：组成字符串的各字符彼此地址相连

‘\0’ 是一个 ASCII 字符，其实就是编码为 0 的那个字符，要注意区分 ‘\0’ 和 ‘0’ 和0（0等于’\0’ ，'0’等于48）。

（5）’\0’ 作为一个特殊的数字被字符串定义为结尾标志。

产生的副作用就是：字符串中无法包含 ‘\0’ 这个字符。（C语言中不可能存在一个包含 ‘\0’ 字符的字符串），这种思路就叫“魔数”（魔数就是选出来的一个特殊的数字，这个数字表示一个特殊的含义，你的正式内容中不能包含这个魔数作为内容）。

4.3 注意：指向字符串的指针和字符串本身是分开的两个东西

char *p = “linux”;

在这段代码中，p 本质上是一个字符指针，占 4 字节：sizeof （p）== 4

"linux"分配在代码段，占 6 个字节

实际上总共耗费了 10 个字节，这 10 个字节中：4 字节的指针 p 叫做字符串指针（用来指向字符串的，理解为字符串的引子，但是它本身不是字符串），5 字节的用来存 linux 这 5 个字符的内存才是真正的字符串，最后一个用来存 ‘\0’ 的内存是字符串结尾标志（本质上也不属于字符串）。

4.4 存储多个字符的两种方式：字符串和字符数组

有多个连续字符（典型就是linux这个字符串）需要存储，实际上有两种方式：
第一种就是字符串；
第二种是字符数组。

4.5 字符串和字符数组的细节

（1）sizeof 是 C 语言的一个关键字，也是 C 语言的一个运算符（ sizeof 使用时是 sizeof (类型或变量名)，所以很多人误以为 sizeof 是函数，其实不是），sizeof 运算符用来返回一个类型或者是变量所占用的内存字节数。

为什么需要 sizeof ？

第一是：int、double 等原生类型占几个字节和平台有关；

第二是：C 语言中除了 ADT 之外还有 UDT，这些用户自定义类型占几个字节无法一眼看出，所以用 sizeof 运算符来让编译器帮忙计算。

char *p = “linux”;

sizeof§ 得到的永远是4，因为这时候 sizeof 测的是字符指针 p 本身的长度，和字符串的长度是无关的。

（2）strlen 是一个 C 语言库函数，这个库函数的原型是：size_t strlen(const char *s);这个函数接收一个字符串的指针，返回这个字符串的长度（以字节为单位）。注意：strlen返回的字符串长度是不包含字符串结尾的’\0’的。

我们为什么需要 strlen 库函数？

因为从字符串的定义（指针指向头、固定结尾、中间依次相连）可以看出无法直接得到字符串的长度，需要用 strlen 函数来计算得到字符串的长度。

(3)sizeof (数组名)： 得到的永远是数组的元素个数（也就是数组的大小），和数组中有无初始化，初始化多、少等是没有关系的；strlen 是用来计算字符串的长度的，只能传递合法的字符串进去才有意义，如果随便传递一个字符指针，但是这个字符指针并不是字符串是没有意义的。

(4)当我们定义数组时如果没有明确给出数组大小，则必须同时给出初始化式，编译器会根据初始化式去自动计算数组的大小（数组定义时必须给出大小，要么直接给，要么给初始化式）

4.6 字符数组与字符串的本质差异（内存分配角度）

（1）字符数组char a[] = “linux”;

定义了一个数组 a ，数组 a 占 6 字节，右值 “linux” 本身只存在于编译器中，编译器将它用来初始化字符数组 a 后丢弃掉（也就是说内存中是没有"linux"这个字符串的）；这句就相当于是：char a[] = {‘l’, ‘i’, ‘n’, ‘u’, ‘x’, ‘\0’};

（2）字符串 char *p = “linux”;

定义了一个字符指针 p，p 占 4 字节，分配在栈上；同时还定义了一个字符串"linux"，分配在代码段；然后把代码段中的字符串（一共占6字节）的首地址（也就是 ‘l’ 的地址）赋值给 p。

总结对比：字符数组和字符串有本质差别。字符数组本身是数组，数组自身自带内存空间，可以用来存东西（所以数组类似于容器）；而字符串本身是指针，本身永远只占4字节，而且这4个字节还不能用来存有效数据，所以只能把有效数据存到别的地方，然后把地址存在 p 中。

也就是说字符数组自己存那些字符；字符串一定需要额外的内存来存那些字符，字符串本身只存真正的那些字符所在的内存空间的首地址。

5. C语言之结构体概述

C语言中的2种类型：原生类型和自定义类型。结构体类型是一种自定义类型。

5.1 结构体使用时先定义结构体类型再用类型定义变量

（1）结构体定义时需要先定义结构体类型，然后再用类型来定义变量；

（2）也可以在定义结构体类型的同时定义结构体变量。

5.2 从数组到结构体的进步之处

（1）结构体可以认为是从数组发展而来的。其实数组和结构体都算是数据结构的范畴了，数组就是最简单的数据结构、结构体比数组更复杂一些，链表、哈希表之类的比结构体又复杂一些；二叉树、图等又更复杂一些。

（2）数组有2个明显的缺陷：第一个是定义时必须明确给出大小，且这个大小在以后不能再更改；第二个是数组要求所有的元素的类型必须一致。更复杂的数据结构中就致力于解决数组的这两个缺陷。

（3）结构体是用来解决数组的第二个缺陷的，可以将结构体理解为一个其中元素类型可以不相同的数组。结构体完全可以取代数组，只是在数组可用的范围内数组比结构体更简单。

5.3 结构体变量中的元素如何访问？

（1）数组中元素的访问方式：表面上有 2 种方式（数组下标方式和指针方式）；实质上都是指针方式访问。

（2）结构体变量中的元素访问方式：只有一种，用 . 或者 -> 的方式来访问。（ . 和 -> 访问结构体元素其实质是一样的，只是 C 语言规定用结构体变量来访问元素用 . 用结构体变量的指针来访问元素用 -> 。实际上在高级语言中已经不区分了，都用 . ）

（3）结构体的访问方式有点类似于数组下标的方式

思考：结构体变量的点号或者 -> 访问元素的实质是什么？其实本质上还是用指针来访问的。

5.4 结构体的对齐访问1

1、举例说明什么是结构体对齐访问

（1）上节讲过结构体中元素的访问其实本质上还是用指针方式，结合这个元素在整个结构体中的偏移量和这个元素的类型来进行访问的。

（2）但是实际上结构体的元素的偏移量比我们上节讲的还要复杂，因为结构体要考虑元素的对齐访问，所以每个元素时间占的字节数和自己本身的类型所占的字节数不一定完全一样。（譬如 char c实际占字节数可能是 1，也可以是 2，也可能是 3，也可以能 4····）

（3）一般来说，我们用 . 的方式来访问结构体元素时，我们是不用考虑结构体的元素对齐的。因为编译器会帮我们处理这个细节。但是因为 C 语言本身是很底层的语言，而且做嵌入式开发经常需要从内存角度，以指针方式来处理结构体及其中的元素，因此还是需要掌握结构体对齐规则。

2、结构体为何要对齐访问

（1）结构体中元素对齐访问主要原因是为了配合硬件，也就是说硬件本身有物理上的限制，如果对齐排布和访问会提高效率，否则会大大降低效率。

（2）内存本身是一个物理器件（ DDR 内存芯片，SoC 上的 DDR 控制器），本身有一定的局限性：如果内存每次访问时按照 4 字节对齐访问，那么效率是最高的；如果你不对齐访问效率要低很多。

（3）还有很多别的因素和原因，导致我们需要对齐访问。譬如 Cache 的一些缓存特性，还有其他硬件（譬如 MMU、LCD 显示器）的一些内存依赖特性，所以会要求内存对齐访问。

（4）对比对齐访问和不对齐访问：对齐访问牺牲了内存空间，换取了速度性能；而非对齐访问牺牲了访问速度性能，换取了内存空间的完全利用。

3、结构体对齐的规则和运算

（1）编译器本身可以设置内存对齐的规则，有以下的规则需要记住：

第一个：32 位编译器，一般编译器默认对齐方式是 4 字节对齐。

总结：结构体对齐的分析要点和关键：

1、结构体对齐要考虑：结构体整体本身必须安置在 4 字节对齐处，结构体对齐后的大小必须 4 的倍数（编译器设置为 4 字节对齐时，如果编译器设置为 8 字节对齐，则这里的 4 是 8 ）

2、结构体中每个元素本身都必须对其存放，而每个元素本身都有自己的对齐规则。

3、编译器考虑结构体存放时，以满足以上 2 点要求的最少内存需要的排布来算。

4、gcc 支持但不推荐的对齐指令：#pragma pack(n) (n=1/2/4/8)

（1）#pragma 是用来指挥编译器，或者说设置编译器的对齐方式的。编译器的默认对齐方式是 4，但是有时候我不希望对齐方式是 4，而希望是别的（譬如希望 1 字节对齐，也可能 希望是 8 ，甚至可能希望 128 字节对齐）。

（2）常用的设置编译器编译器对齐命令有 2 种：

第一种是 #pragma pack()，这种就是设置编译器 1 字节对齐（有些人喜欢讲：设置编译器不对齐访问，还有些讲：取消编译器对齐访问）；

第二种是 #pragma pack(4)，这个括号中的数字就表示我们希望多少字节对齐。

（3）我们需要 #prgama pack(n) 开头，以 #pragma pack() 结尾，定义一个区间，这个区间内的对齐参数就是n。

（4）#prgma pack 的方式在很多 C 环境下都是支持的，但是 gcc 虽然也可以不过不建议使用。

5、gcc推荐的对齐指令 attribute((packed)) attribute((aligned(n)))

(1) attribute((packed)) 使用时直接放在要进行内存对齐的类型定义的后面，然后它起作用的范围只有加了这个东西的这一个类型。packed 的作用就是取消对齐访问。

(2)attribute((aligned(n))) 使用时直接放在要进行内存对齐的类型定义的后面，然后它起作用的范围只有加了这个东西的这一个类型。它的作用是让整个结构体变量整体进行 n 字节对齐（注意是结构体变量整体 n 字节对齐，而不是结构体内各元素也要 n 字节对齐）

6. offsetof宏 与 container_of宏

6.1 由结构体指针进而访问各元素的原理

通过结构体整体变量来访问其中各个元素，本质上是通过指针方式来访问的，形式上是通过 . 的方式来访问的（这时候其实是编译器帮我们自动计算了偏移量）。

1、offsetof宏：

#define offsetof(TYPE, MEMBER) ((int) &((TYPE *)0)->MEMBER)

// TYPE是结构体类型，MEMBER是结构体中一个元素的元素名

//这个宏返回的是 member 元素相对于整个结构体变量的首地址的偏移量，类型是 int

（1）作用：用宏来计算结构体中某个元素和结构体首地址的偏移量（其实质是通过编译器来帮我们计算）。

（2）原理：我们虚拟一个 type 类型结构体变量，然后用 type.member 的方式来访问那个 member 元素，继而得到 member 相对于整个变量首地址的偏移量。

(3)学习思路：第一步先学会用 offsetof 宏，第二步再去理解这个宏的实现原理。

(TYPE *)0 这是一个强制类型转换，把 0 地址强制类型转换成一个指针，这个指针指向一个 TYPE 类型的结构体变量。（实际上这个结构体变量可能不存在，但是只要我不去解引用这个指针就不会出错）。

((TYPE *)0)->MEMBER(TYPE *)0 是一个 TYPE 类型结构体变量的指针，通过指针指针来访问这个结构体变量的 member 元素

&((TYPE *)0)->MEMBER 等效于&(((TYPE *)0)->MEMBER)，意义就是得到 member 元素的地址。是因为整个结构体变量的首地址是0。

2、container_of宏：

#define container_of(ptr, type, member) ({\

const typeof(((type *)0)->member) * __mptr = (ptr);\

(type *)((char *)__mptr - offsetof(type, member)); })

// ptr是指向结构体元素 member 的指针，type 是结构体类型，member 是结构体中一个元素的元素名

//这个宏返回的就是指向整个结构体变量的指针，类型是(type *)

（1）作用：知道一个结构体中某个元素的指针，反推这个结构体变量的指针。有了 container_of 宏，我们可以从一个元素的指针得到整个结构体变量的指针，继而得到结构体中其他元素的指针。

（2）typeof 关键字的作用是：typepef(a) 时由变量 a 得到 a 的类型，typeof 就是由变量名得到变量数据类型的。

（3）这个宏的工作原理：

第一步：const typeof(((type *)0)->member) * __mptr = (ptr)

先用 typeof 得到 member 元素的类型定义成一个指针。

第二步：(type *)((char *)__mptr - offsetof(type, member))

用这个指针减去该元素相对于整个结构体变量的偏移量（偏移量用 offsetof 宏得到的），减去之后得到的就是整个结构体变量的首地址了，再把这个地址强制类型转换为 type * 即可。

7. 共用体union

7.1 共用体类型的定义、变量定义和使用

（1）共用体 union 和结构体 struct 在类型定义、变量定义、使用方法上很相似。

（2）共用体和结构体的不同：结构体类似于一个包裹，结构体中的成员彼此是独立存在的，分布在内存的不同单元中，他们只是被打包成一个整体叫做结构体而已；共用体中的各个成员其实是一体的，彼此不独立，他们使用同一个内存单元。可以理解为：有时候是这个元素，有时候是那个元素。更准确的说法是同一个内存空间有多种解释方式。

（3）共用体 union 就是对同一块内存中存储的二进制的不同的理解方式。

（4）在有些书中把 union 翻译成联合（联合体），这个名字不好。现在翻译成共用体比较合适。

（5）union 的 sizeof 测到的大小实际是 union 中各个元素里面占用内存最大的那个元素的大小。因为可以存的下这个就一定能够存的下其他的元素。

（6）union 中的元素不存在内存对齐的问题，因为 union 中实际只有 1 个内存空间，都是从同一个地址开始的（开始地址就是整个 union 占有的内存空间的首地址），所以不涉及内存对齐。

7.2 共用体和结构体的相同和不同

（1）相同点就是操作语法几乎相同。

（2）不同点是本质上的不同。struct 是多个独立元素（内存空间）打包在一起；union 是一个元素（内存空间）的多种不同解析方式。

7.3 共用体的主要用途

（1）共用体就用在那种对同一个内存单元进行多种不同规则解析的这种情况下。

（2）C 语言中其实是可以没有共用体的，用指针和强制类型转换可以替代共用体完成同样的功能，但是共用体的方式更简单、更便捷、更好理解。

8. 大小端模式1

8.1 什么是大小端模式

（1）大端模式（big endian）和小端模式（little endian）。最早是小说中出现的词，和计算机本来没关系的。

（2）后来计算机通信发展起来后，遇到一个问题就是：在串口等串行通信中，一次只能发送 1 个字节。这时候我要发送一个 int 类型的数就遇到一个问题。int 类型有 4 个字节，我是按照：byte0 byte1 byte2 byte3 这样的顺序发送，还是按照 byte3 byte2 byte1 byte0 这样的顺序发送。规则就是发送方和接收方必须按照同样的字节顺序来通信，否则就会出现错误。这就叫通信系统中的大小端模式。这是大小端这个词和计算机挂钩的最早问题。

（3）现在我们讲的这个大小端模式，更多是指计算机存储系统的大小端。在计算机内存/硬盘/Nnad中。因为存储系统是 32 位的，但是数据仍然是按照字节为单位的。于是乎一个 32 位的二进制在内存中存储时有 2 种分布方式：高字节对应高地址（小端模式）、高字节对应低地址（大端模式）

（4）大端模式和小端模式本身没有对错，没有优劣，理论上按照大端或小端都可以，但是要求必须存储时和读取时按照同样的大小端模式来进行，否则会出错。

（5）现实的情况就是：有些 CPU 公司用大端（譬如 C51 单片机）；有些 CPU用小端（譬如 ARM ）。（大部分是用小端模式，大端模式的不算多）。于是乎我们写代码时，当不知道当前环境是用大端模式还是小端模式时就需要用代码来检测当前系统的大小端。

判断大小端：

#include <stdio.h>
#include <stdlib.h>

union un_test
{
    int x;
    char y;
};

int Is_LittleOrEndian(void)
{
    union un_test u;

    u.x = 0x1234;
	printf("addr is 0x%x\r\n",&(u.x));
    return u.y;
}

int main(void)
{
    int ret;

    ret = Is_LittleOrEndian();

    if(ret == 0x34)
    {
        printf("mode is little\n");
    }
    else
    {
        printf("mode is  endian\n");
    }

    return 0;
}

9. 大小端模式2

9.1 看似可行实则不行的测试大小端方式：位与、移位、强制类型转化

（1）位与运算。

结论：位与的方式无法测试机器的大小端模式。（表现就是大端机器和小端机器的 & 运算后的值相同的）

理论分析：位与运算是编译器提供的运算，这个运算是高于内存层次的（或者说 & 运算在二进制层次具有可移植性，也就是说 & 的时候一定是高字节 & 高字节，低字节 & 低字节，和二进制存储无关）。

（2）移位

结论：移位的方式也不能测试机器大小端。

理论分析：原因和 & 运算符不能测试一样，因为 C语 言对运算符的级别是高于二进制层次的。右移运算永远是将低字节移除，而和二进制存储时这个低字节在高位还是低位无关的。

（3）强制类型转换

同上

9.2 通信系统中的大小端（数组的大小端）

（1）譬如要通过串口发送一个0x12345678给接收方，但是因为串口本身限制，只能以字节为单位来发送，所以需要发4次；接收方分4次接收，内容分别是：0x12、0x34、0x56、0x78.接收方接收到这4个字节之后需要去重组得到0x12345678（而不是得到0x78563412）.

（2）所以在通信双方需要有一个默契，就是：先发/先接的是高位还是低位？这就是通信中的大小端问题。

（3）实际操作中，在通信协议里面会去定义大小端，明确告诉你先发的是低字节还是高字节。

（4）在通信协议中，大小端是非常重要的，大家使用别人定义的通信协议还是自己要去定义通信协议，一定都要注意标明通信协议中大小端的问题。

10. 枚举

10.1 枚举是用来干嘛的？

（1）枚举在 C 语言中其实是一些符号常量集。直白点说：枚举定义了一些符号，这些符号的本质就是 int 类型的常量，每个符号和一个常量绑定。这个符号就表示一个自定义的一个识别码，编译器对枚举的认知就是符号常量所绑定的那个 int 类型的数字。

（2）枚举中的枚举值都是常量

（3）枚举符号常量和其对应的常量数字相对来说，数字不重要，符号才重要。符号对应的数字只要彼此不相同即可，没有别的要求。所以一般情况下我们都不明确指定这个符号所对应的数字，而让编译器自动分配。（编译器自动分配的原则是：从 0 开始依次增加。如果用户自己定义了一个值，则从那个值开始往后依次增加）

10.2 C 语言为何需要枚举

（1）C 语言没有枚举是可以的。使用枚举其实就是对 1、0 这些数字进行符号化编码，这样的好处就是编程时可以不用看数字而直接看符号。符号的意义是显然的，一眼可以看出。而数字所代表的含义除非看文档或者注释。

（3）宏定义的目的和意义是：不用数字而用符号。从这里可以看出：宏定义和枚举有内在联系。宏定义和枚举经常用来解决类似的问题，他们俩基本相当可以互换，但是有一些细微差别。

10.3 宏定义和枚举的区别

（1）枚举是将多个有关联的符号封装在一个枚举中，而宏定义是完全散的。也就是说枚举其实是多选一。

（2）什么情况下用枚举？当我们要定义的常量是一个有限集合时（譬如一星期有7天，譬如一个月有31天，譬如一年有12个月····），最适合用枚举。（其实宏定义也行，但是枚举更好）

（3）不能用枚举的情况下（定义的常量符号之间无关联，或者无限的）用宏定义。

总结：宏定义先出现，用来解决符号常量的问题；后来人们发现有时候定义的符号常量彼此之间有关联（多选一的关系），用宏定义来做虽然可以但是不贴切，于是乎发明了枚举来解决这种情况。

---

参考：

1.嵌入式linux之高级c语言专题—数组&字符串&结构体&共用体&枚举