精华内容
参与话题
问答
  • 在matlab里.m文件分执行文件和函数文件 在c++中执行文件指:main函数 函数文件:其他所有需要用到的函数 在c++中,函数文件名没有特殊讲究,将文件添加到工程目录便能使用 对函数的要求有三点 函数的完整文件 输入...

    在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]);
    

    这样便能实现数组数据的传入和处理后结果的传递了

    展开全文
  • C语言函数调用栈(一)

    万次阅读 多人点赞 2018-07-19 22:16:25
    程序的执行过程可看作连续的函数调用。当一个函数执行完毕时,程序要回到调用指令的下一条指令(紧接call指令)处继续执行。函数调用过程通常使用堆栈实现,每个用户态进程对应一个调用栈结构(call stack)。编译器使用...

    以下全文转载自:C语言函数调用栈(一)

    程序的执行过程可看作连续的函数调用。当一个函数执行完毕时,程序要回到调用指令的下一条指令(紧接call指令)处继续执行。函数调用过程通常使用堆栈实现,每个用户态进程对应一个调用栈结构(call stack)。编译器使用堆栈传递函数参数、保存返回地址、临时保存寄存器原有值(即函数调用的上下文)以备恢复以及存储本地局部变量。

    不同处理器和编译器的堆栈布局、函数调用方法都可能不同,但堆栈的基本概念是一样的。

    1 寄存器分配

    寄存器是处理器加工数据或运行程序的重要载体,用于存放程序执行中用到的数据和指令。因此函数调用栈的实现与处理器寄存器组密切相关。

    Intel 32位体系结构(简称IA32)处理器包含8个四字节寄存器,如下图所示:


    图1 IA32处理器寄存器
    图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 函数调用栈的典型内存布局
    图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 函数调用栈的可能内存布局
    图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输出
    图4 StackFrame输出

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


    图5 StackFrame栈帧
    图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 堆栈操作

    函数调用时的具体步骤如下:

    1. 主调函数将被调函数所要求的参数,根据相应的函数调用约定,保存在运行时栈中。该操作会改变程序的栈指针。
      注:x86平台将参数压入调用栈中。而x86_64平台具有16个通用64位寄存器,故调用函数时前6个参数通常由寄存器传递,其余参数才通过栈传递。

    2. 主调函数将控制权移交给被调函数(使用call指令)。函数的返回地址(待执行的下条指令地址)保存在程序栈中(压栈操作隐含在call指令中)。

    3. 若有必要,被调函数会设置帧基指针,并保存被调函数希望保持不变的寄存器值。

    4. 被调函数通过修改栈顶指针的值,为自己的局部变量在运行时栈中分配内存空间,并从帧基指针的位置处向低地址方向存放被调函数的局部变量和临时变量。

    5. 被调函数执行自己任务,此时可能需要访问由主调函数传入的参数。若被调函数返回一个值,该值通常保存在一个指定寄存器中(如EAX)。

    6. 一旦被调函数完成操作,为该函数局部变量分配的栈空间将被释放。这通常是步骤4的逆向执行。

    7. 恢复步骤3中保存的寄存器值,包含主调函数的帧基指针寄存器。

    8. 被调函数将控制权交还主调函数(使用ret指令)。根据使用的函数调用约定,该操作也可能从程序栈上清除先前传入的参数。

    9. 主调函数再次获得控制权后,可能需要将先前的参数从栈上清除。在这种情况下,对栈的修改需要将帧基指针值恢复到步骤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 出栈入栈操作示意
    图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语言函数调用栈(一)

    展开全文
  • js系列教程4-函数、函数参数教程全解js中的4种函数调用模式javascript一共有4种调用模式:函数调用模式、方法调用模式、构造器调用模式和间接调用模式。【1】函数调用模式 当一个函数并非一个对象的属性时,那么它...
    
        ad1.jpg
    

    全栈工程师开发手册 (作者:栾鹏)

    js系列教程4-函数、函数参数教程全解

    js中的4种函数调用模式

    javascript一共有4种调用模式:函数调用模式、方法调用模式、构造器调用模式和间接调用模式。

    【1】函数调用模式

    当一个函数并非一个对象的属性时,那么它就是被当做一个函数来调用的。对于普通的函数调用来说,函数的返回值就是调用表达式的值

    function add(x,y){
        return x+y;
    }
    var sum = add(3,4);
    console.log(sum)//7
    

    使用函数调用模式调用函数时,非严格模式下,this被绑定到全局对象;在严格模式下,this是undefined

    function add(x,y){
        console.log(this);//window
    }    
    add();
    
    function add(x,y){
        'use strict';
        console.log(this);//undefined
    }    
    add();//window
    

    因此,'this’可以用来判断当前是否是严格模式

    var strict = (function(){return !this;}());
    

    重写

    因为函数调用模式的函数中的this绑定到全局对象,所以会发生全局属性被重写的现象

    var a = 0;
    function fn(){
        this.a = 1;
    }
    fn();
    console.log(this,this.a,a);//window 1 1
    

    【2】方法调用模式

    当一个函数被保存为对象的一个属性时,我们称它为一个方法。当一个方法被调用时,this被绑定到该对象。如果调用表达式包含一个提取属性的动作,那么它就是被当做一个方法来调用

    var o = {
        m: function(){
            console.log(1);
        }
    };
    o.m();//1
    

    方法可以使用this访问自己所属的对象,所以它能从对象中取值或对对象进行修改。this到对象的绑定发生在调用的时候。通过this可取得它们所属对象的上下文的方法称为公共方法。

    var o = {
        a: 1,
        m: function(){
            return this;
        },
        n: function(){
            this.a = 2;
        }
    };
    console.log(o.m().a);//1
    o.n();
    console.log(o.m().a);//2
    

    任何函数只要作为方法调用实际上都会传入一个隐式的实参——这个实参是一个对象,方法调用的母体就是这个对象,通常来讲,基于那个对象的方法可以执行多种操作,方法调用的语法已经很清晰地表明了函数将基于一个对象进行操作

    rect.setSize(width,height);
    setRectSize(rect,width,height);
    

    假设上面两行代码的功能完全一样,它们都作用于一个假定的对象rect。可以看出,第一行的方法调用语法非常清晰地表明这个函数执行的载体是rect对象,函数中的所有操作都将基于这个对象

    和变量不同,关键字this没有作用域的限制,嵌套的函数不会从调用它的函数中继承this。如果嵌套函数作为方法调用,其this的值指向调用它的对象。如果嵌套函数作为函数调用,其this值不是全局对象(非严格模式下)就是undefined(严格模式下)

    var o = {
        m: function(){
             function n(){
                 return this;
             }
             return n();
        }
    }
    console.log(o.m());//window
    
    
    var o = {
        m: function(){
             function n(){
                 'use strict';
                 return this;
             }
             return n();
        }
    }
    console.log(o.m());//undefined
    

    如果想访问这个外部函数的this值,需要将this的值保存在一个变量里,这个变量和内部函数都同在一个作用域内。通常使用变量self或that来保存this

    var o = {
        m: function(){
            var self = this;
            console.log(this === o);//true
             function n(){
                 console.log(this === o);//false
                 console.log(self === o);//true
                 return self;
             }
             return n();
        }
    }
    console.log(o.m() === o);//true
    

    【3】构造函数调用模式

    如果函数或者方法调用之前带有关键字new,它就构成构造函数调用

    
    function fn(){
        this.a = 1;
    };
    var obj = new fn();
    console.log(obj.a);//1
    

    如果构造函数调用在圆括号内包含一组实参列表,先计算这些实参表达式,然后传入函数内

    function fn(x){
        this.a = x;
    };
    var obj = new fn(2);
    console.log(obj.a);//2
    

    如果构造函数没有形参,javascript构造函数调用的语法是允许省略实参列表和圆括号的。凡是没有形参的构造函数调用都可以省略圆括号

    var o = new Object();
    //等价于
    var o = new Object;
    

    [注意]尽管构造函数看起来像一个方法调用,它依然会使用这个新对象作为调用上下文。也就是说,在表达式new o.m()中,调用上下文并不是o

    var o = {
        m: function(){
            return this;
        }
    }
    var obj = new o.m();
    console.log(obj,obj === o);//{} false
    console.log(obj.constructor === o.m);//true
    

    构造函数通常不使用return关键字,它们通常初始化新对象,当构造函数的函数体执行完毕时,它会显式返回。在这种情况下,构造函数调用表达式的计算结果就是这个新对象的值

    function fn(){
        this.a = 2;
    }
    var test = new fn();
    console.log(test);//{a:2}
    

    如果构造函数使用return语句但没有指定返回值,或者返回一个原始值,那么这时将忽略返回值,同时使用这个新对象作为调用结果

    function fn(){
        this.a = 2;
        return;
    }
    var test = new fn();
    console.log(test);//{a:2}
    

    如果构造函数显式地使用return语句返回一个对象,那么调用表达式的值就是这个对象

    var obj = {a:1};
    function fn(){
        this.a = 2;
        return obj;
    }
    var test = new fn();
    console.log(test);//{a:1}
    

    【4】间接调用模式

    javascript中函数也是对象,函数对象也可以包含方法。call()和apply()方法可以用来间接地调用函数

    这两个方法都允许显式指定调用所需的this值,也就是说,任何函数可以作为任何对象的方法来调用,哪怕这个函数不是那个对象的方法。两个方法都可以指定调用的实参。call()方法使用它自有的实参列表作为函数的实参,apply()方法则要求以数组的形式传入参数

    var obj = {};
    function sum(x,y){
        return x+y;
    }
    console.log(sum.call(obj,1,2));//3
    console.log(sum.apply(obj,[1,2]));//3
    
    展开全文
  • C++ 普通函数和模板函数调用规则

    万次阅读 2020-07-29 22:30:45
    1.如果函数模板和普通函数都可以实现,优先调用普通函数 2.可以通过空模板参数列表来强制调用函数模板 3.函数模板也可以发生重载 4.如果函数模板可以产生更好的匹配, 优先调用函数模板 */ #include<iostream>...

    /**
    调用规则如下:
    1.如果函数模板和普通函数都可以实现,优先调用普通函数
    2.可以通过空模板参数列表来强制调用函数模板
    3.函数模板也可以发生重载
    4.如果函数模板可以产生更好的匹配, 优先调用函数模板
    */ 

    总结:既然提供了函数模板,最好就不要提供普通函数,否则容易出现二义性

    #include<iostream>;
    using namespace std;
    
    
    /**
    调用规则如下:
    1.如果函数模板和普通函数都可以实现,优先调用普通函数
    2.可以通过空模板参数列表来强制调用函数模板
    3.函数模板也可以发生重载
    4.如果函数模板可以产生更好的匹配, 优先调用函数模板
    */
    
    //普通函数与函数模板调用规则
    void myPrint(int a,int b) {
    	cout << "调用的普通函数" << endl;
    }
    template<typename T>
    void myPrint(T a, T b) {
    	cout << "调用的模板" << endl;
    }
    template<typename T>
    void myPrint(T a, T b, T C) {
    	cout << "调用重载的模板" << endl;
    }
    void test01() {
    	//1、如果函数模板和普通函数都可以实现,优先调用普通函数
    	//注意如果告诉编译器普通 函数是有的,但只是声明没有实现,或者不在当前文件内实现,就会报错找不
    	int a = 10;
    	int b = 20;
    
    
    	myPrint(a, b); //调用普通函数
    	// 2、可以通过空模板参数列表来强制调用函数模板
    	myPrint<>(a, b); //调用函数模板
    	//3、函数模板也可以发生重载
    	int C = 30;
    	myPrint(a, b, C); //调用重载的函数模板
    	//4、如果函数模板可以产生 更好的匹配,优先调用函数模板
    	char C1 = 'a';
    	char C2 = 'b';
    	myPrint(C1, C2); //调用函数模板
    }
    
    
    int main() {
    	test01();
    	system("pause");
    	return 0;
    }

     

    展开全文
  • C语言函数调用

    千次阅读 2019-04-30 14:50:25
    C函数调用 调用格式: 函数名(实参表) 并且应该避免写出与实际参数计算次序有关的调用。 函数调用可以出现在以下两种情况中: 无返回值的函数通常作为表达式语句,即直接在函数调用的后面加一个分号; 有返回值的...
  • 函数调用过程

    千次阅读 多人点赞 2018-01-31 09:21:19
    今天突然看到有人私信我说一直没写函数调用过程(栈帧的形成和销毁过程)这篇博文,赶紧补上。 刚看的栈帧内容时,我很迷惑,我觉得栈帧创建和销毁很麻烦,几句话根本说不完,而且我好像描述不清楚他的过程,所以...
  • C++中构造函数调用其他函数

    千次阅读 2013-08-30 16:43:55
    #include #include using namespace std; struct CLS { int m_i; CLS( int i ) : m_i(i){} CLS() { CLS(0); } }; int main() { CLS obj; cout ; sys
  • 函数调用堆栈的过程

    万次阅读 多人点赞 2018-05-31 11:46:43
    本篇来分析函数调用的过程:通过下面一个简单的例子来进入话题:#include&lt;stdio.h&gt; int sum(int a,int b) { int tmp=0; tmp=a+b; return tmp; } int main() { int a=10; int b=20; int ret=0; ...
  • 系统调用、函数调用

    千次阅读 2015-04-16 08:43:23
    操作系统的主要功能是为管理硬件资源和为应用程序开发人员提供良好的环境来使应用程序具有更好的兼容性,为了达到这个目的,内核提供一系列具备预定功能的多内核函数,通过一组称为系统调用(system call)的接口...
  • 函数调用栈 剖析+图解

    万次阅读 多人点赞 2013-11-25 16:12:06
    栈: 在函数调用时,第一个进栈的是主函数中函数调用后的下一条指令(函数调用语句的下一条可执行语句)的地址,然后是函数的各个参数,在大多数的C编译器中,参数是由右往左入栈的,然后是函数中的局部变量。...
  • 函数调用

    千次阅读 2019-01-04 22:32:41
    函数调用 子函数 定义:能被其他程序调用,在实现某种功能后能自动返回到调用程序去的程序。其最后一条指令一定是返回指令,故能保证重新返回到调用它的程序中去。也可调用其他子程序,甚至可自身调用(如递归...
  • C语言的函数调用过程

    万次阅读 多人点赞 2018-05-14 16:42:54
    C语言的函数调用过程先上一段代码#include&lt;stdio.h&gt; int Add(int x, int y) { int z = 0; z = x + y; return z; } #include &lt;stdio.h&gt; int main() { int a = 10; int b = 20; int...
  • PHP 函数调用

    千次阅读 2019-09-24 13:20:53
    函数调用 函数调用时,实参要按照顺序给形参。 函数调用时,互相独立,默认没有联系。 执行完毕后,返回调用的位置,继续向下执行。 案例 <?php function A(){ echo "This is A fun!<hr />"; } function B...
  • 我们一般将字符串、列表等变量作为参数进行函数调用。但函数本身也是一个对象,所以我们也可以将函数作为参数传入另外一个函数中并进行调用。 本关的目标是让读者了解并掌握函数作为参数传入另外一个函数中并进行...
  • Shell中的函数调用

    万次阅读 2016-09-03 23:31:46
     ----------函数介绍  ----------函数定义  ----------函数使用  ----------区分return和exit  ----------删除函数  ----------注意事项   1、介绍函数 
  • c语言函数调用及应用举例

    千次阅读 多人点赞 2019-04-20 16:27:29
    一般来说,执行源程序就是执行主函数main,其他函数只能被主函数所调用,而其他函数之间也可以相互调用。 1.标准库函数: 分为:I/O函数,字符串,字符处理函数,数学函数,接口函数,时间转换和操作函数,动态...
  • C++函数调用过程和内置函数详解

    千次阅读 2018-03-12 10:15:01
    上图表示函数调用过程:①程序先执行函数调用之前的语句;②流程的控制转移到被调用函数入口处,同时进行参数传递;③执行被调用函数中函数体的语句;④流程返回调用函数的下一条指令处,将函数返回值带回;⑤接着...
  • C语言函数调用三种方式:传值调用,引用调用和传地址调用
  • 各类分析函数调用关系图的工具

    千次阅读 2011-08-31 17:21:48
    各类分析函数调用关系图的工具 作者: falcon 发表日期: 2008-04-28 16:19 复制链接 描述: calltree.jpg 图片: 描述: calltree1.jpg 图片: 描述: kprof_noargument.jpg 图片: 描述:...
  • 关于函数调用栈(call stack)的个人理解 首先,我们需要知道以下几个概念: 调用栈(call stack):调用栈的主要功能是保存调用的返回地址。 栈在函数调用中的作用:参数传递、局部变量分配、保存调用的返回地址、...
  • 以数组作为函数参数的函数调用

    千次阅读 2018-11-28 15:04:44
    调用有参函数时需要提供实参,实参可以是常量变量或者表达式,数组元素就相当于变量,因此数组元素可以用作函数实参,但是不能用作函数形参(因为在函数调用时临时分配存储单元,不可能为一个数组单独分配存储单元...
  • 函数调用过程中的栈帧结构及其变化

    千次阅读 多人点赞 2018-04-28 02:34:42
    前言:本文旨在从汇编代码的角度出发,分析函数调用过程中栈帧的变化。栈帧的简单介绍: 当某个函数运行时,机器需要分配一定的内存去进行函数内的各种操作,这个过程中分配的那部分栈称为栈帧。下图描述了栈帧的...
  • 函数调用模式4种方式详解

    千次阅读 2017-03-15 22:17:55
    函数调用模式: 函数模式特征:就是一个简单的函数调用,函数名前面没有任何的引导内容function foo(){} var func = function(){}foo(); func(); (function(){})(); this在函数模式中的含义: this在函数中表示全
  • C++函数调用过程深入分析

    万次阅读 2011-08-11 20:43:42
    C++函数调用过程深入分析 刘兵 QQ: 44452114 E-mail: liubing2000@foxmail.com 0. 引言  函数调用的过程实际上也就是一个中断的过程,那么C++中到底是怎样实现一个函数的调用的呢?参数入栈、函数跳转、保护现场...
  • [C++]函数调用

    千次阅读 2018-05-09 00:13:55
    程序的执行过程可看作连续的函数调用。当一个函数执行完毕时,程序要回到调用指令的下一条指令(紧接call指令)处继续执行。函数调用过程通常使用堆栈实现,每个用户态进程对应一个调用栈结构(call stack)。编译器使用...
  • 绘制函数调用图(call graph)(4):doxygen + graphviz

    万次阅读 多人点赞 2018-03-30 21:42:02
    doxygen 也可以生成函数调用关系图,但 doxygen 能做的远不止于此,它是一款优秀的文档自动生成工具。它可以将代码中的注释转换成帮助文档(注释格式要符合 doxygen 要求才行,FFmpeg API Documentation 就是用...
  • 我想,你只要看了C语言上关于传值函数调用的测试题,一切都会了然于胸:1. 考题一:程序代码如下:void Exchg1(int x, int y) {int tmp;tmp=x;x=y;y=tmp;printf(“x=%d,y=%d/n”,x,y)}void main(){int a=4,b=6;...
  • Java函数调用

    千次阅读 2019-09-26 19:44:23
    函数调用 举例说明Java中函数的调用 public class test { public static void main(String[] args) { int i = 0; func(i); i = i++; System.out.println(i); String str = "hello wo...
  • 静态成员函数调用方式--收藏帖子

    千次阅读 2018-12-13 17:14:56
    静态成员函数调用方式 A:: s_fun();//不需要额外传递一个参数,作为this 指针;因为静态函数,属于类,不属于具体对象。非静态成员函数调用方式 。非静态成员函数,属于对象,需要隐式传递 this 指针作为参数...
  • 系统调用和函数调用的区别

    千次阅读 2018-10-10 13:34:49
    系统调用与函数调用的区别 系统调用 1.使用INT和IRET指令,内核和应用程序使用的是不同的堆栈,因此存在堆栈的切换,从用户态切换到内核态,从而可以使用特权指令操控设备 2.依赖于内核,不保证移植性 3.在用户...

空空如也

1 2 3 4 5 ... 20
收藏数 3,793,687
精华内容 1,517,474
关键字:

dotcore 调用shell