五、数组&字符串&结构体&共用体&枚举

时间 2019-11-09

标签数组字符串结构共用枚举繁體版

原文原文链接

程序中内存从哪里来

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

栈（stack）

运行自动分配、自动回收，不须要程序员手工干预；
栈内存能够反复使用；
栈反复使用后，程序不会清理栈，所以，栈是脏的，使用时可能分配到原来保留的值；
函数不能返回栈变量的指针，由于这个空间是临时的；
栈会溢出，若是在函数中无穷的分配内存；

堆（heap）

堆管理器是操做系统的一个模块，堆管理内存分配灵活，按需分配；
堆管理器管理着很大的操做系统内存块，各个进程按需申请使用，用完释放；
堆内存须要使用malloc申请，free释放；
堆内存是反复使用的，使用者用完释放前不会清楚，所以是脏的；
堆内存只在malloc和free之间使用，在这段时间外，不能再访问，不然可能出现不可预料的后果；

堆的使用：

void * 是一个指针类型，malloc返回的是一个void * 类型的指针，实质上malloc返回的死堆管理器分配的那段内存空间的首地址（malloc返回的值实际上是一个数字，这个数字表示一个内存额地址）；
malloc帮咱们分配内存时只分配了内存空间，至于这个空间用来存储什么类型的元素，由程序员本身决定；
void类型，表示万能类型。void的意思是这个数据的类型当前是不肯定的，在须要的时候能够强制转换成任意类型，void *是一个指着类型，这个指针自己占4个字节，指向的元素的类型是不肯定的，也能够说这个指针指向任何类型的元素；
使用malloc申请一片内存后，须要判断　if(NULL == *p) ，申请失败时返回NULL，因此在使用前要检查是否为NULL；
malloc申请的内存使用完后，要使用free(*p)释放内存，在使用free释放内存以前，指向这个内存的指针p必定不能丢（也就是不能给p另外赋值）。由于p一旦丢失，这段malloc申请的内存就永远丢失了（内存泄露)，直到当前程序结束时，操做系统才会回收这段内存。

malloc的一些细节：

malloc(0):若是真的malloc(0)返回的是NULL仍是一个有效指针？答案是：实际分配了16Byte的一段内存而且返回了这段内存的地址。这个答案不是肯定的，由于C语言并无明确规定malloc(0)时的表现，由各malloc函数库的实现者来定义。
malloc(4):gcc中的malloc默认最小是以16B为分配单位的。若是malloc小于16B的大小时都会返回一个16字节的大小的内存。malloc实现时没有实现任意字节的分配而是容许一些大小的块内存的分配。

malloc(20)去访问第2五、第250、第2500····会怎么样？实战中：120字节处正确，1200字节处正确····终于继续日后访问总有一个数字处开始段错误了。

代码段、数据段、bss段

代码段：代码段是程序中的可执行部分，直观理解就是由函数堆叠组成的；
数据段：数据段就是程序中的数据，直观理解就是C语言程序中的全局变量。（全局变量才算是程序的数据，局部变量不算是程序的数据，只能算是函数的数据）；
bss段：（又叫ZI（zero initial）段），bss段的数据的特色就是初始化为0，bss段本质上属于数据段，bss段就是被初始化为0的数据段。

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

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

在代码段中，也有可能包含一些只读的常熟变量，例如字符串常量等，程序段为程序代码在内存中的映射，一个程序能够在内存中有多个副本。C语言中使用 char *p = "linux";定义字符串时，字符串"linux"存放在代码段（有时候放在只读数据段：.ro.data，取决于平台）；也就是说，"linux"字符串其实是一个常量字符，而不是变量字符串，所以，不能使用指针p去改变它；
const型常量：C语言中const关键字用来定义常量，常量就是不能被改变的量。const用法有两种：

第一种：编译器const修饰变量放在普通代码段去，使其不能修改（各类单片机编译器);
第二种：由编译器来检查以确保const型的常量不会被修改，实际上const型的常量仍是和普通变量同样，放在数据段（gcc中是这样实现的）；

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

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

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

bss段和.data段并无本质区别，几乎能够不用明确去区分这两种。

总结:

相同点：三种获取内存的方法，均可以给程序提供可用内存，均可以用来定义变量给程序用。
不一样点：栈内存对应C中的普通局部变量（别的变量还用不了栈，并且栈是自动的，由编译器和运行时环境共同来提供服务的，程序员没法手工控制）；堆内存彻底是独立于咱们的程序存在和管理的，程序须要堆内存时能够去手工申请malloc，使用完成后必须尽快free释放。（堆内存对程序就好象公共图书馆对于人）；数据段对于程序来讲对应C程序中的全局变量和静态局部变量。

C语言的字符串类型

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

不少高级语言像java、C#等就有字符串类型，有个String来表示字符串，用法和int这些很像，能够String s1 = "linux";来定义字符串类型的变量。
C语言没有String类型，C语言中的字符串是经过字符指针来间接实现的。

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

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

C语言中字符串的本质：

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

注意：

指向字符串的指针和字符串自己是分开的两个东西
char *p = "linux";在这段代码中，p本质上是一个字符指针，占4字节；"linux"分配在代码段，占6个字节；实际上总共耗费了10个字节，这10个字节中：4字节的指针p叫作字符串指针（用来指向字符串的，理解为字符串的引子，可是它自己不是字符串），5字节的用来存linux这5个字符的内存才是真正的字符串，最后一个用来存'\0'的内存是字符串结尾标志（本质上也不属于字符串）。

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

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

字符数组初始化与sizeof、strlen

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

字符串初始化与sizeof、strlen

char *p = "linux"; sizeof(p)获得的永远是4，由于这时候sizeof测的是字符指针p自己的长度，和字符串的长度是无关的。
strlen恰好用来计算字符串的长度。

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

字符数组char a[] = "linux";来讲，定义了一个数组a，数组a占6字节，右值"linux"自己只存在于编译器中，编译器将它用来初始化字符数组a后丢弃掉（也就是说内存中是没有"linux"这个字符串的）；这句就至关因而：char a[] = {'l', 'i', 'n', 'u', 'x', '\0'};
字符串char *p = "linux";定义了一个字符指针p，p占4字节，分配在栈上；同时还定义了一个字符串"linux"，分配在只读数据段：.rodata；而后把代码段中的字符串（一共占6字节）的首地址（也就是'l'的地址）赋值给p。
总结对比：字符数组和字符串有本质差异。字符数组自己是数组，数组自身自带内存空间，能够用来存东西（因此数组相似于容器）；而字符串自己是指针，自己永远只占4字节，并且这4个字节还不能用来存有效数据，因此只能把有效数据存到别的地方，而后把地址存在p中。
也就是说字符数组本身存那些字符；字符串必定须要额外的内存来存那些字符，字符串自己只存真正的那些字符所在的内存空间的首地址。

C语言之结构体概述

结构体类型是一种自定义类型

C语言中的2中类型：原生类型和自定义类型；

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

结构体定义时须要先定义结构体类型，而后再用类型定义变量；
也能够在定义结构体类型的同时定义结构体变量

#include <stdio.h> #include <string.h>

struct peple { char name[20]; int age; }; struct student { int s1; char s2; double s3; }s; int main() { struct peple zhangsan; strcpy(zhangsan.name,"张三"); //结构体中的数组要使用strcpy进行赋值；
  zhangsan.age = 19; printf("%s,.%d\n",zhangsan.name,zhangsan.age);

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

结构体能够认为是从数组发展而来的。其实数组和结构体都算是数据结构的范畴了，数组就是最简单的数据结构、结构体比数组更复杂一些，链表、哈希表之类的比结构体又复杂一些；二叉树、图等又更复杂一些。
数组有2个明显的缺陷：第一个是定义时必须明确给出大小，且这个大小在之后不能再更改；第二个是数组要求全部的元素的类型必须一致。更复杂的数据结构中就致力于解决数组的这两个缺陷。
结构体是用来解决数组的第二个缺陷的，能够将结构体理解为一个其中元素类型能够不相同的数组。结构体彻底能够取代数组，只是在数组可用的范围内数组比结构体更简单。

  // 结构体 . 访问和 -> 访问，实质上都是指针访问呢，只是编译器对此做了优化； // 下面是对 . 访问的 指针式理解
  s.s1 = 4;     // int *p1 = (int *)&s; *p1 = 4;
  s.s2 = 'e';   // char *p2 = (char *)((int)&s + 4); *p2 = 'e';
  s.s3 = 3.3;   // double *p3 = (double *)((int)&s + 8); *p3 = 3.3;
 printf("%d, %c, %f\n",s.s1,s.s2,s.s3); int *p1 = (int *)&s; char *p2 = (char *)((int)&s + 4); double *p3 = (double *)((int)&s + 8); //这里是 +8， 而不是 +5
 printf("%d, %c, %f\n",*p1,*p2,*p3); return 0; }

结构体的对齐访问1

参考阅读blog：

什么是结构体对齐访问

结构体中元素的访问其实本质上仍是用指针方式，结合这个元素在整个结构体中的偏移量和这个元素的类型来进行访问的。
可是实际上结构体的元素的偏移量比咱们上节讲的还要复杂，由于结构体要考虑元素的对齐访问，因此每一个元素实际占的字节数和本身自己的类型所占的字节数不必定彻底同样。（譬如char c实际占字节数多是1，也能够是2，也多是3，也能够能4····）
通常来讲，咱们用 . 的方式来访问结构体元素时，咱们是不用考虑结构体的元素对齐的。由于编译器会帮咱们处理这个细节。可是由于C语言自己是很底层的语言，并且作嵌入式开发常常须要从内存角度，以指针方式来处理结构体及其中的元素，所以仍是须要掌握结构体对齐规则。

结构体为什么要对齐访问

结构体中元素对齐访问主要缘由是为了配合硬件，也就是说硬件自己有物理上的限制，若是对齐排布和访问会提升效率，不然会大大下降效率。
内存自己是一个物理器件（DDR内存芯片，SoC上的DDR控制器），自己有必定的局限性：若是内存每次访问时按照4字节对齐访问，那么效率是最高的；若是你不对齐访问效率要低不少。
还有不少别的因素和缘由，致使咱们须要对齐访问。譬如Cache的一些缓存特性，还有其余硬件（譬如MMU、LCD显示器）的一些内存依赖特性，因此会要求内存对齐访问。
对比对齐访问和不对齐访问：对齐访问牺牲了内存空间，换取了速度性能；而非对齐访问牺牲了访问速度性能，换取了内存空间的彻底利用。

结构体对齐的规则和运算

编译器自己能够设置内存对齐的规则，有如下的规则须要记住：
第一个：32位编译器，通常编译器默认对齐方式是4字节对齐。

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

结构体对齐要考虑：结构体总体自己必须安置在4字节对齐处，结构体对齐后的大小必须4的倍数（编译器设置为4字节对齐时，若是编译器设置为8字节对齐，则这里的4是8）
结构体中每一个元素自己都必须对其存放，而每一个元素自己都有本身的对齐规则。
编译器考虑结构体存放时，以知足以上2点要求的最少内存须要的排布来算。

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

#pragma是用来指挥编译器，或者说设置编译器的对齐方式的。编译器的默认对齐方式是4，可是有时候我不但愿对齐方式是4，而但愿是别的（譬如但愿1字节对齐，也可能但愿是8，甚至可能但愿128字节对齐）。
经常使用的设置编译器编译器对齐命令有2种：第一种是#pragma pack()，这种就是设置编译器1字节对齐（有些人喜欢讲：设置编译器不对齐访问，还有些讲：取消编译器对齐访问）；第二种是#pragma pack(4)，这个括号中的数字就表示咱们但愿多少字节对齐。
咱们须要#prgama pack(n)开头，以#pragma pack()结尾，定义一个区间，这个区间内的对齐参数就是n。
#prgma pack的方式在不少C环境下都是支持的，可是gcc虽然也能够不过不建议使用。

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

__attribute__((packed))使用时直接放在要进行内存对齐的类型定义的后面，而后它起做用的范围只有加了这个东西的这一个类型。packed的做用就是取消对齐访问。相似于 #prgama pack(1) 的做用；
__attribute__((aligned(n)))使用时直接放在要进行内存对齐的类型定义的后面，而后它起做用的范围只有加了这个东西的这一个类型。它的做用是让整个结构体变量总体进行n字节对齐（注意是结构体变量总体n字节对齐，而不是结构体内各元素也要n字节对齐）
总结：#prgama pack(n)对齐，是结构体中每个变量字节对齐；__attribute__((aligned(n)))是结构体总体字节对齐

#include <stdio.h> typedef struct E { // 共占24字节 共占9字节 共占20字节 共占24字节 共占24字节
    short i;    // 2 2 2 2
    short j;    // 2 2 2 2
    char m;     // 1(1+3) 1 1(1+1) 1(1+3)
    int n;      // 4 4 4 4
    struct A a; // 12 9 10 12
}E; #pragma pack() typedef struct { // 共占9字节 
    short i;    // 2 
    short j;    // 2 
    char m;     // 1 
    int n;      // 4 
}__attribute__((packed)) CC; // 1字节对齐 2字节对齐 4字节对齐 8字节对齐
struct mystruct111 { // 共占12字节 共占12字节 共占12字节 共占16字节 
    int a;    // 4 4 4 4
    char b;    // 1 1 1 1
    short c;    // 2 2 2 2
    short d;    // 2 2 2 2
}__attribute__((aligned(8))) My111;

offsetof宏与container_of宏

结构体指针访问各个元素的原理：

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

offsetof宏：

offsetof宏的做用是：用宏来计算结构体中某个元素和结构体首地址的偏移量（其实质是经过编译器来帮咱们计算）。
offsetof宏的原理：虚拟一个type类型结构体变量，而后用type.member的方式来访问那个member元素，继而获得member相对于整个变量首地址的偏移量。
学习思路：第一步先学会用offsetof宏，第二步再去理解这个宏的实现原理。
offsetof宏解析：

#define offsetof(TYPE, MEMBER) (int)(&((TYPE *)0) -> MEMBER )，
(TYPE *)0：这是一个强制类型转换，把0地址强制类型转换成一个指针，这个指针指向一个TYPE类型的结构体变量。（实际上这个结构体变量可能不存在，可是只要我不去解引用这个指针就不会出错）。
((TYPE *)0)->MEMBER：(TYPE *)0是一个TYPE类型结构体变量的指针，经过指针指针来访问这个结构体变量的member元素
&((TYPE *)0)->MEMBER：等效于&(((TYPE *)0)->MEMBER)，意义就是获得member元素的地址。可是由于整个结构体变量的首地址是0，因此这个宏返回的是member元素相对于整个结构体变量的首地址的偏移量，类型是int；

container_of宏：

做用：知道一个结构体中某个元素的指针，反推这个结构体变量的指针。有了container_of宏，咱们能够从一个元素的指针获得整个结构体变量的指针，继而获得结构体中其余元素的指针。
typeof关键字的做用是：typepef(a)时由变量a获得a的类型，typeof就是由变量名获得变量数据类型的。
这个宏的工做原理：先用typeof获得member元素的类型并定义一个指针，而后用这个指针减去该元素相对于整个结构体变量的偏移量（偏移量用offsetof宏获得的），减去以后获得的就是整个结构体变量的首地址了，再把这个地址强制类型转换为type *便可。

#include <stdio.h>

// TYPE是结构体类型，MEMBER是结构体中一个元素的元素名 // 这个宏返回的是member元素相对于整个结构体变量的首地址的偏移量，类型是int
#define offsetof(TYPE, MEMBER)      (int)(&((TYPE *)0) -> MEMBER )

// ptr是指向结构体元素member的指针，type是结构体类型，member是结构体中一个元素的元素名 // 这个宏返回的就是指向整个结构体变量的指针，类型是(type *)
#define container_of(ptr, type, member) ({            \
    const typeof(((type *)0)->member) * __mptr = (ptr); \ (type *)((char *)__mptr - offsetof(type, member)); }) struct cc { char a; short b; int c; }; int main(void) { struct cc s; s.b = 12; struct cc *pS = NULL; short *p = &(s.c); pS = container_of(p, struct cc, c); printf("&s.a = %p\n", &s);          //&s.a = 0xbfd88d44
    printf("&s.c = %p\n", p);           //&s.c = 0xbfd88d48
    printf("&pS = %p\n",pS);            //&pS = 0xbfd88d44
 printf("&s.b = %p\n", &(s.b));      //&s.b = 0xbfd88d46
    printf("&s.b = %p\n", &(pS->b));    //&s.b = 0xbfd88d48
    printf("pS.b = %d\n", pS->b);       //12

    return 0; }

学习指南和要求：

最基本要求是：必需要会这两个宏的使用。就是说能知道这两个宏接收什么参数，返回什么值，会用这两个宏来写代码。看见代码中别人用这两个宏能理解什么意思。
升级要求：能理解这两个宏的工做原理，能表述出来。（有些面试笔试题会这么要求）
更高级要求：能本身写出这两个宏（不要着急，慢慢来）

共用体

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

共用体union和结构体struct在类型定义、变量定义、使用方法上很类似。
共用体和结构体的不一样：结构体相似于一个包裹，结构体中的成员彼此是独立存在的，分布在内存的不一样单元中，他们只是被打包成一个总体叫作结构体而已；共用体中的各个成员实际上是一体的，彼此不独立，他们使用同一个内存单元。能够理解为：有时候是这个元素，有时候是那个元素。更准确的说法是同一个内存空间有多种解释方式。
共用体union就是对同一块内存中存储的二进制的不一样的理解方式。
在有些书中把union翻译成联合（联合体），这个名字很差。如今翻译成共用体比较合适。
union的sizeof测到的大小实际是union中各个元素里面占用内存最大的那个元素的大小。由于能够存的下这个就必定可以存的下其余的元素。
union中的元素不存在内存对齐的问题，由于union中实际只有1个内存空间，都是从同一个地址开始的（开始地址就是整个union占有的内存空间的首地址），因此不涉及内存对齐。

#include <stdio.h> union myunion { int a; float b; char c; double d; }; struct aa { char i; int j; double d; }a1; int main(void) { union myunion t1; t1.a = 1123477881; printf("value = %f.\n", t1.b);  //123.456001
    
    int a = 1123477881; printf("指针方式：%f.\n", *((float *)&a));   //123.456001
 t1.a = 12; printf("s1.b = %d.\n", t1.b); printf("s1 = %d\n", sizeof(union myunion));  //8
    printf("a1 = %d\n", sizeof(struct aa)); //16 
    
    return 0; }

共用体和结构体的相同和不一样

相同点就是操做语法几乎相同。
不一样点是本质上的不一样。struct是多个独立元素（内存空间）打包在一块儿；union是一个元素（内存空间）的多种不一样解析方式。

共用体的主要用途

共用体就用在那种对同一个内存单元进行多种不一样规则解析的这种状况下。
C语言中实际上是能够没有共用体的，用指针和强制类型转换能够替代共用体完成一样的功能，可是共用体的方式更简单、更便捷、更好理解。

大小端模式

什么是大小端模式

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

经典笔试题：

用C语言写一个函数来测试当前机器的大小端模式。
用union来测试机器的大小端模式

指针方式来测试机器的大小端

#include <stdio.h> union endian //共用体都是从地地址开始访问的
{ char i; int j; }s; //小端模式返回1,不然为大端模式
int is_little_endian1(void) { s.j = 1;    // 地址0的那个字节内是1（小端）或者0（大端）
    return s.i; } int is_little_endian2(void) { int i = 1; char p = *((char *)(&i)); return p; } int main(void) { char i; // i = is_little_endian2(); //union测试
    i = is_little_endian2();    //指针测试
    if(i == 1) { printf("小端模式\n"); } else { printf("大端模式\n"); } return 0; }

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

位与运算。

结论：位与的方式没法测试机器的大小端模式。（表现就是大端机器和小端机器的&运算后的值相同的）
理论分析：位与运算是编译器提供的运算，这个运算是高于内存层次的（或者说&运算在二进制层次具备可移植性，也就是说&的时候必定是高字节&高字节，低字节&低字节，和二进制存储无关）。

移位

结论：移位的方式也不能测试机器大小端。
理论分析：缘由和&运算符不能测试同样，由于C语言对运算符的级别是高于二进制层次的。右移运算永远是将低字节移除，而和二进制存储时这个低字节在高位仍是低位无关的。

强制类型转换
同上

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

譬如要经过串口发送一个0x12345678给接收方，可是由于串口自己限制，只能以字节为单位来发送，因此须要发4次；接收方分4次接收，内容分别是：0x十二、0x3四、0x5六、0x78.接收方接收到这4个字节以后须要去重组获得0x12345678（而不是获得0x78563412）.
因此在通讯双方须要有一个默契，就是：先发/先接的是高位仍是低位？这就是通讯中的大小端问题。
通常来讲是：先发低字节叫小端；先发高字节就叫大端。（我不能肯定）实际操做中，在通讯协议里面会去定义大小端，明确告诉你先发的是低字节仍是高字节。
在通讯协议中，大小端是很是重要的，你们使用别人定义的通讯协议仍是本身要去定义通讯协议，必定都要注意标明通讯协议中大小端的问题。

枚举

枚举是用来干吗的？

枚举在C语言中实际上是一些符号常量集。直白点说：枚举定义了一些符号，这些符号的本质就是int类型的常量，每一个符号和一个常量绑定。这个符号就表示一个自定义的一个识别码，编译器对枚举的认知就是符号常量所绑定的那个int类型的数字。
枚举中的枚举值都是常量，怎么验证？
枚举符号常量和其对应的常量数字相对来讲，数字不重要，符号才重要。符号对应的数字只要彼此不相同便可，没有别的要求。因此通常状况下咱们都不明确指定这个符号所对应的数字，而让编译器自动分配。（编译器自动分配的原则是：从0开始依次增长。若是用户本身定义了一个值，则从那个值开始日后依次增长）

C语言为什么须要枚举

C语言没有枚举是能够的。使用枚举其实就是对一、0这些数字进行符号化编码，这样的好处就是编程时能够不用看数字而直接看符号。符号的意义是显然的，一眼能够看出。而数字所表明的含义除非看文档或者注释。
宏定义的目的和意义是：不用数字而用符号。从这里能够看出：宏定义和枚举有内在联系。宏定义和枚举常常用来解决相似的问题，他们俩基本至关能够互换，可是有一些细微差异。

宏定义和枚举的区别

枚举是将多个有关联的符号封装在一个枚举中，而宏定义是彻底散的。也就是说枚举实际上是多选一。
什么状况下用枚举？当咱们要定义的常量是一个有限集合时（譬如一星期有7天，譬如一个月有31天，譬如一年有12个月····），最适合用枚举。（其实宏定义也行，可是枚举更好）
不能用枚举的状况下（定义的常量符号之间无关联，或者无限的）用宏定义。
总结：宏定义先出现，用来解决符号常量的问题；后来人们发现有时候定义的符号常量彼此之间有关联（多选一的关系），用宏定义来作虽然能够可是不贴切，因而乎发明了枚举来解决这种状况。

枚举的定义和使用

#include <stdio.h>

//这个枚举用来表示函数返回值，error表示错误，right表示正确
enum return_value { error = 12,  //枚举值是全局的，直接本身就能够用；
    right ,  //由于枚举是全局的，因此全部的枚举类型中，常量符号都不能相同
}; enum return_value func1(void) { enum return_value r1 = right; return (r1); } int main(void) { printf("error = %d\n", error); printf("right = %d\n", right); enum return_value s = func1(); if(s == error) { printf("函数执行错误\n"); } else { printf("函数执行正确\n"); } return 0; }