方法库大体上可以分为两类：静态库和动态库（共享库）。

1. windows中静态库是以 .lib 为后缀的文件，动态库是以 .dll 为后缀的文件。

2. linux中静态库是以 .a 为后缀的文件，动态库是以 .so为后缀的文件。

静态链接：

• 静态库 在链接阶段，会将汇编生成的目标文件.o与引用到的库一起链接打包到可执行文件中。因此对应的链接方式称为静态链接。
• 静态库可以简单看成是一组目标文件（.o .obj文件）的集合, 将若干个.o文件转换为静态库的过程，称之为打包. Linux下是使用ar工具， Windows下是使用lib.exe。
• Linux下静态链接库的后缀是.lib；Windows下静态链接库的后缀是.a。

动态链接：

• 动态库在程序编译时并不会被连接到目标代码中，而是在程序运行时才被载入。不同的应用程序如果调用相同的库，那么在内存里只需要有一份该共享库的实例，规避了空间浪费问题。动态库在程序运行是才被载入，也解决了静态库对程序的更新、部署和发布页会带来麻烦。用户只需要更新动态库即可，增量更新。
• 在Windows系统下的执行文件格式是PE（Portable Executable）格式，动态库需要一个DllMain函数做出初始化的入口，通常在导出函数的声明时需要有_declspec(dllexport)关键字。 跟exe有个main或者WinMain入口函数一样，DLL也有一个入口函数，就是DllMain。根据编写规范，Windows必须查找并执行DLL里的DllMain函数作为加载DLL的依据，它使得DLL得以保留在内存里。这个函数并不属于导出函数，而是DLL的内部函数。这意味着不能直接在应用工程中引用DllMain函数，DllMain是自动被调用的。
  对于动态链接库，DllMain是一个可选的入口函数。一个动态链接库不一定要有DllMain函数，比如仅仅包含资源信息的DLL是没有DllMain函数的。

• Linux下gcc编译的执行文件默认是ELF格式，不需要初始化入口，亦不需要函数做特别的声明，编写比较方便。
  无需打包工具，直接使用编译器即可创建动态库。
• Linux下动态链接库的后缀是.so；Windows下动态链接库的后缀是.dll

一、动态链接库创建和使用

1.创建hello.so动态库

#include <stdio.h>void hello(){	printf("hello world\n");}编译：gcc -fPIC -shared hello.c -o libhello.so

2.hello.h头文件

void hello();

3.链接动态库

#include <stdio.h>#include "hello.h" int main(){	printf("call hello()");	hello();}编译：gcc main.c -L. -lhello -o main

这里-L的选项是指定编译器在搜索动态库时搜索的路径，告诉编译器hello库的位置。”.”意思是当前路径.

3.编译成够后执行./main，会提示：

In function `main':
 
main.c:(.text+0x1d): undefined reference to `hello'
collect2: ld returned 1 exit status

这是因为在链接hello动态库时，编译器没有找到。
解决方法：

sudo cp libhello.so /usr/lib/

这样，再次执行就成功输入:
call hello()

二、静态库 创建和使用

文件有：main.c、hello.c、hello.h
1.编译静态库hello.o: 

gcc hello.c -o hello.o  #这里没有使用-shared

2.把目标文档归档

ar -r libhello.a hello.o  #这里的ar相当于tar的作用，将多个目标打包。

程序ar配合参数-r创建一个新库libhello.a，并将命令行中列出的文件打包入其中。这种方法，如果libhello.a已经存在，将会覆盖现在文件，否则将新创建。

3.链接静态库

gcc main.c -lhello -L. -static -o main

这里的-static选项是告诉编译器,hello是静态库。
或者：

gcc main.c libhello.a -L. -o main

这样就可以不用加-static

4.执行./main

输出：call hello()

区别：

可执行文件大小不一样

从前面也可以观察到，静态链接的可执行文件要比动态链接的可执行文件要大得多，因为它将需要用到的代码从二进制文件中“拷贝”了一份，而动态库仅仅是复制了一些重定位和符号表信息。

占用磁盘大小不一样

如果有多个可执行文件，那么静态库中的同一个函数的代码就会被复制多份，而动态库只有一份，因此使用静态库占用的磁盘空间相对比动态库要大。

扩展性与兼容性不一样

如果静态库中某个函数的实现变了，那么可执行文件必须重新编译，而对于动态链接生成的可执行文件，只需要更新动态库本身即可，不需要重新编译可执行文件。正因如此，使用动态库的程序方便升级和部署。

依赖不一样

静态链接的可执行文件不需要依赖其他的内容即可运行，而动态链接的可执行文件必须依赖动态库的存在。所以如果你在安装一些软件的时候，提示某个动态库不存在的时候也就不奇怪了。

即便如此，系统中一般存在一些大量公用的库，所以使用动态库并不会有什么问题。

复杂性不一样

相对来讲，动态库的处理要比静态库要复杂，例如，如何在运行时确定地址？多个进程如何共享一个动态库？当然，作为调用者我们不需要关注。另外动态库版本的管理也是一项技术活。这也不在本文的讨论范围。

加载速度不一样

由于静态库在链接时就和可执行文件在一块了，而动态库在加载或者运行时才链接，因此，对于同样的程序，静态链接的要比动态链接加载更快。所以选择静态库还是动态库是空间和时间的考量。但是通常来说，牺牲这点性能来换取程序在空间上的节省和部署的灵活性时值得的。再加上局部性原理，牺牲的性能并不多。

运行cpp文件：

如何运行cpp文件：
方法1、vscode runcode
方法2、使用g++命令简单编译，在终端输入 g++ -o test test.cpp # -L. -l动态库名 （如果需要导入动态库）
方法3、对于复杂的程序，需要编写makefile or 使用cmake ，然后执行 make命令

CMake说明: 一般把CMakeLists.txt文件放在工程目录下，使用时，先创建一个叫build的文件夹（这个并非必须，因为cmake命令指向CMakeLists.txt所在的目录，例如cmake .. 表示CMakeLists.txt在当前目录的上一级目录。cmake后会生成很多编译的中间文件以及makefile文件，所以一般建议新建一个新的目录，专门用来编译），然后执行下列操作：

cd build
cmake ..
make
其中cmake .. 在build里生成Makefile，make根据生成makefile文件，编译程序，make应当在有Makefile的目录下，根据Makefile生成可执行文件。

C++编译过程主要分为，预处理、编译、汇编、链接四个过程。如下图所示：

第一步:预处理 将源代码的.c 、.cpp 、.h 等文件包含到一个文件中。在这个过程中会使用一些预处理指令要求编译器使用什么样的方式包含这些文件。预处理结束之后对于c语言编译器会生成一个.i 文件。C++会生成.ii文件。

预编译过程主要处理那些源代码中以#开始的预编译指令，主要处理规则如下：

·将所有的#define删除，并且展开所有的宏定义；

·处理所有条件编译指令，如#if，#ifdef等；

·处理#include预编译指令，将被包含的文件插入到该预编译指令的位置。该过程递归进行，及被包含的文件可能还包含其他文件。

·删除所有的注释//和 /**/；

·添加行号和文件标识，如#2 “hello.c” 2,以便于编译时编译器产生调试用的行号信息及用于编译时产生编译错误或警告时能够显示行号信息；

·保留所有的#pragma编译器指令，因为编译器须要使用它们；

第二步:编译 编译过程就是把预处理完的文件进行一系列词法分析，语法分析，语义分析及优化后生成相应的汇编代码文件.

第三步:汇编 汇编器是将汇编代码转变成机器可以执行的命令，每一个汇编语句几乎都对应一条机器指令。汇编相对于编译过程比较简单，根据汇编指令和机器指令的对照表一一翻译即可。

第四步:链接 链接器ld将各个目标文件组装在一起，解决符号依赖，库依赖关系，并生成可执行文件。

动态链接和静态链接

方法库大体上可以分为两类：静态库和动态库（共享库）。

1. windows中静态库是以 .lib 为后缀的文件，动态库是以 .dll 为后缀的文件。

2. linux中静态库是以 .a 为后缀的文件，动态库是以 .so为后缀的文件。

静态链接：

• 静态库 在链接阶段，会将汇编生成的目标文件.o与引用到的库一起链接打包到可执行文件中。因此对应的链接方式称为静态链接。
• 静态库可以简单看成是一组目标文件（.o .obj文件）的集合, 将若干个.o文件转换为静态库的过程，称之为打包. Linux下是使用ar工具， Windows下是使用lib.exe。
• Linux下静态链接库的后缀是.lib；Windows下静态链接库的后缀是.a。

动态链接：

• 动态库在程序编译时并不会被连接到目标代码中，而是在程序运行时才被载入。不同的应用程序如果调用相同的库，那么在内存里只需要有一份该共享库的实例，规避了空间浪费问题。动态库在程序运行是才被载入，也解决了静态库对程序的更新、部署和发布页会带来麻烦。用户只需要更新动态库即可，增量更新。
• 在Windows系统下的执行文件格式是PE（Portable Executable）格式，动态库需要一个DllMain函数做出初始化的入口，通常在导出函数的声明时需要有_declspec(dllexport)关键字。 跟exe有个main或者WinMain入口函数一样，DLL也有一个入口函数，就是DllMain。根据编写规范，Windows必须查找并执行DLL里的DllMain函数作为加载DLL的依据，它使得DLL得以保留在内存里。这个函数并不属于导出函数，而是DLL的内部函数。这意味着不能直接在应用工程中引用DllMain函数，DllMain是自动被调用的。
  对于动态链接库，DllMain是一个可选的入口函数。一个动态链接库不一定要有DllMain函数，比如仅仅包含资源信息的DLL是没有DllMain函数的。

• Linux下gcc编译的执行文件默认是ELF格式，不需要初始化入口，亦不需要函数做特别的声明，编写比较方便。
  无需打包工具，直接使用编译器即可创建动态库。
• Linux下动态链接库的后缀是.so；Windows下动态链接库的后缀是.dll

区别：

 当程序与静态库链接时，静态库中所包含的所有函数方法都会被copy到最终的可执行文件中去。这就会导致最终生成的可执行代码量相对变多，相当于编译器将代码补充完整了。这种方式会让程序运行起来相对快一些，不过也会有个缺点: 占用磁盘和内存空间，导致可执行exe程序过大。另外，静态库会被添加到和它链接的每个程序中去, 而且这些程序运行时, 都会被加载到内存中，无形中又多消耗了更多的内存空间。

与动态库链接的可执行文件只包含它需要的函数方法的引用表，而不是所有的函数代码，只有在程序执行时, 那些需要的函数代码才会被拷贝到内存中。这样就使可执行文件比较小, 节省磁盘空间，更进一步，操作系统使用虚拟内存，使得一份动态库驻留在内存中被多个程序使用，也同时节约了内存。不过由于运行时要去链接库会花费一定的时间，执行速度相对会慢一些。

       总的来说，静态库是牺牲了空间效率，换取了时间效率，动态库是牺牲了时间效率换取了空间效率，没有好与坏的区别，只看具体需要了。
       另外，一个程序编好后，有时需要做一些修改和优化，如果我们要修改的刚好是库函数的话，在接口不变的前提下，使用动态库的程序只需要将动态库重新编译就可以了，而使用静态库的程序则需要将静态库重新编译好后，将程序再重新编译一遍。

文章来源 图灵人工智能   转自STM32嵌入式开发，版权属于原作者，仅学术分享

先说一下半导体，啥叫半导体？就是介于导体和绝缘体中间的一种东西，比如二极管。相关文章:关于二极管的基础知识。

电流可以从A端流向C端，但反过来则不行。你可以把它理解成一种防止电流逆流的东西。

当C端10V，A端0V，二极管可以视为断开。

当C端0V，A端10V，二极管可以视为导线，结果就是A端的电流源源不断的流向C端，导致最后的结果就是A端=C端=10V。

等等，不是说好的C端0V，A端10V么？咋就变成结果是A端=C端=10V了？你可以把这个理解成初始状态，当最后稳定下来之后就会变成A端=C端=10V。

文科的童鞋们对不住了，实在不懂问高中物理老师吧。反正你不能理解的话就记住这种情况下它相当于导线就行了。

利用半导体的这个特性，我们可以制作一些有趣的电路，比如【与门】。

我们把这个装置成为【与门】，把有电压的地方计为1，0电压的地方计为0。至于具体几V电压，那不重要。也就是AB必须同时输入1，输出端Y才是1;AB有一个是0，输出端Y就是0。

其他还有【或门】【非门】和【异或门】，跟这个都差不多，或门就是输入有一个是1输出就是1，输入00则输入0。

非门也好理解，就是输入1输出0，输入0输出1。

异或门难理解一些，不过也就那么回事，输入01或者10则输出1，输入00或者11则输出0。（即输入两个一样的值则输出0，输入两个不一样的值则输出1）。

这几种门都可以用二极管或者三极管做出来，具体怎么做就不演示了，有兴趣的童鞋可以自己试试。当然实际并不是用二极管三极管做的，因为它们太费电了。实际是用场效应管（也叫MOS管）做的。

然后我们就可以用门电路来做CPU了。当然做CPU还是挺难的，我们先从简单的开始：加法器。相关文章:CPU如何进行数字加法。加法器顾名思义，就是一种用来算加法的电路，最简单的就是下面这种。

AB只能输入0或者1，也就是这个加法器能算0+0，1+0或者1+1。

输出端S是结果，而C则代表是不是发生进位了，二进制1+1=10嘛。这个时候C=1，S=0。

费了大半天的力气，算个1+1是不是特别有成就感？

那再进一步算个1+2吧（二进制01+10），然后我们就发现了一个新的问题：第二位需要处理第一位有可能进位的问题，所以我们还得设计一个全加法器。

每次都这么画实在太麻烦了，我们简化一下。

也就是有3个输入2个输出，分别输入要相加的两个数和上一位的进位，然后输入结果和是否进位。然后我们把这个全加法器串起来：

我们就有了一个4位加法器，可以计算4位数的加法也就是15+15，已经达到了幼儿园中班水平，是不是特别给力？

做完加法器我们再做个乘法器吧，当然乘任意10进制数是有点麻烦的，我们先做个乘2的吧。

乘2就很简单了，对于一个2进制数数我们在后面加个0就算是乘2了。比如：

5=101（2）

10=1010（2）

以我们只要把输入都往前移动一位，再在最低位上补个零就算是乘2了。具体逻辑电路图我就不画，你们知道咋回事就行了。

那乘3呢？简单，先位移一次（乘2）再加一次。乘5呢？先位移两次（乘4）再加一次。

所以一般简单的CPU是没有乘法的，而乘法则是通过位移和加算的组合来通过软件来实现的。这说的有点远了，我们还是继续做CPU吧。

现在假设你有8位加法器了，也有一个位移1位的模块了。串起来你就能算(A＋B)×2了！激动人心，已经差不多到了准小学生水平。

那我要是想算A×2＋B呢？简单，你把加法器模块和位移模块的接线改一下就行了，改成输入A先过位移模块，再进加法器就可以了。

你的意思是我改个程序还得重新接线？

所以你以为呢？

实际上，编程就是把线来回插啊。惊喜不惊喜？意外不意外？

早期的计算机就是这样编程的，几分钟就算完了但插线好几天。关于插线编程的相关文章推荐看着篇:国内大神手工焊接，制作了一个CPU。而且插线是个细致且需要耐心的工作，所以那个时候的程序员都是清一色的漂亮女孩子，穿制服的那种，就像照片上这样。是不是有种生不逢时的感觉？

插线也是个累死人的工作。所以我们需要改进一下，让CPU可以根据指令来相加或者乘2。这里再引入两个模块，一个叫flip-flop，简称FF，中文好像叫触发器，如下图这样。

这个模块的作用是存储1bit数据。比如上面这个RS型的FF，R是Reset，输入1则清零。S是Set，输入1则保存1。RS都输入0的时候，会一直输出刚才保存的内容。

我们用FF来保存计算的中间数据（也可以是中间状态或者别的什么），1bit肯定是不够的，不过我们可以并联嘛，用4个或者8个来保存4位或者8位数据。这种我们称之为寄存器（Register）。另外一个叫MUX，中文叫选择器，如下图就是一个选择器。

这个就简单了，sel输入0则输出i0的数据，i0是什么就输出什么，01皆可。同理sel如果输入1则输出i1的数据。当然选择器可以做的很长，比如这种四进一出的具体原理不细说了，其实看看逻辑图琢磨一下就懂了，知道有这个东西就行了。下图是一个四进一出-选择器。

有这个东西我们就可以给加法器和乘2模块（位移）设计一个激活针脚。

这个激活针脚输入1则激活这个模块，输入0则不激活。这样我们就可以控制数据是流入加法器还是位移模块了。

于是我们给CPU先设计8个输入针脚，4位指令，4位数据。

我们再设计3个指令：

• 0100，数据读入寄存器
• 0001，数据与寄存器相加，结果保存到寄存器
• 0010，寄存器数据向左位移一位（乘2）

为什么这么设计呢，刚才也说了，我们可以为每个模块设计一个激活针脚。然后我们可以分别用指令输入的第二第三第四个针脚连接寄存器，加法器和位移器的激活针脚。

这样我们输入0100这个指令的时候，寄存器输入被激活，其他模块都是0没有激活，数据就存入寄存器了。同理，如果我们输入0001这个指令，则加法器开始工作，我们就可以执行相加这个操作了。

这里就可以简单回答这个问题的第一个小问题了：CPU是为什么能看懂这些二级制的数呢？

为什么CPU能看懂，因为CPU里面的线就是这么接的呗。你输入一个二进制数，就像开关一样激活CPU里面若干个指定的模块以及改变这些模块的连同方式，最终得出结果。

几个可能会被问的问题

Q：CPU里面可能有成千上万个小模块，一个32位/64位的指令能控制那么多吗？

A：我们举例子的CPU里面只有3个模块，就直接接了。真正的CPU里会有一个解码器（decoder），把指令翻译成需要的形式。

Q：你举例子的简单CPU，如果我输入指令0011会怎么样？

A：当然是同时激活了加法器和位移器从而产生不可预料的后果，简单的说因为你使用了没有设计的指令，所以后果自负呗。在真正的CPU上这么干大概率就是崩溃呗，不过肯定会有各种保护性的设计。

细心的小伙伴可能发现一个问题：你设计的指令【0001，数据与寄存器相加，结果保存到寄存器】这个一步做不出来吧？

毕竟还有一个回写的过程，实际上确实是这样。我们设计的简易CPU执行一个指令差不多得三步，读取指令，执行指令，写寄存器。

经典的RISC设计则是分5步：读取指令(IF)，解码指令(ID)，执行指令(EX)，内存操作(MEM)，写寄存器(WB)。我们平常用的x86的CPU有的指令可能要分将近20个步骤。

你可以理解有这么一个开关，我们啪的按一下，CPU就走一步，你按的越快CPU就走的越快。咦？听说你有个想法？少年，你这个想法很危险啊，姑且不说你能不能按那么快。拿现代的CPU来说，也就2GHz多吧，大概一秒也就按个20亿下吧。

就算你能按那么快，虽然速度是上去了，但功耗会大大增加，发热上升稳定性下降。江湖上确实有这种玩法，名曰超频，不过新手不推荐你尝试哈。

那CPU怎么知道自己走到哪一步了呢？前面不是介绍了FF么，这个不光可以用来存中间数据，也可以用来存中间状态，也就是走到哪了。

具体的设计涉及到FSM（finite-state machine），也就是有限状态机理论，以及怎么用FF实装。这个也是很重要的一块，考试必考哈，只不过跟题目关系不大，这里就不展开讲了。

我们再继续刚才的讲，现在我们有3个指令了。我们来试试算个（1+4）X2+3吧。

0100 0001 ；寄存器存入1

0001 0100 ；寄存器的数字加4

0010 0000 ；乘2

0001 0011 ；再加三

太棒了，靠这台计算机我们应该可以打败所有的幼儿园小朋友，称霸大班了。而且现在我们用的是4位的，如果换成8位的CPU完全可以吊打低年级小学生了！

实际上用程序控制CPU是个挺高级的想法，再此之前计算机（器）的CPU都是单独设计的。

1969年一家日本公司BUSICOM想搞程控的计算器，而负责设计CPU的美国公司也觉得每次都重新设计CPU是个挺傻X的事，于是双方一拍即合，于1970年推出一种划时代的产品，世界上第一款微处理器4004。

这个架构改变了世界，那家负责设计CPU的美国公司也一步一步成为了业界巨头。哦对了，它叫Intel，对，就是噔噔噔噔的那个。

我们把刚才的程序整理一下：

“01000001000101000010000000010011”

你来把它输入CPU，我去准备一下去幼儿园大班踢馆的工作。

什么！？等我们输完了人家小朋友掰手指都能算出来了？

没办法机器语言就是这么反人类。哦，忘记说了，这种只有01组成的语言被称之为机器语言（机器码），是CPU唯一可以理解的语言。不过你把机器语言让人读，绝对一秒变典韦，这谁也受不了。

所以我们还是改进一下吧。不过话虽这么讲，也就往前个30年，直接输入01也是个挺普遍的事情。

于是我们把我们机器语言写成的程序：

0100 0001 ；寄存器存入1

0001 0100 ；寄存器的数字加4

0010 0000 ；乘2

0001 0011 ；再加三

改写成：

MOV 1 ；寄存器存入1

ADD 4 ；寄存器的数字加4

SHL 0 ；乘2（介于我们设计的乘法器暂时只能乘2，这个0是占位的）

ADD 3 ；再加三

是不是容易读多了？这就叫汇编语言。

汇编语言的好处在于它和机器语言一一对应。

也就是我们写的汇编可以完美的改写成机器语言，直接指挥cpu，进行底层开发；我们也可以把内存中的数据dump出来，以汇编语言的形式展示出来，方便调试和debug。

汇编语言极大的增强了机器语言的可读性和开发效率，但对于人类来说也依然是太晦涩了，于是我们又发明了高级语言，以近似于人类的语法来表现数据结构和算法。

比如很多语言都可以这么写：

a=(1+4)*2+3;

当然这样计算机是不认识的，我们要把它翻译成计算机认识的形式，这个过程叫编译，用来做这个事的东西叫编译器。

具体怎么把高级语言弄成汇编语言/机器语言的，一本书都写不完，我们就举个简单的例子。

我们把：

(1+4)*2+3

转换成：

1，4，+，2，*，3，+

这种写法叫后缀表示法，也成为逆波兰表示法。相对的，我们平常用的表示法叫中缀表示法，也就是符号方中间，比如1+4。而后缀表示法则写成1，4，+。

转换成这种写法的好处是没有先乘除后加减的影响，也没有括号了，直接算就行了。

具体怎么转换的可以找本讲编译原理的书看看，这里不展开讲了。

转换成这种形式之后我们就可以把它改成成汇编语言了。

从头开始处理，最开始是1，一个数字，那就存入寄存器：

MOV 1

之后是4，+，那就加一下：

ADD 4

然后是2，*，那就乘一下（介于我们设计的乘法器暂时只能乘2，这个0是占位的）：

SHL 0

最后是3，+，那再加一下：

ADD 3

最后我们把翻译好的汇编整理一下：

MOV 1

ADD 4

SHL 0

ADD 3

再简单的转换成机器语言，就可以拿到我们设计的简单CPU上运行了。

其实到了这一步，应该把这个问题都讲清楚了：C语言写出来的东西是怎么翻译成二进制的，电脑又是怎么运行这个二进制的。

只不过题主最后还提到栈和硬件的关系，这里就再多说几句。

其实栈是一种数据结构，跟CPU无关。只不过栈这个数据结构实在太常用了，以至于CPU会针对性的进行优化。为了能让我们的CPU也能用栈，我们给它增加几个组件。

第一，增加一组寄存器。现在有两组寄存器了，我们分别成为A和B。

第二，增加两个指令，RDA/RDB和WRA/WRB，分别为把指定内存地址的数据读到寄存器A/B，和把寄存器A/B的内容写到指定地址。

顺便再说下内存，内存有个地址总线，有个数据总线。比如你要把1100这个数字存到0011这个地址，就把1100接到数据总线，0011接到地址总线，都准备好了啪嚓一按开关（对，就是我们前面提到的那个开关），就算是存进去了。

什么叫DDR内存呢，就是你按这个开关的时候存进去一个数字，抬起来之前你把地址和数据都更新一下，然后一松手，啪！又进去一个。也就是正常的内存你按一下进去1个数据，现在你按一下进去俩数据，这就叫双倍速率（Double Data Rate，简称DDR）

加了这几个命令之后我们发现按原来的设计，CPU每个指令针脚控制一个模块的方式的话针脚不够用了。所以我们就需要加一个解码器了（decoder）。

于是我们选择用第二个位作为是否选择寄存器的针脚。如果为0，则第三第四位可以正常激活位移器和加法器；如果为1则只激活寄存器而不激活位移和加法器，然后用第四位来决定是寄存器A还是B。这样变成了：

• 0100，数据读入寄存器A
• 0101，数据读入寄存器B （我们把汇编指令定义为MOVB）
• 0001，数据与寄存器A相加，结果保存到寄存器A
• 0011，数据与寄存器B相加，结果保存到寄存器B（我们把汇编指令定义为ADDB）
• 0010，寄存器A数据向左位移一位（乘2）

最后我们可以用第一位来控制是不是进行内存操作。如果第一位为1则也不激活位移和加法器模块，然后用第三个针脚来控制是读还是写。这样就有了：

• 1100，把寄存器B的地址数据读入寄存器A（我们把汇编指令定义为RD）
• 1110，寄存器A的数据写到寄存器B指定的地址（我们把汇编指令定义为WR）

我们加了个解码器之后，加法器的激活条件从p4变成了(NOT (p1 OR p2)) AND p4。

加法器的输入则由第三个针脚判断，0则为寄存器A，1为寄存器B。这就是简单的指令解码啦。

当然我们也可以选择不向下兼容，另外设计一套指令。不过放到现实世界恐怕就要出大乱子了，所以你也可以想象我们平常用的x86背了个多大的历史包袱。

这个时候我们用栈的话，先栈地址初始化：

0101 1000 ; MOVB 16; 把栈底地址定义为1000

之后入栈的话，比如把数字3,4入栈：

1111 0011 ; WR 03; 把3写到内存，地址为1000

0011 0001 ; ADDB 01; 栈地址+1

1111 0100 ; WR 04; 把3写到内存，地址为1001

0011 0001 ; ADDB 01; 栈地址+1

这样就把3，4都保存到栈里了。

出栈的话反过来：

0011 1111 ; ADDB -1; 栈地址-1

1101 0000 ; RD 00; 把内容读入寄存器A，00是占位

0011 1111 ; ADDB -1; 栈地址-1

1101 0000 ; RD 00; 把内容读入寄存器A，00是占位

这样就依次得到4，3两个值。

所以，入栈出栈其实就是把数据写道指定的内存位置，CPU其实不知道你是在干啥。相关文章:关于C语言堆栈的经典讲解。当然我们也可以让CPU知道。

接下来我们再改进一下，给CPU再加一个寄存器SP，并定义两个指令：一个PUSH，一个POP。动作分别是把数据写入SP的地址，然后SP=SP+1，POP的话反过来。

这样有什么好处呢？好处在于PUSH/POP这样的指令消耗特别少，速度特别快。而栈这种数据结构在各种程序里用的又特别频繁，设计成专用的指令则可以很大程度上提升效率。

当然前提是编译器知道这个指令，并且做了优化，所以同样的程序（c语言写的），编译参数不一样（打开/关闭某些特性），编译出来的东西也就不一样，在不同硬件上的运行的效率也就会不一样。

比如上古时代的mmx，今天的SSE4.2，AVX-512，给力不给力？特别给力，但你平常用的程序支不支持是另一码事，要支持怎么办？重新编译呗。

这个时候开源的优势就显示出来了，重新编译很方便。闭源的话你就要指望作者开恩啦。

对于大多数人来说，电脑就是个黑箱，我们很难理解它到底是怎用工作的。这个问题又很难一句两句解释清楚，因为它是一环扣一环的，每一环都很抽象，每一环都是基础值俩个学分，展开了讲没上限的那种。

这就导致了即使是系统学过计算机的人也不见得就有一个明确而清晰的思路。想用尽量短的篇幅和尽量简单的语言把这个事从头到位解释了一下，希望能给大家解答一些疑惑。关于软硬件结合，另外也推荐下这篇文章:代码是如何控制硬件的？

1、视频

https://www.bilibili.com/video/BV1et411b73Z?p=2&spm_id_from=pageDriver&vd_source=dab57cea5e1b38b49ad994543c0c61bf

2、github笔记

资料地址：https://github.com/AnkerLeng/Cpp-0-1-Resource

代码实例：

#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
using namespace std;
class Stack
{
public:
Stack(int size=1024);
~Stack();
void init();
bool isEmpty();
bool isFull();
void push(int data);
int pop();
private:
int* space;
int top;
};
Stack::Stack(int size)
{
space = new int[size];
top = 0;
}
Stack::~Stack()
{
delete []space;
}
//void Stack::init()
//{
// memset(space,0,sizeof(space));
// top = 0;
//}
bool Stack::isEmpty()
{
return top == 0;
}
bool Stack::isFull()
{
return top == 1024;
}
void Stack::push(int data)
{
space[top++] = data;
}
int Stack::pop()
{
return space[--top];
}
int main()
{
// Stack s;
Stack s(100);
// s.init();
if(!s.isFull())
s.push(10);
if(!s.isFull())
s.push(20);
if(!s.isFull())
s.push(30);
if(!s.isFull())
s.push(40);
if(!s.isFull())
s.push(50);
while(!s.isEmpty())
cout<<s.pop()<<endl;
return 0;
}

1、构造器（Constructor）：

在类对象创建时，自动调用，完成类对象的初始化。尤其是动态堆内存的申请。
规则:
1 在对象创建时自动调用,完成初始化相关工作。
2 无返回值，与类名同，
3 可以重载，可默认参数。
4 默认无参空体，一经实现，默认不复存在。

class 类名
{
类名(形式参数)
构造体
}
class A
{
A(形参)
{}
}

比如：

Stack::Stack(int size)
{
space = new int[size];
top = 0;
}

private和public，类对象可以直接访问公有成员，但只有公有成员函数内部来访问对象的私有成员

析造器(Destructor)：析构函数的作用，并不是删除对象，而在对象销毁前完成的一些清理工作。
对象销毁时期
1、栈对象离开其作用域。
2、堆对象被手动 delete.

定义：
class 类名
{
~类名()
析造体
}
class A
{
~A()
{}
}

在类对像销毁时，自动调用，完成对象的销毁。尤其是类中己申请的堆内存的释放.
规则:
1 对象销毁时，自动调用。完成销毁的善后工作。
2 无返值，与类名同，无参。不可以重载与默认参数。
3 系统提供默认空析构器，一经实现，不复存在。
Stack::~Stack()
{
delete []space;
}

this 指针

系统在创建对象时，默认生成的指向当前对象的指针。这样作的目的，就是为了带来方
便

1，避免构造器的入参与成员名相同。
2，基于 this 指针的自身引用还被广泛地应用于那些支持多重串联调用的函数中。
比如连续赋值

#include <iostream>
using namespace std;
class Stu
{
public:
Stu(string name, int age) // :name(name),age(age)
{
this->name = name;
this->age = age;
}
Stu & growUp()
{
this->age++;
return *this; // return this; ??
}
void display()
{
cout<<name<<" : "<<age<<endl;
}
private:
string name;
int age;
};
int main()
{
Stu s("wangguilin",30);
s.display();
s.growUp().growUp().growUp().growUp().growUp();
s.display();
return 0;
}

类继承

在 C++中可重用性(software reusability)是通过继承(inheritance)这一机制来实现的。如果没有掌握继承性，就没有掌握类与对象的精华

#include <iostream>
using namespace std;
class Person
{
public:
void eat(string food)
{
cout<<"i am eating "<<food<<endl;
}
};
class Student:public Person
{
public:
void study(string course)
{
cout<<"i am a student i study "<<course<<endl;
}
};
class Teacher:public Person
{
public:
void teach(string course)
{
cout<<"i am a teacher i teach "<<course<<endl;
}
};
int main()
{
Student s;
s.study("C++");
s.eat("黄焖鸡");
Teacher t;
t.teach("Java");
t.eat("驴肉火烧");
return 0;
}

类的继承，是新的类从已有类那里得到已有的特性。或从已有类产生新类的过程就是类的派生。原有的类称为基类或父类，产生的新类称为派生类或子类。派生与继承，是同一种意义两种称谓。

派生类的声明：
class 派生类名：[继承方式] 基类名
{
派生类成员声明；
};

一个派生类可以同时有多个基类，这种情况称为多重继承，派生类只有一个基类，称为单继承。下面从单继承讲起

继承方式规定了如何访问基类继承的成员。继承方式有 public, private, protected。继承方式不影响派生类的访问权限，影响了从基类继承来的成员的访问权限，包括派生类内的访问权限和派生类对象。
简单讲：
公有继承：基类的公有成员和保护成员在派生类中保持原有访问属性，其私有成员仍为基类的私有成员。
私有继承：基类的公有成员和保护成员在派生类中成了私有成员，其私有成员仍为基类的私有成员。
保护继承：基类的公有成员和保护成员在派生类中成了保护成员，其私有成员仍为基类的私有成员

pretected 对于外界访问属性来说，等同于私有，但可以派生类中可见。

#include <iostream>
using namespace std;
class Base
{
public:
int pub;
protected:
int pro;
private:
int pri;
};
class Drive:public Base
{
public:
void func()
{
pub = 10;
pro = 100;
// pri = 1000;
public;
int a;
protected:
int b;
private:
int c
};
//
int main()
{
Base b;
b.pub = 10;
// b.pro = 100;
// b.pri = 1000;
return 0;
}

派生类中的成员，包含两大部分，一类是从基类继承过来的，一类是自己增加的成员。从基类继承过过来的表现其共性，而新增的成员体现了其个性。

几点说明：
1，全盘接收，除了构造器与析构器。基类有可能会造成派生类的成员冗余，所以说基
类是需设计的。
2，派生类有了自己的个性，使派生类有了意义

派生类中由基类继承而来的成员的初始化工作还是由基类的构造函数完成，然后派生类
中新增的成员在派生类的构造函数中初始化。

派生类构造函数的语法：
派生类名::派生类名（参数总表）:基类名（参数表）,内嵌子对象（参数表）
{
派生类新增成员的初始化语句; //也可出现地参数列表中
}

构造函数的初始化顺序并不以上面的顺序进行，而是根据声明的顺序初始化。
如果基类中没有默认构造函数(无参)，那么在派生类的构造函数中必须显示调用基类构
造函数，以初始化基类成员。

代码实现
祖父类
student.h
class Student
{
public:
Student(string sn,int n,char s);
~Student();
void dis();
private:
string name;
int num;
char sex;
};


student.cpp
Student::Student(string sn, int n, char s)
:name(sn),num(n),sex(s)
{
}
Student::~Student()
{
}
void Student:: dis()
{
cout<<name<<endl;
cout<<num<<endl;
cout<<sex<<endl;
}
父类
graduate.h
class Graduate:public Student
{
public:
Graduate(string sn,int in,char cs,float fs);
~Graduate();
void dump()
{
dis();
cout<<salary<<endl;
}
private:
float salary;
};

graduate.cpp
Graduate::Graduate(string sn, int in, char cs, float fs)
:Student(sn,in,cs),salary(fs)
{
}
Graduate::~Graduate()
{
}

 类成员
birthday.h
class Birthday
{
public:
Birthday(int y,int m,int d);
~Birthday();
void print();
private:
int year;
int month;
int day;
};

birthday.cpp
Birthday::Birthday(int y, int m, int d)
:year(y),month(m),day(d)
{
}
Birthday::~Birthday()
{
}
void Birthday::print()
{
cout<<year<<month<<day<<endl;
}

 子类
doctor.h
class Doctor:public Graduate
{
public:
Doctor(string sn,int in,char cs,float fs,string st,int iy,int im,in
t id);
~Doctor();
void disdump();
private:
string title; //调用的默认构造器，初始化为””
Birthday birth; //类中声明的类对象
};

doctor.cpp
Doctor::Doctor(string sn, int in, char cs, float fs, string st, int iy,
int im, int id)
:Graduate(sn,in,cs,fs),birth(iy,im,id),title(st)
{
}
Doctor::~Doctor()
{
}
void Doctor::disdump()
{
dump();
cout<<title<<endl;
birth.print();
}
测试代码
int main()
{
Student s("zhaosi",2001,'m');
s.dis();
cout<<"----------------"<<endl;
Graduate g("liuneng",2001,'x',2000);
g.dump();
cout<<"----------------"<<endl;
Doctor d("qiuxiang",2001,'y',3000,"doctor",2001,8,16);
d.disdump();
return 0;