• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    公众号

C与Lua互相调用的时候,栈变化分析

原作者: [db:作者] 来自: [db:来源] 收藏 邀请

                                                                          1  C调用Lua函数的堆栈变化

例子

Lua文件中的函数
 function testNewCounter2()

 return "第四个结果"

end 

C中的例子
void t_new(lua_State *aaa){

 }


     lua_pushstring(aaa, "feifei");

     lua_pushcfunction(aaa, t_new);
     const char *ccc= lua_tostring(aaa, -2);

     printf("倒数第二个的值为%s\n",ccc);

     lua_getglobal(aaa, "testNewCounter2");

     int iiiiif=lua_gettop(aaa);

     printf("现在栈内得数目=%d\n",iiiiif);

     lua_pcall(aaa, 0, 1, 0);

    int iiiii=lua_gettop(aaa);

    printf("执行函数之后现在栈内得数目=%d\n",iiiii);

    const char *ccfffc= lua_tostring(aaa, -3);//倒数第三个

    const char *ccfffc2= lua_tostring(aaa, -1);//倒数第一个,也就是lua函数的返回值

     printf("倒数第三个=%s\n",ccfffc);

     printf("倒数第一个,也就是lua函数的返回值=%s\n",ccfffc2);

运行结果如下:

倒数第二个的值为feifei

现在栈内得数目=3

执行函数之后现在栈内得数目=3

倒数第三个=feifei

倒数第一个,也就是lua函数的返回值=第四个结果

也就是说函数执行完了之后,首先是把自身弹出,然后把返回结果压住栈内,

而在函数压入之前的,比如feifei等,函数控制不了,也不会把他们弹出

 下面给lua函数加一个参数试试,也就是lua文件的函数为

function testNewCounter2(para)

 return "第四个结果” .. para

end 

 lua_pushstring(aaa, "feifei");

     lua_pushcfunction(aaa, t_new);

     const char *ccc= lua_tostring(aaa, -2);

     printf("倒数第二个的值为%s\n",ccc);

     lua_getglobal(aaa, "testNewCounter2");

     lua_pushstring(aaa, "lua的参数");

     int iiiiif=lua_gettop(aaa);

     printf("现在栈内得数目=%d\n",iiiiif);

     lua_pcall(aaa, 1, 1, 0);

    int iiiii=lua_gettop(aaa);

    printf("执行函数之后现在栈内得数目=%d\n",iiiii);

    const char *ccfffc= lua_tostring(aaa, -3);//倒数第三个

    const char *ccfffc2= lua_tostring(aaa, -1);//倒数第一个,也就是lua函数的返回值

     printf("倒数第三个=%s\n",ccfffc);

     printf("倒数第一个,也就是lua函数的返回值=%s\n",ccfffc2);

返回结果:
倒数第二个的值为feifei

现在栈内得数目=4

执行函数之后现在栈内得数目=3

倒数第三个=feifei

倒数第一个,也就是lua函数的返回值=第四个结果lua的参数

和预期的一样,lua函数在执行完之后,会吧他自身和他的参数弹出,然后把返回结果压入栈中

       

                                                          2  Lua调用C函数的堆栈变化

 

首先lua文件中函数为

   
    function testNewCounter2(para)
        ccc=new222()
     end

c文件中的函数
int t_new(lua_State *aaa){

    int ffdsfdsf=lua_gettop(aaa );

    printf("函数私有栈的数目=%d\n",ffdsfdsf);

    lua_pushstring(aaa, "C函数的结果");

    int ffdsfdsffds=lua_gettop(aaa);

    printf("加入一个结果之后的函数私有栈的数目=%d\n",ffdsfdsffds);

    return 1;

}

备注:这里需要说明的一点是返回值为1,说明就一个返回结果,表示压入栈中的返回值数量。因此这个函数无需在压住结果之前清空栈,在他返回后,Lua会自动删除栈中结果之下的内容,就是说不管你加入几个元素进栈,只看返回结果,返回结果是几,就把几个加入到全局栈,其余的会清空,在函数返回完毕之后,函数内的私有栈也全部清空,在最后一步return数目的时候,确实是加入到了全局栈,而函数开始的时候,获取的参数第一个始终是传过来的参数,而不是全局栈中最顶上一个元素,这一点要区分开

调用代码如下:

 lua_pushstring(aaa, "feifei");

           lua_pushstring(aaa, "wenqian");

        lua_pushcfunction(aaa, t_new);

        lua_setglobal(aaa, "new222");

        lua_getglobal(aaa, "testNewCounter2");

        lua_pcall(aaa, 0, 0, 0);



        const char *ccc= lua_tostring(aaa, -1);

        printf("执行完函数之后倒数第一个=%s\n",ccc);

        const char *ccc2= lua_tostring(aaa, -2);

        printf("执行完函数之后倒数第二个=%s\n",ccc);

 

结果:
函数私有栈的数目=0

加入一个结果之后的函数私有栈的数目=1

执行完函数之后倒数第一个=wenqian

执行完函数之后倒数第二个=feifei

首先来看 t_new函数里面有一个私有栈,不受外部影响,他的栈里面就是传给他的参数。

然后看调用代码,第一和第二是加入两个字符串,然后注册t_new,然后调用

testNewcounter2,调用玩之后,栈弹出这个函数,因为函数没有返回值,所以此时栈内有两个,就是开始加入的两个字符串。

 

下面再看看让testNewCounter2返回结果时候的调用

这里只是修改lua文件中的方法,改为:
    function testNewCounter2( )

    ccc=new222()

     return "返回new222的结果" .. ccc

    end
开始调用
      lua_pushstring(aaa, "feifei");

        lua_pushstring(aaa, "wenqian");

        lua_pushcfunction(aaa, t_new);

        lua_setglobal(aaa, "new222");

        lua_getglobal(aaa, "testNewCounter2");

        lua_pcall(aaa, 0, 1, 0);



        const char *ccc= lua_tostring(aaa, -1);

        printf("执行完函数之后倒数第一个=%s\n",ccc);

        const char *ccc2= lua_tostring(aaa, -2);

        printf("执行完函数之后倒数第二个=%s\n",ccc2);

结果:
函数私有栈的数目=0

加入一个结果之后的函数私有栈的数目=1

执行完函数之后倒数第一个=返回new222的结果C函数的结果

执行完函数之后倒数第二个=wenqian

倒数第一个成了new222返回的结果,和预期的一样

 

 

Lua和c的交互中还有一个比较难理解的地方就是upvalue。upvalue实现了一种类似于C语言中静态变量的机制,这种变量只在一个特定的函数中可见。每当在Lua中创建一个函数时,都可以将任意数量的upvalue与这个函数相关联。每个upvalue都可以保存一个lua值。以后,在调用这个函数时,就可以通过伪索引来访问这些upvalue了
closure可以用一个函数代码来创建多个closure,每个closure可以拥有不同的upvalue。

 

下面得例子,在c语言中创建一个newCounter函数。这个函数是一个工厂函数,每次调用都返回一个新的账户函数

int newCounter(lua_State *aaa){

     lua_pushinteger(aaa, 0);

     lua_pushcclosure(aaa, &counter, 1);

     int fff=lua_gettop(aaa);

    printf("推入了closure之后,站内的数量=%d",fff);

    return 1;

}

static int counter(lua_State *aaa){

   int val=(int)lua_tointeger(aaa, lua_upvalueindex(1));

   int fdsfdsf= lua_gettop(aaa);

    printf("每次进入时栈的数量=%d",fdsfdsf);

    lua_pushinteger(aaa, ++val);

    lua_pushvalue(aaa, -1);

    lua_replace(aaa, lua_upvalueindex(1));

     int fdsfdsf11fds1= (int)lua_gettop(aaa);

    printf("最后栈的数量=%d",fdsfdsf);

     return 1;

}

在Lua文件中,函数如下:
function newCounterFactory()

  counterFun=newCounter();

 return counterFun()

end



function newCounterFactoryAgain()

 return counterFun()

end

C语言调用代码如下:
            lua_pushstring(aaa, "feifei");

            lua_pushstring(aaa, "wenqian");

            lua_pushcfunction(aaa, newCounter);

            lua_setglobal(aaa, "newCounter");

            lua_getglobal(aaa, "newCounterFactory");

            lua_pcall(aaa, 0, 1, 0);



            const char *ccc= lua_tostring(aaa, -1);

            printf("第一次调用倒数第一个值=%s\n",ccc);

            const char *ccc22= lua_tostring(aaa, -2);

            printf("第一次调用倒数第二个值=%s\n",ccc22);

           lua_getglobal(aaa, "newCounterFactoryAgain");

           lua_pcall(aaa, 0, 1, 0);

    

          const char *ccccc= lua_tostring(aaa, -1);

          printf("第二次调用倒数第一个值=%s\n",ccccc);

          const char *ccccc2= lua_tostring(aaa, -2);

          printf("第二次调用倒数第二个值=%s\n",ccccc2);

         const char *ccccc3= lua_tostring(aaa, -3);

        printf("第二次调用倒数第三个值=%s\n",ccccc3);

运行结果:
推入了closure之后,站内的数量=1

每次进入时栈的数量=0

最后栈的数量=1

第一次调用倒数第一个值=1

第一次调用倒数第二个值=wenqian

每次进入时栈的数量=0

最后栈的数量=1

第二次调用倒数第一个值=2

第二次调用倒数第二个值=1

第二次调用倒数第三个值=wenqian


从第二次调用可以看出,每一次counter()调用完了之后,确实是加入到了全局栈

 

现在分析 一下特殊情况

第一:修改一下lua函数,让newCounterFactory只是返回counter函数,而不执行,如下:

function newCounterFactory()
  counterFun=newCounter();
  return counterFun
end
执行代码如下:
   lua_pushstring(aaa, "feifei");
            lua_pushstring(aaa, "wenqian");

            lua_pushcfunction(aaa, newCounter);
            lua_setglobal(aaa, "newCounter");
            lua_getglobal(aaa, "newCounterFactory");
            lua_pcall(aaa, 0,1, 0);
    
   
           auto ffdsfdsfdsfdsfff=lua_isfunction(aaa, -1);
           printf("是不是函数:%d\n",ffdsfdsfdsfdsfff);
           // lua_pcall(aaa, 0,1, 0);
    
            const char *ccc= lua_tostring(aaa, -1);
            printf("第一次调用倒数第一个值=%s\n",ccc);
            const char *ccc22= lua_tostring(aaa, -2);
            printf("第一次调用倒数第二个值=%s\n",ccc22);
           const char *ccc22222= lua_tostring(aaa, -3);
           printf("第一次调用倒数第二个值=%s\n",ccc22222);

运行结果:
推入了closure之后,站内的数量=1
是不是函数:1
第一次调用倒数第一个值=(null)
第一次调用倒数第二个值=wenqian
第一次调用倒数第二个值=feifei

分析得知,newCounter没有执行,因为newCounterFactory()只是返回了他,并把它加入了全局栈中,所以全局栈中第一个是
function。

那么我们现在我们知道现在newCounter函数是位于全局栈的顶部,那么我们可以执行一下他,调用代码如下:
 lua_pushstring(aaa, "feifei");
            lua_pushstring(aaa, "wenqian");

            lua_pushcfunction(aaa, newCounter);
            lua_setglobal(aaa, "newCounter");
            lua_getglobal(aaa, "newCounterFactory");
            lua_pcall(aaa, 0,1, 0);
    
   
           auto ffdsfdsfdsfdsfff=lua_isfunction(aaa, -1);
           printf("是不是函数:%d\n",ffdsfdsfdsfdsfff);
          —-执行以下栈顶函数
           lua_pcall(aaa, 0,1, 0);
    
            const char *ccc= lua_tostring(aaa, -1);
            printf("第一次调用倒数第一个值=%s\n",ccc);
            const char *ccc22= lua_tostring(aaa, -2);
            printf("第一次调用倒数第二个值=%s\n",ccc22);
           const char *ccc22222= lua_tostring(aaa, -3);
           printf("第一次调用倒数第二个值=%s\n",ccc22222);

运行结果如下:
推入了closure之后,站内的数量=1
是不是函数:1
每次进入时栈的数量=0
最后栈的数量=1
第一次调用倒数第一个值=1
第一次调用倒数第二个值=wenqian
第一次调用倒数第二个值=feifei

newCounter函数执行完毕,把他的参数和他自己出栈,然后压入他的返回值

那么返过来再看看最初的执行情况,就是newCounterFactory函数里面直接执行newCounter,这里在运行一遍结果
首先改一下lua代码
function newCounterFactory()
  counterFun=newCounter();
 -- return counterFun
 return counterFun()
end
调用代码如下:
    lua_pushstring(aaa, "feifei");
            lua_pushstring(aaa, "wenqian");

            lua_pushcfunction(aaa, newCounter);
            lua_setglobal(aaa, "newCounter");
            lua_getglobal(aaa, "newCounterFactory");
            lua_pcall(aaa, 0,1, 0);
    
   
           auto ffdsfdsfdsfdsfff=lua_isfunction(aaa, -1);
           printf("是不是函数:%d\n",ffdsfdsfdsfdsfff);
    
    
            const char *ccc= lua_tostring(aaa, -1);
            printf("第一次调用倒数第一个值=%s\n",ccc);
            const char *ccc22= lua_tostring(aaa, -2);
            printf("第一次调用倒数第二个值=%s\n",ccc22);
           const char *ccc22222= lua_tostring(aaa, -3);
           printf("第一次调用倒数第二个值=%s\n",ccc22222);

运行结果:

推入了closure之后,站内的数量=1
每次进入时栈的数量=0
最后栈的数量=1
是不是函数:0
第一次调用倒数第一个值=1
第一次调用倒数第二个值=wenqian
第一次调用倒数第二个值=feifei

和上个例子是一样得,只不过前者是在C里面执行了newCounter,而后者是在lua里面执行的,我认为他们都是一样的,虽然执行完了这个函数就出栈了,
在C语言中无法再次执行了,但是因为在lua中保存了他的一个引用【在哪里引用的?当newCounter执行过程中,lua_pushcclosure讲一个新的
closure留在了栈上,并以此作为newCounter的返回值,而在lua中的全局变量counterFun引用了他的返回值】,所以依然可以再次调用。

 

下面再看最后一种情况,验证函数里面加入栈的元素,到底对全局栈有什么影响

lua函数如下:
function newCounterFactory()
  counterFun=newCounter();
  return counterFun
 --return counterFun()
end
C中newCounter方法
int newCounter(lua_State *aaa){
   
   
      lua_pushstring(aaa, "001");
      lua_pushstring(aaa, "002");
      lua_pushinteger(aaa, 0);
      lua_pushcclosure(aaa, &counter, 1);
     int fff=lua_gettop(aaa);
    printf("推入了closure之后,站内的数量=%d\n",fff);
    return 1;
}
在这里,我们多推入了几个元素,但是还是返回一个
调用代码如下:
lua_pushstring(aaa, "feifei");
            lua_pushstring(aaa, "wenqian");

            lua_pushcfunction(aaa, newCounter);
            lua_setglobal(aaa, "newCounter");
            lua_getglobal(aaa, "newCounterFactory");
            lua_pcall(aaa, 0,1, 0);
    
   
            auto ffdsfdsfdsfdsfff=lua_isfunction(aaa, -1);
            printf("是不是函数:%d\n",ffdsfdsfdsfdsfff);
    
    
            const char *ccc= lua_tostring(aaa, -1);
            printf("第一次调用倒数第一个值=%s\n",ccc);
            const char *ccc22= lua_tostring(aaa, -2);
            printf("第一次调用倒数第二个值=%s\n",ccc22);
           const char *ccc22222= lua_tostring(aaa, -3);
           printf("第一次调用倒数第二个值=%s\n",ccc22222);

运行结果:
推入了closure之后,站内的数量=3
是不是函数:1
第一次调用倒数第一个值=(null)
第一次调用倒数第二个值=wenqian
第一次调用倒数第二个值=feifei

可以看到函数内入栈数目取决于返回值,返回值是几,就入栈几个,加到之前全局栈里面元素的上面,函数内其余的元素都会清除,而函数本身的私有栈也是全部清空了,
通过每次运行函数,在里面调用lua_gettop可以看得出来,私有栈不受全局栈影响,他的第一个参数永远是传入方法的第一个参数,而不是全局栈顶部的元素

 


鲜花

握手

雷人

路过

鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
上一篇:
Luatable.sort()原理和使用的坑发布时间:2022-07-22
下一篇:
lua垃圾回收机制发布时间:2022-07-22
热门推荐
热门话题
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服(服务时间 9:00~18:00)

在线QQ客服
地址:深圳市南山区西丽大学城创智工业园
电邮:jeky_zhao#qq.com
移动电话:139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap