在计算机科学中，栈是一个特殊的容器，用户可以将数据压入栈中（入栈，push），也可以将已经压入栈中的数据弹出（出栈，pop），但栈容器必须准守一个规则：先入栈的数据后出栈（First In Last Out,FIFO）。
     在计算机系统中，栈是一个具有以上属性的动态内存区域（这里的动态指的是栈的空间可以动态增长或减小）。程序可以将数据压入栈中，也可以将数据从栈顶弹出。压栈使得栈空间增大，出栈使得栈空间减小。栈的空间总是自顶向下增长的（由高地址向低地址扩展）。

一，栈帧的介绍

     栈在程序空间中有着非常重要的地位，栈中保存了一个函数调用所需的维护信息，这就是我们常说的栈帧，栈帧一般包括以下几方面内容：
1） 函数的返回地址（用于返回函数调用处）和参数
2） 临时变量：包括函数的非静态局部变量以及编译器自动生成的其他临时变量
3） 保存的上下文：包括在函数调用前后需要保持不变的寄存器。
     在i386中，一个函数的活动记录范围由ebp和esp两个寄存器来
划定，其中esp寄存器始终指向栈顶，同时也指向当前函数的活动记录的顶部；ebp寄存器指向栈底。ebp又被称为帧指针，esp被称为栈指针。
     栈帧是是相对于每一个函数调用而言的，是独立的。

二，函数调用与栈的关系

     一个函数的调用分为以下几步;
1） 将函数参数按照函数定义约定依次压入栈中（_stdcall，_cdcel等）
2） 将当前指令的下一条指令（也就是函数返回地址）压入栈中
3） 跳转到函数体执行函数
4） 栈帧调整：
a) Push ebp：将ebp压入栈中，（old ebp）
b) Move sbp,esp：将esp的值赋给ebp，这时ebp指向栈顶位置，而栈顶就是old ebp
c) Sub esp,XXX栈上分配临时空间，push XXX/pop XXX保存某些寄存器的值
d) mov eax, xxx：保存被调用函数的返回值到寄存器eax中
e) move esp,ebp：恢复esp栈顶指针，同时回收栈上的局部变量
f) pop ebp：恢复ebp栈底指针
g) ret：从栈中取出返回地址，并jump到该地址

三，汇编演示

     以一个简单的函数为例：

Int fun()
{
	return 1;
}

     对该函数反汇编结果如下：（vs编译器调试在函数入口处打断点，调试-窗口-反汇编）

     第1-2行，保存了旧的ebp，并让ebp指向当前的栈顶。
     第3行，将esp栈顶扩展了0XC0个字节，这一大段空出来的空间用来存储局部变量，临时数据或者调试信息。
     第4-6行，将ebx,esi,edi三个寄存器的值保存到了栈上，这三个寄存器的值在函数随后的执行中可能被修改，所以要先保存一下这些寄存器原本的值，以便退出函数时恢复。
     第7-12行，也就是return 1之前是一些调试信息，其中请注意有一步是将eax赋值为0xCCCCCCCC，而eax是用来接受函数返回值的寄存器。
     第13行，将函数返回值1赋值给eax寄存器。
     第14-16行，从栈上恢复ebx,esi,edi三个寄存器的值
     第17行，将esp值加上0XC0个字节，恢复到原先的栈顶
     第18-21行，ebp出栈，恢复原先的栈底
     第22行，使用ret指令返回。

四，总结

1，栈帧是一个函数活动的记录，通过栈帧我们可以进行函数调用参数传递，以及函数返回值调用路径的回溯。
2，函数的返回值是保存在eax寄存器中，在i386中，它是一个32位的寄存器，占4个字节（那么大于4个字节的函数返回值如何传递呢？本系列文章后续揭晓）
3，函数调用的过程中，有进行栈的扩容操作，用于存放函数的入参，临时变量等一些信息，当函数调用结束后，这一部分栈空间会通过栈顶指针（esp寄存器）的移动被回收掉。

参考文献：
1，《程序员的自我修养:链接、装载与库》第十章第二节

学习Matlab自定义函数使用，并结合所学函数简单修改了一下上周的代码实现了Topsis法。

1.Matlab语句构成的程序文件称为M文件，以m作为文件的扩展名，分为函数文件和程序文件。

程序文件即脚本文件，无function；

函数文件有function，且在第一行或者第一个不是注释的行

2.两个文件运行函数：函数定义文件和函数调用文件（函数可在脚本文件或命令窗口直接调用），两文件必须放在同一目录下，函数文件名必须与函数名相同。

1）一个参数：

定义形式：

 function y=f(x) 

          y=x^2; 

2）多个参数：

多元函数可以看做向量函数（四种形式实现同一题的运算）

函数定义形式（两个输入两个输出）

function  [y1,y2]=f1(x1,x2)

          y1=x1+x2;

          y2=x1-x2;

end

函数调用形式

[a,b]=f1(2，3)     

函数定义形式（将两个输入合成一个向量）

function  [y1,y2]=f1(x)

          y1=x(1)+x(2);

          y2=x(1)-x(2);

end

函数调用形式

[a,b]=f2([2，3])

函数定义形式（将两个输出合成一个向量）

function y=f3(x1,x2)

        y(1)=x1+x2;

        y(2)=x1-x2;

end

函数调用形式

c=f3(2,3)

函数定义形式（将两个输入合成一个向量，将两个输出合成一个向量）

function  y=f4(x)

        y(1)=x(1)+x(2);

        y(2)=x(1)-x(2);

end

函数调用形式

d=f4([2,3])

3）任意多个参数的情况：

a.参数

varargin任意多个输入参数

varargout任意多个输出参数

nargin得到实际输入参数个数

nargout得到实际输出参数个数

b.对于输入变量，MATLAB可以识别输入变量的个数，通过nargin来记录当前输入变量个数。通过nargin判断变量个数，然后再写对应的程序

c.对于输出变量，MATLAB可以根据调用情况来输出结果，根据调用的格式，自动忽略没匹配上的输出结果。

d.函数做好之后，需要写好说明，否则代码的通用性会很差。matlab自动将函数下的注释当作函数说明，通过help来查看帮助文档

4)写一个函数计算输入参数之和（输入参数可以是任意多个）

function y=ssum(varargin)

   n=nargin

   y=0;

   for i=1:n

   y=varargin{i}+y;

end

5)对于一组数据 x1,x2,…,xm, 分高优指标、低优指标、中优指标、均优指标，四种标准化方式对数据标准化。（学习代码并理解nargin的用法）

function [x] = standlize(v,type,q)

%STANDLIZE   对列向量v 进行归一化 返回归一化后的向量 x

%  x = STANDLIZE(v,'low') 对列向量按低优指标进行归一化

%  x = STANDLIZE(v,'high') 对列向量按高优指标进行归一化

%  x = STANDLIZE(v,'middle',q) 对列向量按中优指标进行归一化

%  x = STANDLIZE(v,'between',q) 其中 q = [a , b] 对列向量按均优指标进行归一化

m = length(v);

if nargin==2%两个输入参数，一个是向量V,另一个是指标类型

    if strcmp(type,'low') %低优指标

        %[strcmp](https://ww2.mathworks.cn/help/matlab/ref/strcmp.html)

        for i=1:m

            x(i) = (max(v)-v(i))/(max(v)-min(v));

        end

    elseif  strcmp(type,'high') %高优指标

        for i=1:m

            x(i) = (v(i)-min(v))/(max(v)-min(v));

          end

    end

elseif nargin==3

        %输入变量有三个，第一个是向量V、第二个是指标类型、第三个是q；

        %若为中优指标，q用于存放中间值；

        %若为均优指标（即我们所学的区间型指标），q用于存放均优指标的区间（ q = [a , b] ）。

        %因此可结合q的长度来区分中优指标和均优指标。

    if strcmp(type,'middle')&&length(q)==1 %中优指标

        for i=1:m

             if v(i) < q

                x(i) = 1 - (q-v(i))/max([q-min(v),max(v)-q]);

            elseif  v(i) > q

                    x(i)=1- (v(i)-q)/max([q-min(v),max(v)-q]);                

else

                x(i) = 1;

            end

        end

    elseif strcmp(type,'between')&&length(q)==2 %均优指标

        for i=1:m

            if v(i) < q(1)

                x(i) = 1-(q(1)-v(i))/(max([q(1)-min(v),max(v)-q(2)]));

            elseif v(i) > q(2)

                x(i) = 1-(v(i)-q(2))/(max([q(1)-min(v),max(v)-q(2)]));

            else

                x(i)=1;

            end

        end

    end

end

x = reshape(x,size(v));

        %访问链接查看[reshape](https://blog.csdn.net/weixin_33805557/article/details/94506302)

        
end  

简单了解matlab的绘图函数（条形图）

% clear all;

data=S;%代入数据

b=bar(data,'BarWidth',0.6);%可以直接设置条形图的宽度

grid on;

        %grid是显示或隐藏坐标轴网格线，grid on是打开网格，grid off是关闭网格。

set(gca,'XTick',1:25,'XTickLabel',{'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y'})%设置横坐标数值

for i = 1:25

text(i,S(i)+0.1,num2str(data(i)),'VerticalAlignment','middle','HorizontalAlignment','center','FontSize',12);%为条形图添加数标

end

set(gca,'FontSize',9);%设置字体大小

xlabel('评价对象/河流');%横坐标标签

ylabel('评分');%纵坐标标签

axis([0 26 0 0.1]);%设置坐标轴显示范围

        %axis一般用来设置axes的样式，包括坐标轴范围，可来读比例等，

         %这儿用来设置坐标轴的范围，axis([xmin xmax ymin ymax])

1. 从代码的顺序执行说起

每一个程序员脑子里应该都有这么一种印象：“程序是顺序执行的”。这个观点其实和我们开篇所讲的cpu的流水线执行过程直接相关。
让我们再回忆一下脑海中关于函数调用的概念，也许会是这个样子：

这里的“控制流转移”又是如何发生的呢？在解释这个之前，也许我们需要科普一点有关于汇编的知识。

2. 函数调用中的一些细节说明

2.1 函数调用中的关键寄存器

2.1.1 程序计数器PC

程序计数器是一个计算机组成原理中讲过的概念，下面给出一个百度百科中的简单解释

程序计数器是用于存放下一条指令所在单元的地址的地方。
当执行一条指令时，首先需要根据PC中存放的指令地址，将指令由内存取到指令寄存器中，此过程称为“取指令”。与此同时，PC中的地址或自动加1或由转移指针给出下一条指令的地址。此后经过分析指令，执行指令。完成第一条指令的执行，而后根据PC取出第二条指令的地址，如此循环，执行每一条指令。

可以看到，程序计数器是一个cpu执行指令代码过程中的关键寄存器：它指向了当前计算机要执行的指令地址，CPU总是从程序计数器取出当前指令来执行。当指令执行后，程序计数器的值自动增加，指向下一条将要执行的指令。
在x86汇编中，执行程序计数器功能的寄存器被叫做EIP，也叫作指令指针寄存器。

2.1.2 基址指针，栈指针和程序栈

栈是程序设计中的一种经典数据结构，每个程序都拥有自己的程序栈。很重要的一点是，栈是向下生长的。所谓向下生长是指从内存高地址->低地址的路径延伸，那么就很明显了，栈有栈底和栈顶，那么栈顶的地址要比栈底低。对x86体系的CPU而言，其中
—> 寄存器ebp（base pointer ）可称为“帧指针”或“基址指针”，其实语意是相同的。
—> 寄存器esp（stack pointer）可称为“ 栈指针”。
在C和C++语言中，临时变量分配在栈中，临时变量拥有函数级的生命周期，即“在当前函数中有效，在函数外无效”。这种现象就是函数调用过程中的参数压栈，堆栈平衡所带来的。对于这种实现的细节，我们会在接下来的环节中详细讨论。

2.2. 堆栈平衡

堆栈平衡这个概念指的是函数调完成后，要返还所有使用过的栈空间。这种说法可能有点抽象，我们可以举一个简单的例子来类比：
我们都知道函数的临时变量存放在栈中。那我们来看下面的代码，它是一个很简单的函数,用来交换传入的2个参数的值：

void __stdcall swap(int& a,int& b)
{
  int c = a;
  a = b;
  b = c;
}

我们可以看到，在这个函数中使用了一个临时变量int c;这个变量分配在栈中，我们可以简单的理解为，在声明临时变量c后，我们就向当前的程序栈中压入了一个int值：

int c = a; <==> push(a);   //简单粗暴，临时变量的声明理解为简单地向栈中push一个值。

那现在这个函数swap调用结束了，我们是否需要退栈，把之前临时变量c使用的栈空间返还回去？需要吗？不需要吗？
我们假设不需要，当我们频繁调用swap的时候，会发生什么？每次调用，程序栈都在生长。直到栈满，我们就会收到stack overflow错误，程序挂掉了。
所以为了避免这种乌龙的事情发生，我们需要在函数调用结束后，退栈，把堆栈还原到函数调用前的状态，这些被pop掉的临时变量，自然也就失效了，这也解释了我们一直以来关于临时变量仅在当前函数内有效的认知。其实堆栈平衡这个概念本身比这种粗浅的理解要复杂的多，还应包括压栈参数的平衡，暂时我们可以简单地这样理解，后面再做详细说明。

2.3. 函数的参数传递和调用约定

函数的参数传递是一个参数压栈的过程。函数的所有参数，都会依次被push到栈中。那调用约定有是什么呢？
C和C++程序员应该对所谓的调用约定有一定的印象，就像下面这种代码：

void __stdcall add(int a,int b);

函数声明中的__stdcall就是关于调用约定的声明。其中标准C函数的默认调用约定是__stdcall,C++全局函数和静态成员函数的默认调用约定是__cdecl，类的成员函数的调用约定是__thiscall。剩下的还有__fastcall，__naked等。
为什么要用所谓的调用约定？调用约定其实是一种约定方式，它指明了函数调用中的参数传递方式和堆栈平衡方式。

2.3.1 参数传递方式

还是之前那个例子，swap函数有2个参数，int a,int b。这两个参数，入栈的顺序谁先谁后？
其实是从左到右入栈还是从右到左入栈都可以，只要函数调用者和函数内部使用相同的顺序存取参数即可。在上述的所有调用约定中，参数总是从右到左压栈，也就是最后一个参数先入栈。我们可以使用一份伪代码描述这个过程

push b;      //先压入参数b
push a;      //再压入参数a
call swap;  //调用swap函数

其实从这里我们就可以理解为什么在函数内部，不能改变函数外部参数的值：因为函数内部访问到的参数其实是压入栈的变量值，对它的修改只是修改了栈中的"副本"。指针和引用参数才能真正地改变外部变量的值。

2.3.2 堆栈平衡方式

因为函数调用过程中，参数需要压栈，所以在函数调用结束后，用于函数调用的压栈参数也需要退栈。那这个工作是交给调用者完成，还是在函数内部自己完成？其实两种都可以。调用者负责平衡堆栈的主要好处是可以实现可变参数（关于可变参数的话题，在此不做过多讨论。如果可能的话，我们可以以一篇单独的文章来讲这个问题），因为在参数可变的情况下，只有调用者才知道具体的压栈参数有几个。
下面列出了常见调用约定的堆栈平衡方式：

2.4. 栈帧的概念：从esp和ebp说起

为什么我们需要ebp和esp2个寄存器来访问栈？这种观念其实来自于函数的层级调用：函数A调用函数B，函数B调用函数C，函数C调用函数D…
这种调用可能会涉及非常多的层次。编译器需要保证在这种复杂的嵌套调用中，能够正确地处理每个函数调用的堆栈平衡。所以我们引入了2个寄存器：

1. ebp指向了本次函数调用开始时的栈顶指针，它也是本次函数调用时的“栈底”（这里的意思是，在一次函数调用中，ebp向下是函数的临时变量使用的空间）。在函数调用开始时，我们会使用把当前的esp保存在ebp中。

mov ebp,esp 

2. esp，它指向当前的栈顶，它是动态变化的，随着我们申请更多的临时变量，esp值不断减小（正如前文所说，栈是向下生长的）。函数调用结束，我们使用来还原之前保存的esp。

mov esp,ebp

在函数调用过程中，ebp和esp之间的空间被称为本次函数调用的“栈帧”。函数调用结束后，处于栈帧之前的所有内容都是本次函数调用过程中分配的临时变量，都需要被“返还”。这样在概念上，给了函数调用一个更明显的分界。下图是一个程序运行的某一时刻的栈帧图：

3. 汇编中关于“函数调用”的实现

上面铺陈了很多的汇编层面的概念后，我们终于可以切回到我们本次的主题：函数调用。
函数调用其实可以看做4个过程，也就是本篇标题：

1. 压栈: 函数参数压栈，返回地址压栈
2. 跳转: 跳转到函数所在代码处执行
3. 执行: 执行函数代码
4. 返回: 平衡堆栈，找出之前的返回地址，跳转回之前的调用点之后，完成函数调用

3.1 call指令 压栈和跳转

下面我们看一下函数调用指令

0x210000 call swap;
0x210005 mov ecx,eax; 

我们可以把它理解为2个指令：

push 0x210005;
jmp swap;

也就是，首先把call指令的下一条指令地址作为本次函数调用的返回地址压栈，然后使用jmp指令修改指令指针寄存器EIP，使cpu执行swap函数的指令代码。

3.2 ret指令 返回

汇编中有ret相关的指令，它表示取出当前栈顶值，作为返回地址，并将指令指针寄存器EIP修改为该值，实现函数返回。
下面给出一组示意图来演示函数的返回过程：

1. 当前EIP的值为0x210004，指向指令ret 4，程序需要返回

2. 执行ret指令，将当前esp指向的堆栈值当做返回地址，设置eip跳转到此处并弹出该值

经过这两步，函数就返回到了调用处。

4. 从实际汇编代码看函数调用

4.1 程序源码和运行结果

源码：

main.cpp

#include <stdio.h>
 
void __stdcall swap(int& a, int& b);
 
int main(int argc, char* argv)
{
    int a = 1, b = 2;
    printf("before swap: a = %d, b = %d\r\n", a, b);
    swap(a, b);
    printf("after swap: a = %d, b = %d\r\n", a, b);
}
 
 
void __stdcall swap(int& a, int& b)
{
    int c = a;
    a = b;
    b = c;
}

程序运行结果：

4.2 反汇编

可以看到，在函数调用前，函数参数已被压栈，此时:
EBP = 00AFFCAC
ESP = 00AFFBBC
EIP = 00BF1853
我们按F11，进入函数内部，此时：

其实就是call swap指令的下一条指令地址，它就是本次函数调用的返回地址。

下面是一个swap函数的详细注释：

当程序运行到ret 8时

执行返回后：

在返回前，ESP = 00AFFBB8，返回后 ESP = 00AFFBC4
0x00AFFBC4 - 0x00AFFBB8 = 0xC
这里的数值是字节数，而我们知道，int是4字节长度。所以0xC/4 = 3
正好是2个压栈参数+一个返回地址。

4.3 调用堆栈

调试程序的时候，我们经常关注的一个点就是VisualStudio显示给我们的“调用堆栈”功能，这次让我们来仔细看一下它：
我们重新执行一次程序，这次我们关注一下vs显示的调用堆栈，如下图

第一行是当前指令地址
第二行是外层调用者，我们双击它，跳转到如下地址：

也许这也是为什么这个功能被叫做“调用堆栈”的原因：它正是通过对程序栈的分析实现的。

转于：https://www.jianshu.com/p/594357dff57e