程序员不得不了解的硬核知识大全

前言

摘录自 程序员不得不了解的硬核知识大全 这篇文章，本篇文章写的十分不错！！！

CPU

cpu的全称是 Central Processing Unit 他是电脑中最硬核的组件，这种说法一点都不为过。cpu是能够叫你的计算机叫计算机的硬核组件，但是他却不能代表你的电脑，cpu与计算机的关系，就相当于大脑与人的关系，cpu的核心是从程序或应用程序获取指令并计算。此过程可分为三个阶段：提取，解码，执行。

cpu从系统的主存中提取指令，然后解码该指令的实际内容，然后再由cpu的相关部分执行该指令。

CPU内部处理过程

下图展示了一般程序的运行流程（以c语言为例），可以说了解程序的运行流程是掌握程序运行机制的基础和前提。

1:程序员用c语言等高级语言编写程序

#include<stdio.h>
int main()
{
 printf("hello world\n");
 return 0;
 } 

2:编译后转化成机器语言的exe文件

010101010111100010
1001001001010 

3:程序运行时，在内存中生成EXE副本

4:CPU解释并执行程序内容

以上就是程序编译执行的过程

在这个流程中，CPU负责的就是解释和运行最终转换成机器语言的内容。

CPU主要由两部分构成：控制单元和算术逻辑单元（ALU)

• 控制单元：从内存中提取指令并解码执行

• 算术逻辑单元（ALU):处理算术和逻辑运算

CPU是计算机的心脏和大脑，它和内存都是由许多晶体管组成的电子部件。他接收数据输入，执行指令并处理信息。它与输入/输出（I/O）设备进行通信，这些向CPU发送数据和从CPU接收数据。

从功能来看，CPU的内部由寄存器，控制器，运算器和时钟四部组成，各部之间通过电信号连通。

                      CPU内部结构 

• 寄存器 是中央处理器的组成部分，他们可以用来暂存指令，数据和地址，可以将其看作是内存的一种。根据种类的不同，一个cpu内部会有20-100个寄存器。

• 控制器 负责把内存上的指令，数据读入寄存器，并根据指令的结构控制计算机

• 运算器 负责运算从内存中读入寄存器的数据

• 时钟 负责发出CPU开始计时的时钟信号

CPU是一系列寄存器的集合体

在CPU的四个结构中，我们程序员只需要了解寄存器就可以了，其余三个不用过多关注，为什么这么说呢？因为程序是把寄存器当作对象来描述的。

不同的CPU，其内部的寄存器的种类，数量以及寄存器存储的数值范围都是不同的。不过根据功能不同，可以将寄存器划分为下面几类。

种类	功能
累加寄存器	存储运行的数据和运算后的数据。
标志寄存器	用于反应处理器的状态和运算结果的某些特征以及控制指令的执行。
程序计数器	程序计数器是用于存放下一条指令所在单元的地址的地方。
基址寄存器	存储数据内存的起始位置
变址寄存器	存储基址寄存器的相对地址
通用寄存器	存储任意数据
指令寄存器	储存正在被运行的指令，CPU内部使用，程序员无法对该寄存器进行读写
栈寄存器	存储栈区域的起始位置

其中 程序计数器， 累加计数器 ， 标志寄存器 ， 指令寄存器 ， 栈寄存器 ，都只有一个，其他寄存器一般都有多个。

下面就对个寄存器进行说明

程序计数器

程序计数器（Program Counter) 是用来存储下一条指令所在的单元的地址。

程序执行时，PC的初值为程序第一条指令的地址，在顺序执行程序时， 控制器首先按程序计数器所在的指令地址从内存中取出一条指令，然后分析和执行该指令，同时将PC的值加1，指向下一条要执行的指令。

我们还是以一个事例为准来详细的看一下程序计数器的执行过程

这是一段进行相加的操作，程序启动，在经过编译解析后会由操作系统把硬盘中的程序复刻到内存中，实例中的程序是将123和456执行相加并操作，并将结果输出到显示器上。

地址 0100是程序运行的起始位置，Windows等操作系统把程序从硬盘复刻到内存后，会将程序计数器做为设定为起始位置 0100 ，然后执行程序，没执行一条指令程序计数器的数值会加1（或者指向下一条指令的地址），然后cpu就会根据程序计数器的数值，从内存中读取命令并执行，也就是说程序计数器控制着程序的流程。

条件分支和循环机制

高级语言中的条件控制流程主要分为三种： 顺序执行，条件分支，循环判断 三种，顺序执行是按照地址的内容顺序的执行指令。条件分支是根据条件执行任意地址的指令。循环是重复执行同一地址的指令。

• 顺序执行的情况比较简单，每执行一条指令程序计数器的值就是+1

• 条件和循环分支会使程序计数器的值指向任意地址，这样一来，程序便可返回到上个地址来重复执行同一个指令，或者转跳到任意指令。

程序的开始过程和顺序流程是一样的，CPU从0100处开始执行命令，在0100和0101都是顺序执行，PC的值的顺序+1，执行到0102地址的指令时，判断0106寄存器的的数值大于0，转跳到0104地址的指令，将数值输出到显示器中，然后结束程序，0103的指令被跳过了，这就和我们程序中的 if() 判断是一样的，在不满足条件的情况下，指令会直接跳过，所以pc的执行过程也就没有直接+1，而是下一条指令的地址。

标志寄存器

条件和循环分支会使用到 jump命令，会根据当前的指令来判断是否转跳，上面我们提到了 标志寄存器，无论当前累加寄存器的运算结果是整数还是负数，或者0标志寄存器都会将其保存

CPU在进行运算时，标志寄存器的值会根据当前运算结果自动设置，运算结果的正，负和0三个状态由标志寄存器的三个位表示。标志寄存器的第一个字节位，第二个字节位，第三个字节位的各自的结果都为1时，分别代表着整数负数和0。

CPU的执行机制比较有意思，假设累加寄存器中存储的XXX和通用寄存器中存储的YYY作比较，执行比较的背后，CPU的执行机制就会做减法运算，无论减法运算的结果为正，负还是零，都会保存到标志寄存器中。结果为正，则表示XXX比YYY大，结果为零，则表示XXX与YYY相等，结果为负，则表示XXX比YYY小。程序的比较指令实际上是CPU内部在做 减法 运算。

函数调用机制

接下来，我们继续介绍函数调用机制，哪怕是高级语言编写程序，函数调用处理，也是通过把程序计数器的值设定成函数的存储地址来实现的。函数执行转跳指令后，必须进行返回处理，单纯的指令转跳没有意义，下面是一个实现函数转跳的例子。

图中将变量a和b分别赋值为123和456，调用MyFun(a,b)方法，进行指令转跳，图中的地址是将c语言编译成机器语言后运行的地址，由于1行c程序 在编译后通常会变成多行机器语言，所以图中的地址是分散的。在执行完 MyFun(a,b)指令后，程序会返回MyFun(a,b)的下一条指令，CPU继续执行下面的指令。

函数的调用和返回很重要的两个指令是 call和 return指令，再将函数的地址入口地址设定到程序计数器之前， call指令会把调用函数后要执行的指令地址存储在名为栈的主内存。函数处理完毕后，再通过函数的出口来执行。return 指令的功能是把保存在栈中的地址设定到程序计数器。MyFun函数在被调用之前，0154地址保存在栈中，MyFun()函数处理完后，会把0154的地址保存在程序计数器中。这个调用过程如下

，

在一些高级语言的条件或者循环语句中，函数调用的处理机制，函数结束后的处理，则会转换成return 指令。

通过地址和索引实现数组

接下来我们看一下基址寄存器和变址寄存器，通过两个寄存器，我们可以对主存上的特定区域进行划分，来实现类似数组的操作，首先我们用十六进制数将计算机内存上的 00000000 -FFFFFFFF 的地址划分出来。那么，凡是该范围的内存地址，只要有一个32位的寄存器，便可查看全部地址。但如果想要数组那样分割特定的内存区域以达连续查看的目的的话，使用连个寄存器会更加方便。

例如，我们用两个寄存器（基址寄存器和变址寄存器）来表示我们内存的址。

通过地址和索引实现数组

接下来我们看一下基址寄存器和变址寄存器，通过两个寄存器，我们可以对主存上的特定区域进行划分，来实现类似数组的操作，首先我们用十六进制数将计算机内存上的 00000000 -FFFFFFFF 的地址划分出来。那么，凡是该范围的内存地址，只要有一个32位的寄存器，便可查看全部地址。但如果想要数组那样分割特定的内存区域以达连续查看的目的的话，使用连个寄存器会更加方便。

例如，我们用两个寄存器（基址寄存器和变址寄存器）来表示我们内存的址。

这种表示的方式很类似数组的构造，数组是指同样长度的数据在内存种进行连续的排列数据构造，用数组名表示数组的全部值，通过索引来区分数组的各个数据元素，例如a[0]-a[4]， [ ]内的0-4 就是数组下标。

这种表示的方式很类似数组的构造，数组是指同样长度的数据在内存种进行连续的排列数据构造，用数组名表示数组的全部值，通过索引来区分数组的各个数据元素，例如a[0]-a[4]， [ ]内的0-4 就是数组下标。

CPU执行指令过程

几乎的所有的冯 · 诺伊曼型计算机的CPU，其工作可以分为5个阶段：取指令，指令译码，执行指令，访存取数，结果写回。

• 取指令阶段是将内存中的指令读取到CPU中的寄存器的过程，程序寄存器用于存储下一条指令所在的地址。

• 指令译码阶段，在取令完成后，立马进入指令译码阶段，在指令译码阶段，指令译码器按照预定的格式，对取回的指令进行拆分和解释，识别区分出不同的指令类别以及各种获取操作数的方法。

• 执行指令阶段，译码完成后，就需要执行这一指令了，此阶段的任务是完成执行指令所规定的各种操作，具体实现指令的功能。

• 访问取数阶段，根据指令的需要，有可能从内存中提取数据，此阶段任务是：根据指令的地址码，得到操作数在主存中的地址，并从主存中读取该操作数用于运算。

• 结果写回阶段，做为最后一个阶段，结果写回（Write Back,WB)阶段把执行指令的运行结果数据“写回”到某种存储形式:结果数据经出被写到CPU的内部寄存器中，一便被后续的指令快速存取；

内存

CPU和内存就像一对不可分割的恋人一样，是无法拆散的一对，没有内存CPU无法执行程序指令，那么计算机也就失去了意义，只有内存，无法执行指令，那么计算机照样无法运行。

那么什么是内存呢？内存和计算机是如何交互的？我们来介绍一下。

什么是内存

内存（Memory) 是计算机中最重要的部件之一，它是程序与CPU沟通的桥梁，计算机中所有程序的运行都是在内存中进行的，因此内存对计算机的影响非常大，内存又被称为 主存，其作用是存放CPU中的运算数据，以及与硬盘等外部存储设备交换的数据。只要计算机在运行，CPU就会把需要运算的数据调到主存中去运算，当运算完成后，CPU在把结果传送出来，主存的运行也觉定了计算机的稳定运行。

内存的物理结构

内存的内部是由各种IC电路构成的，它的种类很庞大，但是其主要分为三种存储器

• 随机存储器（RAM)：内存中最重要的一种，表示既可以从中读取数据，也可以写入数据。当机器关闭时，内存中的数据会丢失。

• 只读存储器（ROM）：一般只用于数据的读取，不能写入数据，但当机器停电时，这些数据不会丢失。

• 高速缓存（Cache)：Cache也是我们经常见到的，它分为一级缓存（L1 Cache)，二级缓存（L2 Cache)，三级缓存（L3 Cache)这些数据，它位于内存和CPU之间，是一个读写速度比内存更快的存储器。当CPU向内存写入数据时，这些数据也会被写入高速缓存中。当CPU需要读取数据时，会直接从高速缓存中直接读取，当然，如需要的数据在Cache中没有，CPU会再去读内存中的数据。

内存IC是一个完整的结构，它内部有电源，地址信号，数据信号，控制信号和用于寻址的IC引脚来进行数据的读写。下面是一个虚拟的IC引脚示意图

图中VCC 和 CNU表示电源，A0-A9是地址信号的引脚，DO-D7表示控制信号，也就是说一次可以输入8bit=1byte的数据。A0-A9是地址信号共十个，可以指定00000 00000-11111 11111共2^10=1024个地址，每个地址都会存放1byte，因此我们可以得出内存IC的容量就是1KB。

内存的读写过程

让我们把关注点放在内存IC对数据的读写过程来吧！我们来看一个对内存IC进行数据写入和读取的模型

来详细描述一下这个过程，假设我们要向内存IC中写入1byte的数据的话，它的过程是这样的：

• 首先给VCC接通+5V的电源，给GUN接通0V的电源，使用 A0-A9 来指定数据的存储场所，然后在把数据的值输给 D0-D7的数据信号，并把 WR(write)的值设置位1，执行完这些操作后，即可以向内存IC写数据

• 读出数据时，只需要通过A0-A9的地址信号指定数据的存储场所，然后将RD的值置为0即可。

• 图中的RD和 WD又被称位控制信号。当其中WR和DR都为0时，无法进行读写操作。

内存的现实模型

为了便于记忆，我们把内存模型映射成为我们现实世界的模型，在现实世界中，内存的模型很想我们生活的楼房。在这个楼房中，1层可以存储一个字节的数据，楼层号就是 地址，下面是内存和楼层整合的模型图。

我们知道程序中的数据不仅只有数值，还有 数据类型的概念，从内存上看，就是占用内存的大小(占用楼层数）的意思，即是物理上强制以1个字节为单位来逐一读写数据的内存，在程序中，通过指定其他数据类型，也能实现以特定字节数为单位来进行读写。

二进制

我们都知道，计算机的底层都是使用二进制数据进行数据流的传输的，那为什么会使用二进制来表示计算机呢？或者说什么是二进制数呢？在拓展一步如何使用二进制做加减乘除？下面就来看一下

什么是二进制数

那么什么是二进制数呢？为了说明这个问题，我们先把 00100111这个数转化为十进制数看一下，二进制数转化为十进制数，直接将各位置上的值*位权即可，那么我们将上面的值进行转换

也就是说，二进制数代表的 00100111 转换成十进制就是 39，这个 39 并不是 3 和 9 两个数字连着写，而是 3 * 10 + 9 * 1，这里面的 10 , 1 就是位权，以此类推，上述例子中的位权从高位到低位依次就是 7 6 5 4 3 2 1 0。这个位权也叫做次幂，那么最高位就是2的7次幂，2的6次幂 等等。二进制数的运算每次都会以2为底，这个2 指得就是基数，那么十进制数的基数也就是 10 。在任何情况下位权的值都是 数的位数 - 1，那么第一位的位权就是 1 - 1 = 0， 第二位的位权就睡 2 - 1 = 1，以此类推。

那么我们所说的二进制数其实就是 用0和1两个数字来表示的数，它的基数为2，它的数值就是每个数的位数 * 位权再求和得到的结果，我们一般来说数值指的就是十进制数，那么它的数值就是 3 * 10 + 9 * 1 = 39。

移位运算和乘除的关系

在了解过二进制之后，下面我们来看一下二进制的运算，和十进制数一样，加减乘除也适用于二进制数，只要注意逢 2 进位即可。二进制数的运算，也是计算机程序所特有的运算，因此了解二进制的运算是必须要掌握的。

首先我们来介绍移位 运算，移位运算是指将二进制的数值的各个位置上的元素坐左移和右移操作，见下图

补数

刚才我们没有介绍右移的情况，是因为右移之后空出来的高位数值，有 0 和 1 两种形式。要想区分什么时候补0什么时候补1，首先就需要掌握二进制数表示负数的方法。

二进制数中表示负数值时，一般会把最高位作为符号来使用，因此我们把这个最高位当作符号位。 符号位是 0 时表示正数，是 1 时表示 负数。那么 -1 用二进制数该如何表示呢？可能很多人会这么认为： 因为 1 的二进制数是 0000 0001，最高位是符号位，所以正确的表示 -1 应该是 1000 0001，但是这个答案真的对吗？

计算机世界中是没有减法的，计算机在做减法的时候其实就是在做加法，也就是用加法来实现的减法运算。比如 100 - 50 ，其实计算机来看的时候应该是 100 + (-50)，为此，在表示负数的时候就要用到二进制补数，补数就是用正数来表示的负数。

为了获得补数，我们需要将二进制的各数位的数值全部取反，然后再将结果 + 1 即可，先记住这个结论，下面我们来演示一下。

具体来说，就是需要先获取某个数值的二进制数，然后对二进制数的每一位做取反操作(0 —> 1 , 1 —> 0)，最后再对取反后的数 +1 ，这样就完成了补数的获取。

补数的获取，虽然直观上不易理解，但是逻辑上却非常严谨，比如我们来看一下 1 - 1 的这个过程，我们先用上面的这个 1000 0001(它是1的补数，不知道的请看上文，正确性先不管，只是用来做一下计算)来表示一下

奇怪，1 - 1 会变成 130 ，而不是0，所以可以得出结论 1000 0001 表示 -1 是完全错误的。

那么正确的该如何表示呢？其实我们上面已经给出结果了，那就是 1111 1111，来论证一下它的正确性

我们可以看到 1 - 1 其实实际上就是 1 + (-1)，对 -1 进行上面的取反 + 1 后变为 1111 1111, 然后与 1 进行加法运算，得到的结果是九位的 1 0000 0000，结果发生了溢出，计算机会直接忽略掉溢出位，也就是直接抛掉 最高位 1 ，变为 0000 0000。也就是 0，结果正确，所以 1111 1111 表示的就是 -1 。

c/c++模拟二进制减法：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int binary_position[33][2];  //二进制位
void init_binary(int a, int b) {
  for (int i = 31; ~i; i--) {
    binary_position[i][0] = ((a >> i) & 1);
  }
  for (int i = 31; ~i; i--) {
    binary_position[i][1] = ((b >> i) & 1);
  }
}
void binary_reverse() {
  for (int i = 0; i <= 31; i++) {
    binary_position[i][1] ^= 1;
  }
  int k = 1;
  for (int i = 0; i <= 31; i++) {
    binary_position[i][1] += k;
    if (binary_position[i][1] == 2) {
      binary_position[i][1] = 0;
    } else {
      k = 0;
    }
  }
}
void get_binary_result() {
  int ans = 0;
  int k = 0;
  for (int i = 0; i <= 31; i++) {
    int c = binary_position[i][0] + binary_position[i][1] + k;
    if (c == 2) {
      c = 0, k = 1;
    } else {
      k = 0;
    }
    ans += c * (1 << i);
  }
  cout << ans << endl;+
}
int main() {
  int a, b;
  cin >> a >> b;
  init_binary(a, b);
  binary_reverse();
  get_binary_result();
  return 0;
}

所以负数的二进制表示就是先求其补数，补数的求解过程就是对原始数值的二进制数各位取反，然后将结果 + 1。

算数右移和逻辑右移的区别

在了解完补数后，我们重新考虑一下右移这个议题，右移在移位后空出来的最高位有两种情况 0 和 1。

将二进制数作为带符号的数值进行右移运算时，移位后需要在最高位填充移位前符号位的值( 0 或 1)。这就被称为算数右移。如果数值使用补数表示的负数值，那么右移后在空出来的最高位补 1，就可以正确的表示 1/2,1/4,1/8等的数值运算。如果是正数，那么直接在空出来的位置补 0 即可。

下面来看一个右移的例子。将 -4 右移两位，来各自看一下移位示意图

如上图所示，在逻辑右移的情况下， -4 右移两位会变成 63， 显然不是它的 1/4，所以不能使用逻辑右移，那么算数右移的情况下，右移两位会变为 -1，显然是它的 1/4，故而采用算数右移。

那么我们可以得出来一个结论：左移时，无论是图形还是数值，移位后，只需要将低位补 0 即可；右移时，需要根据情况判断是逻辑右移还是算数右移。

下面介绍一下符号扩展：将数据进行符号扩展是为了产生一个位数加倍、但数值大小不变的结果，以满足有些指令对操作数位数的要求，例如倍长于除数的被除数，再如将数据位数加长以减少计算过程中的误差。

以8位二进制为例，符号扩展就是指在保持值不变的前提下将其转换成为16位和32位的二进制数。将0111 1111这个正的 8位二进制数转换成为 16位二进制数时，很容易就能够得出0000 0000 0111 1111这个正确的结果，但是像 1111 1111这样的补数来表示的数值，该如何处理？直接将其表示成为1111 1111 1111 1111就可以了。也就是说，不管正数还是补数表示的负数，只需要将 0 和 1 填充高位即可。

内存和磁盘的关系

我们都知道计算机的五大基础部件是， 存储器， 控制器， 运算器， 输入和输出设备，从中存储功能的角度来看，可以把存储器分为 内存 和 磁盘，我们上面介绍过内存，下面我们介绍一下磁盘以及磁盘和内存之间的关系

程序不读人内存就无法运行

计算机最主要的存储部件就是内存和磁盘。磁盘中存储的程序必须加载到内存中才能运行，在磁盘中保存的程序是无法之间运行的，这是因为负责解析和运行程序的CPU是需要程序计数器来指定内存地址从而读出程序指令的。

磁盘构造

磁盘缓存

我们上面提到，磁盘往往和内存是互利共生的关系，互相协作，彼此持有良好的合作关系。每次内存都需要从磁盘中读取数据，必然会读到相同的内容，所以一定会有一个角色会负责存储我们经出需要读到的内容，我们大家做软件的时候经常会用到 缓存技术，那么硬件层面也不例外，磁盘也有缓存，磁盘的缓存叫做 磁盘缓存。

磁盘缓存指的是把从磁盘中读出的数据存储到内存的方式，这样一来，当接下来需要读取相同的内容时，就不会通过实际的磁盘，而实通过磁盘缓存来读取。某一种技术或框架的出现势必解决某种问题的，那么磁盘缓存就大大盖上了磁盘访问的速度。

虚拟内存

虚拟内存是内存和磁盘交互的第二媒介。虚拟内存是指把磁盘的一部分做为 假想内存来使用。这与磁盘缓存是假想的磁盘（实际上是内存）相对，虚拟内存是假想的内存（实际上是磁盘）。

虚拟内存是计算机系统内存管理的一种技术。它使得应用程序认为它拥有 连续可用的内存（一个完整的地址空间），但实际上它通常被分割成多各物理碎片，还有部分存储在外部磁盘管理器上，必要时进行数据交换。

通过借助虚拟内存，在内存不足时仍然可以运行程序。例如只剩5mb的空间下，仍可以运行10mb的程序。由于cpu只能执行加载到内存中的程序，因此，虚拟内存中的空间就需要和内存中的空间进行 置换swap，然后运行程序。

虚拟内存与内存的交换方式

虚拟内存的方法有 分页式和 分段式两种。windows采用的是分页式，该方式是指在不考虑程序构造的情况下，把运行的程序按照一定大小的页进行分割，并以页的单位进行置换，在分页式中，我们把磁盘的内容读到内存中称位 Page In，把内存的内容写入磁盘称为 Page out，windows计算机每页的大小为4KB的页来进行切分，以页(page)为单位放到磁盘中，然后进行置换。

为了实现内存功能，Windows在磁盘上提供了虚拟内存使用 的文件（Page File，页文件）。该文件由Windows生成和管理，文件的大小和虚拟内存大小相同，通常大小是内存的1-2倍。

磁盘的物理结构

之前我们介绍了CPU，内存的物理结构，现在我们来介绍一下磁盘的物理结构。磁盘的物理结构指的是磁盘存储数据的形式。

磁盘是通过其物理表面划分的多个空间来使用的。划分的方式有两种： 可变长的方式和 扇区方式，前者将物理结构划分成可变的区间，后者将磁盘结构划分成固定长度的空间，一般Windows所使用的硬盘和软盘都是使用扇区这种方式，扇区中，把磁盘表面分成若干个同心圆的空间就是 磁道，把磁道按照固定大小的存储空间划分而成的就是 扇区

扇区是对磁盘进行物理读写的最小单位。windows中使用的磁盘，一般是一个扇区512个字节，不过windows在逻辑方面对磁盘进行读写的单位是扇区整数倍簇。根据磁盘容量不同功能，一簇可以是512字节（一簇等于一扇区），1kb（一簇=2扇区），2kb,4kb,8kb,16kb,32kb(一簇=64扇区）簇和扇区的大小是相等的。

压缩算法

我们想必都有过 压缩和 解压缩的经历，当文件太大时，我们会使用文件压缩来降低文件的占用空间。比如微信上传文件的限制是100MB，我这里有个文件无法上传，但是我解压完成后的文件一定会小于100MB，那么我的文件就可以上传了。

此外我们把相机拍完照片保存到计算机上的时侯，也会使用压缩算法进行文件压缩，文件压缩的格式一般是 JPEG。

那么什么是压缩算法呢？压缩算法又是怎么样定义的呢？在认识算法之前，我们需要先了解一下文件是如何存储的？

文件存储

文件是将数据存储在磁盘等存储媒介的一种形式。程序文件中最基本的存储数据单位是 字节。文件的大小不管是xxxxKB，xxxxMB等来表示，就是因为文件是以字节 B = Byte 为单位来存储的。

文件就是字节数据的集合。一字节（8位）表示的字节数据有256种，用二进制表示的话就是0000 0000-1111 1111。如果文件中存储的数据是文字，那么该文件就是文本文件。如果是图形，那么该文件就是图像文件。在任何情况下，文本中的字节数都是 连续存储的。

压缩算法的定义

上面介绍了文件的集合其实就是一堆字节数据的集合，那么我们就可以给压缩算法下一个定义。

压缩算法(compaction algorithm)指的就是数据压缩算法，主要包括压缩和还原（解压缩）的两个步骤。其实就是在不改变原有文件属性的前提下，降低文件字节空间和占用空间的一种算法。

根据压缩算法的定义，我们可将其分成不同的类型：

有损和无损

无损压缩：能够 无失真从压缩后的数据重构，准确的还原原始数据。可用于对数据的准确性要求的场合。如可执行文件和普通文件的压缩，磁盘的压缩，也可用于多媒体数据的压缩。该方法的压缩比较小。如差分编码，RLE,Huffman编码，LZW编码，算术编码。

有损压缩：有失真， 不能完全准确的恢复原始数据，重构的数据只是原始数据的一个近似。可用于对数据的准确性要求不高的场合，如多媒体数据的压缩。该方法的压缩比较大。例如，预测编码，音感编码，分形压缩，小波压缩，JPEG/MPEG。

对称性

如果编码算法的复杂性和所需时间差不多，则为对称的编码方法，多数压缩算法都是对称的。但也有不对称的，一般是编码难而解码容易，如Huffman编码和分形编码。但用于密码学的编码方法则相反，是编码容易，则解码则非常难。

帧间与帧内

在视频编码中会同时用到帧内与帧间的编码方法，帧内编码是指在一帧图像内独立完成的编码方法，同静态图像的编码，如 JPEG；而帧间编码则需要参照前后帧才能进行编解码，并在编码过程中考虑对帧之间的时间冗余的压缩，如 MPEG。

实时性

在有些多媒体的应用场合，需要实时处理或传输数据（如现场的数字录音和录影、播放MP3/RM/VCD/DVD、视频/音频点播、网络现场直播、可视电话、视频会议），编解码一般要求延时 ≤50 ms。这就需要简单/快速/高效的算法和高速/复杂的CPU/DSP芯片。

分级处理

有些压缩算法可以同时处理不同分辨率、不同传输速率、不同质量水平的多媒体数据，如JPEG2000、MPEG-2/4。

这些概念有些抽象，主要是为了让大家了解一下压缩算法的分类，下面我们就对具体的几种常用的压缩算法来分析一下它的特点和优劣

几种常用压缩算法的理解

RLE 算法的机制

接下来就让我们正式看一下文件的压缩机制。首先让我们来尝试对 AAAAAABBCDDEEEEEF 这 17 个半角字符的文件（文本文件）进行压缩。虽然这些文字没有什么实际意义，但是很适合用来描述 RLE 的压缩机制。

由于半角字符（其实就是英文字符）是作为 1 个字节保存在文件中的，所以上述的文件的大小就是 17 字节。

像这样的可以压缩为：

3a3b然后就是5字节了

哈夫曼算法和莫尔斯编码

下面我们来介绍另外一种压缩算法，即哈夫曼算法。在了解哈夫曼算法之前，你必须舍弃半角英文数字的1个字符是1个字节(8位)的数据。下面我们就来认识一下哈夫曼算法的基本思想。

文本文件是由不同类型的字符组合而成的，而且不同字符出现的次数也是不一样的。例如，在某个文本文件中，A 出现了 100次左右，Q仅仅用到了 3 次，类似这样的情况很常见。哈夫曼算法的关键就在于 多次出现的数据用小于 8 位的字节数表示，不常用的数据则可以使用超过 8 位的字节数表示。A 和 Q 都用 8 位来表示时，原文件的大小就是 100次 * 8 位 + 3次 * 8 位 = 824位，假设 A 用 2 位，Q 用 10 位来表示就是 2 * 100 + 3 * 10 = 230 位。

不过要注意一点，最终磁盘的存储都是以8位为一个字节来保存文件的。

哈夫曼算法比较复杂，在深入了解之前我们先吃点甜品，了解一下 莫尔斯编码，你一定看过美剧或者战争片的电影，在战争中的通信经常采用莫尔斯编码来传递信息，例如下面

接下来我们来讲解一下莫尔斯编码，下面是莫尔斯编码的示例，大家把 1 看作是短点(嘀)，把 11 看作是长点(嗒)即可。

莫尔斯编码一般把文本中出现最高频率的字符用短编码 来表示。如表所示，假如表示短点的位是 1，表示长点的位是 11 的话，那么 E（嘀）这一数据的字符就可以用 1 来表示，C（滴答滴答）就可以用 9 位的 110101101来表示。在实际的莫尔斯编码中，如果短点的长度是 1 ，长点的长度就是 3，短点和长点的间隔就是1。这里的长度指的就是声音的长度。比如我们想用上面的 AAAAAABBCDDEEEEEF 例子来用莫尔斯编码重写，在莫尔斯曼编码中，各个字符之间需要加入表示时间间隔的符号。这里我们用 00 加以区分。

所以，AAAAAABBCDDEEEEEF 这个文本就变为了 A * 6 次 + B * 2次 + C * 1次 + D * 2次 + E * 5次 + F * 1次 + 字符间隔 * 16 = 4 位 * 6次 + 8 位 * 2次 + 9 位 * 1 次 + 6位 * 2次 + 1位 * 5次 + 8 位 * 1次 + 2位 * 16次 = 106位 = 14字节。

所以使用莫尔斯电码的压缩比为 14 / 17 = 82%。效率并不太突出。

用二叉树实现哈夫曼算法

刚才已经提到，莫尔斯编码是根据日常文本中各字符的出现频率来决定表示各字符的编码数据长度的。不过，在该编码体系中，对 AAAAAABBCDDEEEEEF 这种文本来说并不是效率最高的。

下面我们来看一下哈夫曼算法。哈夫曼算法是指，为各压缩对象文件分别构造最佳的编码体系，并以该编码体系为基础来进行压缩。因此，用什么样的编码（哈夫曼编码）对数据进行分割，就要由各个文件而定。用哈夫曼算法压缩过的文件中，存储着哈夫曼编码信息和压缩过的数据。

接下来，我们在对 AAAAAABBCDDEEEEEF 中的 A - F 这些字符，按照出现频率高的字符用尽量少的位数编码来表示这一原则进行整理。按照出现频率从高到低的顺序整理后，结果如下，同时也列出了编码方案。

字符	出现频率	编码（方案）	位数
A	6	0	1
E	5	1	1
B	2	10	2
D	2	11	2
C	1	100	3
F	1	101	3

在上表的编码方案中，随着出现频率的降低，字符编码信息的数据位数也在逐渐增加，从最开始的 1位、2位依次增加到3位。不过这个编码体系是存在问题的，你不知道100这个3位的编码，它的意思是用 1、0、0这三个编码来表示 E、A、A 呢？还是用10、0来表示 B、A 呢？还是用100来表示 C 呢。

而在哈夫曼算法中，通过借助哈夫曼树的构造编码体系，即使在不使用字符区分符号的情况下，也可以构建能够明确进行区分的编码体系。不过哈夫曼树的算法要比较复杂，下面是一个哈夫曼树的构造过程。

自然界树的从根开始生叶的，而哈夫曼树则是叶生枝。

哈夫曼树能够提升压缩比率

使用哈夫曼树之后，出现频率越高的的数据占用的位数越少，这也是哈夫曼树的核心思想，通过上图的步骤二可以看出，

枝条连接数据时，我们是从出现频率较低的数据开始的。这就意味着出现频率低的数据到达根部的枝条也越多。而枝条越多则意味着编码的位数随之增加。

接下来我们来看一下哈夫曼树的压缩比率，用上图得到的数据表示 AAAAAABBCDDEEEEEF 为 000000000000 100100 110 101101 0101010101 111，40位 = 5 字节。压缩前的数据是 17 字节，压缩后的数据竟然达到了惊人的5 字节，也就是压缩比率 = 5 / 17 = 29% 如此高的压缩率，简直是太惊艳了。

大家可以参考一下，无论哪种类型的数据，都可以用哈夫曼树作为压缩算法

文件类型	压缩前	压缩后	压缩比率
文本文件	14862字节	4119字节	28%
图像文件	96062字节	9456字节	10%
EXE文件	24576字节	4652字节	19%

c/c++实现的哈夫曼编码：

#include <bits/stdc++.h>
using namespace std;

int ct;
struct node {
  int Node;
  int w;
  bool operator<(const node& other) const { return other.w < w; }
};
map<char, int> Hash;
int Haffman[10005][3];
priority_queue<node> q;
unordered_map<int, string> Hs;
void Haffmantree_create() {
  while (q.size() != 1) {
    int x = q.top().w;
    int ls = q.top().Node;
    q.pop();
    int y = q.top().w;
    int rs = q.top().Node;
    q.pop();
    int sum = x + y;
    ++ct;
    Haffman[ct][0] = ls;
    Haffman[ct][1] = rs;
    q.push(node{ct, sum});
  }
}
void Haffman_serach(int rt, string s) {
  if (Haffman[rt][0] == Haffman[rt][1]) {
    cout << char(Haffman[rt][2]) << ' ' << s << endl;
    Hs[Haffman[rt][2]] = s;
    return;
  }
  Haffman_serach(Haffman[rt][0], s + '0');
  Haffman_serach(Haffman[rt][1], s + '1');
}
void Haffman_chieve(string s) {
  Haffmantree_create();
  string ss = "";
  Haffman_serach(ct, ss);
  string ans = "";
  for (auto key : s) {
    ans += Hs[key];
  }
  cout << ans << endl;
  cout << ans.size() << "bit" << endl;
}
int main() {
  string s;
  cin >> s;
  for (auto x : s) {
    Hash[x]++;
  }
  for (auto it = Hash.begin(); it != Hash.end(); it++) {
    ++ct;
    q.push(node{ct, it->second});
    Haffman[ct][0] = ct;
    Haffman[ct][1] = ct;
    Haffman[ct][2] = int(it->first);
  }
  Haffman_chieve(s);
  return 0;
}

可逆压缩和非可逆压缩

最后，我们来看一下图像文件的数据形式。图像文件的使用目的通常是把图像数据输出到显示器、打印机等设备上。常用的图像格式有 : BMP、JPEG、TIFF、GIF 格式等。

• BMP ： 是使用 Windows 自带的画笔来做成的一种图像形式

• JPEG：是数码相机等常用的一种图像数据形式

• TIFF: 是一种通过在文件中包含"标签"就能够快速显示出数据性质的图像形式

• GIF： 是由美国开发的一种数据形式，要求色数不超过 256个

图像文件可以使用前面介绍的 RLE 算法和哈夫曼算法，因为图像文件在多数情况下并不要求数据需要还原到和压缩之前一摸一样的状态，允许丢失一部分数据。我们把能还原到压缩前状态的压缩称为 可逆压缩，无法还原到压缩前状态的压缩称为非可逆压缩 。

一般来说，JPEG格式的文件是非可逆压缩，因此还原后有部分图像信息比较模糊。GIF 是可逆压缩