1.程序中内存从哪里来

1.1、程序执行需要内存支持

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

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

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

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

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

1.4、栈的详解

（1）运行时自动分配&自动回收：栈是自动管理的，程序员不需要手工干预、方便简单。
（2）反复使用：栈内存在程序中其实就是那一块空间，程序反复使用这一块空间。
（3）脏内存：栈内存由于反复使用，每次使用后程序不会去清理，因此分配到时保留原来的值，所以说是随机的。
（4）临时性：函数不能返回栈变量的指针，因为这个空间是临时的。
（5）栈会溢出：因为操作系统实现给定了栈的大小，如果在函数中无穷无尽的分配栈内存总能用完。

1.5、堆内存详解

（1）操作系统堆管理器管理：堆管理是操作系统的一个模块，堆管理分配灵活，按需分配。
（2）大块内存：堆内存管理着总量很大的操作系统内存块，各进程可以按需申请使用，使用完释放。
（3）程序手动申请&释放：手动的意思是需要写代码去申请malloc贺师傅free。
（4）脏内存：堆内存也是反复使用的，而且使用者用完释放前不会清除，因此也是脏的。
（5）临时性：堆内存只在malloc和free之间属于我这个进程，而可以访问。在malloc之前和free之后都不能再访问，否则会有错误。

1.6、堆内存范例

int main(void)
{
    // 需要一个1000个int类型元素的数组，申请与绑定
    int *p = (int *)malloc(1000*sizeof(int));
    if (NULL == p)
    {
        printf("malloc error.\n");
        return -1;      
    }
    return 0;
}

（1）void *是个指针类型，malloc返回的是一个void *类型的指针，实质上malloc返回的是堆管理器分配给我本次申请的那段内存空间的首地址（malloc返回的值其实是个数字，这个数字表示一个内存的地址）。为什么要用void *作为类型呢？
主要原因是malloc帮我们分配内存时只是分配了内存空间，至于这段内存空间将来用来存储什么类型的元素malloc是不关心的，由我们程序自己来决定。
（2）什么是void类型？早起被翻译成空型，这个翻译非常不好，会误导人。void类型不表示没有类型，而表示任意类型。void的意思就是说这个数据的类型当前是不确定的，在需要的时候可以再去指定它的具体类型，如(int *)malloc(1000*sizeof(int));，void *类型是一个指针类型，这个指针本身占4字节，但是指针指向的类型是不确定的，换句话说，这个指针在需要的时候可以被强制转化成其他任何一种确定类型的指针，也就是说这个指针可以指向任何类型的元素。
（3）malloc的返回值：成功申请空间后返回这个内存空间的指针，申请失败后返回的是NULL。所以malloc获取的内存指针使用前一定要先检查是否为NULL。
（4）malloc申请的内存用完后要释放，free(q);会告诉堆管理器这段内存我用完了你可以回收了。堆管理器回收了这段内存后这段内存当前进程就不应该再使用了。（虽然还能使用，但随时被堆管理器分配给别的进程）因为释放后堆管理器就可能把这段内存再次分配给其他进程，所以你就不能再使用了。
（5）在调用free归还这段内存之前，指向这段内存的指针p一定不能丢（也就是不能给p另外赋值），因为p一旦丢失这段malloc来的内存就再也找不回了（内存泄露），直到当前程序结束时操作系统才会回收这段内存。

1.7、malloc的一些细节

（1）malloc(4)
gcc中的malloc默认最小是以16B为分配单位的，如果malloc小于16B的大小时都会返回一个16字节大小的内存。malloc实现时没有实现任意自己的分配而是允许一些大小的块内存的分配。
（2）malloc(20)
去访问超限的第25、250、2000会怎样？
实验后：120字节处正确，1200字节处正确，终于继续往后访问总有一个数字处开始发生段错误，超出了堆内存区。

1.8、代码段、数据段、bss段

（1）编译器在编译程序的时候，将程序中的所有元素分成了一些组成部分，各部分构成一个段，所以说段是可执行程序的组成部分。
（2）代码段：代码段就是程序中的可执行部分，直观理解代码段就是函数堆叠组成的。
（3）数据段（也称为数据区、静态数据区、静态区）：数据段就是程序中的数据，直观理解就是C语言程序中的全局变量。（注意：全局变量才算是程序的数据，局部变量不算程序的数据，只能算是函数的数据）。
（4）bss段（又叫ZI，zero initial段）：bss段的特点就是初始化为0，bss段本质上也属于数据段，bss段就是初始化为0的数据段。
（5）注意区分：
数据段（.data）和bss段的区别和联系：
二者本来没有任何区别，都是用来存放C语言程序中的全局变量的。区别在于把显式初始化为非零的全局变量存在.data段中，而把显示初始化为0或者未显示初始化的全局变量存在bss段。（C语言规定，未显式初始化的全局变量值默认为0）

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

（1）C语言中使用const char *p = "Linux";，定义字符串时，字符串"Linux"实际被分配在代码段，也就是说这个"Linux"字符串实际上是一个常量字符串而不是变量字符串。
（2）const型常量：C语言中const关键字用来定义常量，常量就是不能被改变的量。const的实现方法至少有2种：第一种，就是编译将const修饰的变量放在代码段去以实现不能修改（普遍见于各种单片机的编译器）；第二种，就是由编译器来检查以确保const型的常量不会被修改，实际上const型的常量还是和普通变量一样放在数据段的（gcc中就是这样实现的）。

1.10、显式初始化为非零的全局变量和静态局部变量放在数据段

放在.data段的变量有两种:
第一种，是显式初始化为非零的全局变量；
第二种，是静态局部变量，也就是static修饰的局部变量。
普通局部变量分配在栈上，静态局部变量分配在.data段上。

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

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

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

（1）相同点：三种获取内存的方法，都可以给程序提供可用内存，都可以来定义变量给程序用。
（2）不同点：①栈内存对应C中的普通局部变量（别的变量还用不了栈，而且栈是自动的，由编译器和运行时环境共同提供服务，程序员五福手动控制）；②堆内存完全是独立于我们的程序存在和管理的，程序需要内存时可以去手动申请malloc，使用完成后必须尽快free释放（堆内存对程序就好像图书馆对人）。③数据段对应用程序来说对应C程序中的全局变量和静态局部变量。
（3）①函数内部临时使用，除了函数不会用到，就定义局部变量；
②堆内存和数据段几乎拥有完全相同的属性，大部分时候是可以完全替换的，但是生命周期不一，堆内存的生命周期是从malloc开始到free结束，而全局变量是从整个程序一开始执行就开始，直到整个程序才会消灭，伴随程序运行的一生。
③启示：如果你这个变量只是在程序的一个阶段有用，用完就不用了，就适合用堆内存；如果这个变量本身和程序 的一生相伴的，那就适合用全局变量。（堆内存就好像图书馆借书，数据段就好像自己书店买书，堆内存的使用比全局变量广泛）。

2.C语言的字符串类型

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

（1）很多高级语言像JAVA、C#等就有字符串类型，有个String来表示字符串，用法和int这些很像，可以String s1 = "Linux";来定义字符串类型的变量。
（2）C语言没String类型，C语言中的字符串是通过字符指针来间接实现的。

2.2、C语言使用指针来管理字符串

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

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

（1）字符串就是一串字符。字符反映在现实中就是文字、符号、数字等，人用来表达的字符，反映在编程中就是字符类型的变量。C语言中使用ASCII编码对字符进行编程，编码后可以用char型变量来表示一个字符。字符串就是多个字符打包在一起共同组成的。
（2）字符串在内存中其实就是多个字节连续分布构成的（类似于数组、字符串和字符数组）。
（3）C语言中字符串有3个核心要素：第一是用一个指针指向字符串头；第二是固定尾部（字符串总是以'\0'来结尾的）；第三是组成字符串的各字符彼此地址相连。
（4）'\0'是一个ASCII字符，其实就是编码为0的那个字符（真正的0，和数字0是不同的，数字0有它自己的ASCII编码）。要注意区分'\0'、'0'和0（0就是'\0','0'就是48）。
（5）'\0'作为一个特殊的数字被字符串定义为结束标志。产生的副作用就是：字符串中无法包含'\0'这个字符。（C语言中不可能包含存在一个'\0'字符的字符串），这个思路就叫“魔数”。（魔数就是选出来的一个特殊的数字，这个数字表示一个特殊的含义，你的正式内容中不能包含这个魔数）。

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

char *p = "Linux";在这段代码中，p本身是一个字符指针，''Linux"分配在代码段，占6个字节，实际上总共耗费了10个字节，这10个字节中：4字节的指针p叫做字符指针（用来指向字符串的，理解为字符串的引子，但是它本身不是字符串），5字节的用来存Linux这5个字符的内存才是真正的字符串，最后一个用来存'\0'的内存是字符串结尾标志。

2.5、存储多个字符的2种方式：字符串和字符数组

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

3.字符串和字符数组的细节

3.1、字符数组初始化与sizeof、strlen

（1）sizeof是C语言的一个关键字，也是C语言的一个运算符（sizeof使用时是sizeof(类型或对象名)，所以很多人误以为sizeof是函数，其实不是），sizeof运算符用来返回一个类型或者是变量所占用的内存字节数。
为什么需要用sizeof？
主要原因是：①int、double等原生类型占几个字节和平台有关；②C语言中除了ADT外还有UDT，这些用户自定义类型占几个字节无法一眼看出，所以用sizeof运算符来让编译器帮忙计算。
（2）strlen是一个C语言库函数，这个库函数的原型是：size_t strlen(const char *s)，这个函数接收一个字符串的指针，返回这个字符串的长度（以字节为单位）。注意一点是：strlen返回的字符串长度是不包含字符串结尾的'\0'的。
为什么需要strlen库函数？
因为从字符串的定义（指针指向头、固定结尾、中间依次相连）可以看出无法直接得到字符串的长度，需要用strlen函数来计算得到字符串的长度。
（3）sizeof(数组名)得到的永远是数组的元素个数的内存大小（也就是数组的大小），和数组中有无初始化，初始化多或少等都是没有关系的；strlen是用来计算字符串的长度的，只能传递合法的字符串进去才有意义，如果随便传递一个字符指针，但是这个字符指针并不是指向字符串的，这样是没有意义的。
（4）当我们定义数组时如果没有明确给出数组的大小，则必须同时给出初始化，编译器会根据初始化去自动计算数组的大小（数组定义时要么给出大小，要么直接给全部元素，要么给初始化式）。

3.2、字符串初始化与sizeof、strlen

（1）char * p = "Linux"; sizeof(p);得到的永远是4，因为这时候测的是字符指针p本身的长度，和字符串的长度是无关的。
（2）strlen是转么解决计算字符串的长度的问题的，解决了上一步的问题。

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

（1）字符数组char a[] = "Linux";来说，定义了一个数组a，数组a占6字节，右值"Linux"本身存储在.data数据段，"Linux"只是代表一个地址，编译器将这个地址从.data数据段取出"Linux"字符串，然后初始化字符数组a后丢掉，这句就相当于char a[] = {'L', 'i', 'n', 'u', 'x', '\0' };
（2）字符串char *p = "Linux";定义了一个字符指针p，p占4字节，分配在栈上，同时还定义了一个字符串"Linux"，分配在代码段，然后把代码中的字符串（一共占6字节）的首地址（也就是'L'的地址）赋值给p。
总结对比：字符数组和字符串有本质区别
①字符数组本身是数组，数组自身带内存空间，可以用来存东西（所以数组类似于容器）；
②字符串本身是指针，本身永远只占4字节，而且这4字节还不能用来存有效数据，所以只能把有效数据存到别的地方，然后把地址存在p中。
③字符数组自己存那些字符；字符串一定需要额外的内存来存储那些字符，字符串本身只存真正的那些字符所在的内存空间的首地址。

char b[5];
int main(void)
{
    // 字符串存在栈上
    char a[7];
    char *p = a;
    // 字符串存在数据段
    char *p = b;
    // 字符串存在堆空间
    char *p = (char *)malloc(5);  
}

4.C语言结构体概述

4.1、结构体类型也是一种自定义类型

（1）C语言中的2种类型：原生类型和自定义类型；
（2）结构体使用时先定义结构体再用类型定义变量；
（3）结构体可以认为是数组发展而来的。其实数组和结构体都算是数据结构的范畴了，数组就是最简单的数据结构、结构体比数组更复杂一些，然后是链表、哈希表、二叉树、图等。

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

（1）数组中元素的访问方式：表面上2种方式（数组下标方式和指针方式）；实质上都是指针方式访问。
（2）结构体变量中的元素访问方式：只有一种，用.或者->方式来访问。用结构体变量来访问元素用点.，用结构体变量的指针方式来访问元素用->。（高级语言中都用点.）

5.结构体的对齐访问

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

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

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

（1）结构体中元素对齐访问主要原因是为了配合硬件，对齐排布和访问会提高效率，否则会大大降低效率。（空间换时间的例子无处不在）
（2）内存本身就是一个物理器件（DDR内存芯片，Soc上的DDR控制器，本身有一定的局限性）；如果内存每次访问时按照4字节对齐访问，那么效率是最高的；如果不对齐访问效率要低的很多。
（3）还有很多别的因素和原因，导致我们需要对齐访问。比如cache的一些缓存特性，还有其他硬件（比如MMU、LCD显示器）的一些内存依赖特性，所以会要求内存对齐访问。

5.3、结构退对齐的规则和运算

（1）编译器本身可以设置内存对齐的规则，需要记住：32位编译器，一般编译器默认对齐方式是4字节。
（2）总结：结构体对齐的分析要点和关键
①结构体对齐要考虑：结构体整体本身必须安置在4字节处，结构体对齐后的大小必须是4的倍数（编译器设置为4字节对齐时，如果编译器设置为8字节对齐，则这里的4就变成8）。
②结构体中每个元素本身都必须对其存放，而每个元素都有自己的对齐规则。
③编译器考虑结构体存放时，满足以上2点要求的最少内存需要的排布来算。

5.4、gcc支持但不推荐的对齐指令：#pragma pack()

（1）#pragma是用来指挥编译器，或者说设置编译器的对齐方式的。编译器的默认对齐方式是4，但是有时候我们并不希望对齐方式是4，而希望是别的（比如希望1字节对齐，而可能是8，甚至可能是128字节对齐）。
（2）常用的设置编译器对齐命令有2中：
①第一种，#pragma pack()，这种就是设置编译器1字节对齐（有些人喜欢讲：设置编译器不对齐访问，还有些讲：取消编译器对齐访问）；
②第二种，#pragma pack(4)，这个括号的数组就表示我们希望多少字节对齐。

#pragma pack(128)
    // 结构体定义
#pragma pack()

（3）我们需要#pragma pack(n)开头，以#pragma pack()结尾，定义一个区间，这个区间的对齐参数就是n。
（4）#pragma pack的方式在很多C语言环境下都支持，但gcc虽然也可以但不建议使用。

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

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

struct mystruct11
{
    int a;
    char b;
    short c;
}__attribute__((packed));

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

typedef struct mystruct11
{
    int a;
    char b;
    short c;
}__attribute__((aligned(1024)))  My11;

6.offsetof宏与container_of宏

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

通过结构体整体变量来访问其中各个元素，本质上是通过指针方式来访问的，形式上市通过点.的方式访问的。

6.2、offsetof宏（本人还未完全理解）

（1）offsetof宏的作用：用宏来计算结构体中某个元素和结构体首地址的偏移量（其实质是通过编译器来帮我们计算的）。
（2）offsetof宏的原理：我们虚拟一个type类型结构变量，然后用type.member的方式来访问哪个member元素，继而得到member相对于整个变量首地址的便宜了了。
（3）学习思路：第一步先学会用offsetof宏，第二步再去理解这个宏的原理。

struct mystruct
{
    char a;
    int b;
    short c;
};
#define offsetof(TYPE.MEMBER)((size_t)&((TYPE *)0)->MEMBER)

int main(void)
{
    int offsetof a = offsetof(struct mystruct, a);
    printf("offsetof a = %d.\n", offsetof a);;
}

(TYPE *)
这是一个强制类型转换，把0地址强制类型转换成一个指针，这个指针指向一个TYPE类型的结构体变量。（实际上这个结构体变量可能不存在，只要不去解引用就不会有错）
((TYPE *)0)->MEMBER
(TYPE *)0是一个TYPE类型结构体变量的指针，通过指针来访问这个结构体变量MEMBER元素
&((TYPE *)0)->MEMBER
意义就是得到MEMBER元素的地址。但是因为整个结构体变量的首地址是0。

6.3、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 *）。

short *p = &(s1.c);
struct mystruct *pS = NULL;
pS = container_of(p, struct mystruct, c)
//通过p来计算得到s1的指针   

（1）作用：知道一个结构体中某个元素的指针，反推这个结构体变量的指针。有了container_of宏，我们可以从一个元素的指针得到整个结构体变量的指针，继而得到结构体中其他元素的指针。
（2）typeof关键字的作用是：typeof(a)时由变量a得到变量a的类型，typeof就是由变量名得到变量数据类型的。
（3）这个宏的工作原理：先用typeof得到member元素的类型，然后定义一个指针，然后用这个指针减去该元素相对于整个结构体变量的偏移量（偏移量用offsetof宏得到），减去之后得到的就是整个结构体变量的首地址，再把这个地址强制类型转换成type *类型即可。

6.4、学习指南和要求

（1）最基本的要求：必须要会这两个宏的使用。就是说能知道这两个宏接收什么参数，返回什么参数，会用这两个宏写代码。看见别人代码用这两个宏能够理解。
（2）进一步要求：能理解这两个宏的工作原理，能表述出来（面试可能会考到）。

7.共用体union

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

（1）共用体union和结构体struct在类型定义、变量定义、使用方法上有些相似。
（2）共用体和结构体的不同：结构体类似于一个包裹，结构体中的成员彼此是独立存在的额，分布在内存的不同单元中，他们只是被打包成一个整体叫做结构体而已；共用体中的各成员其实是一体的，彼此不独立，他们使用同一个内存单元。同一个内存空间有多种解释方式。
（3）共用体union就是对同一块内存中存储的二进制的不同的理解方式。
（4）union的sizeof测到的大小实际上是union中各个元素里面占用内存最大的那个元素的大小。因为可以存的下这个就一定能够存的下其他的元素。
（5）union中的元素不存在内存对齐的问题。

7.2、共用体和结构体相同点和不同点

（1）相同点就是操作语法几乎相同。
（2）不同点是本质上的不同，struct是多个独立元素（内存空间）打包在一起，union是一个元素（内存空间）的多种不同解析方式。

7.3、共用体的主要用途

（1）共用体就用在那种对同一个内存单元进行多种不同规则解析的这种情况下。
（2）C语言中其实是可以没有共用体的，用指针和强制类型转换可以替代共用体完成同样的功能，但是共用体的方式更好理解。

8.大小端模式

8.1、什么是大小端模式

（1）大小端模式（big endian）和小端模式（little endian）最早是小说中出现的词，和计算机本来没有关系的。
（2）后来计算机通信发展起来后，遇到一个问题就是：在串口等串行通信中，一次只能发送一个字节。这时候我要发送一个int类型的数就遇到一个问题。int类型有4个字节，我是按照：byte0 byte1 byte2 byte3 这样的顺序发送还是反序发送。规则就是发送方和接收方必须按照同样的规则来通信，否则就会出现错误。这就叫通信系统的大小端模式。
（3）现在讲大小端，更多的是指计算机存储系统的大小端。在计算机内存/硬盘/Nnad中。因为存储系统是32位的，但是数据仍然是按照字节为单位的。于是乎一个32位的二进制在内存中存储时有2种分布方式：
①大端模式：高字节对应高字节；
②小端模式：高字节对应低字节。
（4）大端模式和小端模式本身没有对错，没有优劣，理论上按照大端或小端都可以，但是要求必须存储时和读取时按照同样的大小端模式来进行，否则会出错。
（5）现实的情况是：有些CPU公司用大端（比如单片机）；有些CPU用小端（比如ARM）。（大部分是用小端模式，大端模式的不算多）。于是乎我们写代码时，当不知道当前环境是用大端模式还是小端模式时就需要用代码来检测当前系统的大小端。

8.2、共用体union测试大小端

经典笔试题：写一段代码测试大小端

#include <stdio.h>
union myunion
{
    int a;
    char b;
};
// 如果是小端模式则返回1，大端模式则返回0
int  is_little_endian(void)
{
    union myunion u1;
    u1.a = 1;
    return u1.b;
}

int main(void)
{
    int i = is_little_endian();
    if (i == 1)
    {
        printf("小端模式.\n");
    }
    else
    {
        printf("大端模式.\n");
    }
    return 0;
}

大小端

共用体测试大小端的思路:
一开始用int类型的a来存储1（00000001），然后用char类型的b来解析这个1（00000001），因为访问是从低地址开始访问的，所以要么访问到00，要么访问到01。01对于00000001来说属于低字节，若这个01保存在低地址的话，就是小端模式，若这个01保存在高地址的话，就是大端模式。

8.3、指针方式测试大小端（本质方式）

#include <stdio.h>
union myunion
{
    int  a;
    char b;
};

int  is_little_endian(void)
{
    int a = 1;
    char b = *((char *)(&a));  
    // 将a的地址强制类型转换为char解析方式，然后去解引用得到首地址的内容
     return b;
}

int main(void)
{
    int i = is_little_endian();
     if (i == 1)
    {
        printf("小端模式.\n");
    }
    else
    {
        printf("大端模式.\n");
    }
    return 0;
}

解析同上一节

8.4、看似可行失责不可行的测试大小端方式：位与、移位、强制类型转换

（1）位与运算

#include <stdio.h>

int main(void)
{
    // 位与
    int a = 1;
    int b = a & 0xff;  
    printf("b = %d.\n",b);
    return 0;
}

实验结论：位与的方式无法测试机器的大小端模式。表现就是大端机器和小端机器的位与运算后的值是相同的，都是1。
结果分析：位与运算是编译器提供的运算，这个运算是高于内存层次的（或者说&运算在二进制层次具有可移植性，也就是说&的时候一定是高字节&高字节，低字节&低字节，和二进制存储无关），简单的说，位与运算（&）在C语言编译器已经做了优化处理。
理想模型分析：实际不可行
①大端模式：低字节放到了高地址，位与操作结果为0x10000000

大端模式

小端模式

#include <stdio.h>

int main(void)
{
    // 移位
    int a, b;
    a = 1;
    b = a >> 1;
    printf("b = %d.\n",b);
    return 0;
}

实验结论：移位的方式也不能测试机器的大小端模式。表现就是大端机器和小端机器的位与运算后的值是相同的，都是0。
结果分析：
原因和位与运算&不能测试是一样的。因为C语言对运算符的级别是高于二进制层次的。右移运算永远是低字节移除，而和二进制存储时这个低字节在高位还是低位无关。
理想模型分析：实际不可行
①大端模式：低字节放到低地址，移位操作结果为0x800000

大端模式

小端模式

#include <stdio.h>

int main(void)
{
    // 强制类型转换
    int a;
    char b;
    a = 1;
    b = (char)a;
    printf("b = %d.\n",b);
    return 0;
}

实验结论：强制类型转换的方式也不能测试机器的大小端模式。表现就是大端机器和小端机器的位与运算后的值是相同的，都是1。
结果分析：强制类型转换不可以的原因同上，也是编译器进行了优化处理。
理想模型分析：实际不可行
①大端模式：低字节放到高地址，强制类型转换操作结果为0

大端模式

小端模式

8.5、通信系统的大小端（数组的大小端）

（1）比如要通过串口发送一个0x12345678给接收方，但是因为串口本身限制，只能以字节单位来发送，所以需要发4次；接收方分4次接收，内容分别是：0x12、0x34、0x56、0x78。接收方接收到这4个字节之后需要去重组得到0x12345678（而不是0x78563412）。
（2）所以通信双方需要有一个默契，就是：先发/接收的是高位还是低位？这就是通信中的大小端问题。
（3）一般来说：先发低字节叫做小端；先发高字节叫做大端。实际操作中，在通信协议里面回去定义大小端，明确告诉你先发的是低字节还是高字节。
（4）在通信协议中，大小端是非常重要的，大家使用别人的定义的通信协议还是自己要去定义通信协议，一定都要注意标明通信协议中的大小端问题。

9.枚举

9.1枚举是用来做什么的？

（1）枚举在C语言中其实是一些符号常量集。枚举定义了一些符号，这些符号的本质就是int类型的常量，每个符号和一个常量绑定。这个符号就表示一个定义的一个识别码，编译器对枚举的认识就是符号常量所绑定的那个int类型的数字。
（2）枚举符号常量和其对应的常量数字相对来说，数字不重要，符号才重要。一般情况下我们都不明确指定这个符号所对应的数字，而让编译器自动分配。自动分配原则是：从0开始依次增加，如果用户自定义了一个值，则从那个值开始往后依次增加1。

9.2、C语言为何需要枚举

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

9.3、宏定义和枚举的区别

（1）枚举：是将多个有关联的符号封装在一个枚举中，而宏定义完全是散的。也就是说枚举其实是多选一。
（2）什么情况下用枚举？当我们要定义的常量是一个有限集合时（比如一星期7天，性别男女）。