整型在内存中的存储（详细剖析大小端）——“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;
}

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

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

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