高级C语言-数组&字符串&结构体&共用体&枚举

程序中内存哪里来1

三种内存来源
（1）在一个C语言程序中，栈（stack），堆（heap），数据区（.data）
栈的详解
运行时自动分配&自动回收；栈是自动管理的，不要手工干预
反复使用：栈内存在程序中其实就是一块空间，程序反复使用这块内存
脏内存：栈内存由于反复使用，每次使用后程序不会去清理，因此分配到时间保留原来的值，定义程序的时候，一定要初始化
临时性：（函数不能返回栈变量的指针，因为这个空间是临时的）
栈会溢出：因为操作系统事先给定了栈的大小，如果在函数中无穷尽的分配栈内存总能用完（递归）

//函数不能返回函数内部局部变量的地址，因为这个函数执行完返回后这个局部变量已经不在了，这个局部变量是分配在栈上的，虽然不在了，但是栈内存还是可以访问得到，但是访问是实际上这个内存地址已经和那个变量无关了
void func(void)
{
	int a = 4;//a是局部变量，分配在栈上又叫栈变量，又叫临时变量
	printf("&a = %p\n",&a);
	return &a;
}
void func2(void)
{
	int a = 33;
	int b = 33;
	int c = 33;
	printf("in func2 , &a = %p\n",&a);
}
void stack_overflow(void)
{
	int a = 2;
	stack_overflow();
}
int main(void)
{
	int *p = NULL;
	p = func();
	func2();
	func2();
	printf("p = %p.\n",p);
	printf("*p = %d.\n",*p);
	return 0;
	//stack_overflow();栈内存溢出
}

程序中内存从哪里来2.3

堆内存详解
操作系统堆管理器管理：堆管理器是操作系统的一个模块，堆管理器内存分配灵活，按需分配
大块内存：堆内存管理者总量很大的操作系统的系统内存块，个进程可以按需申请使用，使用完释放
程序手动申请&释放：续写代码去申请malloc和释放free
脏内存：堆内存也是反复使用的，而且使用者使用完释放前不会清除，因此也是脏的
临时性：堆内存只在malloc和free之间属于我这个进程，而可以访问。在malloc之前和free之后都不能访问，否则有不可预料的后果
堆内存使用范例
（1）void 是个指针类型，malloc返回的是一个void 类型的指针，实质上malloc返回的是堆管理器分配给我本次申请的那段内存空间的首地址（malloc返回的值其实是一个数字，这个数字表示一个内存地址）。为什么要使用void *作为类型？主要原因是malloc帮我们分配内存时只是分配了内存空间，至于这段空间将来用来存储什么类型的元素malloc是不关心的，由我们程序自己决定的

int main(void)
{
	//第一步：申请和绑定
	int *p = (int *)malloc(1000*sizeof(int));
	//第二步：检验分配成功
	if(NULL == p)
	{
			printf("malloc error\n");
			return -1;
	}
	//第三步：使用申请到的内存
	//p = &a;//如果在free之前给赋值，那么malloc申请的那段内存就丢掉了，malloc后p和返回的内存相绑定，p是那段内存在当前进程的唯一联系人，如果p没有free之前就丢掉了，那么这段内存就永远丢掉了，丢了的概念就是在操作系统的堆管理器中这段内存是当前进程拿着的，但是你也用不了，所以想申请新的内存来替换使用，这就叫程序“吃内存”，学名叫内存泄漏。
	//释放内存
	free(p);
}

（2）什么是void类型，早期被翻译成空型，会误导人。void类型不表示没有类型，而表示万能类型。void的意思是说这个数据的类型当前是不确定的，在需要的时候可以再去指定它的具体类型。void *类型是指针类型，这个指针占4个字节，但是指针指向的类型是不确定的，具体有后面来决定。
（3）malloc的返回值：成功申请空间后返回这个内存空间的指针，申请失败时返回NULL。所以malloc的内存指针使用前一定要先检验是否为NULL。
（4）malloc申请的内存时，用完后要free释放。free（p）；会告诉堆管理器这段内存我用完了你可以回收了，堆管理器回收了这段内存后这段内存当前进程就不应该再使用了。因为释放后堆管理器就可能会把这段内存给其他的进程，不该去使用。
（5）再调用free归还这段内存之前，指向这段内存的指针p一定不能丢（也就是不能给p另外赋值）。因为p一旦丢失这段malloc来的内存就永远丢失了（内存泄漏），直到当前进程结束的时候，操作系统才会回收这段内存。
malloc的一些细节表现
gcc中的malloc默认最小是以16B为分配单位的。如果malloc小于16KB的大小时都会返回一个16字节的大小的内存。malloc实现时没有实现任何任意自己的分配而允许一些大小的块内存的分配。
malloc（20）去访问第25,100,300，时会怎么样
这也是C语言存在的问题，不是很严谨，但是依旧是可以使用的

程序中内存从哪里来4

代码段，数据段，bss段
（1）编译器在编译程序的时候，将程序的所有元素分成了一些组成部分，各部分构成了一个段，所以说段是可执行程序组成部分
（2）代码段：代码段就是程序中的可执行部分，直观理解代码段就是函数堆叠组成的
（3）数据段：（也称为数据区，静态数据区，静态区）数据段就是程序中的数据，直观理解就是C语言中的全局变量。局部变量不能算数据，算是函数的数据，
（4）bss段：（又叫ZI段（0初始化段））：bss段的特点就是被初始化为0，bss段本质上也是属于数据段，bss段就是被初始化为0的数据段
注意区分：数据段（data）和bss段的区别和联系：二者本来没有本质区别，都是用来存放C程序中的全局变量。区别在于把显示显示初始化为非零的全局变量存在data段，而把显示初始化为0或者并未显示初始化（C语言规定未显示初始化的全局变量默认为0）的全局存在bss段
有些特殊数据会被放到代码段
（1）C语言中使用char *p = “linux”；定义字符串时，字符串“linux”实际被分配在代码段的，也就是说这个“linux”字符串实际上是一个常量字符串而不是变量字符串
（2）const型常量：C语言中const关键字用来定义常量，常量就是不能被修改的量。const的实现方法至少有2中：第一种就是编译器将const修饰的变量放在代码段去实现不能修改（普遍见于各种单片机的编译器）；第二种就是编译器来检查以确保const型的常量不会被修改。实际上const型的常量还是和普通变量一样放在数据段的（gcc中就是这样实现的）
显示初始化为非零的全局变量和静态局部变量放在数据段
（1）放在.data段的变量有2种：第一种是显示初始化为非零的全局变量。第二种是静态局部变量，也就是static修饰的局部变量。（普通局部变量分配在栈上，静态局部变量分配在.data）
总结：C语言中所有变量和常量所使用的内存无非以上三种情况
（1）相同点：三种获取内存的方法，都可以给程序提供可用内存，都可以来定义变量给程序用
（2）不同：栈内存对应C中的普通局部变量（别的变量还用不了栈，而且栈是自动的，由编译器和运行时环境共同来提供服务的，程序员无法手工控制）；堆内存完全是独立于我们的程序，程序需要内存时可以手工去申请malloc，使用完成后必须尽快free释放。（堆内存对程序就好像公共图书馆对于人）；数据段对于程序来说对应程序中的全局变量和静态局部变量

#include <str>
char test[] = "hello";//全局变量，放在数据段上
int main(void)
{
	char test1[] = "hello";//局部变量，放在栈上面
	char *p = (char *)malloc(10);//放在malloc申请的堆内存中
	if(NULL == p)
	{
		printf("malloc error.\n");
		return -1;
	}
	memset(p,0,10);//清除申请空间内的数据
	strcpy(p,"hello");//将hello复制到开辟的空间内
}

函数内部临时使用，出了函数不会用到，就定义局部变量
堆内存和数据段几乎拥有完全相同的属性，大部分时候是可以完全替代的。但是生命周期不一样，堆内存的生命周期是从malloc开始到free结束，而全局变量是从整个程序一开始执行就开始，直到整个程序结束才会消灭，伴随程序一生。
堆内存相当于向图书馆借书，数据段就好像自己去书店买书。买不如租，堆内存的使用比全局变量广泛

C语言的字符串类型

C语言没有原生字符串类型
（1）很多高级语言一个string表示字符串，用法和int这些很像，可以像string s1 = “linux”；来定义字符串的变量
（2）C语言没有string类型，C语言中的字符串时通过字符指针来间接实现的
C语言中字符串的本质：指针指向头，固定尾部的地址相连的一段内存
（1）字符串就是一串字符。C语言中使用ASCII编码对字符进行编程，编码后可以用char型变量来表示一个字符。字符串就是多个字符打包在一起共同组成的
（2）字符串在内存中其实就是多个字节连续分布构成的（类似于数组，字符串和字符数组很像）
（3）字符串的3个核心要点：一个指针指向字符串头，尾部固定（\0结尾的），地址连续
（4）‘\0’是一个ASCII字符，其实就是编码为0的那个字符（真正得到0，和数字0是不同的，数字0有它自己的ASCII编码）
（5）“魔数”（魔数就是选出来的一个特殊的数字，这个数字表示一个特殊的含义，你的正式内容中不能包含这个魔数作为内容）
指向字符串的指针和字符串本身是两样东西
（1）char *p = “linux”；这段代码中，p本质是一个字符指针，占4个字节；“linux”分配在代码段，占6个字节；实际上总共耗费了10字节；4字节的指针p叫做字符串指针（用来指向字符串的，；理解为字符串的引子）5字节的用来存linux这5个字符的内存才是真正的字符串，最后一个用来存"“\0”的内存是字符串的结尾标志（本质上也不属于字符串）
存储多个字符的2种方式
（1）一种是字符串，一种是字符数组

char *p = "hello";//字符串
char p[6] = "hello";//字符数组

字符串的字符数组的细节

字符数组初始化与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);这个函数接收一个字符串的指针，返回这个字符串的长度（以字节为单位）。注意：得到的返回值是不包含’\0’，为什么需要strlen函数，因为从字符串的定义（指针指向头，固定结尾，中间依次相连）可以看出无法直接得到字符串的长度，需要用strlen函数来计算得到字符串的长度

int mystrlen(int *p)//strlen函数的实现原型，从字符串的开头开始计算，直到遇到\0为止
{
	int x = 0;
	while(*p++ != '\0')
	{
		x++;
	}
	return x;
}

（3）sizeof（数组名）得到的永远是数组的元素个数（数组的大小），和数组中有无初始化，初始化多，少等是没有关系的；strlen是用来计算字符串的长度的，只能传递合法的字符串进去才有意义，如果随便传递一个字符指针，但是这个字符主子很并不是字符串没有意义
（4）当我们定义数组时没有明确给出数组大小，则必须同时给出初始化式，编译器会根据初始化去自动计算数组的大小（数组定义必须给出大小，要么直接给，要么给初始化式）
字符串初始化sizeof，strlen
（1）char *p = “linux”；sizeof（p）得到的永远是4，因为这个时候sizeof测得是字符指针p本身的长度，和字符串的长度是无关的
（2）strlen刚好用来计算字符串的长度
字符数组与字符串的本质差异
（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中

C语言之结构体概述

C语言之结构体是一种自定义类型
（1）C语言中的2种类型：原生类型和自定义类型
结构体使用时先定义结构体再用类型来定义变量
（1）结构体定义时需要先定义结构体类型，然后再用类型来定义变量
（2）也可以在定义结构体类型的同时定义结构体变量

#include<stdio.h>

struct  people//
{
    char name[5];
    int num;
};//只是定义类型

struct  peoples
{
    char name[5];
    int num;
}p2;//定义类型的同时定义变量

typedef struct  peoples1
{
    char name[5];
    int num;
}p3;//typede直接将p3的类型直接改掉了，将struct  peoples1重定义p3，p3是类型不是变量


int main(void)
{
    struct people p1;
    p1.num = 12;
    printf("p1 = %d\n",p1.num);
    
    
    p2.num = 23;
    printf("p2 = %d\n",p2.num);

    p3 p4;//这里的p3相当于struct  peoples1
    p4.num = 233;
    printf("p2 = %d\n",p4.num);
    
}

从数组到结构体的进步之处
（1）数组有2个明显的缺陷：1.定义时必须明确给出大小，且这个大小在以后不能再更改，2.是数组要求所有的元素的类型必须一致。更复杂的数据结构中就致力于解决数组的这两个缺陷
（2）结构体用来解决数组的第二个缺陷，可以将结构体理解为一个其中元素类型可以不行同的数组。结构体完全可以取代数组，只是在数组可用的范围内数组比结构体更简单
结构体变量中的元素如何访问
（1）数组元素的访问方式：表面有2种方式（数组下标方式和指针方式）；实质都是指针方式访问。
（2）结构体变量中的元素访问方式：只有一种，用 . 或者 -> 的方式来访问（实质都是一样的）
（3）结构体的访问方式有点类似于数组下标的方式

#include<stdio.h>

struct  people//
{
    char name;//在操作系统中，定义访问一个结构体相当于char *p = (char *)(&p1);*p = s
    int num;//在操作系统中，定义访问一个结构体相当于int *p = (int *)((int)&p1 + 4);*p = 12,因char类型占用4字节空间，所以从4字节开始计算
    double test;//相当于double *p = (double *)((int)&p1 + 12);*p = 12,因char+int类型占用12字节空间，所以从12字节开始计算
    //注意地址前面的int是因为加地址的时候强制转换为int类型，才能加到真正的地址上面，显示正确
};//只是定义类型

struct  peoples
{
    char name[5];
    int num;
}p2;//定义类型的同时定义变量

typedef struct  peoples1
{
    char name[5];
    int num;
}p3;//typede直接将p3的类型直接改掉了，将struct  peoples1重定义p3


int main(void)
{
    printf("这里显示的是结构体访问\n");
    struct people p1;                           //这里的p1可以表现为首元素的首地址
    p1.name = 'S';                              //char *s = (char *)((int)&s1)；*s1 = "s"
    printf("p1 = %c\n",p1.name);
    p1.num = 12;                                //int *s = int *((int)&s1 + 4); *s1 =12
    printf("p1 = %d\n",p1.num);
    p1.test = 12.202;                           //int *s = int *((int)&s1 + 4); *s1 =12
    printf("p1 = %lf\n",p1.test);

    
    printf("这里显示的是通过指针访问结构体\n");
    //通过指针的形式来访问结构体
    char *s = (char *)(&p1);
    printf("*s = %c\n",*s);
    int *s1 = (int *)((int)&p1 + 4);
    printf("*s1 = %d\n",*s1);
    double *s2 = (double *)((int)&p1 +12);
    printf("*s2 = %lf\n",*s2);


    printf("这里显示的是结构体定义类型的同时定义变量\n");
    p2.num = 23;
    printf("p2 = %d\n",p2.num);


    printf("这里显示的是重定义结构体的方式来访问\n");   
    p3 p4;//这里的p3相当于struct  peoples1
    p4.num = 233;
    printf("p2 = %d\n",p4.num);
    
}

结构体的对齐访问1

结构体对齐访问的例子
（1）结构体中元素访问的本质还是指针，结合元素在整个结构体中的偏移量和这个元素的类型进行访问的
（2）但是实际上结构体的元素的偏移量还要复杂很多，因为结构体要考虑元素的对齐访问，所以每个元素所占的字节数和自己本身的类型所占的字节数不完全一样（譬如char，可能是1，可能是4）
（3）一般来说，我们用 . 的方式来访问结构体元素时，我们不用考虑结构体的元素对齐，因为编译器会帮我们处理这个环节

#include <stdio.h>

struct people
{
    char c;
    int b;
};

int main(void)
{
    struct people p1;
    p1.b = 12;
    int *p = (int *)((int)&p1 + 4);
    printf("*p = %d\n",*p);//正确显示*p = 12
    printf("int = %d\n",(sizeof(char)));//char所占1
    printf("struct = %d\n",sizeof(struct people));//查看结构体所占的内存，是8
}

结构体为什么要对齐访问
（1）结构体上的元素对齐访问的主要原因是为了配合硬件，硬件本身的物理上的限制；
（2）对比对齐访问和不对齐访问；对齐访问牺牲了内存空间，换取了速度性能；而非对齐访问牺牲了访问速度性能，换取了内存空间的完全利用

//分析过程：首先是结构体，整个结构体变量是4字节对齐是由编译器保证的，我们无须担心，然后是第一个元素a，a的开始地址就是整个结构体的开始地址，所以自然是4字节对齐的，但是a的结束地址要由下一个元素说了算，然后是第二个元素b，因为上一个元素a本身占4字节，本身是对齐的。所以留给b的开始地址也是4字节对齐地址，所以b可以直接放（b放的位置决定了a一共占4字节，因为不需要填充）。b的起始地址定了后，结束地址不能定（因为可能需要填充），结束地址要看下一个元素来定。然后是第三个元素c，short类型需要2字节对齐
#include <stdio.h>

struct people
{
    char c;         //1       4
    int b;          //4       4
    short h;        //2       4
};
struct mystruct
{                           //1字节 4字节
		int a;			    //4		4
		char b;			    //1		2
		short c;		    //2		2
		double d;		    //8		8
        struct people p1;   //12    16
        int e[10];          //10    40
};
int main(void)
{
    struct people p1;
    p1.b = 12;
    int *p = (int *)((int)&p1 + 4);
    printf("*p = %d\n",*p);
    printf("int = %d\n",(sizeof(char)));
    printf("struct = %d\n",sizeof(struct people));
    printf("struct = %d\n",sizeof(struct mystruct));
}

（3）结构体对齐要考虑：结构体本身必须安置在4字节对齐处，结构体对齐后的大小必须4的倍数）编译器设置为4字节对齐时，如果编译器设置为8字节对齐，则这里的4是8
（4）结构体中每个元素本身都必须对齐存放，而每个元素本身都有自己的对齐规则
（5）编译器考虑结构体存放时，以满足以上2点要求的最少内存需要的排布来算
gcc支持但不推荐的对齐指令：#pragma pack() #pragma pack(n) (n =1/2/4/8)
（1）#pargram是用来指挥编译器，或者说设置编译器的对齐方式。编译器的默认对齐方式是4，但是有时候我不希望对齐方式是4，而希望是别的（譬如希望1字节对齐，也可能是8，甚至是128字节对齐）
（2）常用的设置编译器对齐命令有2种：第一种#pargma pack（），这种就是设置编译器1字节对齐（也叫作不对齐访问，或取消对齐访问）；第二种是#pragma pack()，这个括号中的数字就表示我们希望多少字节对齐
gcc推荐的对齐指令__attribute__((packed)) attribute((aligned(n)))
（1）attribute((packed))使用时直接放在要进行内存对齐的类型定义的后面，然后他起作用的范围只有加了这个东西的这个类型。packed的作用就是要取消对齐访问
（2）attribute((aligned(n)))使用时直接放在要进行内存对齐的类型定义的后面，然后它起作用的范围只有加了这个东西的这一个类型。它的作用是让整个结构体变量整体进行n字节对齐（注意是结构体变量整体n字节对齐，而不是结构体内各元素也要n字节对齐）

offsetof宏与container_of宏

offsetof的作用
（1）用宏来计算结构体中某个元素和结构体首地址的偏移量（其本质是利用编译器来计算）
（2）offsetof宏的原理：我们虚拟一个type类型结构体变量，然后type.member的方式来访问那个member元素，继而得到member相对于整个变量首地址。

#include <stdio.h>
struct mystruct1111
{                           //1字节 4字节
		int a;			    //4		4
		char b;			    //1		2
		short c;		    //2		2
		double d;		    //8		8
        struct people p1;   //12    16
        int e[10];          //10    40
};
#define offsetof(TYPE,MEMBER)  ((int) &((TYPE *)0)->MEMBER)
//(TYPE *)0这是一个强制类型转换，把0地址强制类型转换成一个指针，这个指针指向一个TYPE类型的结构体变量；（实际上这个结构体变量可能不存在，但是只要我不去解引用这个指针就不会出错
//((TYPE *)0)->MEMBER是一个TYPE类型结构体变量的指针，通过指针来访问这个结构体变量的member元素
//&((TYPE*)0)->MEMBER等效于&(((TYPE*)0)->MEMBER),意义就是得到member元素的地址，但是因为整个结构体变量的首地址是0
int main(void)
{
	struct mystruct1111 pp;
	int text = (char *)((int)&pp + 4)-((int *)(&pp));//错误
	int s = offsetof(struct mystruct1111,b);
    printf("s = %d\n",s);
    printf("s = %d\n",text);
}

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

struct mystruct1111
{                           //1字节 4字节
		int a;			    //4		4
		char b;			    //1		2
		short c;		    //2		2
		double d;		    //8		8
        struct people p1;   //12    16
        int e[10];          //10    40
}p11;
//ptr是指向结构体元素member的指针，type是结构体类型，member是结构体中一个元素的元素名
//这个宏返回的就是指向整个结构体变量的指针，类型是（type *）
#define container_of(ptr,type,member) ({const typeof(((type *)0)->member) * __mptr = (ptr);(type *)((char *)__mptr - offsetof(type,member));})
//(TYPE *)0这是一个强制类型转换，把0地址强制类型转换成一个指针，这个指针指向一个TYPE类型的结构体变量；（实际上这个结构体变量可能不存在，但是只要我不去解引用这个指针就不会出错
//((TYPE *)0)->MEMBER是一个TYPE类型结构体变量的指针，通过指针来访问这个结构体变量的member元素
//&((TYPE*)0)->MEMBER等效于&(((TYPE*)0)->MEMBER),意义就是得到member元素的地址，但是因为整个结构体变量的首地址是0
int main()
{
	struct mystruct1111 *ps = NULL; 
    short *p111 = &(p11.a);
    ps = container_of(p111,struct mystruct1111,a);
    printf("ps = %p\n",ps);//得到结构体的首元素的首地址
    printf("p11 = %p\n",&p11);//通过指针的方式得到首元素的首地址
}

共用体union

union的基本知识
（1）共用体union就是对同一块内存存储的二进制的不同的理解方式
（2）union的sizeof测到的大小实际是union中各个元素里面占内存最大的那个元素的大小
（3）union中的元素不存在内存对齐的问题，因为union中实质只有1个内存空间，都是从一个地址开始的（开始地址就是整个union占有的内存空间的首地址）不涉及内存对齐
共用体和结构体的相同和不同
（1）相同点就是操作语法几乎相同
（2）不同点是本质的不同。struct是多个独立元素（内存空间）打包在一起；union是一个元素（内存空间）的多种不同的解析方式

#include<stdio.h>
//a和b其实指向同一块内存空间，只是对这块内存空间的2种不同的解析方法。
//如果我们使用u1.a那么就按照int类型来解析这个内存空间，如果我们使用u1.b那么按照char来解析
union mystruct
{
    int a;
    float b;
}u1;
int main(void)
{
    
    u1.a = 1123477881;
    printf("union a = %f",u1.b);//利用float类型的b来解析a
    int a = 1123477881;
    printf("指针方式：%f.",*((float*)&a)) ;//解引用的方式，来用指针方式，用float解析int类型的变量
}

大小端模式1

什么是大端/小端模式？
（1）大端模式（bit endian）和小端模式（little endian）
（2）后来计算机通信发展起来后，遇到一个问题就是：在串口等通信中，一次只能发送1字节。这时候我要发送一个int类型的数就遇到一个问题。int类型有4字节，按照 byte0 byte1 byte2 byte3 这样的顺序发送，还是按照byte3 byte2 byte1 byte0这样的顺序发送。规则就是发送方和接收方必须按照同样的字节顺序来通信，否则就会出现错误，这就叫通信系统的大小端模式。这是大小端这个词和计算机挂钩的最早问题
（3）现在讲的大小端，更多的是计算机存储系统的大小端。在计算机内存/硬盘/NNAD中为存储器为32位的，但是数据任然是按照字节为单位的。于是乎一个32位的二进制在内存中存储的这种分布式：高字节对应高地址（大端模式），高字节对应低地址（小端模式）
用uinon来测试机器的大小端模式

#include <stdio.h>
#include <stdlib.h>
//a和b其实指向同一块内存空间，只是对这块内存空间的2种不同的解析方法。
//如果我们使用u1.a那么就按照int类型来解析这个内存空间，如果我们使用u1.b那么按照char来解析
int main() {
	
    union Un 
    {
		int a;
		char b;
	}Un;
	Un.a = 0x11223344;
	if (Un.b == 0x11) 
    {
		printf("大端\n");
	}
    else 
    {
		printf("小端\n");
	}
	system("pause");
	return 0;
}

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

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

// 判断大端还是小端？？
// 如果是大端序函数返回 1
// 如果是小端序函数返回 0
int Judge_BS(int n) {
	// 如果是大端序，数字 n 的低位存储在高地址中
	// 即 44 存储在高地址中，11 存储在低地址中
	// 地址：	0x100	0x101	0x102	0x103
	// 数字：	11		22		33		44

	// 如果是小端序，数字 n 的低位存储在低地址中
	// 即 11 存储在高地址中，44 存储再低地址中
	// 地址：	0x100	0x101	0x102	0x103
	// 数字：	44		33		22		11

	// 所以我们可以将32位数字 n 的 低 8 位取出来
	// 如果低 8 位是 11 则为大端序
	// 如果低 8 位是 44 则为小端序

	//此处的地址存储的是低地址
	char* p = &n;
	printf("%x\n", *p);
	printf("%x\n", *(p + 1));
	printf("%x\n", *(p + 2));
	printf("%x\n", *(p + 3));
	// 用 p 获得 32 的低地址，每 8 位打印一次数字，打印结果为
	// 44 33 22 11
	// 低地址对应着低位，是小端序
	char t = *p;
	if (t == 11) {
		return 1;
	}
	return 0;
}
int main() {
	int n = 0x11223344;
	if (Judge_BS(n)) {
		printf("是大端序！");
	} else {
		printf("是小端序！");
	}
	system("pause");
	return 0;
}

（4）大端模式和小端模式本身没有对错，没有优劣，理论上按照大端或小端都可以，但是要求必须存储是和读取得到按照同样的大小端模式来进行，否则会出错
（5）现实情况是；有些CPU公司用大端（譬如C51单片机）；有些用小端（譬如RAM）。大部分是小端，少部分用大端

枚举

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

#include<stdio.h>
//这个枚举用来表示函数返回值，ERROR表示错，RIGHT表示对
enum return_value
{
    ERROR,          //枚举值常量是全局的，直接自己就可以用
    RIGHT,
};
enum return_value func1(void);

int main(void)
{
    enum return_value r = func1();
    if (r == RIGHT)
    {
        printf("函数执行正确\n");
    }
    else
    {
        printf("函数执行错误\n");
    }
    return 0;
}
enum return_value func1(void)
{
    enum return_value r1;
    r1 = RIGHT;
    return r1;
}

C语言为何需要枚举
（1）C语言没有枚举也是可以的，使用枚举其实就是对1，0这些数字进行符号化编码，这样的好处就是编程时可以不看数字而直接看符号，符号的意义是显然的，一眼可以看出
（2）宏定义的目的和意义是：不用数字而用符号，宏定义和枚举有内在联系。宏定义和枚举经常用来解决类似问题，基本可以互换，只有细微差别
宏定义和枚举的区别
（1）枚举是将多个有关联的放在一起，而宏定义是闪装的，枚举是在多个里面选一个