整型在内存中的存储（详细剖析大小端）——“C”

各位CSDN的uu们你们好呀，今天小雅兰的内容是整型在内存中的存储噢，现在，就让我们进入整型在内存中的存储的世界吧

---

数据类型详细介绍

整型在内存中的存储：原码、反码、补码

大小端字节序介绍及判断

---

 数据类型介绍

前面我们已经学习了基本的内置类型，以及他们所占存储空间的大小。

char        //字符数据类型
//字符存储和表示的时候本质上使用的是ASCII码值，ASCII码值是整数
//所以字符类型也归类到整型家族
//1个字节
short       //短整型
//2个字节
int         //整形
//4个字节
long        //长整型
//4个字节
long long   //更长的整形
//8个字节
float       //单精度浮点数
//4个字节
double      //双精度浮点数
//8个字节
//C语言有没有字符串类型？

类型的意义：

• 使用这个类型开辟内存空间的大小（大小决定了使用范围）。
• 如何看待内存空间的视角。

 类型的基本归类

整型家族

char

      unsigned char

      signed char

      char是不是signed char，取决于编译器

short

       short [int];

       short int num;

       short num; 

       这几种写法都是一样的，也都是可以的

       unsigned short [int]

       signed short [int]

 int

     unsigned int

     signed int

     int=[signed] int

long

       unsigned long [int]

       signed long [int] 

 浮点数家族

• float
• double

构造类型（自定义类型） 

• 数组类型  int arr[10]  char ch[5]
• 结构体类型  struct
• 枚举类型  enum
• 联合类型  union

 指针类型

• int * pi;
• char * pc;
• float * pf;
• void * pv;

空类型 

void 表示空类型（无类型）

通常应用于函数的返回类型、函数的参数、指针类型。

void * p;  ——无具体类型的指针

void test(...) ——函数不需要返回值

{}

void test(void)  ——函数不需要参数

{}

---

整型在内存中的存储

我们之前讲过一个变量的创建是要在内存中开辟空间的。

空间的大小是根据不同的类型而决定的。

那接下来我们谈谈数据在所开辟内存中到底是如何存储的？

比如：

int a=20;

//00000000000000000000000000010100 ——20的原码

//00000000000000000000000000010100 ——20的反码

//00000000000000000000000000010100 ——20的补码

int b=-10;

//10000000000000000000000000001010 —— -10的原码

//11111111111111111111111111110101 —— -10的反码

//11111111111111111111111111110110 —— -10的补码

原码、反码、补码

计算机中的整数有三种2进制表示方法，即原码、反码和补码。

三种表示方法均有符号位和数值位两部分，符号位都是用0表示“正”，用1表示“负”，

而数值位，正数的原、反、补码都相同，负整数的三种表示方法各不相同。

• 原码 直接将数值按照正负数的形式翻译成二进制就可以得到原码。
• 反码 将原码的符号位不变，其他位依次按位取反就可以得到反码。
• 补码 反码+1就得到补码。

对于整形来说：数据存放内存中其实存放的是补码。

为什么呢？

在计算机系统中，数值一律用补码来表示和存储。

原因在于，使用补码，可以将符号位和数值域统 一处理； 同时，加法和减法也可以统一处理（CPU只有加法器）此外，补码与原码相互转换，其运算过程是相同的，不需要额外的硬件电路。

我们再来看一个例子：

1-1

可以转化成1+(-1)

//00000000000000000000000000000001 —— 1的原码

//00000000000000000000000000000001 —— 1的反码

//00000000000000000000000000000001 —— 1的补码

//10000000000000000000000000000001 —— -1的原码

//11111111111111111111111111111110 —— -1的反码

//11111111111111111111111111111111 —— -1的补码

//然后，1的补码和-1的补码相加

//100000000000000000000000000000000 —— 丢掉最高位

//00000000000000000000000000000000 —— 0

我们看看在内存中的存储：

在内存中，是以二进制存放的，但是，是以十六进制表现出来的（方便观察）每四个二进制位是一个十六进制位

 

 我们可以看到对于a和b分别存储的是补码。

 但是我们发现顺序有点不对劲。

 这是又为什么？

---

 大小端介绍

什么是大端小端：

• 大端（存储）模式，是指数据的低位保存在内存的高地址中，而数据的高位，保存在内存的低地址 中
• 小端（存储）模式，是指数据的低位保存在内存的低地址中，而数据的高位,，保存在内存的高地 址中。

那么，为什么会有大端小端呢？

为什么会有大小端模式之分呢？

这是因为在计算机系统中，我们是以字节为单位的，每个地址单元都对应着一个字节，一个字节为8 bit。但是在C语言中除了8 bit的char之外，还有16 bit的short型，32 bit的long型（要看具体的编译器），另外，对于位数大于8位的处理器，例如16位或者32位的处理器，由于寄存器宽度大于一个字节，那么必然存在着一个如何将多个字节安排的问题。因此就导致了大端存储模式和小端存储模式。

例如：一个 16bit 的 short 型 x ，在内存中的地址为 0x0010 ， x 的值为 0x1122 ，那么 0x11 为 高字节， 0x22 为低字节。对于大端模式，就将 0x11 放在低地址中，即 0x0010 中， 0x22 放在高地址中，即 0x0011 中。小端模式，刚好相反。我们常用的 X86 结构是小端模式，而 KEIL C51 则为大端模式。很多的ARM，DSP都为小端模式。有些ARM处理器还可以由硬件来选择是大端模式还是小端模式。

对于这样一个地址—— 0x 11 22 33 44

来看一道题目：

百度2015年系统工程师笔试题：

请简述大端字节序和小端字节序的概念，设计一个小程序来判断当前机器的字节序。（10分）

 大端字节序存储：

         把一个数据的低位字节的数据，存放在高地址处，把高位字节的数据，存放在低地址处

 小端字节序存储：

         把一个数据的低位字节的数据，存放在低地址处，把高位字节的数据，存放在高地址处

 int a=1;

// 0x 00 00 00 01

#include<stdio.h>
int main()
{int a = 1;char* p = (char*)&a;//本来&a是int *，现在只需要访问一个字节，就把它强制类型转换为char *if (*p == 1){printf("小端\n");}else{printf("大端\n");}return 0;
}

当然，可以把这个代码优化一下，封装一个函数 

#include<stdio.h>
int check_sys()
{int a = 1;return *(char*)&a;
}
int main()
{int ret = check_sys();if (ret == 1){printf("小端\n");}else{printf("大端\n");}return 0;
}

用这样一段代码来写也是非常好的

---

下面，我们来看一些练习题

#include <stdio.h>int main()
{char a= -1;signed char b=-1;unsigned char c=-1;printf("a=%d,b=%d,c=%d",a,b,c);return 0;
}

char a=-1;

//10000000000000000000000000000001 —— -1的原码

//11111111111111111111111111111110 —— -1的反码

//11111111111111111111111111111111 —— -1的补码

//11111111 ——截断

//以%d的形式打印

//整型提升

//11111111111111111111111111111111 —— 整型提升后的补码

//11111111111111111111111111111110 —— 整型提升后的反码

//10000000000000000000000000000001 —— 整型提升后的原码

//最后结果就是-1

signed char b=-1;

//是一样的道理，最后的结果也是-1

unsigned char c=-1;

//10000000000000000000000000000001 —— -1的原码

//11111111111111111111111111111110 —— -1的反码

//11111111111111111111111111111111 —— -1的补码

//11111111 ——截断

//整型提升，无符号数高位直接补0

//00000000000000000000000011111111 ——255

 知识点拓展：

char c;//1 byte —— 8bit

00000000 —— 0

00000001 —— 1

00000010 —— 2

00000011 —— 3

00000100 —— 4

00000101 —— 5

...

01111111 —— 127

10000000 ——  -128

10000001 —— -127

...

11111110 —— -2

11111111 —— -1

同样的道理：

unsigned char

00000000 —— 0

00000001 —— 1

00000010 —— 2

...

01111111 —— 127

10000000 —— 128

10000001 —— 129

...

11111111 —— 255

 

以此类推：

基于此，再来看一个例子：

#include<stdio.h>
int main()
{unsigned int num = -10;//10000000000000000000000000001010 —— -10的原码//11111111111111111111111111110101 —— -10的反码//11111111111111111111111111110110 —— -10的补码printf("%d\n", num);printf("%u\n", num);//把补码当成原码来打印return 0;
}

 看到这里，可不能怪我们的unsigned啦，明明就是一个无符号整型，偏要以一个有符号整型打印，这不是胡搅蛮缠嘛

•  %d —— 打印有符号的数，结果是十进制的
•  %u —— 打印无符号的数，结果是十进制的

知识点就拓展到这里啦，接下来，还有一些练习题，一起来看看吧

#include <stdio.h>int main()
{char a = -128;printf("%u\n",a);return 0;
}

 char a=-128;

//10000000000000000000000010000000 —— -128的原码

//11111111111111111111111101111111 —— -128的反码

//11111111111111111111111110000000 —— -128的补码

//10000000 —— 截断

//这里的char是有符号的char

//整型提升，高位补符号位

//111111111111111111111111110000000

//题目是以%u的形式打印，所以这个直接作原码

#include <stdio.h>int main()
{char a = 128;printf("%u\n",a);return 0;
}

这个题目就和刚刚的是一样的，都是有符号的char，所以截断之后整型提升高位都是补符号位，也就是1

#include<stdio.h>
int main()
{int i= -20;unsigned  int  j = 10;printf("%d\n", i+j); //按照补码的形式进行运算，最后格式化成为有符号整数return 0;
}

int i = -20;

//10000000000000000000000000010100 —— -20的原码

//11111111111111111111111111101011 —— -20的反码

//11111111111111111111111111101100 —— -20的补码

unsigned int j=10;

//00000000000000000000000000001010 —— 10的原码

//00000000000000000000000000001010 —— 10的反码

//00000000000000000000000000001010 —— 10的补码

//补码相加

//11111111111111111111111111110110 —— 相加

//11111111111111111111111111110101 —— 减1

//10000000000000000000000000001010 —— -10

#include<stdio.h>
int main()
{char a[1000];int i;for(i=0; i<1000; i++){a[i] = -1-i;}printf("%d",strlen(a));return 0;
}

 想当然：-1、-2、-3、-4、-5......-999、-1000

可实际上：char类型的取值范围是-128——127

那应该是这样：-1、-2、-3......-128、127、126、125......3、2、1、0、-1、-2......

strlen是求字符串的长度，那么找\0,\0的ASCII码值是0

所以，本题的结果是128+127=255

#include<stdio.h>
int main()
{unsigned int i;for (i = 9; i >= 0; i--){printf("%u\n", i);}return 0;
}

咦，这个代码死循环了耶，为了便于观察，我们把这个代码换一换

#include<stdio.h>
#include<windows.h>
int main()
{unsigned int i;for (i = 9; i >= 0; i--){printf("%u\n", i);Sleep(1000);}return 0;
}

 

 结果竟然是这样，为什么呢？

我们发现了：i是unsigned int类型，恒大于等于0，所以for循环中i>=0这个条件恒成立，那么，自然就会死循环啦

最后一道题：

#include <stdio.h>unsigned char i = 0;int main()
{for(i = 0;i<=255;i++){printf("hello world\n");}return 0;
}

这道题目是不是有点眼熟呢？

那可不，这就是刚才那个题目，所以这个结果也就是死循环啦

---

 好啦，小雅兰今天的内容就到这里啦，今天的内容花了小雅兰很多时间，还请多指教噢，未来会继续努力呀！！！