这是因为在计算机系统中，我们是以字节为单位的，每个地址单元都对应着一个字节，一个字节为 8 个 b i t bit bit 位，但是在 C语言 中除了 8 b i t bit bit 的 c h a r char char 之外，还有 16 b i t bit bit 的 s h o r t short short
类型，32 b i t bit bit 的 l o n g long long 类型（要看具体的编译器），另外，对于位数大于 8 位的处理器，例如 16 位或者 32 位的处理器，由于寄存器宽度大于一个字节，那么就必然存在着如何将多个字节安排的问题。因此就导致了大端存储模式和小端存储模式。
例如：一个 16 b i t bit bit 的 s h o r t short short 类型 x x x ，在内存中的地址为 0 x 0010 0x0010 0x0010， x x x 的值为 0 x 1122 0x1122 0x1122 ，那么 0 x 11 0x11 0x11 为高字节， 0 x 22 0x22 0x22 为低字节。对于大端模式，就将 0 x 11 0x11 0x11 放在低地址中，即 0 x 0010 0x0010 0x0010 中， 022 022 022 放在高地址中，即放在 0 x 0011 0x0011 0x0011 中。而小端模式，刚好相反。
我们常用的 x86 结构是小端模式，而 KEIL C51 则为大端模式。很多的ARM，DSP都为小端模式。有些 ARM 处理器还可以由硬件来选择时大端模式还是小端模式
int check_sys()
{
int i = 1;
return (*(char*)&i);
}
int main()
{
int ret = check_sys();
if (ret == 1)
{
printf("小端\n");
}
else
{
printf("大端\n");
}
return 0;
}
我们来分析return (*(char*)&i);这句代码：
我们取出变量 i i i 的地址，因为 c h a r char char* 型指针只会访问一个字节的内容，所以将其强制类型转换成 c h a r char char* 类型，再对其进行解引用。
同时我们还知道：一个变量的地址，是其所有字节的地址中，地址最小的字节的地址。因此解引用得到的是 i i i 中最小字节地址所存储的内容，如果存储值为 1，则为小端存储，如果为 0，则为大端存储
当然，，我们还可以用联合体来判断
c复制代码
int check_sys()
{
union
{
int i;
char c;
}un;
un.i = 1;
return un.c;
}
关于联合体的知识，我们放到后面去讲
1.3、整型练习
练习一：
c复制代码
#include<stdio.h>
int main()
{
char a = -1;
signed char b = -1;
unsigned char c = -1;
printf("a=%d, b=%d, c=%d\n", a, b, c);
return 0;
}
首先我们来看char a = -1;： c h a r char char 类型是 （ s i g n e d ） c h a r （signed）char （signed）char 还是 （ u n s i g n e d c h a r ） （unsigned char） （unsignedchar） 取决于具体编译器的实现，但大部分是（signed）char。
-1 的补码是 11111111 11111111 11111111 11111111（整数默认4个字节），因为 c h a r char char 只有一个字节大小，发生截断， a a a 中放的是 11111111。同理char b=-1中 b b b 中放的也是11111111。
接下来，我们来看unsigned char c = -1;： c c c 中存放的也是 11111111，虽然 -1 是负数，但是存还是照样存的（先把数据存进去再说）
虽然 a b c abc abc 里存的都是 8 个 1 ，但以什么方式看待这 8 个 1 是不同的，对 a b ab ab 来说，他们认为 8 个 1 是 -1，而对 c c c 来说，他认为 8 个 1 是 255。
再来看最后一句，首先，我们要知道％d是以有符号整型来打印，打印 a b c abc abc 时，他们要先发生整形提升（详情请看【C语言】------详解操作符（下））。
对 a b ab ab 来说他们是有符号类型，整形提升按他们的符号位进行提升，即 11111111 11111111 11111111 11111111，补码转为源码，打印的结果是 -1。
而对于 c c c 来说他是无符号类型，整形提升高位补 0，即 00000000 00000000 00000000 11111111，因为首位是 0，被认为是正数，正数的原反补码相同，结果为 255。
答案：-1、-1、255
练习二：
c复制代码
#include<stdio.h>
int main()
{
char a = -128;
char b = 128;
printf("a=%u, b=%u\n", a, b);
return 0;
}
我们先来看 a a a
首先，我们来看 -128 的原码 反码 补码
原码：10000000 00000000 00000000 10000000
反码：11111111 11111111 11111111 0111111
补码：11111111 11111111 11111111 10000000
a a a 存储时，发生截断，存后面 8 个 b i t bit bit 位，即 10000000
％u是以无符号整型来打印数据，打印前， a a a 先发生整形提升，因为 c h a r char char 为有符号类型，整型提升按符号位提升，即 11111111 11111111 11111111 1000000，而％u认为他是无符号数，因此打印的是一个很大的数。
同理， b b b 也是类似的分析方法
答案：a=4294967168, b=4294967168
练习三：
c复制代码
#include<stdio.h>
#include<string.h>
int main()
{
char a[1000];
int i;
for (i = 0; i < 1000; i++)
{
a[i] = -1 - i;
}
printf("%d", strlen(a));
return 0;
}
让我们一起来分析这道题
数组 a a a 中存放的是 c h a r char char类型 的数据，通过 f o r for for 循环，依次放入 -1，-2，-3······ 等数据，循环 1000 次。而因为 a a a 中元素是 c h a r char char类型，范围是 -128至127，因此放入的数据会周期循环。
而题目要求打印的是strlen(a)的值，我们知 s t r l e n strlen strlen函数 是计算字符串的长度，遇到 '\0' 停止计算，而 '\0' 的本质是 0，因此这题的核心思路就是：计算第一次放入0，是第几个数放入，再减去一，即可知道前面翻入几个数，即字符串长度。
答案：255
练习四：
c复制代码
#include<stdio.h>
int main()
{
unsigned char i = 0;
for (i = 0; i <= 255; i++)
{
printf("hello world\n");
}
return 0;
}
该代码会打印多少个 " h e l l o w o r l d " "hello world" "helloworld" 呢？是 256 256 256 个吗？
答案是：死循环
因为 i i i 是 u n s i g n e d c h a r unsigned char unsignedchar 类型，他的数据范围是 0-255，当值为 255 即 11111111 时，加 1 为 100000000，因为只能存 8 比特位，发生截断，即 00000000，再不断加一，如此往复，永远跳不出循环。
c复制代码
#include<stdio.h>
int main()
{
unsigned int i;
for (i = 9; i >= 0; i--)
{
printf("%u\n", i);
}
return 0;
}
首先我们来看 p t r 1 ptr1 ptr1：& a a a 取出的是整个数组的地址，+1 则是跳过了整个数组，之后将该地址强制类型转换成 i n t int int * 类型。％x 是以十六进制的方式打印数据， p t r 1 [ − 1 ] ptr1[-1] ptr1[−1] 等价于 * （ p t r − 1 ） （ptr -1） （ptr−1），由于 p t r 1 ptr1 ptr1 是整型指针，-1 后退 4 个字节指向元素 4
图示：
接着我们来看 p t r 2 ptr2 ptr2，首先 a a a 是数组首元素的地址，取出后将其强制类型转换成整型变量，后面 +1，即数学上的+1，指针向后移动一位。
再将该整数强制类型转换成整型指针，最后，以十六进制打印 p t r 2 ptr2 ptr2 解引用的值，因为强转成 i n t int int* 指针，所以访问权限为 4 个字节。
对于 32 位（ f l o a t float float） 的浮点数，最高的一位存储的是符号位 S，接着 8 位存储指数位 E，剩下的 23 位存储有效数字 M
而对于 64 位（ d o u b l e double double） 的浮点数，最高的一位存储的是符号位S，接着11位存储指数位E，剩下的52位存储有效数字M
2.3、浮点数的存储过程
IEEE 754 对有效 数字 M 和 指数 E 还有一些特别规定
我们前面说过，M 的取值 1 < = M < 2 1<=M<2 1<=M<2 ，也就是写成 1. x x x x x 1.xxxxx 1.xxxxx 的形式，其中 xxxxx 是小数部分。IEEE 754 中规定，计算机那边存储 M 时，默认这个数的第一位总是 1 ，因此1可以被舍去，只保留后面的小数部分，比如保存 1.01 时，只存储 01。等到读取的时候，再把第一位的 1 加上去。这样做的目的是可以节省 一位有效数字的空间
至于指数E，则更为复杂一些：
首先，规定 E 是一个无符号整数。这样，如果 E 为 8 位，他的存储范围是 0～255 ，如果 E 为 11 位，他的存储范围则是 0～2047。但是，我们知道，指数位是可以有负数 的，所以 IEEE 754 规定，存入内存时 E 的真实值必须再加上一个中间值，对于 8位 的 E，这个中间值是 127 ，对 11位 的E这个中间值是 1023。比如： 2 10 2^{10} 210 ，他的 E 为 10，所以存储为 32 位浮点数时，必须保存成 10+127=137 ，即 10001001 。
