本章为进阶C语言，详细介绍了数据的存储，含有：整型家族数据存储，以及难点浮点型数据存储，干货满满，快来学习吧！！！

1、整形存储和大小端

本章重点：

1、数据类型详细介绍

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

3、大小端字节序介绍及判断

4、浮点型在内存中的存储解析

1.1、数据类型介绍

char         1byte           //字符数据类型
short        2byte       //短整型
int          4byte         //整形
long         4/8byte          //长整型   在32位平台下是4byte，在64位平台下是8byte
long long    8byte         //更长的整形
float        4byte       //单精度浮点数
double       8byte        //双精度浮点数


//C语言规定：sizeof(long) >= size(int)
//C语言没有字符串类型，只有字符类型

类型的意义：

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

1.2、类型的基本归类

整型家族：

char     //字符的本质是ASCII码值，是整型，所以划分为整形家族
    unsigned char       0~255   ，如果unsigned char a = 1945，最后也会分解为0~255之间的数，下面的同理，无论赋值多少，都不会跳出它们所对应的范围。
    signed char         -128~127

short
    unsigned short [int]      0~65535
    signed short [int]        -32768~32767

int 
    unsigned int
    signed int

long
    unsigned long [int]
    signed long [int]

long long
    unsigned long long [int]
    signed long long [int]

有几个点需要说一下：

平常我们使用int是，int a; ------> signed int a;
char分为三种类型：char，signed char，unsigned char。那char到底是signed char还是unsigned char呢？标准是未定义的，取决于编译器。VS编译器是signed char
signed---有符号整型，既有正数又有负数。
unsigned---无符号整型，只有正数。

如果是signed，需要看最高位（符号位），如果符号位是0，就为正数，如果符号位是1，就为负数。

浮点数家族：表示小数就可以使用浮点型。

float          //精度低，存储数值的范围较小

double        //精度高， 存储数值的范围较大

构造类型（自定义类型）：

> 数组类型

> 结构体类型 struct

> 枚举类型 enum

> 联合类型 union

数组类型：只要是元素类型和元素个数不同，在就是不同类型的数组。

eg：

int arr[5]; 这个数组的类型是int [5]。
int arr[8]; 这个数组的类型是int [8]。
char arr[5]; 这个数组的类型是char [5]。

指针类型：

int* pi;

char* pc;

float* pf;

void* pv;

空类型：

void表示空类型（无类型）
通常用于函数的返回类型、函数的参数、指针类型。

//第一个void表示函数不会返回值，第二个void表示函数不需要任何传参。
void test(void)
{
    ;
}

2、整型在内存中的存储

我们之前讲过一个变量的创建是要在内存中开辟空间的。空间的大小是根据不同的类型而决定的。

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

比如：

int a = 10;
int b = -10;

我们知道a分配4个字节的空间。

那如何存储？

如下了解下面的概念：

2.1、原码，反码、补码

整数的二进制表示有3种：

原码
反码
补码

正的整数的原码、反码、补码相同。

负的整数的原码、反码、补码是要计算的：

原码：直接通过正负的形式写出的二进制序列就是原码。
反码：原码的符号位不变，其它位按位取反得到的就是反码。
补码：反码+1就是补码。

1、比如7的原码、反码、补码：

因为7是正值所以，原码 = 反码 = 补码

7是int类型的，占4个字节，一个字节=8bit，所以：

原码 = 00000000000000000000000000000111

注意：最高位（就是最左边的哪一位）0代表是正数，1代表是负数。

2、-7的原码、反码、补码

原码：10000000000000000000000000000111
反码：11111111111111111111111111111000（按照原码的最高位不变，其它的取反）
补码：11111111111111111111111111111001（反码+1=补码）

我们知道数值有不同表示方式：

2进制
8进制
10进制
16进制

现在我们来用不同的表达方式来表示十进制的21：

2进制：0b10101 ，0b代表二进制
8进制：025 ，0代表八进制
16进制：0x15 ，0x代表十六进制

现在我们来分别计算如下程序的原码，补码，反码：

#include <stdio.h>

int main()
{
    int a = 20;
    //20
    //原码==反码==补码 --> 00000000000000000000000000010100

    int b = -10;
    //10
    //原码 --> 100000000000000000000000000001010
    //反码 --> 111111111111111111111111111110101
    //补码 --> 111111111111111111111111111110110
    return 0;
}

【补充一点：】这里我们在使用编译器调试的时候来看，其实是把每4个二进制位转为一个16进制位的。

也就是说数据是以16进制的形式来展示给程序员的。

比如：上述的20的补码：00000000000000000000000000010100

所以20的二进制转为十六级进制就为：0x00000014

同理-10：

原码：0x800000000a
反码：0xfffffff5
补码：0xfffffff6

下面我们进入调试，来看一下：

注意：千万不要认为调试的时候显示的是十六进制的数据，那在内存中存储的形式就是十六进制的。这是错误的，实际上在内存中存储的形式还是二进制的。只不过是二进制的数据需要32bit，看着不方便，不简洁，然后编译器就以每4个二进制位转为十六进制位的方式进行存储的。千万千万要注意这一点。

2.2、得出结论：整型内存中存放的是补码的二进制序列。

其实从&b那张图就可以看出：整型内存中存放的是补码的二进制序列。

那为什么内存中存放的是补码呢？

在计算机系统中，数值一律用补码来表示和存储。原因在于，使用补码，可以将符号位和数值域统一处理。

同时，加法和减法也可以统一处理（CPU只有加法器）此外，补码与原码相互转换，其运算过程是相同的，不需要额外的硬件电路。

CPU只有加法，那减法怎么处理呢？比如：1-1？

其实1-1可以写为1+(-1)，这样就完美转换为加法了。这也就是上述所说的加法和减法可以统一处理的实现。

现在我们就是是一下1+(-1)吧

首先 1的补码：00000000000000000000000000000001

然后-1的补码：11111111111111111111111111111111

然后两个补码相加为：100000000000000000000000000000000（这个变为33位了，因为进位+1了）

但是int类型的大小只有32bit，所以只取32bit个：00000000000000000000000000000000。

所以1+(-1)最终结果就是0。

补码与原码相互转换，其运算过程是相同的，不需要额外的硬件电路。这句话怎么理解呢？

我们知道负数：原码取反得到反码，然后反码+1得到补码。

那如果我们由补码得到原码？大多数人想到的就是：这简单呀，就是：补码-1得到反码，然后反码取反得到原码。

这样就搞定了。对！！！这种方法是可行的，是正确的。

但其实还有另一种方法，就是：补码取反得到反码，然后反码取反得到补码。

也就是说由原码得到补码，或者是由补码得到原码的动作是相同的。

举个例子：-10

-10的补码：11111111111111111111111111110110，然后补码+1得到反码

-10的反码：11111111111111111111111111110111，然后反码取反得到原码

-10的原码：10000000000000000000000000001000。

所以又得到原码=-10了。

所以上补码与原码相互转换，其运算过程是相同的，不需要额外的硬件电路。

2.3、大小端

问题引入：如下图，有没有发现数据在存储的时候是倒着存储的呢？得到的数据是0x00000014，存储的是0x14000000。这里就牵扯到大小端问题。

什么是大小端：

大端（字节序存储），是指数据的低位保存在内存的高地址中，而数据的高位，保存在内存的低地址中；

小端（字节序存储），是指数据的低位保存在内存的低地址中，而数据的高位，保存在内存的高地址中。

【说明：】0x11223344，这里的44是数据的最低位，11是数据的最高位。

我们需要知道数据在存储时，有个顺序问题。

所以可以看出VS的编译器是小端存储的。

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

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

分析：我们就去一个简单的数字，比如：int a = 1; 这里的取值可以任意取，只不过取1可以更简单，更直观的体现出来大小端。

如果是小端字节序，应该是这样存储的：

如果是大端字节序，应该这样存储的：

可以发现大小端字节序的区别就是：第一个字节的值不一样，我们就根据这一点来判断即可。

如下代码：

#include <stdio.h>

int main()
{
    int a = 1;
    if (*(char*)&a == 1)
    {
        printf("小端\n");
    }
    else
    {
        printf("大端\n");
    }
    return 0;
}




//封装为函数的写法
#include <stdio.h>

int check_sys()
{
    int a = 1;
    return *(char*)&a;
}

int main()
{
    int a = 1;
    int ret = check_sys();
    if (ret == 1)
    {
        printf("小端\n");
    }
    else
    {
        printf("大端\n");
    }
    return 0;
}

3、练习题

第一题：打印以下结果

#include <stdio.h>

int main()
{
    char a = -1;
    signed char b = -1;
    unsigned char c = -1;
    printf("%d %d %d\n", a, b, c);
    return 0;
}

//signed char      -128~127
//unsigned char    0~255

分析：首先-1是整型，但现在是char类型所以需要截断。

-1的原码：10000000000000000000000000000001

-1的反码：11111111111111111111111111111110

-1的补码：11111111111111111111111111111111

然后截断，只取上面补码加黑部分。

所以char类型的-1就是11111111。

然后看打印，打印要求是以%d的形式输出，%d代表是int类型的，那由char类型的到打印int类型的需要整型提升。

但是现在是char类型的数据，所以需要整型提升。

那现在需要对a进行整型提升，我们需要先看a的类型，a的类型是char，char是有符号char，所以最高位就是符号位。

既然是有符号char，那整型提升就是：高位需要用符号位进行填充。

所以a整型提升后位：11111111111111111111111111111111，这个二进制序列是补码。但是需打印原码，所以还需要转为原码。

补码：11111111111111111111111111111111

反码：10000000000000000000000000000000

原码：10000000000000000000000000000001

所以记结果就是-1。

所以a输出的结果就是-1。又因为这里的char就是signed char，所以b的结果也是-1。

现在来分析c的值。

首先：unsigned char c = -1; 由于unsigned char的取值范围是0~255，按理说c不能为-1，超出范围了。

按理说不能存，但是实际上是先存进去的。

-1的原码：10000000000000000000000000000001

-1的反码：11111111111111111111111111111110

-1的补码：11111111111111111111111111111111

因为-1是整型，但是c是char类型的，所以需要截断。

截断后的补码：11111111

然后进行整型提升。先看c是什么类型的，c是unsigned char类型的，是无符号类型的char，所以说这里高位不要用符号位填充了。高位直接用0进行填充。

所以整型提升后得补码为：00000000000000000000000011111111

而此时的补码就等于原码。所以结果为255。

第二题：打印以下结果

#include <stdio.h>

int main()
{
    char a = -128;
    printf("%u\n", a);
    return 0;
}

输出：

分析：首先a=-128

a的原码：10000000000000000000000010000000

a的反码：11111111111111111111111101111111

a的补码：11111111111111111111111110000000

因为a是char类型的，所以需要截断。

截断后的补码：10000000

然后由于是以%u进行输出，%u代表无符号整型。所以重点是char类型的想以int类型的打印，需要整型提升。

整型提升后的补码：11111111111111111111111110000000

这时再看打印，要求以%u进行打印输出。因为%u是无符号整型打印。不存在符号位了，补码就是反码就是原码。

所以结果为：4294967168。

第三题：输出程序结果

#include <stdio.h>

int main()
{
    int i = -20;
    unsigned int j = 10;
    printf("%d\n", i+j);
    return 0;
}

输出：

分析：首先因为都是整型，所以不需要整型提升了

-20的原码：10000000000000000000000000010100

-20的反码：11111111111111111111111111101011

-20的补码：11111111111111111111111111101100

10的补码：00000000000000000000000000001010

i+j;就等于-20的补码+10的补码：

11111111111111111111111111101100

00000000000000000000000000001010

相加之后的结果：11111111111111111111111111110110

因为要以%d打印，%d是有符号整型。最高位为符号位=1，所以为负数，应该求反码，原码。

得到反码：10000000000000000000000000001001

得到原码：10000000000000000000000000001010

所以结果为-10。

第四题：输出程序结果

#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;
}

输出 9 8 7 6 5 4 3 2 1 0就不说了，这个是正常的程序。

说一下为什么会打印下面的数：当i=0之后，i--，i变成-1。

但是i是unsigned int类型的。i现在是负数，需要经过反码，补码，然后求其值

-1的原码：10000000000000000000000000000001

-1的反码：11111111111111111111111111111110

-1的补码：11111111111111111111111111111111

-1的补码转为十进制就为：4294967295

显然这个数是>=0的。所以条件满足，然后打印输出。

然后i--，i变为了-2，也是同样的道理。

第五题：填写结果

#include <stdio.h>
#include <string.h>
int main()
{
    if (strlen("abc") - strlen("abcdef") >= 0)
    {
        printf(">\n");
    }
    else
    {
        printf("<\n");
    }
    return 0;
}

输出：

分析：

错误的思路：strlen("abc")返回值=3 strlen("abcdef")返回值=6。3-6=-3<0成立，不应该输出<。其实这样想是错的
正确思路：其实strlen返回的数据类型是size_t，也是就是unsigned int类型的，因为unsigned int - unsigned int得到的还是个unsigned int类型的值，所以就变成了unsigned int -3的。又因为unsigned int的取值范围是>=0恒成立的。所以说unsigned int -3最终还是被分解为大于0的数，所以打印>。

4、浮点型在内存中的存储

首先：一个数据以整型的方式进行存储，那么读取的时候还应该以整型的方式取读取。同理一个数据以浮点型的方式进行存储，那么读取的时候还应该以浮点型的方式取读取。切不可混乱使用，比如：一个数据以整型的方式进行存储，读取的时候以浮点型的方式进行读取，这样是不可取的。

4.1、浮点数存储的规则

4.1.1、存放浮点数

详细解读：

根据国际标准IEEE（电气和电子工程协会）754，任意一个二进制浮点数V可以表示成下面的形式：

(-1)^S M 2^E。

(-1)^S表示符号位，当S=0，V为正数；当S=1，V为负数。

M表示有效数字，大于等于1，小于2。

2^E表示指位数。

浮点数存储只要是存储S、M、E等数字就可以把一个浮点数给存储下来。

示例一：

                       //5的二进制数值是101           //2^2--->2的2次方,第一个2是二进制，
                                                   //第二个2是小数点向左移动了2位
                                                  //123.45科学计数法--->1.23*10^2
V = 5.0f   ---转为二进制--->  101.0 ---转为科学计数法--->   1.01*2^2

  = (-1)^0 * 1.01 * 2 ^ 2

        S=0、M=1.01、 E=2

示例二：V = 9.5f这个怎么表示呢？是这样的吗：1001.101？这个写法是错误的。

应该写为：1001.1 因为小数点后面的权重为，2的-1次方，2的-2次方，2的-3次方...

因为2的-1次方正好是0.5，所以说二进制的.1就是十进制的.5。

V = 9.5f
  = 1001.1
  = 1.0011 * 2 ^ 3
  = (-1)^0 * 1.0011 * 2 ^ 3
  =     S=0、 M=1.0011、  E=3

经过两个示例我们可以意识到，存储浮点数，只要把S、M、E等存储下来，就可以把浮点数存储下来。

但是我们要知道有些浮点数是存储不准确的，比如：V = 9.6f 这个0.6无论如何总会有偏差的。

IEEE 754规定：

对于32位的浮点数，最高的1位是符号位S，接着的8位是指数E，剩下的23位为有效数字M。

对于64位的浮点数，最高的1位是符号位S，接着的11位是指数E，剩下的52位为有效数字M。

上图说明：要把S、M、E的值全部转为二进制，然后拼凑在一起得到一个32bit/64bit的二进制序列，把这个二进制序列存起来，那就是该小数的值。

那具体S、M、E是怎么存的呢？如下：

S其实很好存储，无非就是0或者1。复杂的是M和E。

IEEE 754对有效数字M和指数E，还有一些特别的规定：

有效数字M：

指数E，情况比较复杂：

指数E：简而言之就是，如果是float类型的，真实指数E需要+127（中间值）得到一个存储E，这个+127之后得的存储E的结果才是存储到内存里面的E。

如果是double类型的，真实E需要+1023得到一个存储E，这个+1023之后得的存储E的结果才是存储到内存里面的E。

那么下面来写个程序验证以下：

#include <stdio.h>

int main()
{
    float f = 5.5f;
    //5.5
    //101.1
    //1.011 * 2 ^ 2
    //s=0,m=1.011,e(真实的e)=2
    //s取0    m只取小数部分：011        e+127=129   --->   10000001 --->得到存储e
    //好的，现在把s、e、m按照顺序拼凑在一起：010000001011
    //得到了：010000001011，但是这个不够呀，folat数32bit位的，所以其余的补0
    //最终得到该小数的存储：01000000101100000000000000000000
    //为了等会便于观察，把每4个二进制位转化为1个16进制位：0x40b00000
    //调试，在是否存储的是0x40b00000。（这里存在大小端问题，所以可能是倒放的数据）
    return 0;
}

4.1.2、拿取浮点数数据

指数E从内存中取出还可以再分为三种情况：

E不全为0不全为1的情况下拿取该小数（常规情况，怎么放进去的，然后反向操作在拿出来即可。）

这个还拿上面的那例子演示：

最终得到该小数的存储：01000000101100000000000000000000
S部分为0
E部分为10000001---129，然后-127 得到2
M部分为01100000000000000000000，然后在前面添个1，变成：1.01100000000000000000000

之后拿取该小数：(-1)^0 * 1.01100000000000000000000 * 2 ^ 2。

E为全0
E为全1

4.1.3、举个例子

#include <stdio.h>

int main()
{ 
     //以整数类型进行存储
    int n = 9;    
    float* pFloat = (float*)&n;
    //以整型存储，以整型读取，没问题。
    printf("n的值为：%d\n", n);
    //以整型存储，但是以浮点型读取，这个结果和常规的不一样
    printf("*pFloat的值为：%f\n", *pFloat);
    //以浮点数类型进行存储
    *pFloat = 9.0;    
    //以浮点型存储，以整型读取，这个结果和常规的不一样
    printf("num的值为：%d\n", n);
    //以浮点型存储，以浮点型读取，没问题。
    printf("*pFloat的值为：%f\n", *pFloat);
    return 0;
}

输出：

分析：

第一个printf()不在解释很常规。
第二个printf()：9的补码：00000000000000000000000000001001，现在以*pFloat来看，左侧的补码二进制序列是folat类型的，所以S=0、M=00000000000000000001001，E全为0的情况，E=-126。

那计算值：S(0)00000000000000000001001 2 ^ (-126) = 0*0=0，所以最终结果为0。
第三个printf()：*pFloat = 9.0;

= 1001.0

= 1.001 * 2 ^ 3

= (-1)0 1.001 * 2 ^ 3 ---> S=0、M=1.001、E=3

真实E+127=存储E=130--->100000010

M--->00100000000000000000000

= 010000001000100000000000000000000

好了，现在以n的角度打印，010000001000100000000000000000000，最高位是0，那是补码呀，然后就直接计算出了值，最终值为：1091567616
第四个printf()：以浮点型存储，以浮点型读取，所以结果就是9.00000000。

5、顺带说一点：尽管整型和浮点型的存储形式不同，但是整型和浮点型都存在大小端的顺序问题。

C语言进阶---详解数据的存储

1、整形存储和大小端

1.1、数据类型介绍

1.2、类型的基本归类

2、整型在内存中的存储

2.1、原码，反码、补码

2.2、得出结论：整型内存中存放的是补码的二进制序列。

2.3、大小端

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

3、练习题

第一题：打印以下结果

第二题：打印以下结果

第三题：输出程序结果

第四题：输出程序结果

第五题：填写结果

4、浮点型在内存中的存储

4.1、浮点数存储的规则

4.1.1、存放浮点数

4.1.2、拿取浮点数数据

4.1.3、举个例子

5、顺带说一点：尽管整型和浮点型的存储形式不同，但是整型和浮点型都存在大小端的顺序问题。

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

C语言进阶---详解数据的存储

1、整形存储和大小端

1.1、数据类型介绍

1.2、类型的基本归类

2、整型在内存中的存储

2.1、原码，反码、补码

2.2、得出结论：整型内存中存放的是补码的二进制序列。

2.3、大小端

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

3、练习题

第一题：打印以下结果

第二题：打印以下结果

第三题：输出程序结果

第四题：输出程序结果

第五题：填写结果

4、浮点型在内存中的存储

4.1、浮点数存储的规则

4.1.1、存放浮点数

4.1.2、拿取浮点数数据

4.1.3、举个例子

5、顺带说一点：尽管整型和浮点型的存储形式不同，但是整型和浮点型都存在大小端的顺序问题。

热门文章

最新文章

相关课程

相关电子书

相关实验场景