Lua语言如何调用自己编写的C DLL文件
Lua和C语言的交互详解
Lua和C语⾔的交互详解前⾔对于Lua的基础总结总算告⼀段落了，从这篇博⽂开始，我们才真正的进⼊Lua的世界，⼀个⽆聊⽽⼜有趣的世界。
来吧。
Lua语⾔是⼀种嵌⼊式语⾔，它本⾝的威⼒有限；当Lua遇见了C，那它就展⽰了它的强⼤威⼒。
C和Lua是可以相互调⽤的。
第⼀种情况是，C语⾔拥有控制权，Lua是⼀个库，这种形式中的C代码称为“应⽤程序代码”；第⼆种情况是，Lua拥有控制权，C语⾔是⼀个库，这个时候C代码就是“库代码”。
“应⽤程序代码”和“库代码”都使⽤同样的API来与Lua通信，这些API就称为C API。
C API是⼀组能使C代码与Lua交互的函数，包括很多对Lua代码的操作。
如何操作，操作什么，我们的⽂章我都会⼀⼀总结。
C API是⾮常灵活⽽强⼤的。
为了表⽰它的NB之处，不先来⼀段⼩的DEMO程序展⽰⼀下，怎么能够⾏呢？复制代码代码如下:#include <iostream>#include <string.h>extern "C"{#include "lua.h"#include "lauxlib.h"#include "lualib.h"}int main(){char buff[256] = {0};int error;lua_State *L = luaL_newstate(); // 打开LualuaL_openlibs(L); // 打开标准库while (fgets(buff, sizeof(buff), stdin) != NULL){error = luaL_loadbuffer(L, buff, strlen(buff), "line")|| lua_pcall(L, 0, 0, 0);if (error){fprintf(stderr, "%s", lua_tostring(L, -1));lua_pop(L, 1); // 从栈中弹出错误消息}}lua_close(L);return 0;}如果你没有接触过C API，对于上⾯这段代码，你肯定不会明⽩它是⼲什么的。
lua调用c函数并获取返回值
lua调用c函数并获取返回值摘要：一、Lua 语言简介1.Lua 的发展历程2.Lua 的特点二、C 语言与Lua 语言的交互1.Lua 调用C 函数2.C 函数获取Lua 的返回值三、具体实现Lua 调用C 函数并获取返回值1.编写C 函数2.编写Lua 脚本3.编译运行正文：一、Lua 语言简介Lua 是一种轻量级的脚本语言，由巴西里约热内卢天主教大学的计算机科学系开发。
自1993 年推出以来，Lua 已经广泛应用于游戏开发、嵌入式系统、网络编程等多个领域。
Lua 以其简洁的语法、高效的可执行性和跨平台能力受到了广大开发者的喜爱。
二、C 语言与Lua 语言的交互在实际应用中，C 语言和Lua 语言经常需要相互调用。
C 语言作为底层语言，提供了丰富的功能和性能；而Lua 作为脚本语言，具有较高的开发效率。
通过C 语言与Lua 语言的交互，我们可以充分利用两者的优势。
1.Lua 调用C 函数在Lua 中，我们可以通过C API（应用程序编程接口）调用C 函数。
具体步骤如下：a.包含Lua 头文件b.注册C 函数到Lua 虚拟机c.调用Lua API 函数2.C 函数获取Lua 的返回值在C 函数中，我们可以通过Lua API 函数获取Lua 脚本的返回值。
具体步骤如下：a.创建一个Lua 状态机b.调用Lua API 函数c.获取Lua 返回值三、具体实现Lua 调用C 函数并获取返回值1.编写C 函数```c#include <stdio.h>#include <lua.h>#include <lauxlib.h>int add(int x, int y) {return x + y;}int main() {Lua_State *L = lua_open();lua_pushcfunction(L, add);lua_pushinteger(L, 10);lua_pushinteger(L, 20);int result = lua_pcall(L, 2, 1, 0);if (result) {printf("Error: %s", lua_tostring(L, -1));} else {printf("Result: %d", lua_tointeger(L, -1));}lua_close(L);return 0;}```2.编写Lua 脚本```luafunction add(x, y)return x + yendlocal result = add(10, 20)print("Result: " ..result)```3.编译运行使用gcc 将C 代码编译为可执行文件，然后运行该文件。
lua与c交互原理
lua与c交互原理Lua与C语言可以进行交互，可以通过Lua与C的API来实现。
Lua是一种轻量级的动态脚本语言，其提供了一组API函数，可以用来与C语言进行交互。
C语言是一种低级的、系统级的程序设计语言，相比起Lua，C语言更加高效、底层，可以用来编写性能敏感的代码。
在Lua与C交互的过程中，有两个主要的角色，主程序和辅助库。
主程序使用Lua的API来调用C函数，而辅助库则提供C函数供Lua主程序调用。
下面将介绍主程序中常用的Lua API函数，以及如何在辅助库中编写C函数。
在主程序中，可以使用以下函数来调用C函数：1. `luaL_loadfile`：从文件中加载Lua代码，并将其编译为可执行的函数对象。
2. `lua_pcall`：调用Lua函数并处理可能出现的错误，可以将C语言函数作为回调函数传递给Lua函数。
3. `lua_push*`：将数据压入Lua堆栈中，以便Lua函数使用。
4. `lua_get*`：从Lua堆栈中获取数据，以便C函数使用。
5. `lua_register`：在Lua中注册C函数，使其可以被Lua函数调用。
在辅助库中，可以使用以下函数来编写C函数：1. `lua_to*`：将Lua堆栈中的数据转换为C语言的相应类型。
2. `lua_push*`：将C语言的数据压入Lua堆栈中，以便Lua函数使用。
3. `luaL_check*`：检查堆栈中的数据类型，并返回相应的C语言值，如果类型不匹配，则触发错误。
4. `lua_pushvalue`：将指定的值（在堆栈中的索引处）复制到堆栈的顶部。
通过这些API函数，Lua与C语言可以进行高效的数据传递和函数调用。
主程序可以将C函数注册为Lua的全局函数，从而可以在Lua脚本中直接调用。
而C函数可以通过API函数来获取Lua脚本中的数据，并使用C语言的能力进行处理。
Lua与C交互的具体原理如下：1. 主程序调用`luaL_loadfile`函数加载Lua代码。
Lua编程之lua和c之间互相调用方式
Lua编程之lua和c之间互相调用方式Lua编程之Lua和C之间互相调用方式Lua和C调用主要有两种方式：1.在C中运行，C函数调用Lua，Lua要注册C函数库。
2.程序在lua中运行，C注册到lua中。
第一种方式看起来很奇怪。
既然程序主体运行在C中，而且最终使用的也是C中定义的函数，那么为何要将Lua函数注册给Lua，然后再通过Lua 调用函数呢？其实lua库在此调用中只是一个中间库，他只是一个table 保存C库函数的指针，一旦C函数注册到Lua中，Lua就可以直接通过C 函数的引用获取到C函数的地址（这也是我们注册的意义，将C函数的地址提供给Lua）。
也就是说，我们必须把C 函数的地址以一个适当的方式传递给Lua解释器。
而这个指针只是保存在了Lua虚拟栈中。
首先看第二种Lua如何调用C。
lua可以将C函数注册到lua中，C函数必须遵循统一的原型格式，这个原型定义在lua.h中.typedefint (*) (lua_State *)被注册的C函数接收一个单一的lua_State类型的参数，同时返回一个表示返回值个数的数字。
函数在将返回值入栈之前无需清理栈，在函数返回之后，Lua会自动清除栈中返回结果下面的所有内容。
用C函数扩展lua时，一般将所有的C函数编译成一个独立的模块，方便增加新的函数。
//mylib.c#include#include#include#include#include/* 所有注册给Lua的C函数具有* "typedefint(*lua_CFunction) (lua_State *L);"的原型。
*/staticintmyadd(lua_State *L){//如果给定虚拟栈中索引处的元素可以转换为数字，则返回转换后的数字，否则报错。
int a = luaL_checknumber(L, 1);int b = luaL_checknumber(L, 2);/* 这里可以看出，C可以返回给Lua多个结果， *通过多次调用lua_push*()，之后return返回结果的数量。
lua语言调用c函数
lua语言调用c函数Lua是一门轻量级脚本语言，它可以与C语言进行交互。
这种交互能力使得Lua更加灵活和强大，因为C语言有很多底层功能和库，而Lua则提供了高级的脚本语言特性。
在Lua中调用C函数有两种方式：通过Lua的C API直接调用，或者使用LuaJIT的FFI接口。
无论哪种方式，都需要编写C语言的代码，并将其编译成动态链接库(DLL)或共享库(SO)。
使用Lua的C API调用C函数需要以下步骤：1.编写C函数，它应该接收Lua虚拟机的指针作为参数，然后从栈中读取参数并将结果压入栈中，最后返回结果的数量。
2.在Lua中使用loadfile或dostring函数加载C函数所在的动态链接库或共享库。
3.使用Lua的C API调用C函数。
以下是一个简单的例子，展示了如何在Lua中调用C函数：```c#include <lua.h>#include <lualib.h>#include <lauxlib.h>static int add(lua_State *L) {double a = luaL_checknumber(L, 1);double b = luaL_checknumber(L, 2);lua_pushnumber(L, a + b);return 1;}int luaopen_mylib(lua_State *L) {lua_register(L, 'add', add);return 0;}```这个例子定义了一个名为add的C函数，它接收两个参数并返回它们的和。
然后，我们将这个函数注册到Lua虚拟机中，并将其命名为add。
现在我们可以在Lua中调用它：```luarequire 'mylib'print(add(2, 3)) --> 5```注意：在C语言中，栈的顶部是最后一个元素，而在Lua中，栈的顶部是第一个元素。
lua调用c函数并获取返回值
lua调用c函数并获取返回值Lua是一种轻量级的编程语言，常用于嵌入式系统和游戏开发中。
与其他编程语言相比，Lua的语法简洁、灵活，并且具有良好的扩展性。
在Lua中，我们可以通过调用C函数来扩展其功能，利用C 函数的高效性能来处理一些复杂的任务。
本文将介绍如何在Lua中调用C函数并获取返回值，并探讨其实际应用。
一、Lua中调用C函数的基本原理Lua是通过C API来与C语言进行交互的，因此我们可以编写C函数并将其导出给Lua调用。
在Lua中，通过使用`require`函数加载C模块，然后通过调用C模块中的函数来实现与C函数的交互。
在C 函数中，我们可以通过`lua_push*`系列函数将返回值压入Lua栈中，然后通过`lua_*`系列函数从Lua栈中获取返回值。
二、导出C函数供Lua调用为了将C函数导出给Lua调用，我们需要进行一些额外的工作。
首先，我们需要编写一个C模块，其中包含待导出的C函数。
然后，我们需要在C模块中定义一个名为`luaopen_*`的函数，该函数将在Lua中调用`require`时被自动调用。
在`luaopen_*`函数中，我们需要通过`luaL_newlib`函数创建一个新的Lua库，并将待导出的C 函数注册到该库中。
最后，我们需要将该库返回给Lua，以便在Lua 中调用。
三、Lua中调用C函数并获取返回值的示例下面是一个简单的示例，演示了如何在Lua中调用C函数并获取返回值。
假设我们有一个C函数`add`，用于计算两个数的和，并将结果返回给Lua。
我们需要在C中实现`add`函数：```c#include <lua.h>#include <lualib.h>#include <lauxlib.h>static int add(lua_State* L) {double a = lua_tonumber(L, 1);double b = lua_tonumber(L, 2);double sum = a + b;lua_pushnumber(L, sum);return 1;}static const struct luaL_Reg mylib [] = {{"add", add},{NULL, NULL}};int luaopen_mylib(lua_State* L) {luaL_newlib(L, mylib);return 1;}```然后，我们将上述代码保存为一个名为`mylib.c`的文件，并使用`gcc`编译为共享库：```bashgcc -shared -o mylib.so mylib.c -I/path/to/lua/include -L/path/to/lua/lib -llua```接下来，我们在Lua中调用`add`函数并获取返回值：```lualocal mylib = require("mylib")local sum = mylib.add(1, 2)print(sum) -- 输出：3```在上述示例中，我们首先使用`require`函数加载了`mylib`模块，然后通过`mylib.add`调用了C函数`add`，并将返回值赋给了变量`sum`，最后打印出了计算结果。
lual_newlib用法
lual_newlib用法lual_newlib用法简介lual_newlib是一个Lua库，用于创建和管理自定义的C库函数，使其可以在Lua环境下使用。
本文将详细介绍lual_newlib的使用方法。
使用流程1.引入lual_newlib库local lual = require("lual_newlib")2.创建自定义的C库函数//#include <>// 普通的C函数int add(int a, int b) {return a + b;}// Lua可调用的C函数int lua_add(lua_State* L) {int a = lua_tointeger(L, 1);int b = lua_tointeger(L, 2);int result = add(a, b);lua_pushinteger(L, result);return 1; // 返回值个数}// 注册C函数const struct luaL_Reg samplelib[] = {{"add", lua_add},{NULL, NULL}};// 将C库注册到Lua环境int luaopen_samplelib(lua_State* L) {luaL_newlib(L, samplelib);return 1;}3.编译生成动态链接库gcc -shared -o4.加载动态链接库local samplelib = assert(("", "luaopen_sam plelib"))5.使用自定义C库函数local result = (1, 2)print(result) -- 输出 3注意事项•自定义C库函数的命名需遵循Lua的命名规范，以便在Lua环境中调用•注册C函数时，需要使用luaL_newlib函数将C函数打包成Lua库•加载动态链接库时，需使用``函数，并指定动态链接库的路径和入口函数名称总结本文介绍了lual_newlib的使用流程和一些注意事项，希望可以帮助读者更好地了解和使用lual_newlib库。
在易语言中调用DLL使用说明
易语言中调用DLL使用说明2005年11月大连大有吴涛易语言软件开发有限公司基本说明本文所描述的部分功能需易语言4.01或以上版本支持。
“在易语言中调用DLL”包含两方面的内容：调用Windows系统API函数；调用普通DLL函数。
下文用到的“调用API”或“调用DLL”等字眼，除非特别注明，一般都是指以上两方面之一或之和，视上下文而定。
绝大多数情况下，无需明确区分调用的是系统API还是普通DLL。
目前易语言只支持以stdcall方式调用DLL中的导出函数。
Windows系统API一般都是以stdcall调用方式导出的，故在易语言中调用它们时通常不必考虑函数调用方式的问题。
而普通DLL有可能导出“非stdcall调用方式”（比如cdecl）的函数，调用时需要特别注意。
一般而言，考虑到通用性，DLL开发者都会选择导出以sdtcall方式调用的函数。
（支持生成DLL的编程语言通常都支持导出stdcall调用方式的函数，具体实现请参考各编程语言手册。
）易语言编译生成的DLL，其导出函数全部为stdcall调用方式，所以在易语言中调用易语言生成的DLL不存在问题。
目前在易语言中调用DLL时只支持1字节对齐的结构（自定义数据类型）如果DLL命令的某个参数或参数的某个成员是结构类型（自定义数据类型），则其对齐方式必须是1字节对齐。
Windows系统API中所用到的结构都是1字节对齐的，故在调用API时不受此限制。
但如果想用其它编程语言生成DLL供易语言调用且数据类型中包含了1或2字节数据长度的成员（如字符型或短整数），就需要考虑结构的1字节对齐。
在Delphi中，可以这样定义1字节对齐的结构（结构在Delphi中称为record）：在其它编程语言或编译器中的定义方式请参考各自的编程手册。
目前易语言支持调用任意复杂的DLL命令只要满足了前面的两个条件——调用方式为stdcall，参数结构为1字节对齐——易语言支持调用任意复杂的DLL命令：参数除了可以是基本数据类型或普通结构类型外，还可以是基本类型地址或基本类型数组，也可以是结构类型地址或结构类型数组，结构类型的成员中还可以包含任意数量和任意层次的其它结构、结构地址、结构数组，等等。
Lua中调用C语言函数实例
Lua中调⽤C语⾔函数实例在上⼀篇⽂章()中，讲述了如何⽤c语⾔调⽤lua函数，通常，A语⾔能调⽤B语⾔，反过来也是成⽴的。
正如Java与c语⾔之间使⽤JNI来互调，Lua与C也可以互调。
当lua调⽤c函数时，使⽤了和c调⽤lua中的同⼀种栈，c函数从栈中得到函数，然后将结果压⼊栈中。
为了区分返回结果和栈中的其他值，每⼀个函数返回结果的个数。
这⾥有个重要的概念：这个栈不是全局的结构，每个函数都有⾃⼰的私有局部栈。
哪怕c函数调⽤了lua代码，lua代码再次调⽤该c函数，他们有各⾃独⽴的局部栈。
第⼀个参数的索引是1。
作为第⼀个例⼦，让我们看看如何实现⼀个简单的函数，返回给定2个参数的和：复制代码代码如下:static int l_plus(lua_State* L){lua_Integer a = lua_tointeger(L, 1);lua_Integer b = lua_tointeger(L, 2);lua_pushinteger(L, a+b);return 1;}每⼀个Lua注册的函数都必须是这个原型，它已经在lua.h中定义了：复制代码代码如下:typedef int (*lua_CFunction) (lua_State *L);由于c函数返回了⼀个int类型的返回值个数。
因此，当压⼊返回值之前，不必要清理栈，lua会⾃动移除返回值下⾯的任何数据。
在lua中使⽤该函数之前，我们需要注册它。
使⽤lua_pushcfunction,它接受⼀个c函数，然后在lua内部创建⼀个函数类型的值来表⽰该函数。
复制代码代码如下:lua_pushcfunction(L, lua_plus);lua_setglobal(L, "myplus");⼀个专业点的写法是，我们必须检查它的参数类型：复制代码代码如下:static int l_plus(lua_State* L){lua_Integer a = luaL_checkinteger(L, 1);lua_Integer b = luaL_checkinteger(L, 2);lua_pushinteger(L, a+b);return 1;}完整代码：复制代码代码如下:#include <lua.h>#include <lauxlib.h>#include <lualib.h>static int l_plus(lua_State* L){lua_Integer a = luaL_checkinteger(L, 1);lua_Integer b = luaL_checkinteger(L, 2);lua_pushinteger(L, a+b);return 1;}int main(){lua_State *L = luaL_newstate();luaL_openlibs(L);lua_pushcfunction(L, l_plus);lua_setglobal(L, "myplus");if (luaL_dostring(L, "print(myplus(2,2))")) { lua_close(L);error("Failed to invoke");}lua_close(L);return 0;}（完）。
C#和lua相互调用的方法教程
C#和lua相互调⽤的⽅法教程前⾔⾃从ulua在官⽹上出来后，lua 就被u3d开发⼈员喜爱。
国内有⼏个⾼⼿把lua拿过来 接着进⾏了封装。
很多都是新⼿转过来。
lua语法⼀看遍知，但是⼤多数⼈还是不明⽩两个语⾔之间的互相调⽤是怎么⼀回事，这也是难点和重点。
所以今天想跟⼤家分享⼀下这⽅⾯的知识，让⼤家少⾛弯路吧。
Lua是⼀种很好的扩展性语⾔，Lua解释器被设计成⼀个很容易嵌⼊到宿主程序的库。
LuaInterface则⽤于实现Lua和CLR的混合编程。
C与lua交互⾯临以下⼏个问题：1、由于lua⾥⾯的数据都是动态加载的所以内存也是动态分配的，也没有static 这样的修饰，⽽Ｃ⾥⾯有 static const 这样的静态类型数据2、c⾥⾯是⼿动管理内存lua ⾥⾯是⾃动管理内存所以为了解决这些问题就采⽤了⼀个抽象栈来让lua与c交换值，好⽐c⾥⾯的 void* 可以指向任何地址⽽不⽤管存储类型。
这样两边都不管你传的何种类型的参数，只⽤知道它是⼀个地址指针。
两边⽤的时候再强制转换成对应的类型。
下⾯开始本⽂的正⽂吧。
（⼀）C#调⽤Lua测试环境：在VS2015中建⼀个C#控制台应⽤程序，并添加LuaInterface.dll的引⽤LuaInterface.Lua类是CLR访问Lua解释器的主要接⼝，⼀个LuaInterface.Lua类对象就代表了⼀个Lua解释器（或Lua执⾏环境），Lua解释器可以同时存在多个，并且它们之间是完全相互独⽴的。
简单说明下步骤：在根⽬录处添加LuaInterface.dll的引⽤：不啰嗦、直接上代码：using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;using LuaInterface;namespace CSharpToLua{class Program{static void Main(string[] args){// 新建⼀个Lua解释器，每⼀个Lua实例都相互独⽴, ⼀个global全局域Lua lua = new Lua();//---------------------------------------------------// Lua的索引操作[]可以创建、访问、修改global域lua["age"] = 20;lua["name"] = "Mr.huang";string luaCode = "print(\"This is Lua code\")";lua.DoString(luaCode);//执⾏lua脚本代码lua.DoFile("F:\\CSharpToLua\\CSharpToLua\\ScriptsFromFile.lua");//执⾏lua脚本⽂件，这⾥我直接⽤了绝对定位 double age = (double)lua["age"];Console.WriteLine("age = {0}", age);Console.WriteLine("width = {0}", lua["width"]);Console.ReadKey();}}}可以跟着敲⼀遍，提⾼与代码的亲密度 ~.~ And then 点击启动咦、这时会出现⼀个报错、但是不要紧、解决⽅案：再次运⾏、就可以看到结果啦、惊不惊喜、意不意外简单的介绍C#如何调⽤Lua代码、当然、还有很多丰富的API⼩伙伴们可以⾃⾏查阅哟。
LUA调用Windows下的DLL？客家缘分小筑
LUA调用Windows下的DLL？客家缘分小筑LUA调用Windows下的DLLLUA Add commentsAug 022011LUA调用Windows下的DLL有两个方法。
Alien与LUA LIB库编译。
Alien方法123456 7 8 9 1 0 1 1 1 2 1 3 1 4 1 5 1 6 1 7 1 8 1 9 2 0 2require'alien'local user = alien.load 'user32.dll'-- these are the API calls needed. Note two NB things:-- (1) functions dealing with text ending with 'A' are for ASCII-- (2) need to specify abi to get proper __stdcalluser.FindWindowA:types{"string","string",abi="stdcall"}user.GetWindowTextA:types{"int","string","int",abi="stdcall"}user.GetClassNameA:types{"int","string","int",abi="stdc all"}find = user.FindWindowAgettext = user.GetWindowTextAgetclass = user.GetClassNameAlocal mydll = alien.load "MyLuaDLL.dll"mydll.callme:types{"int","string","int",abi="stdcall"} callme = mydll.callmet1 = alien.buffer(50)callme(2, t1, 50);print("callme=".. t1:tostring());1LUA LIB 库编译方法123 4 5 6 7 8 9 10 11 12 13 14 15 1617 18 19 20 21 22 2324 25 26 27 28 29extern "C"{ #include "lua.h" #include "lualib.h" #include "lauxlib.h"}//不需要参数extern "C" int lua_Nokia_Open (lua_State * L ) { double dRet = Nokia_Open (); lua_pushnumber (L , dRet ); return 1; }struct luaL_reg lrLibs [] = { { "lua_Nokia_Open", lua_Nokia_Open }, { NULL , NULL } /* sentinel */ };   ;extern "C" __declspec (dllexport ) int luaopen_luaNokiaSMS (lua_State * L ) { luaL_register ( L , "luaNokiaSMS", lrLibs ); return 0; }注意哦，你的DLL 名必须是luaNokiaSMS.dll。
C和Lua之间的相互调用
C和Lua之间的相互调⽤前⾯的话第⼀次接触Lua是因为Unity游戏中需要热更，但是⼀直没搞懂Lua是怎么嵌⼊到别的语⾔中执⾏的，如何互相调⽤的。
这次打算好好了解⼀下C跟lua是如何交互的那么如何使⽤Lua语⾔？让我们召唤出编译神器：gcc！【GNU编译器套件（GNU Compiler Collection）包括C、C++、Objective-C、Fortran、Java、Ada和Go语⾔的前端，也包括了这些语⾔的库（如libstdc++、libgcj等等）。
】在Mac上安装GCC如果你安装了Homebrew的话，只要⼀⾏就可以了。
brew install gcc装完后⽤brew info gcc或者gcc -v看⼀下是不是成功了编译Lua当你安装好了编译器后，编译lua就变得⾮常简单了Lua官⽹的⽂档⾥有说编译⽅式, 但MakeFile⾥默认的是编译成静态链接库，被这个坑了，后⾯再说建议安装在/opt⽬录下sudo sucd /optcurl -R -O /ftp/lua-5.3.4.tar.gztar zxf lua-5.3.4.tar.gzcd lua-5.3.4make macosx testmake macosx install安装好后⽤lua -v查看下如果有信息，恭喜你，Lua编译好了！~下⾯正式开⼲了~写⼀个C调⽤Lua的Demo编译运⾏add.c内容//你需要include这⼏个lua头⽂件#include <stdio.h>#include "lua.h"#include "lualib.h"#include "lauxlib.h"lua_State* L;intluaadd(int x, int y){int sum;/*函数名*/lua_getglobal(L,"add");/*参数⼊栈*/lua_pushnumber(L, x);/*参数⼊栈*/lua_pushnumber(L, y);/*开始调⽤函数，有2个参数，1个返回值*/lua_call(L, 2, 1);/*取出返回值*/sum = (int)lua_tonumber(L, -1);/*清除返回值的栈*/lua_pop(L,1);return sum;}intmain(int argc, char *argv[]){int sum;L = luaL_newstate(); /* 创建lua状态机 */luaL_openlibs(L); /* 打开Lua状态机中所有Lua标准库 *//*加载lua脚本*/luaL_dofile(L, "add.lua");/*调⽤C函数，这个⾥⾯会调⽤lua函数*/sum = luaadd(99, 10);printf("The sum is %d \n",sum);/*清除Lua*/lua_close(L);return 0;}add.lua放到与C同级的⽬录下，⾥⾯写⼀个简单的函数，让C调⽤function add(x,y)return x + yend好了，终于到了⽤GCC编译的阶段了，直接gcc add.c⼀下看看⾏不⾏。
lua与C相互调用
在lua中是以函数指针的形式调用函数,并且所有的函数指针都必须满足如下此种类型:type def i nt (*lua_C Funct ion)(lua_State *L);也就是说, 我们在C++中定义函数时必须以l ua_St ate为参数, 以i nt为返回值才能被L ua所调用。
但是不要忘记了,我们的lu a_Sta te是支持栈的, 所以通过栈可以传递无穷个参数,大小只受内存大小限制。
而返回的int值也只是指返回值的个数真正的返回值都存储在l ua_St ate的栈中。
偶们通常的做法是做一个wr apper, 把所有需要调用的函数都wr ap一下,这样就可以调用任意的函数了。
lua和c/c++的数据交互通过"栈"进行,操作数据时，首先将数据拷贝到"栈"上，然后获取数据，栈中的每个数据通过索引值进行定位，索引值为正时表示相对于栈底的偏移索引，索引值为负时表示相对于栈顶的偏移索引，索引值以1或-1为起始值，因此栈顶索引值永远为-1 ,栈底索引值永远为1 。
"栈"相当于数据在l ua和c/c++之间的中转地。
每种数据都有相应的存取接口。
数据入"栈"接口：void (lu a_pus hnil) (lua_Stat e *L);voi d (l ua_pu shnum ber)(lua_State *L,lua_N umber n);void (lua_push integ er) (lua_S tate*L, l ua_In teger n);void (lua_push lstri ng) (lua_S tate*L, c onstchar*s, s ize_t l);void (lua_push strin g) (l ua_St ate *L, co nst c har *s);v oid (lua_pushb oolea n) (l ua_St ate *L, in t b);void (lu a_pus hcclo sure) (lua_Stat e *L, lua_CFunc tionfn, i nt n);数据获取接口：lua_Numbe r (lu a_ton umber) (lu a_Sta te *L, int idx);lua_Inte ger (l ua_to integ er) (lua_S tate*L, i nt id x);i nt (lua_toboo lean) (lua_Stat e *L, intidx);cons t cha r * (lu a_tol strin g) (l ua_St ate *L, in t idx, siz e_t *len);lua_CFunc tion (lu a_toc funct ion)(lua_State *L,int i dx);"栈"操作接口：int (lu a_get top)(lua_State *L);void (lu a_set top)(lua_State *L,int i dx);void (lua_push value) (lu a_Sta te *L, int idx);voi d (l ua_re move) (lua_Stat e *L, intidx);void (lu a_ins ert)(lua_State *L,int i dx);void (lua_repl ace)(lua_State *L,int i dx);int (lua_chec kstac k) (l ua_St ate *L, in t sz);lu a中定义的变量和函数存放在一个全局tab le中，索引值为LU A_GLO BALSI NDEX，tabl e相关操作接口：v oid (lua_getta ble)(lua_State *L,int i dx);void (lua_getf ield) (lua_Stat e *L, intidx,const char *k);void (lu a_set table) (lu a_Sta te *L, int idx);voi d (l ua_se tfiel d) (l ua_St ate *L, in t idx, con st ch ar *k);当"栈"中包含执行脚本需要的所有要素(函数名和参数)后，调用l ua_pc all执行脚本：i nt (lua_pcall) (lu a_Sta te *L, int narg s, in t nre sults, int errf unc);以下是一些参考用例：[P S]******************************************************************** *****#inc lude"stda fx.h"#in clude <std io.h>ext ern "C" {#inc lude"lua.h"#inclu de "l ualib.h"#incl ude "lauxl ib.h"}/* Lua解释器指针 */lua_S tate* L;int m ain ( intargc, char *arg v[] ){/* 初始化Lua */L =lua_o pen();/* 载入L ua基本库 */luaL_open libs(L);/* 运行脚本*/l uaL_d ofile(L, "Lua1.lua");/* 清除L ua */lu a_clo se(L);/* 暂停*/print f( "P ressenter to e xit…" );getc har();r eturn 0;}[PS]*************************************************************************#incl ude<i ostre am>using name space std;#in clude<stdi o.h>exte rn "C" {#incl ude <lua.h>#i nclud e <lu alib.h>#inclu de <l auxli b.h>}//#prag ma co mment(lib, "lua5.1.l ib")lua_State* L;stat ic in t ave rage(lua_S tate*L){//返回栈中元素的个数in t n = lua_getto p(L);do ublesum = 0;inti;for (i = 1; i <= n;i++){if(!lua_isnu mber(L, i)){lua_push strin g(L,"Inco rrect argu mentto 'a verag e'");lua_e rror(L);}sum += l ua_to numbe r(L,i);}/* pu sh th e ave rage*/lua_p ushnu mber(L, su m / n);/* pu sh th e sum */lua_pushn umber(L, s um);/* re turnthe n umber of r esult s */retu rn 2;}int m ain (int a rgc,c har*a rgv[]){/*initi alize Lua*/L = l ua_op en();/* load Lualibra ries*/luaL_openl ibs(L);/* re giste r our func tion*/lua_r egist er(L, "ave rage", ave rage);/* run thescrip t */lua L_dof ile(L, "e15.lua");l ua_ge tglob al(L,"avg");cout<<"avg is:"<<lua_toin teger(L,-1)<<en dl;lua_pop(L,1);lua_getg lobal(L,"s um");co ut<<"sum i s:"<<lua_t ointe ger(L,-1)<<endl;/* cle anupLua */l ua_cl ose(L);re turn0;}//程序中：//*lu a_get top()的作用是返回栈顶元素的序号.由于Lua的栈是从1开始编号的, 所以栈顶元素的序号也相当于栈中的元素个数. 在这里, 栈中元素的个数就是传入的参数个数。
Lua教程（四）：在Lua中调用C语言、C++的函数
Lua教程（四）：在Lua中调⽤C语⾔、C++的函数本教程将介绍如何在Lua⾥⾯调⽤c/c++函数。
在Lua⾥⾯调⽤c/c++函数其实是⽐较简单，本⽂将通过两个⽰例演⽰具体的做法：⼀个是求平均数，另⼀个是打印lua函数的⼀些参数信息。
最后，本⽂会介绍如何把这两个函数定义成⼀个模块，这样lua代码⾥⾯就可以不再使⽤全局的名字空间了。
前⾔当我们需要在Lua⾥⾯调⽤c/c++函数时，所有的函数都必须满⾜以下函数签名：复制代码代码如下:typedef int (*lua_CFunction) (lua_State *L);换句话说，所有的函数必须接收⼀个lua_State作为参数，同时返回⼀个整数值。
因为这个函数使⽤Lua栈作为参数，所以它可以从栈⾥⾯读取任意数量和任意类型的参数。
⽽这个函数的返回值则表⽰函数返回时有多少返回值被压⼊Lua栈。
（因为Lua 的函数是可以返回多个值的）⽰例⼀定义C++函数指针复制代码代码如下:int average(lua_State *L){// get number of argumentsint n = lua_gettop(L);double sum = 0;int i;// loop through each argumentfor (i = 1; i <= n; i++){// total the argumentssum += lua_tonumber(L, i);}// push the averagelua_pushnumber(L, sum / n);// push the sumlua_pushnumber(L, sum);// return the number of resultsreturn 2;}注册此函数给Lua复制代码代码如下:lua_register(L, "average", average);Lua⾥⾯调⽤此函数复制代码代码如下:avg, sum = average(10, 20, 30, 40, 50)print("The average is ", avg)print("The sum is ", sum)⽰例⼆定义C++函数复制代码代码如下:int displayLuaFunction(lua_State *l){// number of input argumentsint argc = lua_gettop(l);// print input argumentsstd::cout << "[C++] Function called from Lua with " << argc<< " input arguments" << std::endl;for(int i=0; i<argc; i++){std::cout << " input argument #" << argc-i << ": "<< lua_tostring(l, lua_gettop(l)) << std::endl;lua_pop(l, 1);}// push to the stack the multiple return valuesstd::cout << "[C++] Returning some values" << std::endl;lua_pushnumber(l, 12);lua_pushstring(l, "See you space cowboy");// number of return valuesreturn 2;}注册此Lua函数复制代码代码如下:// push the C++ function to be called from Luastd::cout << "[C++] Pushing the C++ function" << std::endl;lua_pushcfunction(L, displayLuaFunction);lua_setglobal(L, "displayLuaFunction");注意，上⼀个⽰例，我们使⽤的是函数是复制代码代码如下:lua_register(L, "average", average);它其实只是⼀个宏定义，其实现也是上⾯两个函数组成的。
lua include()用法
lua include()用法Lua include()用法详解Lua中的include()函数是一个非常实用的函数，它允许我们在Lua脚本中引入其他脚本，并且执行被引入脚本中的代码。
include()函数的使用非常灵活，下面我们来详细介绍一些常见的用法。
1. 引入Lua标准库可以通过include()函数来引入Lua标准库，以扩展你的脚本的功能：include("math") -- 引入math标准库include("io") -- 引入io标准库在引入标准库后，你就可以直接使用库中定义的函数和变量了。
2. 引入自定义脚本除了引入标准库，include()函数还可以引入自定义脚本文件，以实现代码重用和模块化开发：include("") -- 引入自定义脚本include("config") -- 引入自定义脚本通过引入自定义脚本，你可以在主脚本中调用被引入脚本中的函数和变量，从而达到复用和组织代码的目的。
3. 处理错误当使用include()函数引入脚本时，如果引入过程中发生了错误，Lua解释器会抛出一个错误信息。
为了避免脚本执行中断，我们可以使用pcall()函数包装include()函数，以捕获错误信息：local status, err = pcall(include, "") -- 引入脚本并捕获错误信息if not status thenprint("Error: " .. err) -- 打印错误信息end通过使用pcall()函数，即使引入脚本中发生了错误，程序仍然可以继续执行。
4. 动态引入脚本include()函数还可以根据需要动态引入脚本，例如根据用户输入的内容来选择引入哪个脚本：local scriptName = ""include(scriptName) -- 根据scriptName引入不同的脚本通过动态引入脚本，你可以根据不同的场景和需求来动态加载不同的功能模块。
Lua教程（二十）：Lua调用C函数
Lua教程（⼆⼗）：Lua调⽤C函数Lua可以调⽤C函数的能⼒将极⼤的提⾼Lua的可扩展性和可⽤性。
对于有些和操作系统相关的功能，或者是对效率要求较⾼的模块，我们完全可以通过C函数来实现，之后再通过Lua调⽤指定的C函数。
对于那些可被Lua调⽤的C函数⽽⾔，其接⼝必须遵循Lua要求的形式，即typedef int (*lua_CFunction)(lua_State* L)。
简单说明⼀下，该函数类型仅仅包含⼀个表⽰Lua环境的指针作为其唯⼀的参数，实现者可以通过该指针进⼀步获取Lua代码中实际传⼊的参数。
返回值是整型，表⽰该C函数将返回给Lua代码的返回值数量，如果没有返回值，则return 0即可。
需要说明的是，C函数⽆法直接将真正的返回值返回给Lua代码，⽽是通过虚拟栈来传递Lua代码和C函数之间的调⽤参数和返回值的。
这⾥我们将介绍两种Lua调⽤C函数的规则。
1. C函数作为应⽤程序的⼀部分。
复制代码代码如下:#include <stdio.h>#include <string.h>#include <lua.hpp>#include <lauxlib.h>#include <lualib.h>//待Lua调⽤的C注册函数。
static int add2(lua_State* L){//检查栈中的参数是否合法，1表⽰Lua调⽤时的第⼀个参数(从左到右)，依此类推。
//如果Lua代码在调⽤时传递的参数不为number，该函数将报错并终⽌程序的执⾏。
double op1 = luaL_checknumber(L,1);double op2 = luaL_checknumber(L,2);//将函数的结果压⼊栈中。
如果有多个返回值，可以在这⾥多次压⼊栈中。
lua_pushnumber(L,op1 + op2);//返回值⽤于提⽰该C函数的返回值数量，即压⼊栈中的返回值数量。
lua调用cs原理
Lua调用C#的原理是通过Lua的扩展模块（C API）与C#代码进行交互。
下面是一个简要的步骤说明：
1. 在C#中，通过使用Lua的扩展库（通常是LuaInterface或NLua）创建Lua虚拟机实例。
2. 在C#中编写需要被Lua调用的方法或类，并使用Lua的扩展库将它们注册到Lua虚拟机中。
这样Lua就可以通过调用这些方法或类来与C#进行交互。
3. 在Lua脚本中，通过加载C#的扩展模块，并创建一个C#对象实例或调用C#的静态方法。
4. 当Lua脚本中的代码需要调用C#方法时，Lua会将调用请求传递给C#的扩展模块。
5. C#的扩展模块会解析Lua传递过来的调用请求，并根据注册的方法或类信息，将调用请求转发给相应的C#代码。
6. C#代码执行完后，将返回值传递给Lua的扩展模块。
7. 扩展模块将返回值传递给Lua虚拟机，Lua可以继续处理返回值或者通过返回值与C#进行交互。
总体而言，Lua调用C#的原理是通过Lua与C#之间的扩展模块实现了两者的交互，Lua负责调用和传递参数，C#负责执行相应的方法并返回结果。
这种机制使得Lua与C#能够在同一个应用程序中协同工作，并实现双方的互操作。