在matlab里.m文件分执行文件和函数文件
 在c++中执行文件指：main函数
 函数文件：其他所有需要用到的函数
 
在c++中，函数文件名没有特殊讲究，将文件添加到工程目录便能使用
 
 对函数的要求有三点
 
函数的完整文件
 输入参数的定义
 函数声明加入头文件
 
1.函数的完整文件
 
#include <opencv2/opencv.hpp>
using namespace cv;

void cameracapture(Mat &frame, int mytime, int imageWidth,int imageHeight)
{
	char c = 0;
	VideoCapture capture(0);
	capture.set(CV_CAP_PROP_FRAME_WIDTH, imageWidth*2);//宽度2560
	capture.set(CV_CAP_PROP_FRAME_HEIGHT, imageHeight);//高度720
	
	for (int i=0; i < mytime; i++)
	{
		capture >> frame;
	}
}
 
函数的完整文件包括了函数需要的头文件
 
 #include <opencv2/opencv.hpp>
 using namespace cv;
 
以及剩下的函数的程序段
 这里解释一下加&和不加&的区别
 Mat &frame 加&的变量传递的是变量地址，直白的理解为，加了后我在函数中对该变量修改后，会对我的主函数main中的对应变量进行修改。这里我的程序是打开相机，并把拍摄图像返回main函数，因此我需要随时根据拍摄修改我的main函数中frame的值。
 int mytime, int imageWidth,int imageHeight这些则是传入值，在函数内进行修改后不影响main里面的值，因为这些值只传入函数，而不需要函数再传回主函数。
 这里还有一点编程技巧
 我们通过函数调用的方式进行运算，有两种方式得到运算结果
 ①设置函数的返回值，return
 ②将传入值的地址（即传入值自身）交给函数，函数对其进行运算相当于直接对传入值进行运算。
 
2.输入参数的定义
 
我们在main中调用其他函数时，我们的输入参数需要提前定义
 
main ()
{
Mat frame; 
int mytime = 10;
int imageWidth = 1280;
int imageHeight = 720;
cameracapture(frame, mytime, imageWidth, imageHeight);//注意这里和函数定义不同
………………
}
 
3.函数声明加入头文件
 
我们调用其他函数前必须先声明
 将
 
 void cameracapture(Mat &frame, int mytime, int imageWidth,int imageHeight)
 
写入.h文件（头文件），写入头文件后也就告知了我们的项目，我们声明了，项目中是有该函数的定义的。为什么要用头文件？因为我们把我们用到的函数声明都写到一个.h文件里，下次再使用时我们直接#include XXX.h即可，没有必要再对用到的函数一个一个地声明。
 
完成上面的三步，我们自己的函数就制作好了，使用起来比较方便。
 这里再扩展一下
 我们在数组传入函数，传出函数时可能会面临着数组无法修改的问题，这里二郎给大家提供一个解决办法，不是最优，但是可行
 main里面：
 
float key_data[10][4] = { 0 };
my_f(img_cir_L, img_cir_R, key_data);
 
函数里面：
 
void my_f(Mat rectifyImageL, Mat rectifyImageR, float(&key_data)[10][4])
 
头文件里面：
 
 void my_f(Mat rectifyImageL, Mat rectifyImageR, float(&key_data)[10][4]);
 
这样便能实现数组数据的传入和处理后结果的传递了

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 堆栈平衡方式
 
因为函数调用过程中，参数需要压栈，所以在函数调用结束后，用于函数调用的压栈参数也需要退栈。那这个工作是交给调用者完成，还是在函数内部自己完成？其实两种都可以。调用者负责平衡堆栈的主要好处是可以实现可变参数（关于可变参数的话题，在此不做过多讨论。如果可能的话，我们可以以一篇单独的文章来讲这个问题），因为在参数可变的情况下，只有调用者才知道具体的压栈参数有几个。
 下面列出了常见调用约定的堆栈平衡方式：
 
调用约定
堆栈平衡方式
__stdcall
函数自己平衡
__cdecl
调用者负责平衡
__thiscall
调用者负责平衡
__fastcall
调用者负责平衡
__naked
编译器不负责平衡，由编写者自己负责
2.4. 栈帧的概念：从esp和ebp说起
 
为什么我们需要ebp和esp2个寄存器来访问栈？这种观念其实来自于函数的层级调用：函数A调用函数B，函数B调用函数C，函数C调用函数D…
 这种调用可能会涉及非常多的层次。编译器需要保证在这种复杂的嵌套调用中，能够正确地处理每个函数调用的堆栈平衡。所以我们引入了2个寄存器：
 
ebp指向了本次函数调用开始时的栈顶指针，它也是本次函数调用时的“栈底”（这里的意思是，在一次函数调用中，ebp向下是函数的临时变量使用的空间）。在函数调用开始时，我们会使用把当前的esp保存在ebp中。
 
mov ebp,esp 
 
esp，它指向当前的栈顶，它是动态变化的，随着我们申请更多的临时变量，esp值不断减小（正如前文所说，栈是向下生长的）。函数调用结束，我们使用来还原之前保存的esp。
 
mov esp,ebp
 
在函数调用过程中，ebp和esp之间的空间被称为本次函数调用的“栈帧”。函数调用结束后，处于栈帧之前的所有内容都是本次函数调用过程中分配的临时变量，都需要被“返还”。这样在概念上，给了函数调用一个更明显的分界。下图是一个程序运行的某一时刻的栈帧图：
 
 
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修改为该值，实现函数返回。
 下面给出一组示意图来演示函数的返回过程：
 
当前EIP的值为0x210004，指向指令ret 4，程序需要返回
 
 
执行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

数学建模
matlab自定义函数
时间
2020年5月10日
学习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])

以下全文转载自：C语言函数调用栈(一)
 
程序的执行过程可看作连续的函数调用。当一个函数执行完毕时，程序要回到调用指令的下一条指令(紧接call指令)处继续执行。函数调用过程通常使用堆栈实现，每个用户态进程对应一个调用栈结构(call stack)。编译器使用堆栈传递函数参数、保存返回地址、临时保存寄存器原有值(即函数调用的上下文)以备恢复以及存储本地局部变量。
 
不同处理器和编译器的堆栈布局、函数调用方法都可能不同，但堆栈的基本概念是一样的。
 
1 寄存器分配
 
寄存器是处理器加工数据或运行程序的重要载体，用于存放程序执行中用到的数据和指令。因此函数调用栈的实现与处理器寄存器组密切相关。
 
Intel 32位体系结构(简称IA32)处理器包含8个四字节寄存器，如下图所示：

 
 
 
 
 图1 IA32处理器寄存器

 
最初的8086中寄存器是16位，每个都有特殊用途，寄存器名城反映其不同用途。由于IA32平台采用平面寻址模式，对特殊寄存器的需求大大降低，但由于历史原因，这些寄存器名称被保留下来。在大多数情况下，上图所示的前6个寄存器均可作为通用寄存器使用。某些指令可能以固定的寄存器作为源寄存器或目的寄存器，如一些特殊的算术操作指令imull/mull/cltd/idivl/divl要求一个参数必须在%eax中，其运算结果存放在%edx(higher 32-bit)和%eax (lower32-bit)中；又如函数返回值通常保存在%eax中，等等。为避免兼容性问题，ABI规范对这组通用寄存器的具体作用加以定义(如图中所示)。
 
对于寄存器%eax、%ebx、%ecx和%edx，各自可作为两个独立的16位寄存器使用，而低16位寄存器还可继续分为两个独立的8位寄存器使用。编译器会根据操作数大小选择合适的寄存器来生成汇编代码。在汇编语言层面，这组通用寄存器以%e(AT&T语法)或直接以e(Intel语法)开头来引用，例如mov $5, %eax或mov eax, 5表示将立即数5赋值给寄存器%eax。
 
在x86处理器中，EIP(Instruction Pointer)是指令寄存器，指向处理器下条等待执行的指令地址(代码段内的偏移量)，每次执行完相应汇编指令EIP值就会增加。ESP(Stack Pointer)是堆栈指针寄存器，存放执行函数对应栈帧的栈顶地址(也是系统栈的顶部)，且始终指向栈顶；EBP(Base Pointer)是栈帧基址指针寄存器，存放执行函数对应栈帧的栈底地址，用于C运行库访问栈中的局部变量和参数。
 
注意，EIP是个特殊寄存器，不能像访问通用寄存器那样访问它，即找不到可用来寻址EIP并对其进行读写的操作码(OpCode)。EIP可被jmp、call和ret等指令隐含地改变(事实上它一直都在改变)。
 
不同架构的CPU，寄存器名称被添加不同前缀以指示寄存器的大小。例如x86架构用字母“e(extended)”作名称前缀，指示寄存器大小为32位；x86_64架构用字母“r”作名称前缀，指示各寄存器大小为64位。
 
编译器在将C程序编译成汇编程序时，应遵循ABI所规定的寄存器功能定义。同样地，编写汇编程序时也应遵循，否则所编写的汇编程序可能无法与C程序协同工作。
 
 
 
【扩展阅读】栈帧指针寄存器
 为了访问函数局部变量，必须能定位每个变量。局部变量相对于堆栈指针ESP的位置在进入函数时就已确定，理论上变量可用ESP加偏移量来引用，但ESP会在函数执行期随变量的压栈和出栈而变动。尽管某些情况下编译器能跟踪栈中的变量操作以修正偏移量，但要引入可观的管理开销。而且在有些机器上(如Intel处理器)，用ESP加偏移量来访问一个变量需要多条指令才能实现。
 因此，许多编译器使用帧指针寄存器FP(Frame Pointer)记录栈帧基地址。局部变量和函数参数都可通过帧指针引用，因为它们到FP的距离不会受到压栈和出栈操作的影响。有些资料将帧指针称作局部基指针(LB-local base pointer)。
 在Intel CPU中，寄存器BP(EBP)用作帧指针。在Motorola CPU中，除A7(堆栈指针SP)外的任何地址寄存器都可用作FP。当堆栈向下(低地址)增长时，以FP地址为基准，函数参数的偏移量是正值，而局部变量的偏移量是负值。
 
 
2 寄存器使用约定
 
程序寄存器组是唯一能被所有函数共享的资源。虽然某一时刻只有一个函数在执行，但需保证当某个函数调用其他函数时，被调函数不会修改或覆盖主调函数稍后会使用到的寄存器值。因此，IA32采用一套统一的寄存器使用约定，所有函数(包括库函数)调用都必须遵守该约定。
 
根据惯例，寄存器%eax、%edx和%ecx为主调函数保存寄存器(caller-saved registers)，当函数调用时，若主调函数希望保持这些寄存器的值，则必须在调用前显式地将其保存在栈中；被调函数可以覆盖这些寄存器，而不会破坏主调函数所需的数据。寄存器%ebx、%esi和%edi为被调函数保存寄存器(callee-saved registers)，即被调函数在覆盖这些寄存器的值时，必须先将寄存器原值压入栈中保存起来，并在函数返回前从栈中恢复其原值，因为主调函数可能也在使用这些寄存器。此外，被调函数必须保持寄存器%ebp和%esp，并在函数返回后将其恢复到调用前的值，亦即必须恢复主调函数的栈帧。
 
当然，这些工作都由编译器在幕后进行。不过在编写汇编程序时应注意遵守上述惯例。
 
3 栈帧结构
 
函数调用经常是嵌套的，在同一时刻，堆栈中会有多个函数的信息。每个未完成运行的函数占用一个独立的连续区域，称作栈帧(Stack Frame)。栈帧是堆栈的逻辑片段，当调用函数时逻辑栈帧被压入堆栈, 当函数返回时逻辑栈帧被从堆栈中弹出。栈帧存放着函数参数，局部变量及恢复前一栈帧所需要的数据等。
 
编译器利用栈帧，使得函数参数和函数中局部变量的分配与释放对程序员透明。编译器将控制权移交函数本身之前，插入特定代码将函数参数压入栈帧中，并分配足够的内存空间用于存放函数中的局部变量。使用栈帧的一个好处是使得递归变为可能，因为对函数的每次递归调用，都会分配给该函数一个新的栈帧，这样就巧妙地隔离当前调用与上次调用。
 
栈帧的边界由栈帧基地址指针EBP和堆栈指针ESP界定(指针存放在相应寄存器中)。EBP指向当前栈帧底部(高地址)，在当前栈帧内位置固定；ESP指向当前栈帧顶部(低地址)，当程序执行时ESP会随着数据的入栈和出栈而移动。因此函数中对大部分数据的访问都基于EBP进行。
 
为更具描述性，以下称EBP为帧基指针， ESP为栈顶指针，并在引用汇编代码时分别记为%ebp和%esp。
 
函数调用栈的典型内存布局如下图所示：

 
 
 
 
 图2 函数调用栈的典型内存布局

 
图中给出主调函数(caller)和被调函数(callee)的栈帧布局，"m(%ebp)“表示以EBP为基地址、偏移量为m字节的内存空间(中的内容)。该图基于两个假设：第一，函数返回值不是结构体或联合体，否则第一个参数将位于"12(%ebp)” 处；第二，每个参数都是4字节大小(栈的粒度为4字节)。在本文后续章节将就参数的传递和大小问题做进一步的探讨。 此外，函数可以没有参数和局部变量，故图中“Argument(参数)”和“Local Variable(局部变量)”不是函数栈帧结构的必需部分。
 
从图中可以看出，函数调用时入栈顺序为
 
实参N~1→主调函数返回地址→主调函数帧基指针EBP→被调函数局部变量1~N
 
其中，主调函数将参数按照调用约定依次入栈(图中为从右到左)，然后将指令指针EIP入栈以保存主调函数的返回地址(下一条待执行指令的地址)。进入被调函数时，被调函数将主调函数的帧基指针EBP入栈，并将主调函数的栈顶指针ESP值赋给被调函数的EBP(作为被调函数的栈底)，接着改变ESP值来为函数局部变量预留空间。此时被调函数帧基指针指向被调函数的栈底。以该地址为基准，向上(栈底方向)可获取主调函数的返回地址、参数值，向下(栈顶方向)能获取被调函数的局部变量值，而该地址处又存放着上一层主调函数的帧基指针值。本级调用结束后，将EBP指针值赋给ESP，使ESP再次指向被调函数栈底以释放局部变量；再将已压栈的主调函数帧基指针弹出到EBP，并弹出返回地址到EIP。ESP继续上移越过参数，最终回到函数调用前的状态，即恢复原来主调函数的栈帧。如此递归便形成函数调用栈。
 
EBP指针在当前函数运行过程中(未调用其他函数时)保持不变。在函数调用前，ESP指针指向栈顶地址，也是栈底地址。在函数完成现场保护之类的初始化工作后，ESP会始终指向当前函数栈帧的栈顶，此时，若当前函数又调用另一个函数，则会将此时的EBP视为旧EBP压栈，而与新调用函数有关的内容会从当前ESP所指向位置开始压栈。
 
若需在函数中保存被调函数保存寄存器(如ESI、EDI)，则编译器在保存EBP值时进行保存，或延迟保存直到局部变量空间被分配。在栈帧中并未为被调函数保存寄存器的空间指定标准的存储位置。包含寄存器和临时变量的函数调用栈布局可能如下图所示：

 
 
 
 
 图3 函数调用栈的可能内存布局

 
在多线程(任务)环境，栈顶指针指向的存储器区域就是当前使用的堆栈。切换线程的一个重要工作，就是将栈顶指针设为当前线程的堆栈栈顶地址。
 
以下代码用于函数栈布局示例：
 
//StackFrame.c
#include <stdio.h>
#include <string.h>

struct Strt{
    int member1;
    int member2;
    int member3;
};

#define PRINT_ADDR(x)     printf("&"#x" = %p\n", &x)
int StackFrameContent(int para1, int para2, int para3){
    int locVar1 = 1;
    int locVar2 = 2;
    int locVar3 = 3;
    int arr[] = {0x11,0x22,0x33};
    struct Strt tStrt = {0};
    PRINT_ADDR(para1); //若para1为char或short型，则打印para1所对应的栈上整型临时变量地址！
    PRINT_ADDR(para2);
    PRINT_ADDR(para3);
    PRINT_ADDR(locVar1);
    PRINT_ADDR(locVar2);
    PRINT_ADDR(locVar3);
    PRINT_ADDR(arr);
    PRINT_ADDR(arr[0]);
    PRINT_ADDR(arr[1]);
    PRINT_ADDR(arr[2]);
    PRINT_ADDR(tStrt);
    PRINT_ADDR(tStrt.member1);
    PRINT_ADDR(tStrt.member2);
    PRINT_ADDR(tStrt.member3);
    return 0;
}

int main(void){
    int locMain1 = 1, locMain2 = 2, locMain3 = 3;
    PRINT_ADDR(locMain1);
    PRINT_ADDR(locMain2);
    PRINT_ADDR(locMain3);
    StackFrameContent(locMain1, locMain2, locMain3);
    printf("[locMain1,2,3] = [%d, %d, %d]\n", locMain1, locMain2, locMain3);
    memset(&locMain2, 0, 2*sizeof(int));
    printf("[locMain1,2,3] = [%d, %d, %d]\n", locMain1, locMain2, locMain3);
    return 0;
}
 
编译链接并执行后，输出打印如下：

 
 
 
 
 图4 StackFrame输出

 
函数栈布局示例如下图所示。为直观起见，低于起始高地址0xbfc75a58的其他地址采用点记法，如0x.54表示0xbfc75a54，以此类推。

 
 
 
 
 图5 StackFrame栈帧

 
内存地址从栈底到栈顶递减，压栈就是把ESP指针逐渐往地低址移动的过程。而结构体tStrt中的成员变量memberX地址=tStrt首地址+(memberX偏移量)，即越靠近tStrt首地址的成员变量其内存地址越小。因此，结构体成员变量的入栈顺序与其在结构体中声明的顺序相反。
 
函数调用以值传递时，传入的实参(locMain13)与被调函数内操作的形参(para13)两者存储地址不同，因此被调函数无法直接修改主调函数实参值(对形参的操作相当于修改实参的副本)。为达到修改目的，需要向被调函数传递实参变量的指针(即变量的地址)。
 
此外，"[locMain1,2,3] = [0, 0, 3]"是因为对四字节参数locMain2调用memset函数时，会从低地址向高地址连续清零8个字节，从而误将位于高地址locMain1清零。
 
注意，局部变量的布局依赖于编译器实现等因素。因此，当StackFrameContent函数中删除打印语句时，变量locVar3、locVar2和locVar1可能按照从高到低的顺序依次存储！而且，局部变量并不总在栈中，有时出于性能(速度)考虑会存放在寄存器中。数组/结构体型的局部变量通常分配在栈内存中。
 
 
 
【扩展阅读】函数局部变量布局方式
 
 
与函数调用约定规定参数如何传入不同，局部变量以何种方式布局并未规定。编译器计算函数局部变量所需要的空间总数，并确定这些变量存储在寄存器上还是分配在程序栈上(甚至被优化掉)——某些处理器并没有堆栈。局部变量的空间分配与主调函数和被调函数无关，仅仅从函数源代码上无法确定该函数的局部变量分布情况。
 
 
基于不同的编译器版本(gcc3.4中局部变量按照定义顺序依次入栈，gcc4及以上版本则不定)、优化级别、目标处理器架构、栈安全性等，相邻定义的两个变量在内存位置上可能相邻，也可能不相邻，前后关系也不固定。若要确保两个对象在内存上相邻且前后关系固定，可使用结构体或数组定义。
 
 
4 堆栈操作
 
函数调用时的具体步骤如下：
 
 
主调函数将被调函数所要求的参数，根据相应的函数调用约定，保存在运行时栈中。该操作会改变程序的栈指针。
 注：x86平台将参数压入调用栈中。而x86_64平台具有16个通用64位寄存器，故调用函数时前6个参数通常由寄存器传递，其余参数才通过栈传递。
 
 
主调函数将控制权移交给被调函数(使用call指令)。函数的返回地址(待执行的下条指令地址)保存在程序栈中(压栈操作隐含在call指令中)。
 
 
若有必要，被调函数会设置帧基指针，并保存被调函数希望保持不变的寄存器值。
 
 
被调函数通过修改栈顶指针的值，为自己的局部变量在运行时栈中分配内存空间，并从帧基指针的位置处向低地址方向存放被调函数的局部变量和临时变量。
 
 
被调函数执行自己任务，此时可能需要访问由主调函数传入的参数。若被调函数返回一个值，该值通常保存在一个指定寄存器中(如EAX)。
 
 
一旦被调函数完成操作，为该函数局部变量分配的栈空间将被释放。这通常是步骤4的逆向执行。
 
 
恢复步骤3中保存的寄存器值，包含主调函数的帧基指针寄存器。
 
 
被调函数将控制权交还主调函数(使用ret指令)。根据使用的函数调用约定，该操作也可能从程序栈上清除先前传入的参数。
 
 
主调函数再次获得控制权后，可能需要将先前的参数从栈上清除。在这种情况下，对栈的修改需要将帧基指针值恢复到步骤1之前的值。
 
 
步骤3与步骤4在函数调用之初常一同出现，统称为函数序(prologue)；步骤6到步骤8在函数调用的最后常一同出现，统称为函数跋(epilogue)。函数序和函数跋是编译器自动添加的开始和结束汇编代码，其实现与CPU架构和编译器相关。除步骤5代表函数实体外，其它所有操作组成函数调用。
 
以下介绍函数调用过程中的主要指令。
 
压栈(push)：栈顶指针ESP减小4个字节；以字节为单位将寄存器数据(四字节，不足补零)压入堆栈，从高到低按字节依次将数据存入ESP-1、ESP-2、ESP-3、ESP-4指向的地址单元。
 
出栈(pop)：栈顶指针ESP指向的栈中数据被取回到寄存器；栈顶指针ESP增加4个字节。

 
 
 
 
 图6 出栈入栈操作示意

 
可见，压栈操作将寄存器内容存入栈内存中(寄存器原内容不变)，栈顶地址减小；出栈操作从栈内存中取回寄存器内容(栈内已存数据不会自动清零)，栈顶地址增大。栈顶指针ESP总是指向栈中下一个可用数据。
 
调用(call)：将当前的指令指针EIP(该指针指向紧接在call指令后的下条指令)压入堆栈，以备返回时能恢复执行下条指令；然后设置EIP指向被调函数代码开始处，以跳转到被调函数的入口地址执行。
 
离开(leave)： 恢复主调函数的栈帧以准备返回。等价于指令序列movl %ebp, %esp(恢复原ESP值，指向被调函数栈帧开始处)和popl %ebp(恢复原ebp的值，即主调函数帧基指针)。
 
返回(ret)：与call指令配合，用于从函数或过程返回。从栈顶弹出返回地址(之前call指令保存的下条指令地址)到EIP寄存器中，程序转到该地址处继续执行(此时ESP指向进入函数时的第一个参数)。若带立即数，ESP再加立即数(丢弃一些在执行call前入栈的参数)。使用该指令前，应使当前栈顶指针所指向位置的内容正好是先前call指令保存的返回地址。
 
基于以上指令，使用C调用约定的被调函数典型的函数序和函数跋实现如下：
 
 
 
 
 
指令序列
 
 
含义
 
 
函数序
 
(prologue)
 
 
push %ebp
 
 
将主调函数的帧基指针%ebp压栈，即保存旧栈帧中的帧基指针以便函数返回时恢复旧栈帧
 
 
mov %esp, %ebp
 
 
将主调函数的栈顶指针%esp赋给被调函数帧基指针%ebp。此时，%ebp指向被调函数新栈帧的起始地址(栈底)，亦即旧%ebp入栈后的栈顶
 
 
sub <n>, %esp
 
 
将栈顶指针%esp减去指定字节数(栈顶下移)，即为被调函数局部变量开辟栈空间。<n>为立即数且通常为16的整数倍(可能大于局部变量字节总数而稍显浪费，但gcc采用该规则保证数据的严格对齐以有效运用各种优化编译技术)
 
 
push <r>
 
 
可选。如有必要，被调函数负责保存某些寄存器(%edi/%esi/%ebx)值
 
 
函数跋
 
(epilogue)
 
 
pop <r>
 
 
可选。如有必要，被调函数负责恢复某些寄存器(%edi/%esi/%ebx)值
 
 
mov %ebp, %esp*
 
 
恢复主调函数的栈顶指针%esp，将其指向被调函数栈底。此时，局部变量占用的栈空间被释放，但变量内容未被清除(跳过该处理)
 
 
pop %ebp*
 
 
主调函数的帧基指针%ebp出栈，即恢复主调函数栈底。此时，栈顶指针%esp指向主调函数栈顶(espßesp-4)，亦即返回地址存放处
 
 
ret
 
 
从栈顶弹出主调函数压在栈中的返回地址到指令指针寄存器%eip中，跳回主调函数该位置处继续执行。再由主调函数恢复到调用前的栈
 
 
*：这两条指令序列也可由leave指令实现，具体用哪种方式由编译器决定。
 
 
若主调函数和调函数均未使用局部变量寄存器EDI、ESI和EBX，则编译器无须在函数序中对其压栈，以便提高程序的执行效率。
 
参数压栈指令因编译器而异，如下两种压栈方式基本等效：
 
 
extern CdeclDemo(int w, int x, int y, intz);  //调用CdeclDemo函数
 
CdeclDemo(1, 2, 3, 4);  //调用CdeclDemo函数
 
 
压栈方式一
 
 
压栈方式二
 
 
pushl 4  //压入参数z
 
pushl 3  //压入参数y
 
pushl 2  //压入参数x
 
pushl 1  //压入参数w
 
call CdeclDemo  //调用函数
 
addl $16, %esp  //恢复ESP原值，使其指向调用前保存的返回地址
 
 
subl   $16, %esp //多次调用仅执行一遍
 
movl  $4, 12(%esp) //传送参数z至堆栈第四个位置
 
movl  $3, 8(%esp) //传送参数y至堆栈第三个位置
 
movl  $2, 4(%esp) //传送参数x至堆栈第二个位置
 
movl  $1, (%esp) //传送参数w至堆栈栈顶
 
call CdeclDemo  //调用函数
 
 
两种压栈方式均遵循C调用约定，但方式二中主调函数在调用返回后并未显式清理堆栈空间。因为在被调函数序阶段，编译器在栈顶为函数参数预先分配内存空间(sub指令)。函数参数被复制到栈中(而非压入栈中)，并未修改栈顶指针，故调用返回时主调函数也无需修改栈顶指针。gcc3.4(或更高版本)编译器采用该技术将函数参数传递至栈上，相比栈顶指针随每次参数压栈而多次下移，一次性设置好栈顶指针更为高效。设想连续调用多个函数时，方式二仅需预先分配一次参数内存(大小足够容纳参数尺寸和最大的函数即可)，后续调用无需每次都恢复栈顶指针。注意，函数被调用时，两种方式均使栈顶指针指向函数最左边的参数。本文不再区分两种压栈方式，"压栈"或"入栈"所提之处均按相应汇编代码理解，若无汇编则指方式二。
 
某些情况下，编译器生成的函数调用进入/退出指令序列并不按照以上方式进行。例如，若C函数声明为static(只在本编译单元内可见)且函数在编译单元内被直接调用，未被显示或隐式取地址(即没有任何函数指针指向该函数)，此时编译器确信该函数不会被其它编译单元调用，因此可随意修改其进/出指令序列以达到优化目的。
 
尽管使用的寄存器名字和指令在不同处理器架构上有所不同，但创建栈帧的基本过程一致。
 
注意，栈帧是运行时概念，若程序不运行，就不存在栈和栈帧。但通过分析目标文件中建立函数栈帧的汇编代码(尤其是函数序和函数跋过程)，即使函数没有运行，也能了解函数的栈帧结构。通过分析可确定分配在函数栈帧上的局部变量空间准确值，函数中是否使用帧基指针，以及识别函数栈帧中对变量的所有内存引用。
 
以上全文转载自：C语言函数调用栈(一)