SHARE
TWEET

lua api c++

egor230 Feb 19th, 2019 (edited) 107 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. lua c++ api подготовка проекта
  2. Начальная проверка
  3.  
  4. #include<iostream>
  5. using namespace std;
  6.  
  7. int main(int argc, char *argv[]) {
  8.  
  9. return 0;
  10. };
  11.  
  12.  
  13. Проверка lua
  14.  
  15. #include<iostream>
  16. #include"incude/lua.hpp"
  17. using namespace std;
  18.  
  19. int main(int argc, char *argv[]) {
  20.  
  21. return 0;
  22. };
  23.  
  24. lua api c++. Работа со стеком.
  25.  
  26. #include<iostream>
  27. #include"lua/lua.hpp"
  28. using namespace std;
  29.  
  30. //Стек(англ.stack — стопка; читается стэк) — абстрактный тип данных, представляющий собой список элементов,
  31. //организованных по принципу LIFO(англ.last in — first out, «последний вошёл — первым вышел»)
  32. int main(int argc, char *argv[]) {
  33.  
  34.     lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  35.     lua_pushnumber(L, 10);// отправить в стек число.
  36.     lua_pushnumber(L, 20);// отправить в стек число.
  37.     lua_pushnumber(L, 30);// отправить в стек число.
  38.     int number = lua_tonumber(L, -3);// получить 10 из стека 1
  39.     cout << number << endl;
  40.     int number2 = lua_tonumber(L, -2);// получить 20 из стека 2
  41.     cout << number2 << endl;
  42.     int number3 = lua_tonumber(L, -1);// получить 30 из стека 3
  43.     cout << number3 << endl;
  44.  
  45.     lua_close(L);// закрыть состояние
  46. return 0;
  47. };
  48.  
  49.  
  50. lua c++ api. Работа со стеком. Полезность отрицательных индексов стека.
  51.  
  52. int main(int argc, char *argv[]) {lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  53.  
  54.     lua_pushnumber(L, 10);// 1
  55.     lua_pushnumber(L, 20);// 2
  56.     lua_pushnumber(L, 30);// 3
  57.     /* стек выглядит так
  58.     3 = 30    -1 = 30  
  59.     2 = 20    -2 = 20
  60.     1 = 10    -3 = 10
  61.     */
  62.     cout << lua_tonumber(L, -1) << endl;// 30
  63.     lua_pop(L, 1);// удалить n элементы из стека с его вершины. Если 3, выводится 0.
  64.     cout << lua_tonumber(L, -1) << endl;// 20
  65.     lua_close(L);// закрыть состояние
  66.     cin.get();//ожидает ввода символа программа завершается.
  67.     return 0;}
  68.  
  69.  
  70. еще пример.
  71.  
  72. int checklua(lua_State *L, const char *file) {
  73.     int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
  74.     try {
  75.         if (status == 0) {// если нет ошибки в файле.
  76.             luaL_dofile(L, file);// запуск файла, в которым все происходит.
  77.             return 0;
  78.         }
  79.         else {
  80.             string x = lua_tostring(L, -1);
  81.             throw x;
  82.         }
  83.     }
  84.     catch (string x) {
  85.         cout << x << endl;
  86.         //luaL_error(L,"error");
  87.     }
  88. };
  89.  
  90. template <class T>
  91. void pushlua(lua_State * L, const T & value) {// функция добавление любого значение в стек.
  92.     if constexpr (std::is_same_v<T, std::string>)
  93.         lua_pushstring(L, value.c_str());
  94.     else if constexpr (std::is_array_v<T> && std::is_same_v<std::remove_extent_t<T>, char>)
  95.         lua_pushstring(L, value);
  96.     else if constexpr (std::is_same_v<T, int>)
  97.         lua_pushinteger(L, value);
  98.     else if constexpr (std::is_same_v<T, double>)
  99.         lua_pushnumber(L, value);
  100.     else if constexpr (std::is_same_v<T, bool>)
  101.         lua_pushboolean(L, value);
  102.     else
  103.         std::cerr << "I do not know what to do :(" << std::endl;
  104. };
  105.  
  106. void showstack(lua_State* L) {// вывести весь стек.
  107.     int i = lua_gettop(L);/* получаем количество элементов в стеке.*/
  108.     cout << "\n  the number on the stack = " << i << "\n\n\n";
  109.     int j = (i) * -1-1;
  110.     i = -1;
  111.     for (i; i > j; i--) {
  112.         int t = lua_type(L, i);
  113.         cout << "\t " << i << "  " << (j - i) * -1 << "\t";
  114.         if (LUA_TSTRING == t) {
  115.             cout << lua_tostring(L, i) << endl;
  116.         }
  117.         if (LUA_TNUMBER == t) {
  118.             double x = lua_tonumber(L, i);
  119.             int x2 = (int)x;
  120.             if (x == x2) { cout << x2 << endl; }
  121.             else { cout << x << endl; }
  122.         }
  123.         if (LUA_TBOOLEAN == t) {
  124.             cout << lua_toboolean(L, i) << endl;
  125.         }
  126.         if (LUA_TLIGHTUSERDATA == t) {
  127.             cout << "LIGHTUSERDATA " << endl;
  128.         }
  129.         if (LUA_TTABLE == t) {
  130.             cout << "LUA_TTABLE " << endl;
  131.         }
  132.         if (LUA_TFUNCTION == t) {
  133.             cout << "LUA_TFUNCTION " << endl;
  134.         }
  135.         if (LUA_TUSERDATA == t) {
  136.             cout << "LUA_TUSERDATA " << endl;
  137.         }
  138.         if (LUA_TNIL == t) {
  139.             cout << "LUA_TNIL " << endl;
  140.         }
  141.     }
  142. };
  143.  
  144. int main() {
  145.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  146.     luaL_openlibs(L);
  147.     pushlua(L, 10);// отправить любое значение в стек.  
  148.     pushlua(L, 20);// отправить любое значение в стек.  
  149.     pushlua(L, 30);// отправить любое значение в стек.
  150.     showstack(L);// вывести стек.
  151.  
  152.     cin.get();//ожидает ввода символа.
  153.  
  154.     pushlua(L, "a");// отправить любое значение в стек.
  155.     pushlua(L, "b");// отправить любое значение в стек. 
  156.     pushlua(L, "c");// отправить любое значение в стек. 
  157.     showstack(L);// вывести стек.
  158.  
  159.     cin.get();//ожидает ввода символа.
  160.  
  161.     lua_pop(L, 4); //удалить 4 элемента из стека.
  162.  
  163.     showstack(L);// вывести стек.
  164.  
  165.     cin.get();//ожидает ввода символа.
  166.  
  167. Выводится.
  168.  
  169.  
  170.   the number on the stack = 3
  171.  
  172.  
  173.          -1  3  30
  174.          -2  2  20
  175.          -3  1  10
  176.  
  177.  
  178.   the number on the stack = 6
  179.  
  180.  
  181.          -1  6  c
  182.          -2  5  b
  183.          -3  4  a
  184.          -4  3  30
  185.          -5  2  20
  186.          -6  1  10
  187.  
  188.  
  189.   the number on the stack = 2
  190.  
  191.  
  192.          -1  2  20
  193.          -2  1  10
  194.  
  195.  
  196. C:\Users\e\source\repos\Project1luaapi\Debug\Project1luaapi.exe (процесс 4608) завершает работу с кодом 0.
  197. Чтобы закрыть это окно, нажмите любую клавишу…
  198.  
  199. lua c++ api. Получение значения переменных из lua.
  200.  
  201. #include<iostream>
  202. #include<string>
  203. #include"lua/lua.hpp"
  204. using namespace std;
  205. int main() {
  206.     lua_State *L = luaL_newstate();
  207.     luaL_openlibs(L);
  208.     luaL_dofile(L, "man.lua");
  209.     lua_getglobal(L, "x");
  210.     lua_getglobal(L, "y");
  211.     lua_getglobal(L, "z");
  212.     int x = lua_tonumber(L, 1);
  213.     cout << x << endl;
  214.     string y = lua_tostring(L, 2);
  215.     cout << y << endl;
  216.     bool z = lua_toboolean(L, 3);
  217.     cout << z << endl;
  218.     lua_close(L);
  219.     return 0;
  220.  
  221. lua
  222. x=3
  223. y="jh"
  224. z =false
  225.  
  226. lua c++ api. Получение значения переменных из lua с помощью отрицательных индексов стека.
  227.  
  228. int checklua(lua_State *L, const char *file) {
  229.     int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
  230.     try {
  231.         if (status == 0) {// если нет ошибки в файле.
  232.             luaL_dofile(L, file);// запуск файла, в которым все происходит.
  233.             return 0;
  234.         }
  235.         else {
  236.             string x = lua_tostring(L, -1);
  237.             throw x;
  238.         }
  239.     }
  240.     catch (string x) {
  241.         cout << x << endl;
  242.         //luaL_error(L,"error");
  243.     }
  244. };
  245.  
  246. int main() {int t;
  247.     lua_State *L = luaL_newstate();
  248.    checklua(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
  249.     lua_getglobal(L, "x");// получить значение глобальной переменной x.
  250.    
  251.     t = lua_type(L, -1);
  252.     if (LUA_TSTRING == t) { cout << "string x " << lua_tostring(L, -1) << endl; }
  253.     else { cout << "not string  x " << endl; }
  254.  
  255.     lua_getglobal(L, "y");// получить значение глобальной переменной x.
  256.     t = lua_type(L, -1);
  257.     if (LUA_TSTRING == t) { cout << "string y " << lua_tostring(L, -1) << endl; }
  258.     else { cout << "not string  y " << endl; }
  259.  
  260.     int n = lua_gettop(L);/* получаем количество элементов в стеке.*/
  261.     cout <<"\nthe number on the stack = "  << n<<"\n";
  262.     lua_settop(L, 0);// уст кол-во элементов в стеке. 0 - очистить стек.
  263.  
  264.        n = lua_gettop(L);/* получаем количество элементов в стеке.*/
  265.     cout << "\nthe number on the stack = " << n << "\n";
  266.  
  267.     lua_close(L);// закрыть состояние
  268.     cin.get();//ожидает ввода символа программа завершается.
  269.  
  270.     return 0;
  271. }
  272.  
  273. Lua
  274. y="i str"
  275. x=23
  276.  
  277. выводится.
  278.  
  279. not string  x
  280. string y i str
  281.  
  282. the number on the stack = 3
  283.  
  284. the number on the stack = 0
  285.  
  286.  
  287. lua c++ api. Функции вывода элементов из стека и добавление лобого значение в стек.
  288.  
  289.  
  290. int checklua(lua_State *L, const char *file) {
  291.     int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
  292.     try {
  293.         if (status == 0) {// если нет ошибки в файле.
  294.             luaL_dofile(L, file);// запуск файла, в которым все происходит.
  295.             return 0;
  296.         }
  297.         else {
  298.             string x = lua_tostring(L, -1);
  299.             throw x;
  300.         }
  301.     }
  302.     catch (string x) {
  303.         cout << x << endl;
  304.         //luaL_error(L,"error");
  305.     }
  306. };
  307. int main() {
  308.     lua_State *L = luaL_newstate();
  309.     checklua(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
  310.    pushlua(L, "yes");// отправить любое значение в стек.
  311.     pushlua(L,true);// отправить любое значение в стек. 
  312.     pushlua(L,100);// отправить любое значение в стек.
  313.     pushlua(L,33.23);// отправить любое значение в стек.
  314.     pushlua(L, "no");// отправить любое значение в стек.
  315.     pushlua(L, 202);// отправить любое значение в стек. 
  316.     showstack(L);
  317.     lua_pushvalue(L, 3);// отправляет копию элемент на вершину стека.
  318.     showstack(L);
  319.     lua_close(L);// закрыть состояние
  320.     cin.get();//ожидает ввода символа программа завершается.
  321.     return 0;
  322. };
  323.  
  324.  
  325. Выводится на экран.
  326.  
  327.  
  328.   the number on the stack = 6
  329.  
  330.  
  331.          6  202
  332.          5  no
  333.          4  33.23
  334.          3  100
  335.          2  1
  336.          1  yes
  337.  
  338.   the number on the stack = 7
  339.  
  340.  
  341.          7  100
  342.          6  202
  343.          5  no
  344.          4  33.23
  345.          3  100
  346.          2  1
  347.          1  yes
  348.  
  349.  
  350.  
  351. lua c++ api. Функции вывода элементов через отрицательные индексы из стека и добавление лобого значение в стек.
  352.  
  353. int checklua(lua_State *L, const char *file) {
  354.     int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
  355.     try {
  356.         if (status == 0) {// если нет ошибки в файле.
  357.             luaL_dofile(L, file);// запуск файла, в которым все происходит.
  358.             return 0;
  359.         }
  360.         else {
  361.             string x = lua_tostring(L, -1);
  362.             throw x;
  363.         }
  364.     }
  365.     catch (string x) {
  366.         cout << x << endl;
  367.         //luaL_error(L,"error");
  368.     }
  369. };
  370.  
  371. int main() {
  372.     lua_State *L = luaL_newstate();
  373.     pushlua(L, "yes");// отправить любое значение в стек.   
  374.     pushlua(L, true);// отправить любое значение в стек.
  375.     pushlua(L, 100);// отправить любое значение в стек.
  376.     pushlua(L, 33.23);// отправить любое значение в стек.
  377.    pushlua(L, "no");// отправить любое значение в стек. 
  378.     pushlua(L, 202);// отправить любое значение в стек. 
  379.     showstack(L);
  380.     lua_pushvalue(L, -3);// отправляет копию элемент на вершину стека.
  381.     showstack(L);
  382.     lua_close(L);// закрыть состояние
  383.     cin.get();//ожидает ввода символа программа завершается.
  384.     return 0;
  385. }
  386.  
  387.  
  388. Выводится
  389.  
  390.   the number on the stack = 6
  391.  
  392.  
  393.          -1  202
  394.          -2  no
  395.          -3  33.23
  396.          -4  100
  397.          -5  1
  398.          -6  yes
  399.  
  400.   the number on the stack = 7
  401.  
  402.  
  403.          -1  33.23
  404.          -2  202
  405.          -3  no
  406.          -4  33.23
  407.          -5  100
  408.          -6  1
  409.          -7  yes
  410.  
  411.  
  412. lua c++ api. Получение значения переменных из lua,  обработка ошибок в lua.
  413.  
  414.  
  415. int checklua(lua_State *L, const char *file) {
  416.     int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
  417.     try {if (status == 0) {// если нет ошибки в файле.
  418.             luaL_dofile(L, file);// запуск файла, в которым все происходит.
  419.     return 0;}
  420.     else {  string x =lua_tostring(L, -1);
  421.     throw x;    }
  422.     }
  423.     catch (string x) {
  424.         cout << x << endl; 
  425.         //luaL_error(L,"error");
  426.     }
  427. };
  428.  
  429. int main() {
  430.     lua_State *L = luaL_newstate();
  431.     luaL_openlibs(L);
  432.     checklua(L, "main.lua");
  433.     lua_getglobal(L, "x");
  434.     int x = lua_tonumber(L, -1);
  435.  
  436.     cout << x << endl;
  437.     lua_close(L);
  438.     return 0;
  439. };
  440.  
  441. Lua
  442.  
  443. X=23
  444.  
  445.  
  446. lua c++ api. Получение значение переменной любого типа из lua.
  447.  
  448. using namespace std;
  449.  
  450. int checklua(lua_State *L, const char *file) {
  451.     int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
  452.     try {if (status == 0) {// если нет ошибки в файле.
  453.             luaL_dofile(L, file);// запуск файла, в которым все происходит.
  454.     return 0;}
  455.     else {  string x =lua_tostring(L, -1);
  456.     throw x;    }
  457.     }
  458.     catch (string x) {
  459.         cout << x << endl; 
  460.         //luaL_error(L,"error");
  461.     }
  462. };
  463.  
  464. int main(int argc, char *argv[]) {
  465.  
  466.     lua_State *L = luaL_newstate();
  467.     luaL_openlibs(L);//открыть все стандартные библиотеки lua.
  468.     checklua(lua, "main.lua");// Загружает и запускает заданный файл. Файл в котором все происходит.
  469.     lua_getglobal(L, "x");// получить значение x
  470.     if (lua_isnumber(L, 1)) {//  если 1 позиция в стеке число.
  471.         int number = lua_tonumber(L, 1);// получить число.
  472.         cout << "number x = " << number << endl;}
  473.  
  474.     else if (lua_isstring(L, 1)) {//  если 1 позиция в стеке строка.
  475.         string str = lua_tostring(L, 1);// получить строка.
  476.         cout << "string x = " << str << endl;}
  477.  
  478.     else if (lua_isboolean(L, 1)) {//  если 1 позиция в стеке булевая переменная.
  479.         bool bo = lua_toboolean(L, 1);// получить булевая переменная.
  480.         cout << "bool x = " << bo << endl;}
  481.     else {  cout << "not x " <<endl;}
  482.     lua_close(L);// закрыть состояние
  483.     cin.get();//ожидает ввода символа программа завершается.
  484. return 0;
  485. }
  486.  
  487. Lua
  488.  x=false
  489.  
  490.  
  491.  
  492. lua c++ api. Узнать тип переменной.
  493.  
  494. int main() {
  495.     lua_State *L = luaL_newstate();
  496.     luaL_openlibs(L);//открыть все стандартные библиотеки lua.
  497.     checklua(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
  498.     lua_getglobal(L, "x");// получить значение глобальной переменной x.
  499.     int t = lua_type(L, 1); /* LUA_TNIL, LUA_TNUMBER, LUA_TBOOLEAN, LUA_TSTRING, LUA_TTABLE, LUA_TFUNCTION, LUA_TUSERDATA, LUA_TTHREAD,
  500.     и LUA_TLIGHTUSERDATA.*/
  501.     if (LUA_TSTRING == t){
  502.         cout << "string x " << lua_tostring(L, 1) << endl;  }
  503.     if (LUA_TNUMBER == t) {
  504.         double x = lua_tonumber(L, 1);
  505.         int x2 = (int)x;
  506.         if (x==x2){ cout << "number int x "<<x2 << endl;}
  507.         else {cout << "number double x "<< x << endl;   }   }
  508.     if (LUA_TBOOLEAN == t) {    cout << "bool x = " << lua_toboolean(L, 1) << endl;
  509.     }
  510.     if (LUA_TNIL == t) { // если x нет.
  511.         cout << "not x " << endl;   }
  512.     lua_close(L);// закрыть состояние
  513.    
  514.     cin.get();//ожидает ввода символа программа завершается.
  515.  
  516.     return 0;
  517. }
  518.  
  519. Lua
  520. x=20.1
  521.  
  522. lua api. Определение типа переменной в lua через структуру.
  523.  
  524. using namespace std;
  525. struct st{ string str; int x2; double x; bool bo;
  526. double copyx = x; int copyx2 = x2; bool bo2 = bo;// это нужно,чтобы, избежать вывода мусор.
  527. st(){}
  528. st(string str) {
  529.     this->str = str;}
  530. st(int x2) {
  531.     this->x2 = x2;}
  532. st(double x) {
  533.     this->x = x;}
  534. st(bool bo) {
  535.     this->bo = bo;}
  536. void show() {
  537.     if (str != "") {
  538.         cout << str << endl;    }; 
  539.     if (x != copyx) {
  540.         cout << x << endl;  };
  541.     if (x2 != copyx2) {
  542.         cout << x2 << endl; };
  543.     if (bo != bo2) {
  544.     cout << bo << endl; };};
  545. };
  546.  
  547. st getvar(lua_State *lua, const char *var ) {
  548.     lua_getglobal(lua, var);// получить значение x
  549.     st s;
  550.     if (LUA_TSTRING == lua_type(lua, -1)) {// если  строка.
  551.         s.str = lua_tostring(lua, -1);
  552.         lua_pop(lua, 1);
  553.         return s;   }
  554.     if (LUA_TNUMBER == lua_type(lua, -1)) {// значение число.
  555.         double x = lua_tonumber(lua, -1);
  556.         int x2 = (int)x;
  557.         if (x == x2) { s.x2=x2;
  558.         lua_pop(lua, 1);
  559.         return s;       }
  560.         else {  s.x=x;
  561.         lua_pop(lua, 1);
  562.         return s;   }
  563.     }
  564.  
  565.     if (LUA_TBOOLEAN == lua_type(lua, -1)) {// значение булевая переменная.
  566.         s.bo = lua_toboolean(lua, 1);
  567.         lua_pop(lua, 1);
  568.         return s;
  569.     }
  570.  
  571.     if (LUA_TNIL == lua_type(lua, -1)) { { cout << "not x " << endl; }
  572.     }
  573. }
  574.  
  575.  
  576. int checklua(lua_State *L, const char *file) {
  577.     int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
  578.     try {if (status == 0) {// если нет ошибки в файле.
  579.             luaL_dofile(L, file);// запуск файла, в которым все происходит.
  580.     return 0;}
  581.     else {  string x =lua_tostring(L, -1);
  582.     throw x;    }
  583.     }
  584.     catch (string x) {
  585.         cout << x << endl; 
  586.         //luaL_error(L,"error");
  587.     }
  588. };
  589.  
  590. int main(int argc, char *argv[]) {
  591.  
  592.     lua_State *L = luaL_newstate();
  593.     luaL_openlibs(L);//открыть все стандартные библиотеки lua.
  594.     checklua(L, "main.lua");// Загружает и запускает заданный файл. Файл в котором все происходит.
  595.     st t = getvar(L, "y");
  596.     t.show();
  597.     lua_close(L);// закрыть состояние
  598.     cin.get();//ожидает ввода символа программа завершается.
  599.     return 0;
  600. }
  601.  
  602. Lua
  603.  
  604.  
  605. x =10.3
  606. y="hi lua"
  607. z=true
  608.  
  609.  
  610.  
  611. Отправка в стек любого значение.
  612.  
  613. void pushtolua(lua_State *L, const char* v) {
  614.     lua_pushstring(L, v);
  615. }
  616.  
  617. void pushtolua(lua_State *L, int v) {
  618.     lua_pushinteger(L, v);
  619. }
  620.  
  621. void pushtolua(lua_State *L, double v) {
  622.     lua_pushnumber(L, v);
  623. }
  624.  
  625. void pushtolua(lua_State *L, bool v) {
  626.     lua_pushboolean(L, v);
  627. }
  628.  
  629. int main(int argc, char *argv[]) {
  630.     lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  631.     luaL_openlibs(L);
  632.     checkerror(L, LUA);//Функция проверка на ошибки.
  633.     pushtolua(L, 10);
  634.     pushtolua(L, 10.20);
  635.     pushtolua(L, "10");
  636.     pushtolua(L, true);
  637.     showstack(L);
  638.  
  639.     lua_close(L);
  640.  
  641.     return 0;
  642. }
  643.  
  644. lua c++ api. Присвовение значение переменной в lua.
  645.  
  646. int main(int argc, char *argv[]) {
  647.  
  648.     lua_State *L = luaL_newstate();
  649.     luaL_openlibs(L);//открыть все стандартные библиотеки lua.
  650.     lua_pushinteger(L, 30);// отправить целое число в стек.
  651.     lua_setglobal(L, "c");// уст значение переменной в lua.
  652.     checklua(L, "main.lua");// Загружает и запускает заданный файл. Файл в котором все происходит.
  653.     lua_pcall(L, 0, 0, 0);// вызов функции в lua файле. 1 параметр кол-во передаваемых, кол-во возвращаемых, обработчик ошибок.
  654.     lua_close(L);// закрыть состояние
  655.     cin.get();//ожидает ввода символа программа завершается.
  656.     return 0;
  657. }
  658.  
  659. Lua
  660.  
  661. print(c)
  662.  
  663. выводится 30.
  664.  
  665.  
  666. lua c++ api. функция вывода ключей и значений таблицы.
  667.  
  668. int pri(lua_State *L, const char t[] ) {// передаем указатель на состояние.
  669.     lua_getglobal(L, t);// получить значение глобальной переменной, таблица.
  670.     lua_assert(lua_istable(L, -1));// проверить является 1 элемент стека таблицей.
  671.     if (LUA_TTABLE == lua_type(L, -1)) {// это таблица.
  672.     lua_pushnil(L);//кладем на вершину стека NULL
  673.   while (lua_next(L, 1) != 0) {/* получает ключ из стека и отправляет пару ключ - значение из таблицы.
  674.       Ключ имеет - 2, а значение - 1.*/
  675.         if (LUA_TSTRING == lua_type(L, -2)) {// если ключ строка.
  676.         if (LUA_TNUMBER == lua_type(L, -1)) {// значение число.
  677.         cout << "key " << lua_tostring(L, -2) << " value " << lua_tonumber(L, -1) << endl;}
  678.         lua_pop(L, 1);// удалить n элементы из стека.
  679.         }
  680.     }
  681. }
  682. return 1;// вернуть 1.
  683. };
  684. int main() {
  685.     lua_State *L = luaL_newstate();
  686.     luaL_openlibs(L);
  687.     checklua(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
  688.     pri(L,"t");// вывести ключи и значения таблицы.
  689.     lua_pcall(L, 0, 0, 0);// вызов функции в lua файле. 1 параметр кол-во передаваемых, кол-во возвращаемых, обработчик ошибок.
  690.     lua_close(L);// закрыть состояние
  691.     cin.get();//ожидает ввода символа программа завершается.
  692.     return 0;}
  693.  
  694. lua
  695.  
  696. t= {x=10, y=20, z=30}
  697. t1= {x=1, y=2, z=3}
  698.  
  699. выводится.
  700. key y value 20
  701. key x value 10
  702. key z value 30
  703.  
  704.  
  705. lua c++ api. Функции вывода ключей и значений таблицы, добавление ключа и значение в таблицу.
  706.  
  707. int checklua(lua_State *L, const char *file) {
  708.     int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
  709.     try {
  710.         if (status == 0) {// если нет ошибки в файле.
  711.             //luaL_dofile(L, file);// запуск файла, в которым все происходит.  
  712.             return 0;
  713.         }
  714.         else {
  715.             string x = lua_tostring(L, -1);
  716.             throw x;
  717.             return 0;
  718.         }
  719.     }
  720.     catch (string x) {
  721.         cout << x << endl;
  722.         return 0;
  723.         //luaL_error(L,"error");
  724.     }
  725. };
  726.  
  727. int pri(lua_State *L, const char t[]) {// передаем указатель на состояние.
  728.     lua_getglobal(L, t);// получить значение глобальной переменной, таблица.
  729.     lua_assert(lua_istable(L, -1));// проверить является 1 элемент стека таблицей.
  730.     if (LUA_TTABLE == lua_type(L, -1)) {// это таблица.
  731.         lua_pushnil(L);//кладем на вершину стека NULL
  732.         while (lua_next(L, 1) != 0) {/* получает ключ из стека и отправляет пару ключ - значение из таблицы.
  733.             Ключ имеет - 2, а значение - 1.*/
  734.             if (LUA_TSTRING == lua_type(L, -2)) {// если ключ строка.
  735.                 if (LUA_TNUMBER == lua_type(L, -1)) {// значение число.
  736.                     cout << "key " << lua_tostring(L, -2) << " value " << lua_tonumber(L, -1) << endl;
  737.                 }
  738.                 lua_pop(L, 1);// удалить n элементы из стека.
  739.             }
  740.         }
  741.     }cout << "\n";
  742.     return 1;// вернуть 1.
  743. }
  744.  
  745. int addtab(lua_State *L, const char t[], const char key[], int value) {// передаем указатель на состояние.
  746.     lua_getglobal(L, t);// получить значение глобальной переменной, таблицей.
  747.     lua_pushnumber(L, value);// отправить значение в таблицу..
  748.     lua_setfield(L, -2, key);// уст ключ для него.
  749.     lua_getglobal(L, t);// получить значение глобальной переменной, таблицей.
  750.     lua_getfield(L, -1, key);// отправить ключ в таблицу.
  751.     return 0;// вернуть 1.
  752. }
  753. int main() {
  754.     lua_State *L = luaL_newstate();
  755.     //checklua(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
  756.  
  757.     luaL_dofile(L, "main.lua");// запуск файла, в которым все происходит.  
  758.     pri(L, "t");// вывести ключи и значения таблицы.
  759.     addtab(L, "t", "a", 1000);// уст ключ и значение для таблицы
  760.     pri(L, "t");// вывести ключи и значения таблицы.
  761.     addtab(L, "t", "b", 99);// уст ключ и значение для таблицы
  762.     pri(L, "t");// вывести ключи и значения таблицы.
  763.     lua_pcall(L, 0, 0, 0);// вызов функции в lua файле. 1 параметр кол-во передаваемых, кол-во возвращаемых, обработчик ошибок.
  764.     lua_close(L);// закрыть состояние
  765.     cin.get();//ожидает ввода символа программа завершается.
  766.     return 0;
  767. }
  768.  
  769.  
  770. lua
  771.  
  772. t= {x=10, y=20, z=30}
  773. t1= {x=1, y=2, z=3}
  774.  
  775. выводится.
  776.  
  777. key z value 30
  778. key y value 20
  779. key x value 10
  780.  
  781. key z value 30
  782. key y value 20
  783. key x value 10
  784. key a value 1000
  785.  
  786. key x value 10
  787. key z value 30
  788. key a value 1000
  789. key b value 99
  790. key y value 20
  791.  
  792. вариант 2.
  793.  
  794.  
  795. void getstack(lua_State* L, int pos) {
  796.     if (LUA_TSTRING == lua_type(L, pos)) {
  797.         cout << lua_tostring(L, pos);
  798.     }
  799.     if (LUA_TNUMBER == lua_type(L, pos)) {
  800.         double x = lua_tonumber(L, pos);
  801.         int x2 = (int)x;
  802.         if (x == x2) { cout << x2; }
  803.         else { cout << x; }
  804.     }
  805.     if (LUA_TBOOLEAN == lua_type(L, pos)) {
  806.         cout << (lua_toboolean(L, pos) ? "true " : "false ");
  807.     }
  808.     if (LUA_TNIL == lua_type(L, pos)) {
  809.         cout << "not /n";
  810.     }
  811.     if (LUA_TTABLE == lua_type(L, pos)) {
  812.         cout << "LUA_TTABLE " << endl;
  813.     }
  814.     if (LUA_TFUNCTION == lua_type(L, pos)) {
  815.         cout << "LUA_TFUNCTION " << endl;
  816.     }
  817.     if (LUA_TLIGHTUSERDATA == lua_type(L, pos)) {
  818.         cout << "LIGHTUSERDATA " << endl;
  819.     }
  820.     if (LUA_TTABLE == lua_type(L, pos)) {
  821.         cout << "LUA_TTABLE " << endl;
  822.     }
  823.     if (LUA_TFUNCTION == lua_type(L, pos)) {
  824.         cout << "LUA_TFUNCTION " << endl;
  825.     }
  826.     if (LUA_TUSERDATA == lua_type(L, pos)) {
  827.         cout << "LUA_TUSERDATA " << endl;
  828.     }
  829.     if (LUA_TNIL == lua_type(L, pos)) { // если x нет.
  830.         cout << "nill " << endl;
  831.     }
  832. };
  833. int pri(lua_State* L, const char t[]) {// передаем указатель на состояние.
  834.     lua_getglobal(L, t);// получить значение глобальной переменной, таблица.
  835.     lua_assert(lua_istable(L, -1));// проверить является 1 элемент стека таблицей.
  836.     if (LUA_TTABLE == lua_type(L, -1)) {// это таблица.
  837.         lua_pushnil(L);//кладем на вершину стека NULL
  838.         while (lua_next(L, 1) != 0) {/* получает ключ из стека и отправляет пару ключ - значение из таблицы.
  839.             Ключ имеет - 2, а значение - 1.*/
  840.             cout << "key "; getstack(L, -2); cout << " value "; getstack(L, -1); cout << endl;
  841.             lua_pop(L, 1);// удалить n элементы из стека.
  842.         }
  843.        
  844.     }
  845. return 0;// вернуть 1.
  846. };
  847. int main() {
  848.     lua_State* L = luaL_newstate();
  849.     luaL_openlibs(L);
  850.     luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
  851.     pri(L, "t");// вывести ключи и значения таблицы.
  852.     lua_close(L);// закрыть состояние
  853.     return 0;
  854. };
  855.  
  856.  
  857.  
  858.  
  859.  
  860. lua c++ api. Работа с таблицей.
  861.  
  862. int main() {
  863.     lua_State *L = luaL_newstate();
  864.     luaL_openlibs(L);//открыть все стандартные библиотеки lua.
  865.     checklua(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
  866.     lua_getglobal(L, "t");// получить значение глобальной переменной, таблица.
  867.     lua_assert(lua_istable(L, 1));// проверить является 1 элемент стека таблицей.
  868.     lua_pushstring(L, "x");// отправить ключ x в стек.
  869.     lua_gettable(L, 1);// получить значение по ключу из стека.
  870.     lua_assert(lua_isnumber(L, 2));// проверить является значение 2 элемента стека число.  
  871.     int x = lua_tonumber(L, 2);
  872.     lua_getglobal(L, "t");// получить значение глобальной переменной таблица.
  873.     lua_pushstring(L, "y");
  874.     lua_gettable(L, 1);
  875.     lua_assert(lua_isstring(L, 4));
  876.     string y = lua_tostring(L, 4);
  877.     lua_getglobal(L, "t");// получить значение глобальной переменной, таблицей.
  878.     lua_getfield(L, 5, "z");// отправить ключ в таблицу.
  879.     lua_assert(lua_isboolean(L, 5));
  880.     bool z = lua_toboolean(L, 5);// получить булевое значение по ключу.
  881.     lua_getglobal(L, "t");// получить значение глобальной переменной, таблицей.
  882.     lua_pushstring(L, "dog");// отправить значение в таблицу.
  883.     lua_setfield(L, 5, "a");// уст ключ для него.
  884.     lua_getglobal(L, "t");// получить значение глобальной переменной, таблицей.
  885.     lua_getfield(L, 5, "a");// отправить ключ в таблицу.
  886.     lua_assert(lua_isstring(L, 5));
  887.     string a = lua_tostring(L, -1);
  888.     cout << "x = " << x << "\ny = " << y << "\nz = " << z << "\na = " << a << endl;
  889.     lua_close(L);// закрыть состояние
  890.  
  891.     cin.get();//ожидает ввода символа программа завершается.
  892.  
  893.     return 0;
  894. }
  895.  
  896. Lua
  897.  
  898. t= {x=300,y="ok you y",z=true}
  899.  
  900.  
  901. lua c++ api. Работа с таблицей 2.
  902.  
  903.  
  904. int main() {
  905.     lua_State *L = luaL_newstate();
  906.     luaL_openlibs(L);//открыть все стандартные библиотеки lua.
  907.     checklua(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
  908.     lua_getglobal(L, "t");// получить значение глобальной переменной, таблица.
  909.     lua_assert(lua_istable(L, 1));// проверить является 1 элемент стека таблицей.
  910.     lua_pushstring(L, "x");// отправить ключ x в стек.
  911.     lua_gettable(L, 1);{// получить значение по ключу из стека.
  912.     int t = lua_type(L, 2); /*Возвращает тип значения в указанном допустимом индексе или LUA_TNONE для недопустимого индекса
  913.     (то есть индекса для «пустой» позиции стека). Типы возвращаемых lua_type кодируются с помощью следующих констант,
  914.     определенных в lua.h: LUA_TNIL, LUA_TNUMBER, LUA_TBOOLEAN, LUA_TSTRING, LUA_TTABLE, LUA_TFUNCTION, LUA_TUSERDATA, LUA_TTHREAD,
  915.     и LUA_TLIGHTUSERDATA.*/
  916.     switch (t) {
  917.     case LUA_TSTRING:// если строка.
  918.         cout << "string x "<< lua_tostring(L, 2) << endl;
  919.         break;
  920.     case LUA_TBOOLEAN:// если булевая.
  921.         cout <<"bool x = "<< lua_toboolean(L, 2)<<  endl;
  922.         break;
  923.     case LUA_TNUMBER:  // если число.
  924.         cout << "number x = "<< lua_tonumber(L, 2) << endl;
  925.         break;
  926.     case LUA_TNIL:  // если x нет.
  927.         cout << "not x " << endl;
  928.         break;
  929.     default:  // иначе.
  930.         cout <<"other x = "<< lua_typename(L, t) << endl;
  931.         break;  } }
  932.     lua_close(L);// закрыть состояние
  933.    
  934.     cin.get();//ожидает ввода символа программа завершается.
  935.  
  936.     return 0;
  937. }
  938.  
  939. Lua
  940.  
  941. t= {x="20"}
  942.  
  943.  
  944. lua c++ api. Работа с таблицей. Извлечение из таблицы ключа и значение.
  945.  
  946.  
  947. int pri(lua_State *lua) {// передаем указатель на состояние.
  948.  
  949.     if (LUA_TTABLE == lua_type(lua, 1)) {// это таблица.
  950.         lua_pushnil(lua);//кладем на вершину стека NULL
  951.         while (lua_next(lua, 1) !=0) {/* получает ключ из стека и отправляет пару ключ - значение из таблицы
  952.           по заданному индексу(«следующая» пара после заданного ключа). Если в таблице больше нет элементов.
  953.           Ключ имеет - 2, а значение - 1.*/
  954.         if (LUA_TSTRING == lua_type(lua, -2)) {// если ключ строка.
  955.             if (LUA_TNUMBER == lua_type(lua, -1)) {// значение число.
  956.                 cout << "key " << lua_tostring(lua, -2) << " value " << lua_tonumber(lua, -1) << endl;}
  957.            
  958.             if (LUA_TSTRING == lua_type(lua, -1)) {// значение строка.
  959.             cout << "key " << lua_tostring(lua, -2) << " value " << lua_tostring(lua, -1) << endl; }
  960.             lua_pop(lua, 1);// удалить n элементы из стека.
  961.         }}
  962. }
  963.     return 1;// вернуть 1.
  964. }
  965. int main() {
  966.     lua_State *L = luaL_newstate();
  967.     luaL_openlibs(L);//открыть все стандартные библиотеки lua.
  968.     lua_register(L, "pri", pri);// регистрируем функцию- имя состояние, имя функ в lua, имя функ тут.
  969.     checklua(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
  970.     lua_pcall(L, 0, 0, 0);// вызов функции в lua файле. 1 параметр кол-во передаваемых, кол-во возвращаемых, обработчик ошибок.
  971.     lua_close(L);// закрыть состояние
  972.     cin.get();//ожидает ввода символа программа завершается.
  973.     return 0;
  974. }
  975.  
  976. Lua
  977.  
  978. t={z="kj", x=23, y="dog",a=30,b=33}
  979. pri(t)
  980.  
  981.  
  982.  
  983. lua c++ api работа с таблицей. Функция принимающую таблицу для изменения значений ключей.
  984.  
  985. #include<iostream>
  986. #include<string>
  987. #include<vector>
  988.  
  989. #include"include/lua.hpp"
  990. using namespace std;
  991.  
  992. int pri(lua_State *L) {// передаем указатель на состояние.
  993.  
  994.     vector<string>v; // вектор для хранение ключей таблиции.
  995.     if (LUA_TNUMBER != lua_type(L, 2)) {//проверка, второй аргумент является числом.
  996.     cout << "bad second argument in function " << endl;
  997.     return 1;   };
  998.     int n = lua_tonumber(L, 2);
  999.     if (LUA_TTABLE == lua_type(L, 1)) {
  1000.         cout << "\nthis is table \n" << endl;
  1001.         lua_pushnil(L);//кладем на вершину стека NULL.
  1002.         while (lua_next(L, 1) != 0) {// получает ключ из стека и отправляет пару ключ - значение из таблицы.
  1003.  
  1004.             if (LUA_TSTRING == lua_type(L, -2)) {// значение число.
  1005.                 cout << "key " << lua_tostring(L, -2) << " value ";
  1006.                 v.push_back(lua_tostring(L, -2));
  1007.                 double x = lua_tonumber(L, -1);
  1008.                 int x2 = (int)x;
  1009.                 if (x == x2) {// int
  1010.                     cout << "number int  " << x2 << endl;   }
  1011.                 else { cout << "number double " << x << endl; }
  1012.                 lua_pop(L, 1);// удалить n элементы из стека.
  1013.             }
  1014.         }
  1015.     }
  1016.     else {  cout << "NOT table " << endl;
  1017.         if (LUA_TSTRING == lua_type(L, 1)) {
  1018.             cout << "this string " << lua_tostring(L, 1) << endl;   }
  1019.         if (LUA_TNUMBER == lua_type(L, 1)) {
  1020.             double x = lua_tonumber(L, 1);
  1021.             int x2 = (int)x;
  1022.             if (x == x2) { cout << "this number int " << x2 << endl; }
  1023.             else { cout << "this number double this " << x << endl; }
  1024.         }
  1025.         if (LUA_TBOOLEAN == lua_type(L, 1)) { cout << "this bool " << lua_toboolean(L, 1) << endl; }
  1026.         if (LUA_TNIL == lua_type(L, 1)) { // если нет.
  1027.             cout << "Nothing was passed.  " << endl;}
  1028.     }
  1029.     for (auto i : v){
  1030.         const char* x = i.c_str(); // из строки массив char.
  1031.         lua_getglobal(L, "t");// получить значение глобальной переменной, таблицей.
  1032.         lua_pushinteger(L, n);// отправить значение в таблицу.
  1033.         lua_setfield(L, 1, x);// уст ключ для него.
  1034.         lua_getglobal(L, "t");// получить значение глобальной переменной, таблицей.
  1035.         lua_getfield(L, 1, x);// отправить ключ в таблицу.
  1036. }
  1037.     return 1;// вернуть 1.
  1038. }
  1039. int main() {
  1040.     lua_State *L = luaL_newstate();
  1041.     luaL_openlibs(L);//открыть все стандартные библиотеки lua.
  1042.     lua_register(L, "pri", pri);// регистрируем функцию- имя состояние, имя функ в lua, имя функ тут.
  1043.     checklua(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
  1044.     lua_pcall(L, 0, 0, 0);// вызов функции в lua файле. 1 параметр кол-во передаваемых, кол-во возвращаемых, обработчик ошибок.
  1045.     lua_close(L);// закрыть состояние
  1046.     cin.get();//ожидает ввода символа программа завершается.
  1047.     return 0;
  1048. }
  1049.  
  1050.  
  1051. Lua
  1052.  
  1053. t={x=1, y=2 ,a=3,b=4}
  1054. a=nil
  1055.  
  1056. for k,v in pairs(t) do
  1057.     print(k,v)
  1058. end
  1059. pri(a,100)
  1060.  
  1061.     print("\n After \n")
  1062. for k,v in pairs(t) do
  1063.     print(k,v)
  1064. end
  1065.  
  1066.  
  1067. lua c++ api. Отправить таблицу с ключами и значением в lua.
  1068.  
  1069.  
  1070. int checklua(lua_State *L, const char *file) {
  1071.     int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
  1072.     try {
  1073.         if (status == 0) {// если нет ошибки в файле.
  1074.             luaL_dofile(L, file);// запуск файла, в которым все происходит.
  1075.             return 0;
  1076.         }
  1077.         else {
  1078.             string x = lua_tostring(L, -1);
  1079.             throw x;
  1080.         }
  1081.     }
  1082.     catch (string x) {
  1083.         cout << x << endl;
  1084.         //luaL_error(L,"error");
  1085.     }
  1086. };
  1087. int main() {
  1088.     lua_State *L = luaL_newstate();
  1089.     luaL_openlibs(L);
  1090.     lua_newtable(L); /*создать пустую таблицу */
  1091.  
  1092.     lua_pushstring(L, "key x"); /* отправить ключ в стек */
  1093.     lua_pushstring(L, "value x"); /* отправить значение ключа в стек. */
  1094.     lua_rawset(L, -3); /*Сохраняет пару в таблице */
  1095.     lua_pushstring(L, "key y"); /* */
  1096.     lua_pushstring(L, "value y"); /*  */
  1097.     lua_rawset(L, -3); /*Сохраняет пару в таблице */
  1098.     lua_setglobal(L, "foo");// уст имя таблицы в lua.
  1099.  
  1100.     checklua(L, "main.lua");
  1101.     lua_close(L);
  1102.     return 0;
  1103. };
  1104.  
  1105. Lua
  1106.  
  1107. print(foo)
  1108. for k,v in pairs(foo) do
  1109. print(k.." "..v)
  1110. end
  1111.  
  1112. выводит
  1113.  
  1114. table: 013154E0
  1115. key x value x
  1116. key y value y
  1117.  
  1118. еще так можно.
  1119.  
  1120. void addkeyintab(lua_State *L, const char* key, const char* value){
  1121.  
  1122.     lua_pushstring(L, key); /* отправить ключ в стек */
  1123.     lua_pushstring(L, value); /* отправить значение ключа в стек. */
  1124.     lua_rawset(L, -3); /*Сохраняет пару в таблице */
  1125. }
  1126. void addkeyintab(lua_State *L, const char* key, int value) {
  1127.  
  1128.     lua_pushstring(L, key); /* отправить ключ в стек */
  1129.     lua_pushinteger(L, value); /* отправить значение ключа в стек. */
  1130.     lua_rawset(L, -3); /*Сохраняет пару в таблице */
  1131. }
  1132. int main() {lua_State *L = luaL_newstate();
  1133.     luaL_openlibs(L);
  1134.     lua_newtable(L); /*создать пустую таблицу */
  1135.     addkeyintab(L, "key y", "10"); /*добавить ключ и значение в таблицу */
  1136.     addkeyintab(L, "key x", 10); /*добавить ключ и значение в таблицу */
  1137.     lua_setglobal(L, "foo");// уст имя таблицы в lua.
  1138.  
  1139.     checklua(L, "main.lua");
  1140.     showstack(L);// вывести стек.
  1141.     lua_close(L);
  1142.     return 0;
  1143. };
  1144.  
  1145. Lua
  1146.  
  1147. print(foo)
  1148. for k,v in pairs(foo) do
  1149. print(k.." "..v)
  1150. end
  1151.  
  1152. Выводится
  1153.  
  1154. table: 00855520
  1155. key x 10
  1156. key y 10
  1157.  
  1158.   the number on the stack = 0
  1159.  
  1160.  
  1161. lua c++ api. Запуск lua файла.
  1162.  
  1163. #include"include/lua.hpp"
  1164.  
  1165. using namespace std;
  1166.  
  1167. int checklua(lua_State *L, const char *file) {
  1168.     int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
  1169.     try {
  1170.         if (status == 0) {// если нет ошибки в файле.
  1171.             luaL_dofile(L, file);// запуск файла, в которым все происходит.
  1172.             return 0;
  1173.         }
  1174.         else {
  1175.             string x = lua_tostring(L, -1);
  1176.             throw x;
  1177.         }
  1178.     }
  1179.     catch (string x) {
  1180.         cout << x << endl;
  1181.         //luaL_error(L,"error");
  1182.     }
  1183. };
  1184.  
  1185.  
  1186. int main(int argc, char *argv[]) {
  1187.  
  1188.     lua_State *L = luaL_newstate();
  1189.     luaL_openlibs(L);//открыть все стандартные библиотеки lua.
  1190.     checklua(L, "main.lua");// Загружает и запускает заданный файл. Файл в котором все происходит.
  1191.     lua_pcall(L, 0, 0, 0);// вызов функции в lua файле. 1 параметр кол-во передаваемых, кол-во возвращаемых, обработчик ошибок.
  1192.     lua_close(L);// закрыть состояние
  1193.     cin.get();//ожидает ввода символа программа завершается.
  1194. return 0;
  1195. }
  1196.  
  1197. Lua
  1198. a = 3
  1199. b = 6
  1200. c= a+b
  1201. print(c)
  1202.  
  1203. lua c++ api. Регистрация новой C функции в lua.
  1204.  
  1205. int q(lua_State *L) {// передаем указатель на состояние.
  1206.     int x = lua_tonumber(L, 1); // получаем 1 элемент из стека.
  1207.     x = x * x;
  1208.    //cout << x << endl;
  1209.     lua_pushnumber(L, x);// умножаем x и отправляет в стек.
  1210.     return 1;// вернуть 1.
  1211. }
  1212. int main() {
  1213.     lua_State *L = luaL_newstate();
  1214.     luaL_openlibs(L);//открыть все стандартные библиотеки lua.
  1215.     lua_register(L, "q", q);// регистрируем функцию- имя состояние, имя функ в lua, имя функ тут.
  1216.     checklua(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
  1217.     lua_pcall(L, 0, 0, 0);// вызов функции в lua файле. 1 параметр кол-во передаваемых, кол-во возвращаемых, обработчик ошибок.
  1218.     lua_close(L);// закрыть состояние
  1219.     cin.get();//ожидает ввода символа программа завершается.
  1220.     return 0;}
  1221.  
  1222. lua
  1223. x = q(2)
  1224. print(x)
  1225.  
  1226.  
  1227.  
  1228. lua c++ api. Регистрация C функции в lua.
  1229.  
  1230.  
  1231. int foo(lua_State *L) {
  1232.  
  1233.     int x= lua_tonumber(L, -1);
  1234.     cout << x << endl;
  1235.     return 0; /* number of results */
  1236. }
  1237. int main(int argc, char *argv[]) {
  1238.  
  1239.     lua_State *L = luaL_newstate();
  1240.     luaL_openlibs(L);//открыть все стандартные библиотеки lua.
  1241.     lua_register(L, "foo", foo);// регистрируем функцию- имя состояние, имя функ в lua, имя функ тут.
  1242.  
  1243.     checklua(L, "main.lua");
  1244.     lua_pcall(L, 0, 0, 0);// вызов функции в lua файле. 1 параметр кол-во передаваемых, кол-во возвращаемых, обработчик ошибок.
  1245.     lua_close(L);// закрыть состояние
  1246.     cin.get();//ожидает ввода символа программа завершается.
  1247.     return 0;
  1248. }
  1249.  
  1250.  
  1251. Lua
  1252. foo(2)
  1253.  
  1254. lua c++ api. Запуск C функции в lua.
  1255.  
  1256.  
  1257. int checklua(lua_State *L, const char *file) {
  1258.     int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
  1259.     try {if (status == 0) {// если нет ошибки в файле.
  1260.             luaL_dofile(L, file);// запуск файла, в которым все происходит.
  1261.     return 0;}
  1262.     else {  string x =lua_tostring(L, -1);
  1263.     throw x;    }
  1264.     }
  1265.     catch (string x) {
  1266.         cout << x << endl; 
  1267.         //luaL_error(L,"error");
  1268.     }
  1269. };
  1270. int foo(lua_State *L) {
  1271.     cout << "hi foo c++" << endl;
  1272.     return 0;
  1273. }
  1274. int main() {
  1275.     lua_State *L = luaL_newstate();
  1276.     luaL_openlibs(L);
  1277.     checklua(L, "main.lua");
  1278.     lua_pushcfunction(L, foo);// отправить c функцию в стек.
  1279.     lua_pcall(L, 0, 0, 0);// вызвать функцию foo.
  1280.     lua_close(L);
  1281.     return 0;
  1282. };
  1283.  
  1284.  
  1285. Lua
  1286.  
  1287. Foo()
  1288.  
  1289.  
  1290. lua c++ api. Запуск функции на lua, с возвращаемыми параметрами.
  1291.  
  1292. int main() {
  1293.     lua_State *L = luaL_newstate();
  1294.     luaL_openlibs(L);//открыть все стандартные библиотеки lua.
  1295.     checklua(L, "main.lua");
  1296.     lua_getglobal(L, "pri");// получаем из lua функцию pri.
  1297.     lua_pushnumber(L, 5);// отправляем в стек число.
  1298.     lua_pushnumber(L, 10);// отправляем в стек число.
  1299.  
  1300.     lua_pcall(L, 2, 1, 0);// вызов функции, передаем 2 параметра, возвращаем 1.
  1301.     cout << lua_tonumber(L, 1) << endl;// получаем из стека возвращаемое значение из функции.
  1302.     lua_close(L);// закрыть состояние
  1303.     cin.get();//ожидает ввода символа программа завершается.
  1304.  
  1305.     return 0;
  1306. }
  1307.  
  1308. Lua
  1309.  
  1310. function pri(x,y)
  1311. sum = x+y
  1312. return sum
  1313. end
  1314.  
  1315.  
  1316. lua c++ api. Вызов определенной функции из lua.
  1317.  
  1318. int main() {
  1319.     lua_State *L = luaL_newstate();
  1320.     int x = 5, y = 6;
  1321.     luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
  1322.     lua_getglobal(L, "f"); /* вызываемая функция */
  1323.     lua_pushnumber(L, x); /* поместить на стек 1-й аргумент */
  1324.     lua_pushnumber(L, y); /* поместить на стек 2-й аргумент */
  1325.     if (lua_pcall(L, 2, 1, 0) != 0) {/* вызвать функцию (2 аргумента, 1 результат) */
  1326.         luaL_error(L, "error running function 'f': %s", lua_tostring(L, -1));}/* получить результат */
  1327.     cout << lua_tonumber(L, -1) << "\n";
  1328.     lua_pop(L, 1);
  1329.     lua_close(L);
  1330.     cin.get();//ожидает ввода символа программа завершается.
  1331.     return 0;
  1332. }
  1333.  
  1334. Lua
  1335.  
  1336. function f(x, y)
  1337.     return (x*y)
  1338. end
  1339.  
  1340.  
  1341. lua c++ api. Функция, принимающая переменное количество аргументов.
  1342.  
  1343. //Эта функция может принимать переменное число параметров через L
  1344. int pri(lua_State * L) {// передаем указатель на состояние.
  1345.     int n = lua_gettop(L);/* получаем количество параметров переданных в функцию.
  1346.     Возвращает индекс верхнего элемента в стеке. Поскольку индексы начинаются с 1, этот результат
  1347.     равен количеству элементов в стеке (и поэтому 0 означает пустой стек).*/
  1348.     cout <<"count elements "<< n << endl;
  1349.     for (int i = 1; i <= n; ++i) {
  1350.     int t = lua_type(L, i); /* LUA_TNIL, LUA_TNUMBER, LUA_TBOOLEAN, LUA_TSTRING, LUA_TTABLE, LUA_TFUNCTION, LUA_TUSERDATA, LUA_TTHREAD,
  1351.        и LUA_TLIGHTUSERDATA.*/
  1352.     if (LUA_TSTRING == t) {
  1353.             cout <<i << " string = " << lua_tostring(L, i) << endl;}
  1354.     if (LUA_TNUMBER == t) {
  1355.             double x = lua_tonumber(L, i);
  1356.             int x2 = (int)x;
  1357.             if (x == x2) { cout << i<<" number int = " << x2 << endl; }
  1358.             else { cout << i<<" number double = " << x << endl; }}
  1359.     if (LUA_TBOOLEAN == t) {cout <<i<< " bool = " << lua_toboolean(L, i) << endl;   }
  1360.  
  1361.     }
  1362.     return 1;// вернуть 1.
  1363. }
  1364. int main() {
  1365.     lua_State *L = luaL_newstate();
  1366.     luaL_openlibs(L);//открыть все стандартные библиотеки lua.
  1367.     lua_register(L, "pri", pri);// регистрируем функцию- имя состояние, имя функ в lua, имя функ тут.
  1368.     checklua(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
  1369.     lua_pcall(L, 0, 0, 0);// вызов функции в lua файле. 1 параметр кол-во передаваемых, кол-во возвращаемых, обработчик ошибок.
  1370.     lua_close(L);// закрыть состояние
  1371.     cin.get();//ожидает ввода символа программа завершается.
  1372.     return 0;
  1373. }
  1374.  
  1375. Lua
  1376.  
  1377. pri(2,"youtube", false, 6,"end",5.236, true)
  1378.  
  1379.  
  1380.  
  1381. lua c++ api. мета таблицы.
  1382.  
  1383.  
  1384. void addkeyintab(lua_State *L, const char* key, int value) {
  1385.     lua_pushstring(L, key); /* отправить ключ в стек */
  1386.     lua_pushinteger(L, value); /* отправить значение ключа в стек. */
  1387.     lua_rawset(L, -3); /*Сохраняет пару в таблице */
  1388. }
  1389. struct vec{ static int vector(lua_State* L) {// методы классы должны быть статик.
  1390.         lua_newtable(L); //создать новую таблицу.
  1391.         addkeyintab(L, "x", 0);// установить значение ключа таблицы.
  1392.         luaL_getmetatable(L, "mt");// получить мета таблицу.
  1393.         lua_setmetatable(L, -2);
  1394.         return 1;   }
  1395.  
  1396.     static int __add(lua_State* L)  {
  1397.         lua_pushstring(L, "x");
  1398.         lua_gettable(L, -3);
  1399.         int firts = lua_tonumber(L, -1);
  1400.  
  1401.         lua_pushstring(L, "x");
  1402.         lua_gettable(L, -3);
  1403.         int second = lua_tonumber(L, -1);
  1404.  
  1405.         vec::vector(L);// вывоз метода обнулиние таблицы суммы ключей.
  1406.         lua_pushstring(L, "z");// ключ таблицы со значение ее суммы.
  1407.         lua_pushnumber(L, firts + second);// сумму отправить в стек как ключ таблицы.
  1408.         lua_rawset(L, -3);// уст таблицу без мета.методов.
  1409.         return 1;
  1410.     }
  1411. };
  1412.  
  1413. const char * LUA_FILE = R"(
  1414.         v1 = vector()   -- v1 is a table
  1415.         v2 = vector() -- v2 is a table
  1416.         v1.x = 5  v2.x = 18
  1417.         v3 = v1 + v2
  1418.         result = v3.z)";
  1419. int main(){lua_State* L = luaL_newstate();
  1420.  
  1421. lua_pushcfunction(L, vec::vector);
  1422. lua_setglobal(L, "vector");
  1423.  
  1424. luaL_newmetatable(L, "mt");
  1425. lua_pushstring(L, "__add");
  1426. lua_pushcfunction(L, vec::__add);
  1427. lua_settable(L, -3);
  1428.  
  1429. luaL_dostring(L, LUA_FILE);
  1430.  
  1431. lua_getglobal(L, "result");
  1432. cout << "result = " <<lua_tonumber(L, -1)<< endl;
  1433. lua_close(L);
  1434. }
  1435.  
  1436.  
  1437. lua c++ api. мета таблицы 2.
  1438.  
  1439.  
  1440. struct Sprite { int x;// структура.
  1441.  
  1442.     Sprite() : x(0) {}//конструктор по умолчанию.
  1443.  
  1444.     ~Sprite() { cout << "destror "<< this << endl; }
  1445.  
  1446.     void set(int x) {this->x = x;}// уст значение x.
  1447.  
  1448.     void show() {
  1449.         printf("sprite(%p): x = %d\n", this, x);
  1450.     }
  1451. };
  1452.  
  1453. int create(lua_State* L) {// создать структуру.
  1454.     void* st = lua_newuserdata(L, sizeof(Sprite));// выделить память под польз.данные отправить в стек.
  1455.     new (st) Sprite();//выделить память под новый объект класса.
  1456.     luaL_getmetatable(L, "mt");// получить мета таблицу.
  1457.     lua_setmetatable(L, -2);// уст мета таблицу.
  1458.     return 1;
  1459. };
  1460.  
  1461. int set(lua_State* L) {
  1462.     Sprite* sprite = (Sprite*)lua_touserdata(L, -2);// получить польз.данные.
  1463.     int x = lua_tonumber(L, -1);
  1464.     sprite->set(x);// вызов метода класса, уст значение x
  1465.     return 0;
  1466. };
  1467.  
  1468. int show(lua_State* L) {
  1469.     Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
  1470.     sprite->show();
  1471.     return 0;
  1472. };
  1473. int DestroySprite(lua_State* L) {
  1474.     Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
  1475.     sprite->~Sprite();
  1476.     return 0;
  1477. };
  1478.  
  1479. const char* LUA_FILE = R"(
  1480.         sprite = create()
  1481.         set( sprite, 5 )
  1482.         show( sprite )
  1483.         set( sprite, 12 )
  1484.         show( sprite )
  1485.         sprite2 = create()
  1486.         set( sprite2, 33 )
  1487.         show( sprite2 )
  1488.         )";
  1489.  
  1490. int main() {lua_State* L = luaL_newstate();
  1491.  
  1492.     luaL_newmetatable(L, "mt");// создать метп таблицу.
  1493.     lua_pushstring(L, "__gc");// отправить в стек сборщик мусора.
  1494.     lua_pushcfunction(L, DestroySprite);// установить значение ключа, как вызов деструктор.
  1495.     lua_settable(L, -3);// установить таблицу.
  1496.  
  1497.     lua_pushcfunction(L, create);// отправить ключ как функцию в стек.
  1498.     lua_setglobal(L, "create");
  1499.     lua_pushcfunction(L, set);// отправить ключ как функцию в стек.
  1500.     lua_setglobal(L, "set");
  1501.     lua_pushcfunction(L, show);// отправить ключ как функцию в стек.
  1502.     lua_setglobal(L, "show");
  1503.  
  1504.     luaL_dostring(L, LUA_FILE);
  1505.  
  1506.     lua_close(L);
  1507. }
  1508.  
  1509.  
  1510. lua c++ api. мета таблицы 3.
  1511.  
  1512.  
  1513. static int numberOfSpritesExisting = 0;
  1514.  
  1515. struct Sprite
  1516. {
  1517.     int x;
  1518.     int y;
  1519.  
  1520.     Sprite() : x(0), y(0)
  1521.     {
  1522.         numberOfSpritesExisting++;
  1523.     }
  1524.  
  1525.     ~Sprite()
  1526.     {
  1527.         numberOfSpritesExisting--;
  1528.     }
  1529.  
  1530.     void Move(int velX, int velY)
  1531.     {
  1532.         x += velX;
  1533.         y += velY;
  1534.     }
  1535.  
  1536.     void Draw()
  1537.     {
  1538.         printf("sprite(%p): x = %d, y = %d\n", this, x, y);
  1539.     }
  1540. };
  1541.  
  1542. int CreateSprite(lua_State* L){
  1543.     void* pointerToASprite = lua_newuserdata(L, sizeof(Sprite));
  1544.     new (pointerToASprite) Sprite();
  1545.     luaL_getmetatable(L, "SpriteMetaTable");
  1546.     lua_assert(lua_istable(L, -1));
  1547.     lua_setmetatable(L, -2);
  1548.     return 1;
  1549. };
  1550.  
  1551. int DestroySprite(lua_State* L){
  1552.     Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
  1553.     sprite->~Sprite();
  1554.     return 0;
  1555. };
  1556.  
  1557. int MoveSprite(lua_State* L){
  1558.     Sprite* sprite = (Sprite*)lua_touserdata(L, -3);
  1559.     lua_Number velX = lua_tonumber(L, -2);
  1560.     lua_Number velY = lua_tonumber(L, -1);
  1561.     sprite->Move((int)velX, (int)velY);
  1562.     return 0;
  1563. };
  1564.  
  1565. int DrawSprite(lua_State* L){
  1566.     Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
  1567.     sprite->Draw();
  1568.     return 0;
  1569. };
  1570.  
  1571. const char* LUA_FILE = R"(
  1572.     sprite = Sprite.new()
  1573.     sprite:Move( 5, 7 )     -- Sprite.Move( sprite, 5, 7 )
  1574.     sprite:Draw()
  1575.     sprite:Move( 1, 2 )
  1576.     sprite:Draw()
  1577.     sprite2 = Sprite.new()
  1578.     sprite2:Move( 3, 3 )
  1579.     sprite2:Draw()
  1580.         -- sprite   -> sprite is a userdatum
  1581.         --      has a metatable called SpriteMetaTable
  1582.         --          dont have Move(), use the __index metamethod
  1583.         --          __index metamethod is a table which is Sprite
  1584.         --          Sprite has a field called Move(), invoke that
  1585.         --          Move() is a c function
  1586.         --          invoke, pass the userdatum as the first parameter.
  1587.         )";
  1588.  
  1589.  
  1590. int main() {
  1591.     lua_State* L = luaL_newstate();
  1592.  
  1593.     lua_newtable(L);
  1594.     int spriteTableIdx = lua_gettop(L);
  1595.     lua_pushvalue(L, spriteTableIdx);
  1596.     lua_setglobal(L, "Sprite");
  1597.  
  1598.     lua_pushcfunction(L, CreateSprite);
  1599.     lua_setfield(L, -2, "new");
  1600.     lua_pushcfunction(L, MoveSprite);
  1601.     lua_setfield(L, -2, "Move");
  1602.     lua_pushcfunction(L, DrawSprite);
  1603.     lua_setfield(L, -2, "Draw");
  1604.  
  1605.     luaL_newmetatable(L, "SpriteMetaTable");
  1606.     lua_pushstring(L, "__gc");
  1607.     lua_pushcfunction(L, DestroySprite);
  1608.     lua_settable(L, -3);
  1609.  
  1610.     lua_pushstring(L, "__index");
  1611.     lua_pushvalue(L, spriteTableIdx);
  1612.     lua_settable(L, -3);
  1613.  
  1614.     luaL_dostring(L, LUA_FILE);
  1615.     lua_close(L);
  1616.  
  1617.     lua_assert(numberOfSpritesExisting == 0);
  1618.     return 0;
  1619. }
  1620.  
  1621.  
  1622. lua c++ api. мета таблицы 4.
  1623.  
  1624.  
  1625. static int numberOfSpritesExisting = 0;
  1626.  
  1627. struct Sprite {
  1628.     int x;
  1629.     int y;
  1630.  
  1631.     Sprite() : x(0), y(0)
  1632.     {
  1633.         numberOfSpritesExisting++;
  1634.     }
  1635.  
  1636.     ~Sprite()
  1637.     {
  1638.         numberOfSpritesExisting--;
  1639.     }
  1640.  
  1641.     void Move(int velX, int velY)
  1642.     {
  1643.         x += velX;
  1644.         y += velY;
  1645.     }
  1646.  
  1647.     void Draw()
  1648.     {
  1649.         printf("sprite(%p): x = %d, y = %d\n", this, x, y);
  1650.     }
  1651. };
  1652.  
  1653. auto CreateSprite = [](lua_State* L) -> int
  1654. {
  1655.     void* pointerToASprite = lua_newuserdata(L, sizeof(Sprite));
  1656.     new (pointerToASprite) Sprite();
  1657.     luaL_getmetatable(L, "mt");
  1658.     lua_assert(lua_istable(L, -1));
  1659.     lua_setmetatable(L, -2);
  1660.     return 1;
  1661. };
  1662.  
  1663. auto DestroySprite = [](lua_State* L) -> int
  1664. {
  1665.     Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
  1666.     sprite->~Sprite();
  1667.     return 0;
  1668. };
  1669.  
  1670. auto MoveSprite = [](lua_State* L) -> int
  1671. {
  1672.     Sprite* sprite = (Sprite*)lua_touserdata(L, -3);
  1673.     lua_Number velX = lua_tonumber(L, -2);
  1674.     lua_Number velY = lua_tonumber(L, -1);
  1675.     sprite->Move((int)velX, (int)velY);
  1676.     return 0;
  1677. };
  1678.  
  1679. auto DrawSprite = [](lua_State* L) -> int
  1680. {
  1681.     Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
  1682.     sprite->Draw();
  1683.     return 0;
  1684. };
  1685.  
  1686. auto SpriteIndex = [](lua_State* L) -> int
  1687. {
  1688.     lua_assert(lua_isuserdata(L, -2));
  1689.     lua_assert(lua_isstring(L, -1));
  1690.  
  1691.     Sprite* sprite = (Sprite*)lua_touserdata(L, -2);
  1692.     const char* index = lua_tostring(L, -1);
  1693.     if (strcmp(index, "x") == 0)
  1694.     {
  1695.         lua_pushnumber(L, sprite->x);
  1696.         return 1;
  1697.     }
  1698.     else if (strcmp(index, "y") == 0)
  1699.     {
  1700.         lua_pushnumber(L, sprite->y);
  1701.         return 1;
  1702.     }
  1703.     else
  1704.     {
  1705.         lua_getglobal(L, "Sprite");
  1706.         lua_pushstring(L, index);
  1707.         lua_rawget(L, -2);
  1708.         return 1;
  1709.     }
  1710. };
  1711.  
  1712. const char* LUA_FILE = R"(
  1713.     sprite = Sprite.new()
  1714.     sprite:Move( 6, 7 )     -- Sprite.Move( sprite, 6, 7 )
  1715.     sprite:Draw()
  1716.     temp_x = sprite.x
  1717.     )";
  1718. int main(){
  1719.     lua_State* L = luaL_newstate();
  1720.  
  1721.     lua_newtable(L);
  1722.     int spriteTableIdx = lua_gettop(L);
  1723.     lua_pushvalue(L, spriteTableIdx);
  1724.     lua_setglobal(L, "Sprite");
  1725.  
  1726.     lua_pushcfunction(L, CreateSprite);
  1727.     lua_setfield(L, -2, "new");
  1728.     lua_pushcfunction(L, MoveSprite);
  1729.     lua_setfield(L, -2, "Move");
  1730.     lua_pushcfunction(L, DrawSprite);
  1731.     lua_setfield(L, -2, "Draw");
  1732.  
  1733.     luaL_newmetatable(L, "mt");
  1734.     lua_pushstring(L, "__gc");
  1735.     lua_pushcfunction(L, DestroySprite);
  1736.     lua_settable(L, -3);
  1737.  
  1738.     lua_pushstring(L, "__index");
  1739.     lua_pushcfunction(L, SpriteIndex);
  1740.     lua_settable(L, -3);
  1741.  
  1742.     int doResult = luaL_dostring(L, LUA_FILE);
  1743.     if (doResult != LUA_OK)
  1744.     {
  1745.         printf("Error: %s\n", lua_tostring(L, -1));
  1746.     }
  1747.  
  1748.     lua_getglobal(L, "temp_x");
  1749.     lua_Number temp_x = lua_tonumber(L, -1);
  1750.     lua_assert(temp_x == 6);
  1751.  
  1752.     lua_close(L);
  1753.  
  1754.     lua_assert(numberOfSpritesExisting == 0);
  1755. }
  1756.  
  1757.  
  1758. lua c++ api. Функции для работы с указателем.
  1759.  
  1760. struct st { int number =10;
  1761.     int *x = &number;
  1762.     st() { this->x = *&x; }
  1763.     st(int number) { this->number = *&number; }
  1764. };
  1765. int create(lua_State* L) {//Функция создания объекта структуры.
  1766.    int x = lua_tonumber(L, -1);
  1767.    void *s = lua_newuserdata(L, sizeof(st));/*Эта функция выделяет новый блок памяти с заданным размером,*/
  1768.    new(s) st(x);  luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при
  1769.      заданном приемлемом индексе.*/
  1770.    lua_setmetatable(L, 1);//получает таблицу из стека и уст ее в качестве  новой метатаблицы для значения с заданным допустимым индексом.
  1771.     return 1;
  1772. };
  1773.  
  1774. int show(lua_State* L) {
  1775.     st *s = (st*)lua_touserdata(L, -1);;// получаем польз. данные.
  1776.     cout << "andress " << &(s->x) <<" value " << *(s->x)<<endl;// адрес памяти
  1777.     s->~st();//вызов метода деструктор.
  1778.     return 0;
  1779. };
  1780.  
  1781. int checklua(lua_State *L, const char *file) {
  1782.     int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
  1783.     try {if (status == 0) {// если нет ошибки в файле.
  1784.             luaL_dofile(L, file);// запуск файла, в которым все происходит.
  1785.     return 0;}
  1786.     else {  string x =lua_tostring(L, -1);
  1787.     throw x;    }
  1788.     }
  1789.     catch (string x) {
  1790.         cout << x << endl; 
  1791.         //luaL_error(L,"error");
  1792.     }
  1793. };
  1794.  
  1795. int main() {lua_State* L = luaL_newstate();
  1796.     lua_newtable(L);
  1797.     lua_pushcfunction(L, create);//уст указатель на функцию C++ и создает внутри Lua
  1798.     lua_setglobal(L, "get"); //получает значение из стека и уст значение global name.
  1799.     lua_pushcfunction(L, show);
  1800.     lua_setglobal(L, "show"); //получает значение из стека и уст значение global name.
  1801.     luaL_newmetatable(L, "mt");/*int luaL_newmetatable (lua_State * L, const    char * t); */
  1802.     lua_settable(L, 2);
  1803.     checklua(L, "main.lua");// Загружает и запускает заданный файл. файл в котором все происходит.
  1804.     lua_close(L);// закрыть состояние
  1805.     cin.get();//ожидает ввода символа программа завершается.
  1806.     return 0;
  1807. }
  1808.  
  1809.  
  1810.  
  1811. lua c++ api. Работа с указателем.
  1812.  
  1813. int get_point_number(lua_State *L) {// передаем указатель на состояние
  1814.     int s = 10;//значение переменной по умолчанию.
  1815.     int *a = &s;// указатель на переменную.
  1816.     (int*)lua_newuserdata(L, sizeof(a));// выделяет памяти с заданным размером,
  1817.     //помещает в стек пользовательские данные и возвращает этот адрес.
  1818.     if (LUA_TNUMBER == lua_type(L, 1)) {
  1819.         double x = lua_tonumber(L, 1);
  1820.         int x2 = (int)x;
  1821.         if (x == x2) { lua_pushinteger(L, x);// отправить в стек целое число.
  1822.             cout << "this number int " << x2 << endl;       }
  1823.         else { cout << "this number double this " << x << endl;
  1824.         lua_pushnumber(L, x);   }
  1825.     }
  1826.     else {  cout <<"the default number  "<< s  << endl;
  1827.         lua_pushinteger(L, s);}
  1828.     return 2;// вернуть 2.
  1829. }
  1830. int getpoint(lua_State *L) {// передаем указатель на состояние 
  1831.     if (LUA_TUSERDATA == lua_type(L, 1)) {// если это польз. данные.
  1832.         void *x = lua_touserdata(L, 1);/*Если значение в данном приемлемом индексе является полными данными пользователя,
  1833.  возвращает адрес его блока. Если значение является легким userdata, возвращает его указатель. В противном случае возвращается NULL.*/
  1834.         cout << "address point " << x << endl;  }
  1835.     return 1;// вернуть 1.
  1836. }
  1837. int main() {
  1838.     lua_State *L = luaL_newstate();
  1839.     luaL_openlibs(L);//открыть все стандартные библиотеки lua.
  1840.     lua_pushcfunction(L, get_point_number);//уст указатель на функцию C++ и создает внутри Lua
  1841.     lua_setglobal(L, "getpointnum"); //получает значение из стека и уст значение global name.
  1842.     lua_pushcfunction(L, getpoint);//уст указатель на функцию C++ и создает внутри Lua
  1843.     lua_setglobal(L, "getpoint"); //получает значение из стека и уст значение global name.
  1844.     luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
  1845.     lua_pcall(L, 0, 0, 0);// вызов функции в lua файле.
  1846.     lua_close(L);// закрыть состояние
  1847.     cin.get();//ожидает ввода символа программа завершается.
  1848.     return 0;
  1849. }
  1850.  
  1851. Lua
  1852.  
  1853. adress, num =getpointnum(5.3)
  1854. --print(adress, num ) --адрес памяти выводится
  1855. getpoint(adress)
  1856.  
  1857.  
  1858.  
  1859.  
  1860. Вызывает функцию в защищенном режиме.
  1861. Оба nargs и nresults имеют то же значение, что и в lua_call. Если при звонке ошибок нет, lua_pcall ведет себя точно так же lua_call. Однако, если есть какая-либо ошибка, lua_pcall она перехватывает ее, помещает в стек одно значение (сообщение об ошибке) и возвращает код ошибки. Мол lua_call, lua_pcall всегда удаляет функцию и ее аргументы из стека.
  1862. Если errfunc равно 0, то сообщение об ошибке, возвращаемое в стеке, является точно исходным сообщением об ошибке. В противном случае errfunc это индекс стека функции обработчика ошибок . (В текущей реализации этот индекс не может быть псевдоиндексом.) В случае ошибок времени выполнения эта функция будет вызываться с сообщением об ошибке, а ее возвращаемое значение будет сообщением, возвращаемым в стеке lua_pcall.
  1863. Как правило, функция обработчика ошибок используется для добавления дополнительной отладочной информации к сообщению об ошибке, такой как трассировка стека. Такая информация не может быть собрана после возврата lua_pcall, так как к тому времени стек уже размотан.
  1864. lua_pcall Функция возвращает 0 в случае успеха или один из следующих кодов ошибок (определены в lua.h):
  1865. LUA_ERRRUN: ошибка во время выполнения.
  1866. LUA_ERRMEM: ошибка выделения памяти. Для таких ошибок Lua не вызывает функцию обработчика ошибок.
  1867. LUA_ERRERR: ошибка при запуске функции обработчика ошибок.
  1868.  
  1869.  
  1870.  
  1871.  
  1872.  
  1873. api lua c++. Реализация ООП через функции. Структура конструктор по умолчанию.
  1874.  
  1875. int checklua(lua_State *L, const char *file) {
  1876.     int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
  1877.     try {
  1878.         if (status == 0) {// если нет ошибки в файле.
  1879.             luaL_dofile(L, file);// запуск файла, в которым все происходит.
  1880.             return 0;
  1881.         }
  1882.         else {
  1883.             string x = lua_tostring(L, -1);
  1884.             throw x;
  1885.         }
  1886.     }
  1887.     catch (string x) {
  1888.         cout << x << endl;
  1889.         //luaL_error(L,"error");
  1890.     }
  1891. };
  1892. struct a {  int x = 30;
  1893. a() { this->x = x; }//конструктор по умолчанию
  1894.     void show() { cout << "x = " << x << endl; }    
  1895. ~a() { cout << "destory object " << this << endl << endl; }
  1896. };
  1897. int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
  1898.     a* st = (a*)lua_touserdata(L, -1);/* Если значение в данном приемлемом индексе является полными данными пользователя.*/
  1899.     st->~a();//вызов метода деструктор.
  1900.     return 0;};
  1901.  
  1902. int create(lua_State* L) {//Функция создания объекта структуры.
  1903.     void* st = lua_newuserdata(L, sizeof(a));/*Эта функция выделяет новый блок памяти с заданным размером,*/
  1904.     new (st) a();// Выделить память под польз. данные.
  1905.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  1906.     lua_setmetatable(L, 1);//получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
  1907.     return 1;};
  1908.  
  1909. int show(lua_State* L) {
  1910.     a* st = (a*)lua_touserdata(L, -1);// получаем польз. данные.
  1911.     st->show();// вызов метода.
  1912.     return 0;};
  1913.  
  1914. int main() {
  1915.     lua_State* L = luaL_newstate();
  1916.     lua_newtable(L);
  1917.     lua_pushcfunction(L, create);//уст указатель на функцию C++ и создает внутри Lua
  1918.     lua_setglobal(L, "get"); //получает значение из стека и уст значение global name.
  1919.     lua_pushcfunction(L, show);
  1920.     lua_setglobal(L, "show"); //получает значение из стека и уст значение global name.
  1921.     luaL_newmetatable(L, "mt");/*int luaL_newmetatable (lua_State * L, const char * t); */
  1922.     lua_pushstring(L, "__gc");
  1923.     lua_pushcfunction(L, destroy);
  1924.     lua_settable(L, 2);
  1925.     checklua(L, "main.lua");
  1926.     showstack(L);// вывести стек.
  1927.     lua_close(L);// закрыть состояние
  1928.     cin.get();//ожидает ввода символа программа завершается.
  1929. return 0;}
  1930.  
  1931. lua
  1932. a= get()
  1933. show(a)
  1934.  
  1935. передача польз. Данных.
  1936.  
  1937. struct a {  int x = 3010;
  1938. a() { this->x = x; }//конструктор по умолчанию
  1939.     void show() { cout << "x = " << x << endl; }
  1940. };
  1941.  
  1942. int create(lua_State* L) {//    Функция создания объекта структуры.
  1943.     void* st = lua_newuserdata(L, sizeof(a));/*Эта функция выделяет новый блок памяти с заданным размером,*/
  1944.     new (st) a();// Выделить память под польз. данные.
  1945.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  1946.     lua_setmetatable(L, 1);//получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
  1947.     return 1;};
  1948.  
  1949. int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
  1950.     a* st = (a*)lua_touserdata(L, 1);/* Если значение в данном приемлемом индексе является полными данными пользователя.*/
  1951.     st->~a();//вызов метода деструктор.
  1952.     return 0;};
  1953.  
  1954. int show(lua_State* L) {
  1955.     a* st = (a*)lua_touserdata(L, -1);
  1956.     st->show();
  1957.     return 0;};
  1958.  
  1959. int main() {
  1960.     lua_State* L = luaL_newstate();
  1961.     lua_newtable(L);
  1962.     lua_pushcfunction(L, create);//уст указатель на функцию C++ и создает внутри Lua
  1963.     lua_setglobal(L, "get"); //получает значение из стека и уст значение global name.
  1964.     lua_pushcfunction(L, show);
  1965.     lua_setglobal(L, "show"); //получает значение из стека и уст значение global name.
  1966.     luaL_newmetatable(L, "mt");/*int luaL_newmetatable (lua_State * L, const char * t); */
  1967.     lua_pushstring(L, "__gc");
  1968.     lua_pushcfunction(L, destroy);
  1969.     lua_settable(L, 2);
  1970.     luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
  1971.     lua_close(L);// закрыть состояние
  1972.     cin.get();//ожидает ввода символа программа завершается.
  1973. return 0;
  1974. }
  1975. Lua
  1976.  
  1977. a = get()
  1978. show(a)
  1979.  
  1980.  
  1981.  
  1982.  
  1983. api lua c++. Реализация ООП через функции 2. Структура конструктор по умолчанию.
  1984.  
  1985. struct a {
  1986.     int x = 10;
  1987.     a() { cout << "create object " << this << endl; }//конструктор по умолчанию
  1988.  
  1989.     void show() { cout << "\nobject - " << this << "\tx = " << x <<"\n\n"; }//вывести значение x на экран.
  1990.  
  1991.     ~a() { cout << "destory object " << this << endl << endl; }//вызов деструктора.
  1992. };
  1993.  
  1994. int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
  1995.     cout << "destroy " << endl;
  1996.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  1997.     a** st = (a**)lua_touserdata(L, -2); // получаем польз. данные.
  1998.     //a *b = &**st;
  1999.     //b->~a();//вызов метода деструктор.
  2000.     delete *st;
  2001.     return 0;
  2002.  
  2003. };
  2004. int create(lua_State* L) {//    Функция создания объекта структуры.
  2005.     luaL_newmetatable(L, "mt");// создать мета таблицу.
  2006.     lua_pushstring(L, "__gc");// отправить в стек сборщик мусора.
  2007.     lua_pushcfunction(L, destroy);// установить значение ключа, как вызов деструктор.
  2008.  
  2009.     lua_settable(L, -3);// установить таблицу.
  2010.     a** c = (a**)lua_newuserdata(L, sizeof(a*));/*Эта функция выделяет новый блок памяти с заданным размером,*/
  2011.     *c = new a();
  2012.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  2013.  
  2014.     lua_setmetatable(L, -2); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
  2015.  
  2016. return 1;
  2017. };
  2018. int show(lua_State* L) {
  2019.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  2020.     a** st = (a**)lua_touserdata(L, -2);// получаем польз. данные.
  2021.     a *b = &**st;
  2022.     b->show();// вызов метода.  
  2023.     return 0;
  2024. };
  2025.  
  2026. int main() {
  2027.     lua_State* L = luaL_newstate();
  2028.     lua_register(L, "create", create );//уст указатель на функцию C++ и создает внутри Lua
  2029.     lua_register(L, "show", show); //получает значение из стека и уст значение global name.
  2030.     lua_register(L, "__gc", destroy); //получает значение из стека и уст значение global name.
  2031.     luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
  2032.  
  2033.     lua_close(L);// закрыть состояние
  2034.     cin.get();//ожидает ввода символа программа завершается.
  2035.     return 0;
  2036. }
  2037.  
  2038.  
  2039. lua
  2040. a= create()
  2041. show(a)
  2042.  
  2043.  
  2044. Выводится
  2045. create object 0152FD78
  2046.  
  2047. object - 0152FD78       x = 10
  2048.  
  2049. destroy
  2050. destory object 0152FD78
  2051.  
  2052.  
  2053.  
  2054.  
  2055. api lua c++. Реализация ООП через функции 2. 2 класса. Структура конструктор по умолчанию.
  2056.  
  2057.  
  2058. struct a {
  2059.     int x = 10;
  2060.     a() { cout << "create object " << this << endl; }//конструктор по умолчанию
  2061.  
  2062.     void show() { cout << "\nobject - " << this << "\tx = " << x << "\n\n"; }//вывести значение x на экран.
  2063.     void get() { cout << "\nget "<< "\n\n"; }//вывести значение x на экран.
  2064.  
  2065.     ~a() { cout << "destory object " << this << endl << endl; }//вызов деструктора.
  2066. };
  2067. struct b {
  2068.     int y = 10;
  2069.     b() { cout << "create object b" << this << endl; }//конструктор по умолчанию
  2070.  
  2071.     void get() { cout << "\ngeta " << "\n\n"; }//вывести значение x на экран.
  2072.  
  2073.     ~b() { cout << "destory object " << this << endl << endl; }//вызов деструктора.
  2074. };
  2075. int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
  2076.     cout << "destroy " << endl;
  2077.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  2078.     a** st = (a**)lua_touserdata(L, -2); // получаем польз. данные.
  2079.     //a *b = &**st;
  2080.     //b->~a();//вызов метода деструктор.
  2081.     delete *st;
  2082.     return 0;
  2083.  
  2084. };
  2085. int create(lua_State* L) {//    Функция создания объекта структуры.
  2086.     luaL_newmetatable(L, "mt");// создать мета таблицу.
  2087.     lua_pushstring(L, "__gc");// отправить в стек сборщик мусора.
  2088.     lua_pushcfunction(L, destroy);// установить значение ключа, как вызов деструктор.
  2089.  
  2090.     lua_settable(L, -3);// установить таблицу.
  2091.     a** c = (a**)lua_newuserdata(L, sizeof(a*));/*Эта функция выделяет новый блок памяти с заданным размером,*/
  2092.     *c = new a();
  2093.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  2094.  
  2095.     lua_setmetatable(L, -2); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
  2096.  
  2097. return 1;
  2098. };
  2099. int create1(lua_State* L) {//   Функция создания объекта структуры.
  2100.     luaL_newmetatable(L, "mt");// создать мета таблицу.
  2101.     lua_pushstring(L, "__gc");// отправить в стек сборщик мусора.
  2102.     lua_pushcfunction(L, destroy);// установить значение ключа, как вызов деструктор.
  2103.  
  2104.     lua_settable(L, -3);// установить таблицу.
  2105.     b** c = (b**)lua_newuserdata(L, sizeof(b*));/*Эта функция выделяет новый блок памяти с заданным размером,*/
  2106.     *c = new b();
  2107.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  2108.  
  2109.     lua_setmetatable(L, -2); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
  2110.  
  2111.     return 1;
  2112. };
  2113. int show(lua_State* L) {
  2114.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  2115.     a** st = (a**)lua_touserdata(L, -2);// получаем польз. данные.
  2116.     a *b = &**st;
  2117.     b->show();// вызов метода.  
  2118.     return 0;
  2119. };
  2120. int get(lua_State* L) {
  2121.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  2122.     a** st = (a**)lua_touserdata(L, -2);// получаем польз. данные.
  2123.     a *b = &**st;
  2124.     b->get();// вызов метода.   
  2125.     return 0;
  2126. };
  2127.  
  2128. int geta(lua_State* L) {
  2129.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  2130.     b** st = (b**)lua_touserdata(L, -2);// получаем польз. данные.
  2131.     b *c = &**st;
  2132.     c->get();// вызов метода.   
  2133.     return 0;
  2134. };
  2135.  
  2136. int main() {
  2137.     lua_State* L = luaL_newstate();
  2138.     lua_register(L, "create", create);//уст указатель на функцию C++ и создает внутри Lua
  2139.     lua_register(L, "create1", create1);//уст указатель на функцию C++ и создает внутри Lua
  2140.     lua_register(L, "show", show); //получает значение из стека и уст значение global name.
  2141.     lua_register(L, "get", get); //получает значение из стека и уст значение global name.
  2142.     lua_register(L, "geta", geta); //получает значение из стека и уст значение global name.
  2143.     lua_register(L, "__gc", destroy); //получает значение из стека и уст значение global name.
  2144.     luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
  2145.  
  2146.     lua_close(L);// закрыть состояние
  2147.     cin.get();//ожидает ввода символа программа завершается.
  2148.     return 0;
  2149. }
  2150.  
  2151.  
  2152.  
  2153.  
  2154.  
  2155. lua
  2156. a1 = create()
  2157. show(a1)
  2158. get(a1)
  2159. a2 = create1()
  2160. show(a2)
  2161. geta(a2)
  2162. a3 = create()
  2163. show(a3)
  2164.  
  2165. Выводится
  2166.  
  2167.  
  2168. create object 0157AE00
  2169.  
  2170. object - 0157AE00       x = 10
  2171.  
  2172.  
  2173. get
  2174.  
  2175. create object b01582220
  2176.  
  2177. object - 01582220       x = 10
  2178.  
  2179.  
  2180. geta
  2181.  
  2182. create object 0157FDA0
  2183.  
  2184. object - 0157FDA0       x = 10
  2185.  
  2186. destroy
  2187. destory object 0157FDA0
  2188.  
  2189. destroy
  2190. destory object 01582220
  2191.  
  2192. destroy
  2193. destory object 0157AE00
  2194.  
  2195.  
  2196.  
  2197.  
  2198.  
  2199.  
  2200.  
  2201.  
  2202.  
  2203.  
  2204.  
  2205. api lua c++. Реализация ООП через функции. Структура, конструктор с парамертами.
  2206.  
  2207. struct a {  int x = 10;
  2208. a() { this->x = x; cout << "create object " << this << endl;}//конструктор по умолчанию
  2209.  
  2210. a(int x) { this->x = x; cout << "create object " << this << endl; }//конструктор с параметрами.
  2211. void show() { cout << "\nobject - " << this << "\nx = " << x << endl; }//вывести значение x на экран.
  2212.  
  2213. ~a() { cout << "destory object " << this << endl << endl; }//вызов деструктора.
  2214. };
  2215. int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
  2216.     a* st = (a*)lua_touserdata(L, -1);/* Если значение в данном приемлемом индексе является полными данными пользователя.*/
  2217.     st->~a();//вызов метода деструктор.
  2218.     return 0;};
  2219.  
  2220. int create(lua_State* L) {//    Функция создания объекта структуры.
  2221.     void* st = lua_newuserdata(L, sizeof(a));/*Эта функция выделяет новый блок памяти с заданным размером,*/
  2222.        
  2223.     if (LUA_TNUMBER == lua_type(L, -2)) {// значение число.
  2224.         int x = lua_tointeger(L, -2);
  2225.         new (st) a(x);// Выделить память под польз. данные.
  2226.         luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  2227.         lua_setmetatable(L, -2);//получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
  2228.     }
  2229.     else {  new (st) a();// Выделить память под польз. данные.
  2230.         luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  2231.         lua_setmetatable(L, -2);};//получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
  2232.     return 1;};
  2233.  
  2234. int show(lua_State* L) {
  2235.     a* st = (a*)lua_touserdata(L, -1);// получаем польз. данные.
  2236.     st->show();// вызов метода.
  2237.     return 0;};
  2238.  
  2239. int main() {
  2240.     lua_State* L = luaL_newstate();
  2241.     lua_newtable(L);
  2242.     lua_pushcfunction(L, create);//уст указатель на функцию C++ и создает внутри Lua
  2243.     lua_setglobal(L, "get"); //получает значение из стека и уст значение global name.
  2244.     lua_pushcfunction(L, show);
  2245.     lua_setglobal(L, "show"); //получает значение из стека и уст значение global name.
  2246.     luaL_newmetatable(L, "mt");/*int luaL_newmetatable (lua_State * L, const char * t); */
  2247.     lua_pushstring(L, "__gc");
  2248.     lua_pushcfunction(L, destroy);
  2249.     lua_settable(L, -3);
  2250.     luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
  2251.     lua_close(L);// закрыть состояние
  2252.     cin.get();//ожидает ввода символа программа завершается.
  2253. return 0;
  2254. }
  2255.  
  2256. Lua
  2257. a1 = get()
  2258. show(a1)
  2259. a2 = get(2)
  2260. show(a2)
  2261. a3 = get(3)
  2262. show(a3)
  2263.  
  2264. struct a {
  2265.     int x = 10;
  2266.     a() { cout << "create object " << this << endl; }//конструктор по умолчанию
  2267.  
  2268.     void show() { cout << "\nobject - " << this << "\tx = " << x <<"\n\n"; }//вывести значение x на экран.
  2269.  
  2270.     ~a() { cout << "destory object " << this << endl << endl; }//вызов деструктора.
  2271. };
  2272.  
  2273. int create(lua_State* L) {//    Функция создания объекта структуры.
  2274.     a** c = (a**)lua_newuserdata(L, sizeof(a*));/*Эта функция выделяет новый блок памяти с заданным размером,*/
  2275.     *c = new a();
  2276.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  2277.     lua_setmetatable(L, -1); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
  2278.  
  2279. return 1;
  2280. };
  2281.  int show(lua_State* L) {
  2282.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  2283.  
  2284.     a** st = (a**)lua_touserdata(L, -2);// получаем польз. данные.
  2285.     (*st)->show();// вызов метода.
  2286.     a *b = &**st;
  2287.     b->show();// вызов метода.
  2288.     return 0;
  2289. };
  2290.  
  2291. int main() {
  2292.     lua_State* L = luaL_newstate();
  2293.     lua_register(L, "create", create );//уст указатель на функцию C++ и создает внутри Lua
  2294.     lua_register(L, "show", show); //получает значение из стека и уст значение global name.
  2295.     luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
  2296.     lua_close(L);// закрыть состояние
  2297.     cin.get();//ожидает ввода символа программа завершается.
  2298.     return 0;
  2299. }
  2300.  
  2301.  
  2302.  
  2303.  
  2304.  
  2305.  
  2306.  
  2307.  
  2308.  
  2309.  
  2310.  
  2311. struct a{int x=0;
  2312.   a() : x() { cout <<"create object "<< this << endl; }//конструктор по умолчанию
  2313.  
  2314.     void set(int x){this->x = x;}//уст значение x.
  2315.  
  2316.     void show() {cout << "object - " << this << " x = " << x << endl;}
  2317.     //вывести значение x на экран.
  2318.     ~a() {cout <<"destory object "<< this << endl;  }//вызов деструктора.
  2319. };
  2320.  
  2321. int create(lua_State* L){// Функция создания объекта структуры.
  2322.     void* pointerToAa = lua_newuserdata(L, sizeof(a));/*Эта функция выделяет новый блок памяти с заданным размером,
  2323. помещает в стек новые полные пользовательские данные с адресом блока и возвращает этот адрес. Пользовательские данные
  2324. представляют значения C в Lua. Полный UserData представляет собой блок памяти. Это объект (например, таблица):
  2325. вы должны создать его, у него может быть свой собственный метатабль, и вы можете определить, когда он собирается.
  2326. Полные пользовательские данные равны только себе (при необработанном равенстве). Когда Lua собирает полные данные
  2327. пользователя с gcметаметодом, Lua вызывает метаметод и помечает данные пользователя как завершенные.
  2328. Когда эти пользовательские данные собираются снова, Lua освобождает соответствующую память.*/
  2329.     new (pointerToAa) a();// Выделить память под польз. данные.
  2330.     luaL_getmetatable(L, "aMetaTable"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.
  2331.     Если индекс не является действительным, или если значение не имеет метатаблицы, функция возвращает 0 и не отправляет ничего в стеке.*/
  2332.     lua_assert(lua_istable(L, 2));//ловит исключения если ли условия ложное.
  2333.     lua_setmetatable(L, 1);//получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
  2334.     return 1;
  2335. };
  2336.  
  2337. int destroy(lua_State* L){// Функция вызывает деструктор для объекта.
  2338.     a* st = (a*)lua_touserdata(L, 1);/* Если значение в данном приемлемом индексе является полными данными пользователя,
  2339.     возвращает адрес его блока. Если значение является легким userdata, возвращает его указатель.В противном случае возвращается NULL.*/
  2340.     st->~a();//вызов метода деструктор.
  2341.     return 0;};
  2342.  
  2343. int set(lua_State* L){
  2344.     a* st = (a*)lua_touserdata(L, 1);
  2345.     lua_Number x = lua_tonumber(L, 2);
  2346.     st->set((int)x);
  2347.     return 0;};
  2348.  
  2349. int show(lua_State* L){
  2350.     a* st = (a*)lua_touserdata(L, 1);
  2351.     st->show();
  2352.     return 0;};
  2353.  
  2354. int index(lua_State* L){
  2355.     lua_assert(lua_isuserdata(L, 1));
  2356.     lua_assert(lua_isstring(L, 2));
  2357.  
  2358.     a* st = (a*)lua_touserdata(L, 1);
  2359.     const char* index = lua_tostring(L, 2);
  2360.     if (strcmp(index, "x") == 0){
  2361.         lua_pushnumber(L, st->x);
  2362.         return 1;   }
  2363.     else{lua_getglobal(L, "a");
  2364.         lua_pushstring(L, index);
  2365.         lua_rawget(L, 3);// Аналогично lua_settable, но делает необработанное назначение(т.Е.Без метаметодов).
  2366.         return 1;   }
  2367. };
  2368.  
  2369. int newindex(lua_State* L){
  2370.     lua_assert(lua_isuserdata(L, -3));
  2371.     lua_assert(lua_isstring(L, -2));//
  2372.     a* st = (a*)lua_touserdata(L, -3);
  2373.     const char* index = lua_tostring(L, -2);
  2374.     if (strcmp(index, "x") == 0){
  2375.         st->x = (int)lua_tonumber(L, -1);   }
  2376.     else{lua_assert(false); }
  2377.     return 0;
  2378. };
  2379.  
  2380. int main() {
  2381.     lua_State* L = luaL_newstate();
  2382.     lua_newtable(L);
  2383.     int stTableIdx = lua_gettop(L);
  2384.     lua_pushvalue(L, stTableIdx);// отправляет копию элемента с заданным допустимым индексом в стек.
  2385.     lua_setglobal(L, "a");// Установить значение глобальной переменной.
  2386.  
  2387.     lua_pushcfunction(L, create);/* отправляет функцию C в стек. функция получает указатель на функцию C и отправляет в стек
  2388.      значение типа Lua, function которое при вызове вызывает соответствующую функцию C.   Любая функция, которая должна быть
  2389.      зарегистрирована в Lua, должна следовать правильному протоколу, чтобы получать свои параметры и возвращать свои результаты*/
  2390.     lua_setfield(L, 1, "new");/*(lua_State * L, int index, const char * k); Соответствует ли t[k] = v, где t значение данного
  2391.     заданного допустимого индекса и vзначение в верхней части стека. Эта функция извлекает значение из стека. Как и в Lua,
  2392.     эта функция может запускать метаметод для события «newindex» (см. §2.8 ). уст ключ для new.   */
  2393.     lua_pushcfunction(L, set);
  2394.     lua_setfield(L, 1, "set");
  2395.     lua_pushcfunction(L, show);
  2396.     lua_setfield(L, 1, "show");
  2397.  
  2398.     luaL_newmetatable(L, "aMetaTable");/*int luaL_newmetatable (lua_State * L, const char * t); Если в реестре уже есть ключ t,
  2399.      возвращает 0. В противном случае создает новую таблицу, которая будет использоваться в качестве метатаблицы
  2400.      для пользовательских данных, добавляет ее в реестр с ключом tnameи возвращает 1. В обоих случаях помещает в стек
  2401.      окончательное значение, связанное с t реестром.*/
  2402.     lua_pushstring(L, "__gc");
  2403.     lua_pushcfunction(L, destroy);
  2404.     lua_settable(L, 2);
  2405.  
  2406.     lua_pushstring(L, "__index");
  2407.     lua_pushcfunction(L, index);
  2408.     lua_settable(L, 2);
  2409.  
  2410.     lua_pushstring(L, "__newindex");
  2411.     lua_pushcfunction(L, newindex);
  2412.     lua_settable(L, 2);
  2413.  
  2414.     int x = luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
  2415.  
  2416.     if (x == LUA_OK) {  lua_close(L);// если поллучилось открыть файл.
  2417.         cin.get();}//ожидает ввода символа программа завершается.
  2418.    
  2419.     else {  cout << "Error: "<<lua_tostring(L, -1)<<endl;
  2420.         lua_close(L);// закрыть состояние
  2421.         cin.get();//ожидает ввода символа программа завершается.
  2422.         return 0;   }
  2423. }
  2424. Lua
  2425. st = a.new()
  2426. --st:show()
  2427. st:set(100)
  2428. st:show()
  2429. st1 = a.new()
  2430. st1:set(200)   
  2431. st1:show()
  2432.  
  2433.  
  2434.  
  2435.  
  2436.  
  2437.  
  2438. struct ArenaAllocator
  2439. {
  2440.     void* m_begin;
  2441.     void* m_end;
  2442.     char* m_curr;
  2443.  
  2444.  
  2445.     ArenaAllocator(void* begin, void* end) :
  2446.         m_begin(begin),
  2447.         m_end(end),
  2448.         m_curr(static_cast<char*>(m_begin) )
  2449.     {
  2450.     }
  2451.  
  2452.     void* Allocate(size_t sizeBytes)
  2453.     {
  2454.         assert(m_curr + sizeBytes < m_end);
  2455.         printf("-- allocated from the freelist --\n");
  2456.         void* ptr = m_curr;
  2457.         m_curr += sizeBytes;
  2458.         return ptr;
  2459.     }
  2460.  
  2461.     void DeAllocate(void* ptr, size_t osize)
  2462.     {
  2463.         assert(ptr != nullptr);     //can't decallocate null!!!
  2464.         printf("DeAllocated %d bytes\n", (int)osize);
  2465.     }
  2466.  
  2467.     void* ReAllocate(void* ptr, size_t osize, size_t nsize)
  2468.     {
  2469.         printf("ReAllocated %d bytes\n", (int)nsize);
  2470.         void* newPtr = Allocate(nsize);
  2471.         memcpy(newPtr, ptr, osize);
  2472.         DeAllocate(ptr, osize);
  2473.         return newPtr;
  2474.     }
  2475.  
  2476.     static void *l_alloc(void *ud, void *ptr, size_t osize, size_t nsize) {
  2477.         ArenaAllocator * pool = static_cast<ArenaAllocator *>(ud);
  2478.         if (nsize == 0)
  2479.         {
  2480.             if (ptr != nullptr)
  2481.             {
  2482.                 pool->DeAllocate(ptr, osize);
  2483.             }
  2484.             return NULL;
  2485.         }
  2486.         else
  2487.         {
  2488.             if (ptr == nullptr)
  2489.             {
  2490.                 return pool->Allocate(nsize);
  2491.             }
  2492.             else
  2493.             {
  2494.                 return pool->ReAllocate(ptr, osize, nsize);
  2495.             }
  2496.         }
  2497.     }
  2498. };
  2499. int main() {
  2500.     constexpr int pool_size = 1024 * 10;
  2501.     char memory[pool_size];
  2502.     ArenaAllocator pool(memory, &memory[pool_size-1]);
  2503.  
  2504.     lua_State *L = lua_newstate(ArenaAllocator::l_alloc, &pool);
  2505.     //luaL_openlibs(L);
  2506.     assert(L != nullptr);
  2507.     lua_close(L);
  2508.     //cin.get();//ожидает ввода символа программа завершается.  
  2509.     return 0;
  2510. }
  2511.  
  2512.  
  2513. Нативнный код, позволяет писать lua скрипт в cpp файле, мы можем вносит в него изменения не переключаясь на lua файл, однако изменения, требуют собрать проект заново.
  2514.  
  2515. Определение типа переменной и вывод ее на экран.
  2516.  
  2517. void showstack(lua_State* L) {
  2518.     int i = lua_gettop(L);/* получаем количество элементов в стеке.*/
  2519.     cout << "\n  the number on the stack = " << i << "\n\n\n";
  2520.     int j = (i) * -1-1;
  2521.     i = -1;
  2522.     for (i; i > j; i--) {
  2523.         int t = lua_type(L, i);
  2524.         cout << "\t " << i << "  " << (j - i) * -1 << "\t";
  2525.         if (LUA_TSTRING == t) {
  2526.             cout << lua_tostring(L, i) << endl;
  2527.         }
  2528.         if (LUA_TNUMBER == t) {
  2529.             double x = lua_tonumber(L, i);
  2530.             int x2 = (int)x;
  2531.             if (x == x2) { cout << x2 << endl; }
  2532.             else { cout << x << endl; }
  2533.         }
  2534.         if (LUA_TBOOLEAN == t) {
  2535.             cout << lua_toboolean(L, i) << endl;
  2536.         }
  2537.         if (LUA_TLIGHTUSERDATA == t) {
  2538.             cout << "LIGHTUSERDATA " << endl;
  2539.         }
  2540.         if (LUA_TTABLE == t) {
  2541.             cout << "LUA_TTABLE " << endl;
  2542.         }
  2543.         if (LUA_TFUNCTION == t) {
  2544.             cout << "LUA_TFUNCTION " << endl;
  2545.         }
  2546.         if (LUA_TUSERDATA == t) {
  2547.             cout << "LUA_TUSERDATA " << endl;
  2548.         }
  2549.         if (LUA_TNIL == t) {
  2550.             cout << "LUA_TNIL " << endl;
  2551.         }
  2552.     }
  2553. };
  2554.  
  2555. void getlaststack(lua_State* L) {// показать последний элемент стека.
  2556.  
  2557.     if (LUA_TSTRING == lua_type(L, -1)) {
  2558.         cout << "string " << lua_tostring(L, -1);
  2559.     }
  2560.     if (LUA_TNUMBER == lua_type(L, -1)) {
  2561.         double x = lua_tonumber(L, -1);
  2562.         int x2 = (int)x;
  2563.         if (x == x2) { cout << "int " << x2; }
  2564.         else { cout << "double " << x; }
  2565.     }
  2566.     if (LUA_TBOOLEAN == lua_type(L, -1)) {
  2567.         cout << "bool " << (lua_toboolean(L, -1) ? "true " : "false ");
  2568.     }
  2569.     if (LUA_TNIL == lua_type(L, -1)) {
  2570.         cout << "not /n";
  2571.     }  
  2572.     if (LUA_TTABLE == lua_type(L, -1)) {
  2573.         cout << "LUA_TTABLE "  << endl;
  2574.     }
  2575.     if (LUA_TFUNCTION == lua_type(L, -1)) {
  2576.         cout << "LUA_TFUNCTION " << endl;
  2577.     }
  2578.     if (LUA_TLIGHTUSERDATA == lua_type(L, -1)) {
  2579.         cout << "LIGHTUSERDATA " << endl;
  2580.     }
  2581.     if (LUA_TTABLE == lua_type(L, -1)) {
  2582.         cout << "LUA_TTABLE " << endl;
  2583.     }
  2584.     if (LUA_TFUNCTION == lua_type(L, -1)) {
  2585.         cout << "LUA_TFUNCTION " << endl;
  2586.     }
  2587.     if (LUA_TUSERDATA == lua_type(L, -1)) {
  2588.         cout << "LUA_TUSERDATA " << endl;
  2589.     }
  2590.     if (LUA_TNIL == lua_type(L, -1)) { // если x нет.
  2591.         cout << "nill " << endl;
  2592.     }
  2593.     cout << endl;
  2594. };
  2595.  
  2596. void getvar(lua_State* L, const char* var) {
  2597.     lua_getglobal(L, var);// получить значение глобальной переменной x.
  2598.     if (LUA_TSTRING == lua_type(L, -1)) {
  2599.         cout << "string " << var << " = " << lua_tostring(L, -1);
  2600.     }
  2601.     if (LUA_TNUMBER == lua_type(L, -1)) {
  2602.         double x = lua_tonumber(L, -1);
  2603.         int x2 = (int)x;
  2604.         if (x == x2) { cout << "number int " << var << " = " << x2; }
  2605.         else { cout << "number double " << var << " = " << x; }
  2606.     }
  2607.     if (LUA_TBOOLEAN == lua_type(L, -1)) {
  2608.         cout << "bool " << var << " = " << (lua_toboolean(L, -1) ? "true " : "false ");
  2609.     }
  2610.     if (LUA_TTABLE == lua_type(L, -1)) {
  2611.         cout << "LUA_TTABLE " << var << " = " << endl;
  2612.     }
  2613.     if (LUA_TFUNCTION == lua_type(L, -1)) {
  2614.         cout << "LUA_TFUNCTION " << var << " = " << endl;
  2615.     }
  2616.     if (LUA_TNIL == lua_type(L, -1)) { // если x нет.
  2617.         cout << "not " << var;
  2618.     }
  2619.     cout << endl;
  2620. };
  2621.  
  2622. int checkerror(lua_State* L, const char* file) {
  2623.     int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
  2624.     try {
  2625.         if (luaL_dostring(L, file) == LUA_OK) {
  2626.             return 0;
  2627.         }
  2628.         else {
  2629.             string x = lua_tostring(L, -1);
  2630.             throw x;
  2631.             return 0;
  2632.         }
  2633.     }
  2634.     catch (string x) {
  2635.         cout << x << endl;
  2636.         //luaL_error(L,"error");
  2637.         return 0;
  2638.     }
  2639. };
  2640.  
  2641. template <class T>//любое значение отправить в стек.
  2642. void pushlua(lua_State * L, const T & value) {
  2643.     if constexpr (std::is_same_v<T, std::string>)
  2644.         lua_pushstring(L, value.c_str());
  2645.     else if constexpr (std::is_array_v<T> && std::is_same_v<std::remove_extent_t<T>, char>)
  2646.         lua_pushstring(L, value);
  2647.     else if constexpr (std::is_same_v<T, int>)
  2648.         lua_pushinteger(L, value);
  2649.     else if constexpr (std::is_same_v<T, double>)
  2650.         lua_pushnumber(L, value);
  2651.     else if constexpr (std::is_same_v<T, bool>)
  2652.         lua_pushboolean(L, value);
  2653.     else
  2654.         std::cerr << "I do not know what to do :(" << std::endl;
  2655. };
  2656. template <class t1, class t2>
  2657. void addkeyintab(lua_State* L, t1 key, t2 value) {
  2658.     /* Устанавливает реальное значение t[i] = value  как value, без вызова метаметода. t это таблица, i - любым числом, отличным от nil и NaN,
  2659.     а value - значение. Данная функция возвращает table. */
  2660.     if (std::is_same_v<t1, const char*> && std::is_same_v<t2, int>) {
  2661.         cout << "key string " << key << " int " << value << endl;
  2662.         const char* key1 = (const char*)key;
  2663.         int value1 = (int)value;
  2664.         lua_pushstring(L, key1); /* отправить ключ в стек */
  2665.         lua_pushinteger(L, value1); /* отправить значение ключа в стек. */
  2666.         lua_rawset(L, -3);  } /*Сохраняет пару в таблице */
  2667.  
  2668.     else if (std::is_same_v<t1, int> && std::is_same_v<t2, const char*>) {
  2669.         cout << "key int " << key << " string " << value << endl;
  2670.         int key1 = (int)key;
  2671.         const char* value1 = (const char*)value;
  2672.         lua_pushinteger(L, key1); /* отправить ключ в стек */
  2673.         lua_pushstring(L, value1); /* отправить значение ключа в стек. */
  2674.         lua_rawset(L, -3);  } /*Сохраняет пару в таблице */
  2675.  
  2676.     else if (std::is_same_v<t1, const char*> && std::is_same_v<t2, const char*>) {
  2677.         cout << "key string " << key << " value string " << value << endl;
  2678.         const char* key1 = (const char*)key;
  2679.         const char* value1 = (const char*)value;
  2680.         lua_pushstring(L, key1); /* отправить ключ в стек */
  2681.         lua_pushstring(L, value1); /* отправить значение ключа в стек. */
  2682.         lua_rawset(L, -3);} /*Сохраняет пару в таблице */
  2683.  
  2684.     else if (std::is_same_v<t1, int> && std::is_same_v<t2, int>) {
  2685.         cout << "key int " << key << " value int " << value << endl;
  2686.         int key1 = (int)key;
  2687.         int value1 = (int)value;
  2688.         lua_pushinteger(L, key1); /* отправить ключ в стек */
  2689.         lua_pushinteger(L, value1); /* отправить значение ключа в стек. */
  2690.         lua_rawset(L, -3); /*Сохраняет пару в таблице */
  2691.     }
  2692. };
  2693.  
  2694. int main(int argc, char *argv[]) {
  2695.     const char* LUA = R"(
  2696. x = true
  2697. )";
  2698.     lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  2699.     luaL_openlibs(L);
  2700.     checkerror(L, LUA);//Функция проверка на ошибки.
  2701.     getvar(L, "x");
  2702.  
  2703.     lua_close(L);
  2704.  
  2705.     return 0;
  2706.  
  2707. Присвоение значений переменной через отправку в стек.
  2708.  
  2709.  
  2710. int main(int argc, char *argv[]) {
  2711.     const char* LUA = R"(
  2712. print(c)
  2713.  
  2714. )";
  2715.     lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  2716.     luaL_openlibs(L);
  2717.     pushlua(L, 12);
  2718.     lua_setglobal(L, "c");// уст значение переменной в lua.
  2719.     checkerror(L, LUA);//Функция проверка на ошибки.
  2720.  
  2721.     lua_close(L);
  2722.  
  2723.     return 0;
  2724. }
  2725.  
  2726.  
  2727. Вызов функции в нативном коде через получение переменной.
  2728.  
  2729. int main(int argc, char *argv[]) {
  2730. const char* LUA = R"(
  2731.  function foo()
  2732.   return 4
  2733.  end )";
  2734.     lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  2735.     luaL_openlibs(L);  
  2736.     checkerror(L, LUA);//Функция проверка на ошибки.
  2737.     lua_getglobal(L, "foo");
  2738.    
  2739.     if (lua_isfunction(L, -1)) {
  2740.         lua_pcall(L, 0, 1, 0);
  2741.         cout << lua_tonumber(L, -1) << endl;    }
  2742.     lua_close(L);
  2743.     return 0;
  2744. }
  2745.  
  2746. Вызов функции в нативном коде через присвоение.
  2747.  
  2748. int foo(lua_State *L) {
  2749.     cout << "hi foo c++" << endl;
  2750.     return 0;
  2751. }
  2752.  
  2753. int main(int argc, char *argv[]) {
  2754.     const char* LUA = R"(
  2755. foo()
  2756.  
  2757. )";
  2758.     lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  2759.     luaL_openlibs(L);
  2760.     lua_pushcfunction(L, foo);// отправить c функцию в стек.
  2761.  
  2762.     lua_setglobal(L, "foo");// уст для переменной значение в виде функции.
  2763.  
  2764.     checkerror(L, LUA);//Функция проверка на ошибки.
  2765.  
  2766.     lua_close(L);
  2767.  
  2768.     return 0;
  2769. };
  2770.  
  2771. Вызов функции в нативном коде через отправку в таблицу.
  2772.  
  2773. int foo(lua_State *L) {
  2774.     cout << "hi foo c++" << endl;
  2775.     return 0;
  2776. }
  2777.  
  2778. int main(int argc, char *argv[]) {
  2779.     const char* LUA = R"(
  2780. foo()
  2781. )";
  2782.     lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  2783.     luaL_openlibs(L);
  2784.  
  2785.     lua_newtable(L); /*создать пустую таблицу */
  2786.     lua_pushcfunction(L, foo);// отправить c функцию в стек как ключ.
  2787.     lua_setglobal(L, "foo");// уст для переменой(ключ) значение в новой пустой таблицы в виде функции.
  2788.  
  2789.     checkerror(L, LUA);//Функция проверка на ошибки.
  2790.  
  2791.     lua_close(L);
  2792.  
  2793.     return 0;
  2794. };
  2795.  
  2796.  
  2797. Вызов функции с параметром в нативном коде через отправку в таблицу.
  2798.  
  2799. int foo(lua_State *L) {
  2800.     int x = lua_tointeger(L, -1);
  2801.     pushlua(L, x * 2);
  2802.  
  2803. return 1;
  2804. }
  2805.  
  2806. int main(int argc, char *argv[]) {
  2807.     const char* LUA = R"(
  2808. g=foo(12)
  2809. print(g)
  2810. )";
  2811.     lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  2812.     luaL_openlibs(L);
  2813.  
  2814.     lua_newtable(L); /*создать пустую таблицу */
  2815.     lua_pushcfunction(L, foo);// отправить c функцию в стек.
  2816.     lua_setglobal(L, "foo");// уст для переменой(ключ) значение в новой пустой таблицы в виде функции.
  2817.  
  2818.     checkerror(L, LUA);//Функция проверка на ошибки.
  2819.  
  2820.     lua_close(L);
  2821.  
  2822.     return 0;
  2823. };
  2824.  
  2825. Таблица в стеке.
  2826.  
  2827. int main(int argc, char *argv[]) {
  2828.     lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  2829.     luaL_openlibs(L);
  2830.     lua_newtable(L);
  2831.     lua_pushstring(L, "key");
  2832.     lua_pushnumber(L, 100);
  2833.     lua_rawset(L,-3);
  2834.  
  2835.     lua_pushstring(L, "key");
  2836.     lua_gettable(L, -2);
  2837.    cout << lua_tonumber(L,-1) << endl; //Функция 100.
  2838.  
  2839.     lua_close(L);
  2840.  
  2841.     return 0;
  2842. };
  2843.  
  2844. Вариант 2.
  2845.  
  2846. int main(int argc, char* argv[]) {
  2847.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  2848.     luaL_openlibs(L);
  2849.     lua_newtable(L);
  2850.     lua_pushnumber(L, 100);
  2851.     lua_setfield(L, -2, "key");// уст в таблицу ключ - key со значение 100.
  2852.  
  2853.     pushlua(L, "key");
  2854.     lua_gettable(L, -2);
  2855.     getlaststack(L); //Функция 100.
  2856.  
  2857.     lua_close(L);
  2858.  
  2859.     return 0;
  2860. };
  2861.  
  2862. Добавление следующего ключа со значением в таблицу.
  2863.  
  2864. int main(int argc, char* argv[]) {
  2865.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  2866.     luaL_openlibs(L);
  2867.     lua_newtable(L);
  2868.  
  2869.     pushlua(L, "key");
  2870.     pushlua(L, 100);
  2871.     lua_rawset(L, -3);// table["key"] = 100.
  2872.    
  2873.     pushlua(L, "a");
  2874.     pushlua(L, 6);
  2875.     lua_rawset(L, -3);// table["a"] = 6.
  2876.  
  2877.  
  2878.     pushlua(L, "a");
  2879.     lua_gettable(L, -2);
  2880.     getlaststack(L); // 6.
  2881.  
  2882.     lua_close(L);
  2883.  
  2884.     return 0;
  2885. };
  2886.  
  2887.  
  2888. Функция добавление в таблицу нового ключа со значением.
  2889.  
  2890. template <class t1, class t2>
  2891. void addkeyintab(lua_State* L, t1 key, t2 value) {
  2892.     /* Устанавливает реальное значение t[i] = value  как value, без вызова метаметода. t это таблица, i - любым числом, отличным от nil и NaN,
  2893.     а value - значение. Данная функция возвращает table. */
  2894.     if (std::is_same_v<t1, const char*> && std::is_same_v<t2, int>) {
  2895.         cout << "key string " << key << " value int " << value << endl;
  2896.         const char* key1 = (const char*)key;
  2897.         int value1 = (int)value;
  2898.         lua_pushstring(L, key1); /* отправить ключ в стек */
  2899.         lua_pushinteger(L, value1); /* отправить значение ключа в стек. */
  2900.         lua_rawset(L, -3);  } /*Сохраняет пару в таблице */
  2901.  
  2902.     else if (std::is_same_v<t1, int> && std::is_same_v<t2, const char*>) {
  2903.         cout << "key int " << key << " value string " << value << endl;
  2904.         int key1 = (int)key;
  2905.         const char* value1 = (const char*)value;
  2906.         lua_pushinteger(L, key1); /* отправить ключ в стек */
  2907.         lua_pushstring(L, value1); /* отправить значение ключа в стек. */
  2908.         lua_rawset(L, -3);  } /*Сохраняет пару в таблице */
  2909.  
  2910.     else if (std::is_same_v<t1, const char*> && std::is_same_v<t2, const char*>) {
  2911.         cout << "key string " << key << " value string " << value << endl;
  2912.         const char* key1 = (const char*)key;
  2913.         const char* value1 = (const char*)value;
  2914.         lua_pushstring(L, key1); /* отправить ключ в стек */
  2915.         lua_pushstring(L, value1); /* отправить значение ключа в стек. */
  2916.         lua_rawset(L, -3);} /*Сохраняет пару в таблице */
  2917.  
  2918.     else if (std::is_same_v<t1, int> && std::is_same_v<t2, int>) {
  2919.         cout << "key int " << key << " value int " << value << endl;
  2920.         int key1 = (int)key;
  2921.         int value1 = (int)value;
  2922.         lua_pushinteger(L, key1); /* отправить ключ в стек */
  2923.         lua_pushinteger(L, value1); /* отправить значение ключа в стек. */
  2924.         lua_rawset(L, -3); /*Сохраняет пару в таблице */
  2925.     }
  2926. };
  2927. int main(int argc, char *argv[]) {
  2928. const char* LUA = R"(
  2929. print(foo)
  2930. for k,v in pairs(foo) do
  2931. print(k.." "..v)
  2932. end
  2933.  
  2934. )";
  2935.     lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  2936.     luaL_openlibs(L);
  2937.  
  2938.     lua_newtable(L); /*создать пустую таблицу */
  2939.     addkeyintab(L, "a", " 10 z "); /*добавить ключ и значение в таблицу */
  2940.     addkeyintab(L, "x1", 99); /*добавить ключ и значение в таблицу */
  2941.     addkeyintab(L, 100, 10); /*добавить ключ и значение в таблицу */
  2942.     addkeyintab(L, 100, "y"); /*добавить ключ и значение в таблицу */
  2943.     lua_setglobal(L, "foo");// уст имя таблицы в lua.
  2944.     cout << "\n" << endl;
  2945.     checkerror(L, LUA);//Функция проверка на ошибки.
  2946.  
  2947.     lua_close(L);
  2948.     return 0;
  2949. };
  2950.  
  2951. Выводится.
  2952. key string a value string  10 z
  2953. key string x1 int 99
  2954. key int 100 value int 10
  2955. key int 100 string y
  2956.  
  2957.  
  2958. table: 009F0830
  2959. 100 y
  2960. x1 99
  2961. a  10 z
  2962.  
  2963. C:\Users\e\source\repos\Project1luaapi\Debug\Project1luaapi.exe (процесс 6000) завершает работу с кодом 0.
  2964. Чтобы закрыть это окно, нажмите любую клавишу…
  2965.  
  2966.  
  2967.  
  2968. Функция возвращает таблицу с ключами в качестве функциями.
  2969.  
  2970. int square(lua_State* L) {//    Функция создания объекта структуры.
  2971.     cout << lua_tonumber(L,-1)*2 << endl;
  2972.     return 0;
  2973. };
  2974. int cube(lua_State* L) {//  Функция создания объекта структуры.
  2975.     cout << lua_tonumber(L, -1) * 3 << endl;
  2976.     return 0;
  2977. };
  2978.  
  2979.  
  2980. int create(lua_State* L) {//    Функция создания объекта структуры.
  2981.     lua_newtable(L);
  2982.     lua_pushcfunction(L, square);  
  2983.     lua_setfield(L, -2, "square");
  2984.     lua_pushcfunction(L, cube);
  2985.     lua_setfield(L, -2, "cube");
  2986.     return 1;
  2987. };
  2988.  
  2989. int main(int argc, char* argv[]) {
  2990. const char* LUA = R"(
  2991.  
  2992. a = create()
  2993. a.square(5) --10
  2994. a.square(10)--20
  2995. a.cube(4)--12
  2996. a.cube(6)--18
  2997. print(a)
  2998. )";
  2999.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3000.     luaL_openlibs(L);
  3001.    
  3002.     lua_pushcfunction(L, create);/* отправляет функцию C в стек. функция получает указатель на функцию C и отправляет в стек*/
  3003.     lua_setglobal(L, "create");
  3004.  
  3005.     checkerror(L, LUA);//Функция проверка на ошибки.
  3006.  
  3007.     lua_close(L);
  3008.  
  3009.     return 0;
  3010. };
  3011.  
  3012. Вывод всех ключей и значений в таблице.
  3013.  
  3014. int pri(lua_State* L, const char t[]) {
  3015.     lua_getglobal(L, t);// получить значение глобальной переменной, таблица.
  3016.     lua_pushvalue(L, -1);
  3017.     lua_pushnil(L);
  3018.     while (lua_next(L, -2)) {
  3019.         lua_pushvalue(L, -2);
  3020.         cout << "key "; getstack(L, -2); cout << " value "; getstack(L, -1); cout << endl;
  3021.         lua_pop(L, 2);
  3022.     }
  3023.     lua_pop(L, 1);
  3024.     return 0;
  3025. };
  3026. int main() {
  3027. const char* LUA = R"(
  3028. t= {x=10, y=20, z=30}
  3029. )";
  3030.  
  3031.     lua_State* L = luaL_newstate();
  3032.     luaL_openlibs(L);
  3033.    
  3034.     checkerror(L, LUA);//Функция проверка на ошибки.
  3035.     pri(L, "t");// вывести ключи и значения таблицы.  
  3036.  
  3037.     lua_close(L);// закрыть состояние
  3038.     return 0;
  3039. };
  3040.  
  3041.  
  3042.  
  3043. Модуль с. Писать модули для lua на c++.
  3044.  
  3045. int q(lua_State* L) {
  3046.     int d = lua_tonumber(L, -1);
  3047.     pushlua(L, d * 2);
  3048.     return 1; /*число умножено на 2*/
  3049. }
  3050. int foo(lua_State * L) {
  3051.     int d = lua_tonumber(L, -1);
  3052.     pushlua(L, d * 3);
  3053.     return 1; /*число умножено на 3*/
  3054. }
  3055.  struct luaL_Reg mylib[] = {
  3056.     { "q", q },{ "foo", foo }, { NULL, NULL } /*регистрация функций, на вершину отправим NULL NULL*/
  3057. };
  3058.  
  3059. int lua_lib(lua_State * L) {
  3060.     luaL_newlib(L, mylib);/*void luaL_newlib (lua_State * L, const luaL_Reg lib []); Создает новую таблицу и
  3061.       регистрирует там свои функции в списке lib. Это реализовано в виде следующего макроса:
  3062.   (luaL_newlibtable (L, lib), luaL_setfuncs (L, l, 0))
  3063.   Массив lib должен быть фактическим массивом, а не указателем на него.*/
  3064.   return 1;
  3065. }
  3066.  
  3067. int main(int argc, char* argv[]) {
  3068.     const char* LUA = R"(
  3069. mylib = require 'mylib'
  3070. print(mylib.q(2))
  3071. print(mylib.foo(2)) )";
  3072.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3073.     luaL_openlibs(L);
  3074.  
  3075.     luaL_requiref(L, "mylib", lua_lib, 1);/* модуль. void luaL_requiref (lua_State * L, const char * modname,
  3076.  lua_CFunction cfunc, int glb); Если modname еще нет, package.loaded, вызывает функцию cfunc со строкой modname
  3077.  в качестве аргумента и устанавливает результат вызова package.loaded[modname], как если бы эта функция была вызвана
  3078.  require. Если glb это правда, также сохраняет модуль в глобальном modname. Оставляет копию модуля в стеке.*/
  3079.     checkerror(L, LUA);//Функция проверка на ошибки.
  3080.  
  3081.     return 0;
  3082. };
  3083.  
  3084.  
  3085. Реестр глобальная таблица.
  3086.  
  3087.  
  3088. int main(int argc, char* argv[]) {
  3089.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3090.     luaL_openlibs(L);
  3091.    
  3092.     pushlua(L, 9);//отправить значение для ключа 12.  
  3093.     lua_rawseti(L, LUA_REGISTRYINDEX, 12);// отправить ключ в реестре. установить ключ со значение в реестр.
  3094.  
  3095.     lua_rawgeti(L, LUA_REGISTRYINDEX, 12);/* вернуть значение для ключа в реестр. */
  3096.     getlaststack(L);// 9
  3097.  
  3098.     lua_close(L);
  3099.  
  3100.     return 0;
  3101. };
  3102.  
  3103.  
  3104. Реестр передача значение между функциями.
  3105.  
  3106. int show(lua_State* L) {
  3107.     lua_rawgeti(L, LUA_REGISTRYINDEX, 12);/* вернуть значение для ключа в реестр. */
  3108.     getlaststack(L);// 100
  3109.     return 0;
  3110. };
  3111. int create(lua_State * L) {//   Функция создания объекта структуры.
  3112.     pushlua(L, 100);//отправить значение для ключа 12.
  3113.     lua_rawseti(L, LUA_REGISTRYINDEX, 12);// отправить ключ в реестре. установить ключ со значение в реестр.
  3114.     return 0;
  3115. };
  3116.  
  3117. int main(int argc, char* argv[]) {
  3118.     const char* LUA = R"(
  3119. create()
  3120. show()
  3121. )";
  3122.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3123.     luaL_openlibs(L);
  3124.  
  3125.     lua_newtable(L);
  3126.     lua_pushcfunction(L, create);
  3127.     lua_setglobal(L, "create");// уст глоб имя в таблице как С функцию.
  3128.  
  3129.     lua_pushcfunction(L, show);
  3130.     lua_setglobal(L, "show");
  3131.  
  3132.     checkerror(L, LUA);//Функция проверка на ошибки.
  3133.  
  3134.     lua_close(L);
  3135.  
  3136.     return 0;
  3137. };
  3138.  
  3139.  
  3140. Реестр, отправка и получение значение по уникальному ключу. В качестве ключей ссылка на псевдоиндекс.
  3141.  
  3142.  
  3143. int main(int argc, char* argv[]) {
  3144.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3145.     luaL_openlibs(L);
  3146.    
  3147.     int ref = luaL_ref(L, LUA_REGISTRYINDEX); /*Возвращает ссылку - это уникальный целочисленный ключ. Для значения в реестре*/
  3148.  
  3149.     pushlua(L, 9);//отправить значение для ключа ref. 
  3150.     lua_rawseti(L, LUA_REGISTRYINDEX, ref);// установить ключ со значение в реестр.
  3151.  
  3152.     pushlua(L, ref);
  3153.     lua_rawgeti(L, LUA_REGISTRYINDEX, ref);/* вернуть значение для ключа в реестр. */
  3154.     getlaststack(L);// 9
  3155.  
  3156.     lua_close(L);
  3157.  
  3158.     return 0;
  3159. };
  3160.  
  3161.  
  3162.  
  3163. Работа в реестр. Отправка значение переменной в реестр, получение из него.
  3164.  
  3165. int main(int argc, char* argv[]) {
  3166.     const char* LUA = R"(
  3167. x=4
  3168. )";
  3169.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3170.     luaL_openlibs(L);
  3171.     checkerror(L, LUA);//Функция проверка на ошибки.
  3172.     lua_getglobal(L, "x");
  3173.     int ref = luaL_ref(L, LUA_REGISTRYINDEX); /*Создает и возвращает ссылку в таблице в индексе t для объекта на вершине стека(и извлекает объект).
  3174.     Ссылка - это уникальный целочисленный ключ. Пока вы не добавляете вручную целочисленные ключи в таблицу t, вы luaL_ref гарантируете уникальность возвращаемого ключа. Вы можете получить объект, на который ссылается ссылка r, вызывая lua_rawgeti(L, t, r).
  3175. Функция luaL_unref освобождает ссылку и связанный с ней объект.
  3176.     Если объект на вершине стека равен нулю, luaL_ref возвращает константу LUA_REFNIL. Константа LUA_NOREF
  3177. гарантированно будет отличаться от любой ссылки, возвращаемой luaL_ref.*/
  3178.  
  3179.  
  3180.     lua_rawgeti(L, LUA_REGISTRYINDEX, ref);
  3181.     cout <<"x = "<< lua_tonumber(L, -1) << endl;
  3182.     lua_rawseti(L, LUA_REGISTRYINDEX, ref);/*
  3183.     Функции, которые API предоставляет для работы с массивами:
  3184.  
  3185.     void lua_rawgeti (lua_State * L, int index, int key);
  3186.     void lua_rawseti (lua_State * L, int index, int key); Описание lua_rawgeti и lua_rawseti немного сбивает с толку,
  3187.     поскольку включает в себя два индекса:
  3188.     index указывает, где таблица находится в стеке;
  3189.     key относится к тому, где элемент находится в таблице.
  3190.     Вызов lua_rawgeti(L, t, key) эквивалентен последовательности lua_pushnumber (L, ключ); lua_rawget (L, t);
  3191.  
  3192.     когда t положительно (в противном случае вы должны компенсировать новый элемент в стеке).
  3193.     Вызов lua_rawseti(L, t, key)(опять же для t положительного) эквивалентен
  3194.     lua_pushnumber (L, ключ);
  3195.     lua_insert (L, -2); // поставить `ключ 'ниже предыдущего значения
  3196.     lua_rawset (L, t); Обратите внимание, что обе функции используют необработанные операции.
  3197.     Они быстрее и, в любом случае, таблицы, используемые в качестве массивов, редко используют метаметоды.
  3198.      В качестве конкретного примера использования этих функций мы могли бы переписать тело цикла
  3199.      из нашей предыдущей l_dirфункции из
  3200.  
  3201.         lua_pushnumber (L, i ++); // ключ  /
  3202.         lua_pushstring (L, entry-> d_name); / значение /
  3203.     lua_settable(L, -3);
  3204.                                            */
  3205.     luaL_unref(L, LUA_REGISTRYINDEX, ref); // удалить значение по ключу ref.
  3206.     cout << lua_tonumber(L, -1) << endl;
  3207.  
  3208.     lua_close(L);
  3209.  
  3210.     return 0;
  3211. };
  3212.  
  3213.  
  3214. Выводится.
  3215.  
  3216. x = 4
  3217. 0
  3218.  
  3219. Вариант 2.
  3220.  
  3221. int main(int argc, char* argv[]) {
  3222.     const char* LUA = R"(
  3223. x=4
  3224. )";
  3225.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3226.     luaL_openlibs(L);
  3227.     checkerror(L, LUA);//Функция проверка на ошибки.
  3228.     int ref = luaL_ref(L, LUA_REGISTRYINDEX); /*Создает и возвращает ссылку в таблице в индексе t для объекта на вершине стека(и извлекает объект).
  3229. .*/
  3230.  
  3231.     lua_getglobal(L, "x");
  3232.  
  3233.     lua_rawseti(L, LUA_REGISTRYINDEX, ref);/* установить в таблице*/
  3234.  
  3235.     lua_rawgeti(L, LUA_REGISTRYINDEX, ref);/* получить значение по ключу */
  3236.     cout << "x = " ;
  3237.     getlaststack(L);
  3238.  
  3239. //  luaL_unref(L, LUA_REGISTRYINDEX, ref); // удалить значение по ключу ref.
  3240.  
  3241.     lua_rawgeti(L, LUA_REGISTRYINDEX, ref);/*              */
  3242.     getlaststack(L);
  3243.  
  3244.     lua_close(L);
  3245.  
  3246.     return 0;
  3247. };
  3248.  
  3249.  
  3250. Уникальность ключа в реестре, обеспечивается адресом в памяти переменной.
  3251. Использовать lua_settable и lua_gettable.
  3252.  
  3253. int main(int argc, char* argv[]) {
  3254.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3255.     luaL_openlibs(L);
  3256.     static char Key = 'k';// лучше стастик переменная.
  3257.  
  3258.     lua_pushlightuserdata(L, &Key);  /* отправить адрес памяти переменной в стек */
  3259.     lua_pushstring(L, &Key);  /* отправить значение в стек */
  3260.     lua_settable(L, LUA_REGISTRYINDEX);  /* уст ключа и значение таблице реестре.  */
  3261.  
  3262.     lua_pushlightuserdata(L, &Key);  /*отправить адрес, который является ключом в стек. */
  3263.     lua_gettable(L, LUA_REGISTRYINDEX);  /* получить таблицу и значение ключа будет в -1 */
  3264.     cout << lua_tostring(L, -1) << endl;// k
  3265.  
  3266.     lua_close(L);
  3267.     return 0;
  3268. };
  3269.  
  3270.  
  3271. Реестр способен хранить польз. данные, ключ может их адрес в пямяти.
  3272.  
  3273. int main(int argc, char* argv[]) {
  3274.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3275.     luaL_openlibs(L);
  3276.  
  3277.     static char Key = 'k';// лучше стастик переменная.
  3278.  
  3279.     lua_pushlightuserdata(L, &Key);  /* отправить адресс в стек */
  3280.     lua_rawsetp(L, LUA_REGISTRYINDEX,  &Key);/* Имеет ли эквивалент t[k] = v, где t таблица,
  3281.  k указатель, представленный в виде легких пользовательских данных, и v значение в верхней части стека.
  3282.  Эта функция извлекает значение из стека. Не вызывает метаметоды.*/
  3283.    
  3284.     lua_pushlightuserdata(L, &Key);  /*отправить адресс, который является ключом в стек. */
  3285.     lua_rawgetp(L, LUA_REGISTRYINDEX, &Key); /* получить таблицу и значение ключа будет в -1 */
  3286.  
  3287.     char* k = (char*)lua_touserdata(L, -1);// получить польз.данные.
  3288.     cout << k <<" adress "<< &k << endl;// k.
  3289.    
  3290.     lua_close(L);
  3291.     return 0;
  3292. };
  3293.  
  3294. int main(int argc, char* argv[]) {
  3295.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3296.     luaL_openlibs(L);
  3297.  
  3298.      int Key = 100;// лучше стастик переменная.
  3299.  
  3300.     lua_pushlightuserdata(L, &Key);  /* отправить адресс в стек */
  3301.     lua_rawsetp(L, LUA_REGISTRYINDEX, &Key);/* Имеет ли эквивалент t[k] = v, где t таблица,
  3302.  k указатель, представленный в виде легких пользовательских данных, и v значение в верхней части стека.
  3303.  Эта функция извлекает значение из стека. Не вызывает метаметоды.*/
  3304.  
  3305.     lua_pushlightuserdata(L, &Key);  /*отправить адресс, который является ключом в стек. */
  3306.     lua_rawgetp(L, LUA_REGISTRYINDEX, &Key); /* получить таблицу и значение ключа будет в -1 */
  3307.  
  3308.     int* k = (int*)lua_touserdata(L, -1);// получить польз.данные.
  3309.     cout << *k << " adress " << &k << endl;// 100.
  3310.  
  3311.     lua_close(L);
  3312.     return 0;
  3313. };
  3314.  
  3315. Реестр адрес переменной k ключ.
  3316.  
  3317. int main(int argc, char* argv[]) {
  3318.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3319.     luaL_openlibs(L);
  3320.     static char k = 'key';// лучше стастик переменная она выступает ключом в реестре.
  3321.  
  3322.     int i = 5;
  3323.     lua_pushlightuserdata(L, &i);  /* отправить адрес памяти числа 5 в стек */
  3324.     lua_rawsetp(L, LUA_REGISTRYINDEX, &k);  /* уст ключ в реестре адрес k.
  3325.  void lua_rawsetp (lua_State * L, int index, const void * p);  Записывает ли эквивалент t[p] = v,
  3326. где t таблица с заданным индексом, p как легкие пользовательские данные и v является значением в верхней части стека.
  3327.  
  3328. Эта функция извлекает значение из стека. Назначение является необработанным,  */
  3329.  
  3330.     lua_pushlightuserdata(L, &i);  /*отправить адрес памяти, который является ключом в стек.*/
  3331.  
  3332.     lua_rawgetp(L, LUA_REGISTRYINDEX, &k);/* получить значение по ключу адрес k*/
  3333.     int* number = (int*)lua_touserdata(L, -1);// получить польз.данные.
  3334.  
  3335.     cout << *number << " adress " << number << endl;// 5.
  3336.  
  3337.  
  3338.     lua_close(L);
  3339.     return 0;
  3340. };
  3341.  
  3342. Реестр. Передача значение из функции в ключ возвращаемой таблицы.
  3343.  
  3344. int show(lua_State* L) {
  3345.     luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
  3346.     lua_pushstring(L, "key");//отправить key, чтобы получить ref
  3347.     lua_gettable(L, -2);
  3348.     int ref = lua_tonumber(L, -1);
  3349.     lua_rawgeti(L, LUA_REGISTRYINDEX, ref);/* получить значение по ключу ref.*/
  3350.  
  3351.     getlaststack(L);
  3352.     return 0;
  3353. };
  3354. int create(lua_State * L) {//   Функция создания объекта структуры.
  3355.     lua_gettable(L, -3);// получить глоб. таблицу.
  3356.     luaL_newmetatable(L, "mt");// создать мета таблицу.
  3357.     lua_pushcfunction(L, show);
  3358.     lua_setfield(L, -2, "show");// ключ таблицы является функцией.  
  3359.     int ref = luaL_ref(L, LUA_REGISTRYINDEX);// получить уникальный ключ.
  3360.     pushlua(L, 5);// значение для ключа. mt.ref = 5.
  3361.     lua_rawseti(L, LUA_REGISTRYINDEX, ref); /* уст ключ со значением 5 в реестре адрес. */
  3362.  
  3363.     lua_setmetatable(L, -2); //уст метатаблицу.
  3364.  
  3365.     lua_gettable(L, -2);// получить таблицу.
  3366.     luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
  3367.  
  3368.     lua_pushstring(L, "key");// это ключ для получение ref.
  3369.     lua_pushnumber(L, ref);
  3370.     lua_rawset(L, -3);
  3371.  
  3372.     luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
  3373.     return 1;
  3374. };
  3375.  
  3376. int main(int argc, char* argv[]) {
  3377.     const char* LUA = R"(
  3378. a = create()
  3379. a.show()
  3380. )";
  3381.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3382.     luaL_openlibs(L);
  3383.  
  3384.     lua_newtable(L);
  3385.     lua_pushcfunction(L, create);
  3386.     lua_setglobal(L, "create");// уст глоб имя в таблице как С функцию.
  3387.  
  3388.  
  3389.     checkerror(L, LUA);//Функция проверка на ошибки.
  3390.  
  3391.     lua_close(L);
  3392.  
  3393.     return 0;
  3394. };
  3395.  
  3396. Реестр. Передача числа из функции в ключ возвращаемой таблицы с помощью мета таблицы.
  3397.  
  3398. int show(lua_State* L) {
  3399.     luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
  3400.     lua_pushstring(L, "key");//отправить key, чтобы получить ref
  3401.     lua_gettable(L, -2);
  3402.     int ref = lua_tonumber(L, -1);
  3403.     lua_rawgeti(L, LUA_REGISTRYINDEX, ref);/* получить значение по ключу ref.*/
  3404.  
  3405.     getlaststack(L);
  3406.     return 0;
  3407. };
  3408. int create(lua_State * L) {//  
  3409.     int k = lua_tointeger(L, -1);
  3410.     lua_gettable(L, -4);// получить глоб. таблицу.
  3411.     luaL_newmetatable(L, "mt");// создать мета таблицу.
  3412.     lua_pushcfunction(L, show);
  3413.     lua_setfield(L, -2, "show");// ключ таблицы является функцией.  
  3414.     int ref = luaL_ref(L, LUA_REGISTRYINDEX);// получить уникальный ключ.
  3415.  
  3416.     pushlua(L, k);// значение для ключа. mt.ref = 5.
  3417.     lua_rawseti(L, LUA_REGISTRYINDEX, ref); /* уст ключ со значением 5 в реестре адрес. */
  3418.  
  3419.     lua_setmetatable(L, -2); //уст метатаблицу.
  3420.  
  3421.     lua_gettable(L, -3);// получить таблицу.
  3422.     luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
  3423.  
  3424.     lua_pushstring(L, "key");// это ключ для получение ref.
  3425.     lua_pushnumber(L, ref);
  3426.     lua_rawset(L, -3);
  3427.  
  3428.     luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
  3429.     return 1;
  3430. };
  3431.  
  3432. int main(int argc, char* argv[]) {
  3433.     const char* LUA = R"(
  3434. a = create(6)
  3435. a.show()
  3436. )";
  3437.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3438.     luaL_openlibs(L);
  3439.  
  3440.     lua_newtable(L);
  3441.     lua_pushcfunction(L, create);
  3442.     lua_setglobal(L, "create");// уст глоб имя в таблице как С функцию.
  3443.  
  3444.  
  3445.     checkerror(L, LUA);//Функция проверка на ошибки.
  3446.  
  3447.     lua_close(L);
  3448.  
  3449.     return 0;
  3450. };
  3451.  
  3452.  
  3453. Реестр хранить мета таблицу с польз.данными.
  3454.  
  3455. int main(int argc, char* argv[]) {
  3456.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3457.     luaL_openlibs(L);
  3458.  
  3459.     luaL_newmetatable(L, "mt");// создать мета таблицу.
  3460.     luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
  3461.  
  3462.     lua_pushstring(L, "key");// это ключ для получение 5.
  3463.  
  3464.     a** c = (a * *)lua_newuserdata(L, sizeof(a*));/*Эта функция выделяет новый блок памяти с заданным размером,*/
  3465.     *c = new a();
  3466.  
  3467.     lua_rawsetp(L, LUA_REGISTRYINDEX, "mt");  /* уст ключ в реестре адрес k.  */
  3468.    
  3469.  
  3470.     lua_pushstring(L, "key");// это ключ для получение объекта.*/
  3471.     lua_rawgetp(L, LUA_REGISTRYINDEX, "mt");/* получить значение по ключу key объект*/
  3472.    
  3473.     a** st = (a** )lua_touserdata(L, -1);// получаем польз. данные.
  3474.     a * b = &**st;
  3475.     b->show();// вызов метода.  
  3476.  
  3477.     b->~a();//вызов метода деструктор.
  3478.  
  3479.     lua_close(L);
  3480.     return 0;
  3481. };
  3482.  
  3483. Реестр и метатаблицы, реализация ооп через таблицу с функциями.
  3484.  
  3485. struct a {  int x = 10;
  3486.     a() { cout << "create object " << this << endl; }//конструктор по умолчанию
  3487.  
  3488.     void show() { cout << "\nobject - " << this << "\tx = " << x << "\n\n"; }//вывести значение x на экран.
  3489.  
  3490.     ~a() { cout << "destory object " << this << endl << endl; }//вызов деструктора.
  3491. };
  3492.  
  3493.  
  3494. int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
  3495.     lua_pushstring(L, "key");// это ключ для получение объекта.*/
  3496.     lua_rawgetp(L, LUA_REGISTRYINDEX, "mt");/* получить значение (объект) по ключу key */
  3497.     a** st = (a * *)lua_touserdata(L, -1);// получаем польз. данные.
  3498.     a * b = &**st;
  3499.     b->~a();//вызов метода деструктор.
  3500.     return 0;
  3501. };
  3502.  
  3503. int show(lua_State * L) {
  3504.     lua_pushstring(L, "key");// это ключ для получение объекта.*/
  3505.     lua_rawgetp(L, LUA_REGISTRYINDEX, "mt");/* получить значение (объект) по ключу key */
  3506.     a** st = (a * *)lua_touserdata(L, -1);// получаем польз. данные.
  3507.     a * b = &**st;
  3508.     b->show();// вызов метода.  
  3509.     return 0;
  3510. };
  3511. int create(lua_State * L) {//   Функция создания объекта структуры.
  3512.     lua_newtable(L);
  3513.     luaL_newmetatable(L, "mt");// создать мета таблицу.
  3514.     lua_pushcfunction(L, destroy);
  3515.     lua_setfield(L, -2, "__gc");
  3516.  
  3517.     lua_pushstring(L, "key");// это ключ для получение объекта.
  3518.  
  3519.     a** c = (a * *)lua_newuserdata(L, sizeof(a*));/*Эта функция выделяет новый блок памяти с заданным размером,*/
  3520.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  3521.     *c = new a();
  3522.     lua_setmetatable(L, -2); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
  3523.  
  3524.     lua_rawsetp(L, LUA_REGISTRYINDEX, "mt");  /* уст ключ в реестре адрес k.  */
  3525.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  3526.     lua_pushcfunction(L, show);
  3527.     lua_setfield(L, -2, "show");
  3528.  
  3529.     return 1;
  3530. };
  3531.  
  3532. int main(int argc, char* argv[]) {
  3533.     const char* LUA = R"(
  3534.  
  3535. a = create()
  3536. a.show()
  3537.  
  3538. )";
  3539.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3540.     luaL_openlibs(L);
  3541.  
  3542.     lua_pushcfunction(L, create);
  3543.     lua_setglobal(L, "create");//уст указатель на функцию C++ и создает внутри Lua
  3544.  
  3545.     checkerror(L, LUA);//Функция проверка на ошибки.
  3546.  
  3547.     lua_close(L);
  3548.  
  3549.     return 0;
  3550. };
  3551.  
  3552.  
  3553.  
  3554.  
  3555.  
  3556. Метатаблица, передача значение между функциями.
  3557.  
  3558.  
  3559. int show(lua_State* L) {
  3560.     luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
  3561.     lua_pushstring(L, "key");//отправить key, чтобы получить ref
  3562.     lua_gettable(L, -2);
  3563.     cout << lua_tonumber(L, -1) << " == 5" << endl;//должно быть 5.
  3564.     return 0;
  3565. };
  3566. int create(lua_State * L) {//   Функция создания объекта структуры.
  3567.     luaL_newmetatable(L, "mt");// создать мета таблицу.
  3568.     luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
  3569.  
  3570.     lua_pushstring(L, "key");// это ключ для получение 5.
  3571.     lua_pushnumber(L, 5);// значение ключа key это 5.
  3572.     lua_settable(L, -3);// установить таблицу.
  3573.     return 1;
  3574. };
  3575.  
  3576. int main(int argc, char* argv[]) {
  3577.     const char* LUA = R"(
  3578. create()
  3579. show()
  3580. )";
  3581.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3582.     luaL_openlibs(L);
  3583.  
  3584.     lua_newtable(L);
  3585.     lua_pushcfunction(L, create);
  3586.     lua_setglobal(L, "create");// уст глоб имя в таблице как С функцию.
  3587.  
  3588.     lua_pushcfunction(L, show);
  3589.     lua_setglobal(L, "show");
  3590.  
  3591.     checkerror(L, LUA);//Функция проверка на ошибки.
  3592.  
  3593.     lua_close(L);
  3594.  
  3595.     return 0;
  3596. };
  3597.  
  3598.  
  3599. Метатаблица, передача польз.данных(объекта структуры) между функциями.
  3600.  
  3601.  
  3602. struct a {
  3603.     int x = 10;
  3604.     a() { cout << "create object " << this << endl; }//конструктор по умолчанию
  3605.  
  3606.     void show() { cout << "\nobject - " << this << "\tx = " << x << "\n\n"; }//вывести значение x на экран.
  3607.  
  3608.     ~a() { cout << "destory object " << this << endl << endl; }//вызов деструктора.
  3609. };
  3610.  
  3611. int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
  3612.     cout << "destroy " << endl;
  3613.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  3614.     a** st = (a * *)lua_touserdata(L, -2); // получаем польз. данные.
  3615.     a * b = &**st;
  3616.     b->~a();//вызов метода деструктор.
  3617.     return 0;
  3618.  
  3619. };
  3620.  
  3621. int show(lua_State* L) {
  3622.     luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
  3623.     lua_pushstring(L, "key");//отправить key, чтобы получить объект.
  3624.     lua_gettable(L, -2);   
  3625.     a** st = (a * *)lua_touserdata(L, -1);// получаем польз. данные.
  3626.     a * b = &**st;
  3627.     b->show();// вызов метода.  
  3628.     b->~a();//вызов метода деструктор.
  3629.  
  3630.     return 0;
  3631. };
  3632. int create(lua_State * L) {//   Функция создания объекта структуры.
  3633.     luaL_newmetatable(L, "mt");// создать мета таблицу.
  3634.     luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
  3635.  
  3636.     lua_pushstring(L, "key");// это ключ для получение 5.
  3637.  
  3638.     a** c = (a **)lua_newuserdata(L, sizeof(a*));/*Эта функция выделяет новый блок памяти с заданным размером,*/
  3639.     *c = new a();
  3640.  
  3641.     lua_settable(L, -3);// установить таблицу.
  3642.     return 1;
  3643. };
  3644.  
  3645. int main(int argc, char* argv[]) {
  3646.     const char* LUA = R"(
  3647. create()
  3648. show()
  3649. )";
  3650.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3651.     luaL_openlibs(L);
  3652.  
  3653.     lua_newtable(L);
  3654.     lua_pushcfunction(L, create);
  3655.     lua_setglobal(L, "create");// уст глоб имя в таблице как С функцию.
  3656.  
  3657.     lua_pushcfunction(L, show);
  3658.     lua_setglobal(L, "show");
  3659.  
  3660.     checkerror(L, LUA);//Функция проверка на ошибки.
  3661.  
  3662.     lua_close(L);
  3663.  
  3664.     return 0;
  3665. };
  3666.  
  3667.  
  3668.  
  3669.  
  3670.  
  3671.  
  3672.  
  3673.  
  3674.  
  3675. int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
  3676.     cout << "destroy " << endl;
  3677.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  3678.     a** st = (a * *)lua_touserdata(L, -2); // получаем польз. данные.
  3679.     a *b = &**st;
  3680.  
  3681.     b->~a();//вызов метода деструктор.
  3682.     return 0;
  3683.  
  3684. };
  3685.  
  3686. int show(lua_State * L) {
  3687.  
  3688.     cout << "show " << endl;
  3689.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/ 
  3690.     cout << lua_type(L,-2) << endl;
  3691.     //a** st = (a * *)lua_touserdata(L, -2);// получаем польз. данные.
  3692.     //a * b = &**st;
  3693.     //b->show();// вызов метода.
  3694.     return 0;
  3695. };
  3696.     //lua_newtable(L);
  3697.     //luaL_newmetatable(L, "mt");// создать мета таблицу.
  3698.     //pushlua(L, "__gc");
  3699.     //lua_pushcfunction(L, destroy);
  3700.     //lua_settable(L, -3); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
  3701.  
  3702. int create(lua_State* L) {//    Функция создания объекта структуры.
  3703.     lua_newtable(L);
  3704.     luaL_newmetatable(L, "mt");// создать мета таблицу.
  3705.     lua_pushcfunction(L, destroy);
  3706.     lua_setfield(L, -2, "__gc");
  3707.    
  3708.     a** c = (a * *)lua_newuserdata(L, sizeof(a*));/*Эта функция выделяет новый блок памяти с заданным размером,*/
  3709.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  3710.     *c = new a();
  3711.     lua_setmetatable(L, -2); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
  3712.  
  3713.     lua_gettable(L, -3);
  3714.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  3715.  
  3716.    lua_pushcfunction(L, show);
  3717.     lua_setfield(L, -2, "show");
  3718.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  3719.  
  3720.     return 1;
  3721. };
  3722.  
  3723. int main(int argc, char* argv[]) {
  3724. const char* LUA = R"(
  3725.  
  3726. a= create()
  3727. a.show()
  3728.  
  3729. )";
  3730.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3731.     luaL_openlibs(L);
  3732.    
  3733.     lua_pushcfunction(L, create);
  3734.     lua_setglobal(L, "create");//уст указатель на функцию C++ и создает внутри Lua
  3735.  
  3736.     checkerror(L, LUA);//Функция проверка на ошибки.
  3737.  
  3738.     lua_close(L);
  3739.  
  3740.     return 0;
  3741. };
  3742.  
  3743.  
  3744.  
  3745. По указателю.
  3746. int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
  3747.     cout << "destroy " << endl;
  3748.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  3749.     a* st = (a* )lua_touserdata(L, -2); // получаем польз. данные.
  3750.  
  3751.     st->~a();//вызов метода деструктор.
  3752.     return 0;
  3753. };
  3754.  
  3755. int create(lua_State * L) {//   Функция создания объекта структуры.
  3756.     lua_newtable(L);
  3757.     luaL_newmetatable(L, "mt");// создать мета таблицу.
  3758.     pushlua(L, "__gc");
  3759.     lua_pushcfunction(L, destroy);
  3760.     lua_settable(L, -3); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
  3761.  
  3762.  
  3763.     a* c = (a *)lua_newuserdata(L, sizeof(a));/*Эта функция выделяет новый блок памяти с заданным размером,*/
  3764.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  3765.     c = new a();
  3766.     lua_setmetatable(L, -2); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
  3767.  
  3768.     return 1;
  3769. };
  3770.  
  3771.  
  3772. Через реестр.
  3773.  
  3774. struct a {
  3775.     int x = 10;
  3776.     a() { cout << "create object " << this << endl; }//конструктор по умолчанию
  3777.  
  3778.     void show() { cout << "\nobject - " << this << "\tx = " << x << "\n\n"; }//вывести значение x на экран.
  3779.  
  3780.     ~a() { cout << "destory object " << this << endl << endl; }//вызов деструктора.
  3781. };
  3782.  
  3783. int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
  3784.     cout << "destroy " << endl;
  3785.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  3786.     a** st = (a * *)lua_touserdata(L, -2); // получаем польз. данные.
  3787.     a *b = &**st;
  3788.  
  3789.     b->~a();//вызов метода деструктор.
  3790.  
  3791.  
  3792.     return 0;
  3793.  
  3794. };
  3795.  
  3796. int show(lua_State * L) {
  3797.  
  3798. luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/ 
  3799.  
  3800.     lua_pushstring(L, "key");
  3801.     lua_gettable(L, -2);
  3802.     cout << lua_tonumber(L, -1)<<"ref \n";
  3803.     int ref = 3;
  3804.     pushlua(L, ref);
  3805.     lua_rawgetp(L, LUA_REGISTRYINDEX, &ref);/* получить значение по ключу адрес k*/
  3806.  
  3807.     //getlaststack(L);
  3808. cout << lua_type(L,-1) << endl;
  3809. //  a** st = (a * *)lua_touserdata(L, -1);// получаем польз. данные.
  3810. //  a * b = &**st;
  3811. //  b->show();// вызов метода.  
  3812.     return 0;
  3813. };
  3814. int create(lua_State* L) {//    Функция создания объекта структуры.
  3815.     lua_gettable(L, -3);
  3816.     luaL_newmetatable(L, "mt");// создать мета таблицу.
  3817.     lua_pushcfunction(L, destroy);
  3818.     lua_setfield(L, -2, "__gc");
  3819.    
  3820.     lua_pushcfunction(L, show);
  3821.     lua_setfield(L, -2, "show");
  3822.     int ref = luaL_ref(L, LUA_REGISTRYINDEX);
  3823.  
  3824.     //luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  3825.     a** c = (a * *)lua_newuserdata(L, sizeof(a*));/*Эта функция выделяет новый блок памяти с заданным размером,*/
  3826.     *c = new a();
  3827.     lua_rawsetp(L, LUA_REGISTRYINDEX, &ref);  /* уст ключ в реестре адрес k.  */
  3828.  
  3829.     lua_setmetatable(L, -2); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
  3830.  
  3831.     lua_gettable(L, -2);
  3832.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  3833.  
  3834.     lua_pushcfunction(L, show);
  3835.     lua_setfield(L, -2, "show");
  3836.     lua_pushstring(L, "key");
  3837.     lua_pushnumber(L, ref);
  3838.     lua_rawset(L, -3);
  3839.  
  3840.     cout << ref<<" kkmj\n";
  3841.  
  3842.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  3843.     return 1;
  3844. };
  3845.  
  3846. int main(int argc, char* argv[]) {
  3847. const char* LUA = R"(
  3848.  
  3849. a= create()
  3850. a.show()
  3851.  
  3852. )";
  3853.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3854.     luaL_openlibs(L);
  3855.  
  3856.     lua_newtable(L);
  3857.     lua_pushcfunction(L, create);
  3858.     lua_setglobal(L, "create");//уст указатель на функцию C++ и создает внутри Lua
  3859.  
  3860.     checkerror(L, LUA);//Функция проверка на ошибки.
  3861.  
  3862.     lua_close(L);
  3863.  
  3864.     return 0;
  3865. };
  3866.  
  3867. Реестр. Передача значение между функциями через метатаблицу.
  3868.  
  3869. int show(lua_State * L) {
  3870.     luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
  3871.     lua_pushstring(L, "key");//отправить key, чтобы получить ref
  3872.     lua_gettable(L, -2);
  3873.     int ref = lua_tonumber(L, -1);
  3874.     lua_rawgetp(L, LUA_REGISTRYINDEX, &ref);/* получить значение по ключу ref.*/
  3875.     cout << lua_tonumber(L, -1) << " value 5" << endl;//должно быть 5.
  3876.     return 0;
  3877. };
  3878. int create(lua_State * L) {//   Функция создания объекта структуры.
  3879.     lua_gettable(L, -3);// получить глоб. таблицу.
  3880.     luaL_newmetatable(L, "mt");// создать мета таблицу.
  3881.     int ref = luaL_ref(L, LUA_REGISTRYINDEX);// получить уникальный ключ.
  3882.     pushlua(L, 5);// отправить значение для ключа. mt.ref = 5.
  3883.     lua_rawsetp(L, LUA_REGISTRYINDEX, &ref); /* уст ключ со значением 5 в реестре адрес. */
  3884.  
  3885.     lua_pushstring(L, "key");// это ключ для получение ref.
  3886.     lua_pushnumber(L, ref);
  3887.  
  3888.     lua_setmetatable(L, -2); //уст метатаблицу.
  3889.     luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
  3890.     return 1;
  3891. };
  3892.  
  3893. int main(int argc, char* argv[]) { 
  3894.     const char* LUA = R"(
  3895. create()
  3896. show()
  3897. )";
  3898.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3899.     luaL_openlibs(L);
  3900.  
  3901.     lua_newtable(L);
  3902.     lua_pushcfunction(L, create);
  3903.     lua_setglobal(L, "create");// уст глоб имя в таблице как С функцию.
  3904.    
  3905.     lua_pushcfunction(L, show);
  3906.     lua_setglobal(L, "show");
  3907.  
  3908.     checkerror(L, LUA);//Функция проверка на ошибки.
  3909.  
  3910.     lua_close(L);
  3911.  
  3912.     return 0;
  3913. };
  3914.  
  3915. Выводится.
  3916. 5 value 5
  3917.  
  3918. C:\Users\e\source\repos\Project1luaapi\Debug\Project1luaapi.exe (процесс 2764) завершает работу с кодом 0.
  3919. Чтобы закрыть это окно, нажмите любую клавишу…
  3920.  
  3921. Реестр. Передача в функцию числа, возвращаем из другой функции.
  3922.  
  3923. int show(lua_State* L) {
  3924.     luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
  3925.    
  3926.     pushlua(L, "key");
  3927.     lua_gettable(L, -2);
  3928.     int ref = lua_tonumber(L, -1);
  3929.     cout << "in func show regis key " << ref  << endl;
  3930.     lua_rawgetp(L, LUA_REGISTRYINDEX, &ref);/* получить значение по ключу ref.*/
  3931.  
  3932.     cout << lua_tonumber(L, -1) << " value 5" << endl;//должно быть 5.
  3933.     return 0;
  3934. };
  3935. int create(lua_State * L) {//   Функция создания объекта структуры.
  3936.     int k = lua_tonumber(L, -1);
  3937.     cout << k << endl;// 5
  3938.     int ref = luaL_ref(L, LUA_REGISTRYINDEX);// получить уникальный ключ.
  3939.     cout <<"in func create regis key " << ref  << endl;
  3940.    
  3941.     luaL_newmetatable(L, "mt");// создать мета таблицу.
  3942.     luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
  3943.     lua_gettable(L, -2);// получить глоб. таблицу.
  3944.     pushlua(L, k);// значение для ключа. mt.ref = 5.
  3945.     lua_rawsetp(L, LUA_REGISTRYINDEX, &k); /* уст ключ со значением 5 в реестре адрес. */
  3946.     lua_setmetatable(L, -2); //уст метатаблицу.
  3947.     luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
  3948.     pushlua(L, "key");// это ключ для получение ref.
  3949.     pushlua(L, ref);
  3950.     lua_settable(L, -3);
  3951. return 1;
  3952. };
  3953.  
  3954. int main(int argc, char* argv[]) {
  3955.     const char* LUA = R"(
  3956. create(5)
  3957. show()
  3958. )";
  3959.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3960.     luaL_openlibs(L);
  3961.  
  3962.     lua_newtable(L);
  3963.     lua_pushcfunction(L, create);
  3964.     lua_setglobal(L, "create");// уст глоб имя в таблице как С функцию.
  3965.  
  3966.     lua_pushcfunction(L, show);
  3967.     lua_setglobal(L, "show");
  3968.  
  3969.     checkerror(L, LUA);//Функция проверка на ошибки.
  3970.  
  3971.     lua_close(L);
  3972.  
  3973.     return 0;
  3974. };
  3975. Выводится.
  3976. 5
  3977. in func create regis key 3
  3978. in func show regis key 3
  3979. 5 value 5
  3980.  
  3981. C:\Users\e\source\repos\Project1luaapi\Debug\Project1luaapi.exe (процесс 5912) завершает работу с кодом 0.
  3982. Чтобы закрыть это окно, нажмите любую клавишу…
  3983.  
  3984.  
  3985.  
  3986. int main(int argc, char *argv[]) {
  3987.  
  3988.     lua_State* L = luaL_newstate();
  3989.     luaL_openlibs(L);
  3990.  
  3991.     const char* file1 = "test1.lua";
  3992.     const char* file2 = "test2.lua";
  3993.  
  3994.     //We load the file
  3995.     luaL_loadfile(L, file1);
  3996.     //Create _ENV tables
  3997.     lua_newtable(L);
  3998.     //Create metatable
  3999.     lua_newtable(L);
  4000.     //Get the global table
  4001.     lua_getglobal(L, "_G");
  4002.     lua_setfield(L, -2, "__index");
  4003.     //Set global as the metatable
  4004.     lua_setmetatable(L, -2);
  4005.     //Push to registry with a unique name.
  4006.     //I feel like these 2 steps could be merged or replaced but I'm not sure how
  4007.     lua_setfield(L, LUA_REGISTRYINDEX, "test1");
  4008.     //Retrieve it.
  4009.     lua_getfield(L, LUA_REGISTRYINDEX, "test1");
  4010.     //Set the upvalue (_ENV)
  4011.     lua_setupvalue(L, 1, 1);
  4012.     //Run chunks
  4013.     lua_pcall(L, 0, LUA_MULTRET, 0);
  4014.  
  4015.     //Repeat
  4016.     luaL_loadfile(L, file2);
  4017.     lua_newtable(L);
  4018.     lua_newtable(L);
  4019.     lua_getglobal(L, "_G");
  4020.     lua_setfield(L, -2, "__index");
  4021.     lua_setmetatable(L, -2);
  4022.     lua_setfield(L, LUA_REGISTRYINDEX, "test2");
  4023.     lua_getfield(L, LUA_REGISTRYINDEX, "test2");
  4024.     lua_setupvalue(L, 1, 1);
  4025.     lua_pcall(L, 0, LUA_MULTRET, 0);
  4026.  
  4027.     //Retrieve the table containing the functions of the chunk
  4028.     lua_getfield(L, LUA_REGISTRYINDEX, "test1");
  4029.     //Get the function we want to call
  4030.     lua_getfield(L, -1, "hi");
  4031.     //Call it
  4032.     lua_call(L, 0, 0);
  4033.     //Repeat
  4034.     lua_getfield(L, LUA_REGISTRYINDEX, "test2");
  4035.     lua_getfield(L, -1, "hi");
  4036.     lua_call(L, 0, 0);
  4037.     lua_getfield(L, LUA_REGISTRYINDEX, "test2");
  4038.     lua_getfield(L, -1, "hi");
  4039.     lua_call(L, 0, 0);
  4040.     lua_getfield(L, LUA_REGISTRYINDEX, "test1");
  4041.     lua_getfield(L, -1, "hi");
  4042.     lua_call(L, 0, 0);
  4043.  
  4044.  
  4045.     lua_close(L);// закрыть состояние
  4046.     cin.get();//ожидает ввода символа программа завершается.
  4047.  
  4048.     return 0;
  4049. }
  4050.  
  4051.  
  4052. Замыкание.
  4053.  
  4054. struct Sprite
  4055.     {
  4056.         int x;
  4057.         int y;
  4058.  
  4059.         Sprite() : x(0), y(0) {}
  4060.         ~Sprite() {}
  4061.  
  4062.         void Move(int velX, int velY)
  4063.         {
  4064.             x += velX;
  4065.             y += velY;
  4066.         }
  4067.  
  4068.         void Draw()
  4069.         {
  4070.             printf("sprite(%p): x = %d, y = %d\n", this, x, y);
  4071.         }
  4072.     };
  4073.  
  4074.     struct SpriteManager
  4075.     {
  4076.         std::vector<Sprite*> m_sprites;
  4077.         int numberOfSpritesExisting = 0;
  4078.         int numberOfSpritesMade = 0;
  4079.  
  4080.         void LookAfterSprite(Sprite* sprite)
  4081.         {
  4082.             numberOfSpritesExisting++;
  4083.             numberOfSpritesMade++;
  4084.             m_sprites.push_back(sprite);
  4085.         }
  4086.  
  4087.         void ForgetSprite(Sprite* sprite)
  4088.         {
  4089.             int i = 0;
  4090.             for (auto& s : m_sprites)
  4091.             {
  4092.                 if (s == sprite)
  4093.                 {
  4094.                     numberOfSpritesExisting--;
  4095.                     m_sprites.erase(m_sprites.begin() + i);
  4096.                     return;
  4097.                 }
  4098.                 i++;
  4099.             }
  4100.         }
  4101.     };
  4102.  
  4103.     SpriteManager spriteManager;
  4104.  
  4105.     int CreateSprite(lua_State* L){
  4106.         SpriteManager* sm = (SpriteManager*)lua_touserdata(L, lua_upvalueindex(1));
  4107.         lua_assert(sm);
  4108.  
  4109.         void* pointerToASprite = lua_newuserdata(L, sizeof(Sprite));
  4110.         new (pointerToASprite) Sprite();
  4111.         luaL_getmetatable(L, "SpriteMetaTable");
  4112.         lua_assert(lua_istable(L, -1));
  4113.         lua_setmetatable(L, -2);
  4114.  
  4115.         lua_newtable(L);
  4116.         lua_setuservalue(L, 1);
  4117.  
  4118.         sm->LookAfterSprite((Sprite*)pointerToASprite);
  4119.  
  4120.         return 1;
  4121.     };
  4122.  
  4123.     int DestroySprite(lua_State* L){
  4124.         SpriteManager* sm = (SpriteManager*)lua_touserdata(L, lua_upvalueindex(1));
  4125.         lua_assert(sm);
  4126.  
  4127.         Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
  4128.         sm->ForgetSprite(sprite);
  4129.         sprite->~Sprite();
  4130.         return 0;
  4131.     };
  4132.  
  4133.     int MoveSprite(lua_State* L){
  4134.         Sprite* sprite = (Sprite*)lua_touserdata(L, -3);
  4135.         lua_Number velX = lua_tonumber(L, -2);
  4136.         lua_Number velY = lua_tonumber(L, -1);
  4137.         sprite->Move((int)velX, (int)velY);
  4138.         return 0;
  4139.     };
  4140.  
  4141.     int DrawSprite(lua_State* L){
  4142.         Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
  4143.         sprite->Draw();
  4144.         return 0;
  4145.     };
  4146.  
  4147.     int SpriteIndex(lua_State* L){
  4148.         lua_assert(lua_isuserdata(L, -2));  //1
  4149.         lua_assert(lua_isstring(L, -1));    //2
  4150.  
  4151.         Sprite* sprite = (Sprite*)lua_touserdata(L, -2);
  4152.         const char* index = lua_tostring(L, -1);
  4153.         if (strcmp(index, "x") == 0)
  4154.         {
  4155.             lua_pushnumber(L, sprite->x);
  4156.             return 1;
  4157.         }
  4158.         else if (strcmp(index, "y") == 0)
  4159.         {
  4160.             lua_pushnumber(L, sprite->y);
  4161.             return 1;
  4162.         }
  4163.         else
  4164.         {
  4165.             lua_getuservalue(L, 1);
  4166.             lua_pushvalue(L, 2);
  4167.             lua_gettable(L, -2);
  4168.             if (lua_isnil(L, -1))
  4169.             {
  4170.                 lua_getglobal(L, "Sprite");
  4171.                 lua_pushstring(L, index);
  4172.                 lua_rawget(L, -2);
  4173.             }
  4174.             return 1;
  4175.         }
  4176.     };
  4177.  
  4178.     int SpriteNewIndex(lua_State* L){
  4179.         lua_assert(lua_isuserdata(L, -3));  //1
  4180.         lua_assert(lua_isstring(L, -2));    //2
  4181.                                         // -1 - value we want to set    //3
  4182.  
  4183.         Sprite* sprite = (Sprite*)lua_touserdata(L, -3);
  4184.         const char* index = lua_tostring(L, -2);
  4185.         if (strcmp(index, "x") == 0)
  4186.         {
  4187.             sprite->x = (int)lua_tonumber(L, -1);
  4188.         }
  4189.         else if (strcmp(index, "y") == 0)
  4190.         {
  4191.             sprite->y = (int)lua_tonumber(L, -1);
  4192.         }
  4193.         else
  4194.         {
  4195.             lua_getuservalue(L, 1); //1
  4196.             lua_pushvalue(L, 2);    //2
  4197.             lua_pushvalue(L, 3);    //3
  4198.             lua_settable(L, -3);    //1[2] = 3
  4199.         }
  4200.  
  4201.         return 0;
  4202.     };
  4203.  
  4204. int main(int argc, char *argv[]) {
  4205.     const char* LUA_FILE = R"(
  4206.         sprite = Sprite.new()
  4207.         sprite:Move( 6, 7 )     -- Sprite.Move( sprite, 6, 7 )
  4208.         sprite:Draw()
  4209.         sprite.y = 10
  4210.         sprite.zzz = 99
  4211.         sprite.x = sprite.zzz
  4212.         sprite:Draw()
  4213.         Sprite.new()
  4214.         Sprite.new()
  4215.         )";
  4216.  
  4217.     lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  4218.     luaL_openlibs(L);
  4219.  
  4220.     lua_newtable(L);
  4221.     int spriteTableIdx = lua_gettop(L);
  4222.     lua_pushvalue(L, spriteTableIdx);
  4223.     lua_setglobal(L, "Sprite");
  4224.  
  4225.     constexpr int NUMBER_OF_UPVALUES = 1;
  4226.     lua_pushlightuserdata(L, &spriteManager);
  4227.     lua_pushcclosure(L, CreateSprite, NUMBER_OF_UPVALUES);
  4228.     lua_setfield(L, -2, "new");
  4229.     lua_pushcfunction(L, MoveSprite);
  4230.     lua_setfield(L, -2, "Move");
  4231.     lua_pushcfunction(L, DrawSprite);
  4232.     lua_setfield(L, -2, "Draw");
  4233.  
  4234.     luaL_newmetatable(L, "SpriteMetaTable");
  4235.     lua_pushstring(L, "__gc");
  4236.     lua_pushlightuserdata(L, &spriteManager);
  4237.     lua_pushcclosure(L, DestroySprite, NUMBER_OF_UPVALUES);
  4238.     lua_settable(L, -3);
  4239.  
  4240.     lua_pushstring(L, "__index");
  4241.     lua_pushcfunction(L, SpriteIndex);
  4242.     lua_settable(L, -3);
  4243.  
  4244.     lua_pushstring(L, "__newindex");
  4245.     lua_pushcfunction(L, SpriteNewIndex);
  4246.     lua_settable(L, -3);
  4247.  
  4248.     int doResult = luaL_dostring(L, LUA_FILE);
  4249.     if (doResult != LUA_OK)
  4250.     {
  4251.         printf("Error: %s\n", lua_tostring(L, -1));
  4252.     }
  4253.  
  4254.     lua_close(L);
  4255.  
  4256.     lua_assert(spriteManager.numberOfSpritesExisting == 0);
  4257.     lua_assert(spriteManager.numberOfSpritesMade == 3);
  4258.  
  4259.     cin.get();//ожидает ввода символа программа завершается.
  4260.     return 0;
  4261. }
  4262.  
  4263.  
  4264. struct Sprite
  4265.     {
  4266.         int x;
  4267.  
  4268.         Sprite() : x(0) {}
  4269.         ~Sprite() {}
  4270.  
  4271.         void Move(int velX)
  4272.         {
  4273.             x += velX;
  4274.         }
  4275.  
  4276.         void Draw()
  4277.         {
  4278.             printf("sprite(%p): x = %d\n", this, x);
  4279.         }
  4280.     };
  4281.  
  4282.     struct SpriteManager
  4283.     {
  4284.         std::vector<Sprite*> m_sprites;
  4285.         void ForgetSprite(Sprite* sprite)
  4286.         {
  4287.             int i = 0;
  4288.             for (auto& s : m_sprites)
  4289.             {
  4290.                 if (s == sprite){
  4291.                     m_sprites.erase(m_sprites.begin() + i);
  4292.                     return;
  4293.                 }
  4294.                 i++;
  4295.             }
  4296.         }
  4297.     };
  4298.  
  4299. SpriteManager sp;
  4300.  
  4301.     int CreateSprite(lua_State* L){
  4302.  
  4303.         SpriteManager* sm = (SpriteManager*)lua_touserdata(L, lua_upvalueindex(1));
  4304.         void* pointerToASprite = lua_newuserdata(L, sizeof(Sprite));
  4305.         new (pointerToASprite) Sprite();
  4306.         luaL_getmetatable(L, "mt");
  4307.         lua_setmetatable(L, -2);
  4308.         lua_newtable(L);
  4309.         lua_setuservalue(L, 1);
  4310.         return 1;
  4311.     };
  4312.  
  4313.     int DestroySprite(lua_State* L){
  4314.         SpriteManager* sm = (SpriteManager*)lua_touserdata(L, lua_upvalueindex(1));
  4315.         Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
  4316.         sm->ForgetSprite(sprite);
  4317.         sprite->~Sprite();
  4318.         return 0;
  4319.     };
  4320.    
  4321.     int DrawSprite(lua_State* L){
  4322.         Sprite* sprite = (Sprite*)lua_touserdata(L, -2);
  4323.         sprite->Move(lua_tonumber(L, -1));
  4324.         sprite->Draw();
  4325.         return 0;
  4326.     };
  4327.  
  4328.     int SpriteIndex(lua_State* L){
  4329.  
  4330.         Sprite* sprite = (Sprite*)lua_touserdata(L, -2);
  4331.         const char* index = lua_tostring(L, -1);
  4332.             lua_getuservalue(L, 1);
  4333.             lua_pushvalue(L, 2);
  4334.             lua_gettable(L, -2);
  4335.  
  4336.             lua_getglobal(L, "sprite");
  4337.             lua_pushstring(L, index);
  4338.             lua_rawget(L, -2);
  4339.            
  4340.             return 1;
  4341.     };
  4342.  
  4343.  
  4344. int main(int argc, char *argv[]) {
  4345.     const char* LUA_FILE = R"(
  4346.         sp = sprite.new()
  4347.         sp:draw(6)
  4348.         )";
  4349.  
  4350.     lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  4351.     luaL_openlibs(L);
  4352.  
  4353.     lua_newtable(L);
  4354.     lua_pushvalue(L, 1);
  4355.     lua_setglobal(L, "sprite");
  4356.  
  4357.     lua_pushlightuserdata(L, &sp);
  4358.     lua_pushcclosure(L, CreateSprite, 1);
  4359.     lua_setfield(L, -2, "new");
  4360.     lua_pushcfunction(L, DrawSprite);
  4361.     lua_setfield(L, -2, "draw");
  4362.  
  4363.     luaL_newmetatable(L, "mt");
  4364.     lua_pushstring(L, "__gc");
  4365.     lua_pushlightuserdata(L, &sp);
  4366.     lua_pushcclosure(L, DestroySprite, 1);
  4367.     lua_settable(L, -3);
  4368.  
  4369.     lua_pushstring(L, "__index");
  4370.     lua_pushcfunction(L, SpriteIndex);
  4371.     lua_settable(L, -3);
  4372.     luaL_dostring(L, LUA_FILE);
  4373.  
  4374.     lua_close(L);
  4375.    
  4376.     cin.get();//ожидает ввода символа программа завершается.
  4377.     return 0;
  4378. }
  4379.  
  4380.  
  4381. Замыкание 2.
  4382. struct Sprite
  4383.     {
  4384.         int x;
  4385.  
  4386.         Sprite() : x(0) {}
  4387.         ~Sprite() {}
  4388.  
  4389.         void Move(int velX)
  4390.         {
  4391.             x += velX;
  4392.         }
  4393.  
  4394.         void Draw()
  4395.         {
  4396.             printf("sprite(%p): x = %d\n", this, x);
  4397.         }
  4398.     };
  4399.  
  4400.     struct SpriteManager
  4401.     {
  4402.         std::vector<Sprite*> m_sprites;
  4403.         void ForgetSprite(Sprite* sprite)
  4404.         {
  4405.             int i = 0;
  4406.             for (auto& s : m_sprites)
  4407.             {
  4408.                 if (s == sprite){
  4409.                     m_sprites.erase(m_sprites.begin() + i);
  4410.                     return;
  4411.                 }
  4412.                 i++;
  4413.             }
  4414.         }
  4415.     };
  4416.     int pri(lua_State* L) { cout << "pri " << endl;
  4417.     return 0;
  4418.     }
  4419. SpriteManager sp;
  4420.  
  4421.     int CreateSprite(lua_State* L){
  4422.         SpriteManager* sm = (SpriteManager*)lua_touserdata(L, lua_upvalueindex(1));
  4423.         void* pointerToASprite = lua_newuserdata(L, sizeof(Sprite));
  4424.         new (pointerToASprite) Sprite();
  4425.         luaL_getmetatable(L, "mt");
  4426.         lua_setmetatable(L, -2);
  4427.         lua_newtable(L);
  4428.         lua_setuservalue(L, 1);
  4429.         return 1;
  4430.     };
  4431.  
  4432.     int DestroySprite(lua_State* L){
  4433.         SpriteManager* sm = (SpriteManager*)lua_touserdata(L, lua_upvalueindex(1));
  4434.         Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
  4435.         sm->ForgetSprite(sprite);
  4436.         sprite->~Sprite();
  4437.         return 0;
  4438.     };
  4439.    
  4440.     int DrawSprite(lua_State* L){
  4441.         Sprite* sprite = (Sprite*)lua_touserdata(L, -2);
  4442.         sprite->Move(lua_tonumber(L, -1));
  4443.         sprite->Draw();
  4444.         return 0;
  4445.     };
  4446.  
  4447.     int SpriteIndex(lua_State* L){
  4448.  
  4449.         Sprite* sprite = (Sprite*)lua_touserdata(L, -2);
  4450.         const char* index = lua_tostring(L, -1);
  4451.             lua_getuservalue(L, 1);
  4452.             lua_pushvalue(L, 2);
  4453.             lua_gettable(L, -2);
  4454.  
  4455.             lua_getglobal(L, "sprite");
  4456.             lua_pushstring(L, index);
  4457.             lua_rawget(L, -2);
  4458.            
  4459.             return 1;
  4460.     };
  4461.  
  4462.  
  4463. int main(int argc, char *argv[]) {
  4464.     const char* LUA_FILE = R"(
  4465.         sp = sprite.new()
  4466.         sp:draw(6)
  4467.         )";
  4468.  
  4469.     lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  4470.     luaL_openlibs(L);
  4471.  
  4472.     lua_newtable(L);
  4473.     lua_pushvalue(L, 1);
  4474.     lua_setglobal(L, "sprite");
  4475.  
  4476.     lua_pushlightuserdata(L, &sp);
  4477.     lua_pushcclosure(L, CreateSprite, 1);
  4478.     lua_setfield(L, -2, "new");
  4479.     lua_pushcfunction(L, DrawSprite);
  4480.     lua_setfield(L, -2, "draw");
  4481.  
  4482.     luaL_newmetatable(L, "mt");
  4483.     lua_pushstring(L, "__gc");
  4484.     lua_pushlightuserdata(L, &sp);
  4485.     lua_pushcclosure(L, DestroySprite, 1);
  4486.     lua_settable(L, -3);
  4487.  
  4488.     lua_pushstring(L, "__index");
  4489.     lua_pushcfunction(L, SpriteIndex);
  4490.     lua_settable(L, -3);
  4491.     luaL_dostring(L, LUA_FILE);
  4492.  
  4493.     lua_close(L);
  4494.    
  4495.     cin.get();//ожидает ввода символа программа завершается.
  4496.     return 0;
  4497. }
  4498.  
  4499. Замыкание 3
  4500.  
  4501. struct Sprite
  4502. {
  4503.     int x;
  4504.  
  4505.     Sprite() : x(0) { cout << " sp" << endl; }
  4506.     ~Sprite() { cout << " des " << endl; }
  4507.  
  4508. };
  4509.  
  4510.  
  4511. int pri(lua_State* L) {
  4512.     cout << "pri " << endl;
  4513.     return 0;
  4514. }
  4515.  
  4516. int CreateSprite(lua_State* L) {
  4517.     void* pointerToASprite = lua_newuserdata(L, sizeof(Sprite));
  4518.     new (pointerToASprite) Sprite();
  4519.     luaL_getmetatable(L, "mt");
  4520.     lua_setmetatable(L, -2);
  4521.     lua_newtable(L);
  4522.     lua_setuservalue(L, 1);
  4523.     return 1;
  4524. };
  4525.  
  4526. int DestroySprite(lua_State* L) {
  4527.     Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
  4528.     sprite->~Sprite();
  4529.     return 0;
  4530. };
  4531.  
  4532.  
  4533. int main(int argc, char *argv[]) {
  4534.     const char* LUA_FILE = R"(
  4535.         sp = sprite.new()
  4536.         )";
  4537.  
  4538.     lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  4539.     luaL_openlibs(L);
  4540.  
  4541.     lua_newtable(L);
  4542.     lua_pushvalue(L, 1);
  4543.     lua_setglobal(L, "sprite");
  4544.  
  4545.     lua_pushinteger(L, 2);
  4546.     lua_pushcclosure(L, CreateSprite, 1);
  4547.     lua_setfield(L, -2, "new");
  4548.  
  4549.     luaL_newmetatable(L, "mt");
  4550.     lua_pushstring(L, "__gc");
  4551.  
  4552.     lua_pushinteger(L, 2);
  4553.     lua_pushcclosure(L, DestroySprite, 1);
  4554.     lua_settable(L, -3);
  4555.  
  4556.     luaL_dostring(L, LUA_FILE);
  4557.  
  4558.     lua_close(L);
  4559.  
  4560.     cin.get();//ожидает ввода символа программа завершается.
  4561.     return 0;
  4562. }
  4563.  
  4564. Замыкание 4.
  4565.  
  4566. int pri(lua_State* L) {
  4567.     showstack(L);
  4568.     cout << "pri " << endl;
  4569.     return 0;
  4570. }
  4571.  
  4572. int CreateSprite(lua_State* L) {
  4573.     cout << "cre " << endl;
  4574.     lua_gettable(L, -2);
  4575.     lua_setuservalue(L, 1);
  4576.     return 1;
  4577. };
  4578.  
  4579. int main(int argc, char *argv[]) {
  4580.     const char* LUA_FILE = R"(
  4581.         sp = sprite.new()
  4582.         )";
  4583.  
  4584.     lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  4585.     luaL_openlibs(L);
  4586.  
  4587.     lua_newtable(L);
  4588.     lua_pushvalue(L, 1);
  4589.     lua_setglobal(L, "sprite");
  4590.    
  4591.     lua_pushinteger(L, 2);
  4592.     lua_pushcclosure(L, pri, 1);
  4593.     lua_setfield(L, -2, "new");
  4594.  
  4595.  
  4596.     luaL_dostring(L, LUA_FILE);
  4597.     lua_close(L);
  4598.  
  4599.     cin.get();//ожидает ввода символа программа завершается.
  4600.     return 0;
  4601. }
  4602.  
  4603. Замыкание 5.
  4604.  
  4605. static int newcounter(lua_State *L) {
  4606.     cout << lua_tonumber(L, -1) << endl;
  4607.     cout << " new" << endl;
  4608.     int val = lua_tointeger(L, lua_upvalueindex(1));
  4609.     lua_pushinteger(L, 1);  /* new value */
  4610.     lua_copy(L, -1, lua_upvalueindex(1));  /* update upvalue */
  4611.     return 1;
  4612. }
  4613. static int counter(lua_State *L) {
  4614.     cout << "coun " << endl;
  4615.     lua_pushinteger(L, 10);
  4616.     lua_pushcclosure(L, newcounter, 1);
  4617.     return 1;  /* return new value */
  4618. }
  4619.  
  4620.  
  4621. int main(int argc, char *argv[]) {
  4622.     const char* LUA = R"(
  4623. c1 = counter()
  4624.    print(c1(), c1(), c1())   --> 1    2    3
  4625.     -- c2 = newcounter()
  4626.      --print(c2(), c2(), c1())   --> 1    2    4
  4627.  
  4628.        )";
  4629.  
  4630.     lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  4631.     luaL_openlibs(L);
  4632.     //lua_newtable(L);
  4633.    
  4634.     //lua_pushnumber(L, 142);
  4635.     lua_register(L,"counter", counter);// отправить c функцию в стек.
  4636.     luaL_dostring(L, LUA);
  4637.     //lua_pushnumber(L, 142);
  4638.   lua_pushcclosure(L, newcounter, 1);
  4639.  
  4640. //  lua_settable(L, -3);
  4641.  
  4642.     lua_pcall(L, 0, 0, 0);// вызвать функцию foo.
  4643.  
  4644.     lua_close(L);
  4645.  
  4646.     cin.get();//ожидает ввода символа программа завершается.
  4647.     return 0;
  4648. }
  4649.  
  4650.  
  4651. Замыкание 6.
  4652. static int newcounter(lua_State *L) {
  4653.     int val = lua_tointeger(L, lua_upvalueindex(1));/*Возвращает псевдоиндекс, который представляет
  4654.     i-ковою внешнюю локальную переменную (upvalue) выполняемой функции.*/
  4655.     lua_pushinteger(L, ++val);  /*  новое  значение    */
  4656.     lua_pushvalue(L, -1);   /*дублирует    его  */
  4657.     lua_replace(L, lua_upvalueindex(1));/*  обновляет  верхнее  значение*/
  4658.     return 1;
  4659. }
  4660. static int counter(lua_State *L) {
  4661.     lua_pushinteger(L, 0);
  4662.     lua_pushcclosure(L, newcounter, 1);
  4663.     return 1;  /* return new value */
  4664. }
  4665.  
  4666. int main(int argc, char *argv[]) {
  4667.     const char* LUA = R"(
  4668.   c1 = counter()
  4669.   print(c1(), c1(), c1())   --> 1    2    3
  4670.   )";
  4671.  
  4672.     lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  4673.     luaL_openlibs(L);
  4674.  
  4675.     lua_register(L,"counter", counter);// отправить c функцию в стек.
  4676.     checkerror(L, LUA);
  4677.  
  4678.     lua_pushcclosure(L, newcounter, 1);/* Помещает в стек новое C замыкание. При создании C функций, можно увязать
  4679. с ней некоторые значения, таким образом создавая C замыкания (closure); затем эти значения будут доступны функции
  4680. каждый раз при её вызове. Для связывания значений с C функцией, вначале эти значения помещаются в стек
  4681. (когда имеется несколько значений, первое значение помещается первым). Затем вызывается lua_pushcclosure для
  4682. создания и помещения в стек C функции, с аргументом n, сообщающим сколько значений будет связано с этой функцией.
  4683. lua_pushcclosure также выводит из стека эти значения. Макс значением для n является 255. При n равным нулю,
  4684. эта функция создает легкую C функцию, которая является просто указателем на C функцию. В этом случае, она никогда
  4685. не вызывает ошибку памяти.*/
  4686.  
  4687.     lua_close(L);
  4688.     return 0;
  4689.  
  4690. };
  4691.  
  4692. Замыкание 7.
  4693.  
  4694.  
  4695. int newcounter(lua_State* L) {
  4696.     int val = lua_tointeger(L, lua_upvalueindex(1));/*Возвращает псевдоиндекс, который представляет
  4697.     i-ковою внешнюю локальную переменную (upvalue) выполняемой функции.*/
  4698.     lua_pushinteger(L, val++);  /*  новое  значение    */
  4699.     lua_pushvalue(L, -1);   /*дублирует    его  */
  4700.     lua_replace(L, lua_upvalueindex(1));/*  обновляет верхнее значение. снимает значение с вершины стека
  4701.                 и устанавливает его как значение элемента с заданным индексом.*/
  4702.     return 1;
  4703. }
  4704. int counter(lua_State * L) {
  4705.     lua_pushinteger(L, 1);
  4706.     lua_pushcclosure(L, newcounter, 1);/* Помещает в стек новое C замыкание. При создании C функций, можно увязать
  4707. с ней некоторые значения, таким образом создавая C замыкания (closure); затем эти значения будут доступны функции
  4708. каждый раз при её вызове. Для связывания значений с C функцией, вначале эти значения помещаются в стек
  4709. (когда имеется несколько значений, первое значение помещается первым). Затем вызывается lua_pushcclosure для
  4710. создания и помещения в стек C функции, с аргументом n, сообщающим сколько значений будет связано с этой функцией.
  4711. lua_pushcclosure также выводит из стека эти значения. Макс значением для n является 255. При n равным нулю,
  4712. эта функция создает легкую C функцию, которая является просто указателем на C функцию. В этом случае, она никогда
  4713. не вызывает ошибку памяти.*/
  4714.  
  4715.     return 1;  /* return new value */
  4716. }
  4717.  
  4718. int main(int argc, char* argv[]) {
  4719.     const char* LUA = R"(
  4720.   c = counter()
  4721.   print(c(), c(), c())   --> 1    2    3
  4722.   )";
  4723.  
  4724.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  4725.     luaL_openlibs(L);
  4726.  
  4727.     lua_register(L, "counter", counter);// отправить c функцию в стек.
  4728.     checkerror(L, LUA);
  4729.  
  4730.    
  4731.     lua_close(L);
  4732.     return 0;
  4733.  
  4734. };
  4735.  
  4736.  
  4737.  
  4738.  
  4739. luaL_setfuncs
  4740.  
  4741. int foo1(lua_State * L){
  4742.     cout << "foo1 " << endl;
  4743.     return 0;
  4744. }
  4745.  
  4746. int foo2(lua_State * L) {
  4747.     cout << "foo2 " << endl;
  4748.     return 0;
  4749. }
  4750.  
  4751. void RegisterFoo(lua_State * L){
  4752.     luaL_Reg sFooRegs[] =
  4753.     {
  4754.         { "foo1", foo1 },
  4755.         { "foo2", foo2 },
  4756.         { NULL, NULL }
  4757.     };
  4758.  
  4759.     luaL_newmetatable(L, "luaL_Foo");
  4760.  
  4761.     // Register the C functions _into_ the metatable we just created.
  4762.     luaL_setfuncs(L, sFooRegs, 0);/*    void luaL_setfuncs(lua_State * L, const luaL_Reg * l, int nup);
  4763.     Регистрирует все функции в массиве l(см.luaL_Reg) В таблице на вершине стека(ниже необязательных
  4764.     значений повышений).Когда nupне ноль, все функции создаются с nup общими значениями повышения, которые
  4765.     должны быть предварительно помещены в стек поверх таблицы библиотеки. Эти значения выталкиваются
  4766.     из стека после регистрации.*/   
  4767.    
  4768.     lua_pushvalue(L, -1);
  4769.     lua_setfield(L, -1, "__index");
  4770.  
  4771.     lua_setglobal(L, "Foo");
  4772. }
  4773. int main(int argc, char *argv[]) {
  4774.     const char* LUA = R"(
  4775. Foo.foo1()
  4776. Foo.foo2()
  4777.   )";
  4778.  
  4779.     lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  4780.     luaL_openlibs(L);
  4781.     RegisterFoo(L);
  4782.     checkerror(L, LUA);
  4783.  
  4784.     lua_pcall(L, 0, 0, 0);// вызвать функцию.
  4785.  
  4786.     lua_close(L);
  4787.  
  4788.     cin.get();//ожидает ввода символа программа завершается.
  4789.     return 0;
  4790. };
  4791.  
  4792.  
  4793. Мета метод _index
  4794.  
  4795. int main(int argc, char* argv[]) {
  4796. const char* LUA = R"(
  4797. foo={} foo.key="value"
  4798. bar = setmetatable({},{__index=foo},print("index\n") )
  4799. print(bar.key)-- value
  4800. )";
  4801.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  4802.     luaL_openlibs(L);
  4803.     checkerror(L, LUA);//Функция проверка на ошибки.
  4804.     lua_close(L);
  4805.  
  4806.     return 0;
  4807. };
  4808.  
  4809.  
  4810. alignas - это новая штука с с++11 стандарта и предназначена, чтобы устаканить то, что творится в разных компиляторах. Чтобы не говорили разработчики других языков, но иногда нужно писать немножко низкоуровневого кода, чтобы получить существенный плюс в скорости.
  4811. Как известно, процессоры лучше работают с данными в памяти, если они выровнены по границе в 4/8/16 байт. А в некоторых случаях данные обязаны быть выровнены (например, с некоторыми SSE командами и на некоторых ARM процессорах).
  4812. Что такое выравнивание по границе? Это просто адрес, который кратен заданной степени двойки. То есть, адрес 24 выровнен по границе 2, 4, 8, но не 16. Адрес 1024 выровнен по 2, 4, 8, 16, 32 и многим другим. Можно сказать и по-другому - адрес, выровненный по границе 16 в бинарном виде заканчивается на 4 нуля.
  4813. alignas как раз и заставляет компилятор сделать это выравнивание. Да, часто это идет в ущерб памяти (появляются пустоты), но в некоторых случаях (с SSE) можно получить двукратный прирост просто по той причине, что адрес выровнен по границе 16/32. Почему так происходит? Все просто - современные процессоры уже давно не загружают данные по байту из памяти - они обычно грузят как минимум по 4 байта сразу, более того, грузят по выровненным адресам по границе 4. И если нужно загрузить 4 невыровненных байта, то процессору приходится делать это в три этапа - загружаем первые байт (но при этом загружаем 4 байта), потом загружаем вторую половину, а потом складываем в памяти. А так как операция обращения к памяти - медленная - это длится достаточно долго.
  4814. Нужно ли в своем коде постоянно писать выравнивание? Нет, не нужно. Компиляторы достаточно умные и сами могут догадаться. Но есть случаи, когда это лучше сделать.
  4815. переменная используется для SSE/MMX.
  4816. переменная-массив, достаточно большого размера, по которому нужно будет много итерироваться (бегать).
  4817. числодробилки.
  4818. Почему расстояние равно 2016, а без него 24?
  4819. а на ideone вообще получилось -252:)
  4820. alignas говорит "выровняй", а как именно разместить в памяти - это другое дело. В Вашем случае компилятор вначале разместил первую переменную по адресу кратному 16. Вторую, нужно разместить по адресу кратному 1024. Логично, что такое может быть как сразу (потому что первая переменная занимает ровно 16 байт, так и через много-много байт (мы же не знаем адреса первой переменной).
  4821. Многие компиляторы в отладочном режиме за массивами всегда добавляют несколько байт - для того, что бы препятствовать классическому выходу за пределы массива на один элемент. Поэтому, чтобы понять, почему там именно 2016 - нужно смотреть в конкретную версию компилятора и параметры компиляции.
  4822.  
  4823.  
  4824.  
  4825.  
  4826. int main(int argc, char *argv[]) {
  4827.     lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  4828.     luaL_openlibs(L);  
  4829.     int *i= NULL;
  4830.     lua_pushnumber(L, 10);// отправить в стек число.
  4831.     lua_pushstring(L, "yes");
  4832.     cout <<  lua_tonumberx(L, 2, i) << endl;// если в позиции не число, то вернет 0.
  4833.     /* i булевое значение. */
  4834.  
  4835.  cout << i << endl;
  4836.     lua_close(L);// закрыть состояние
  4837.     cin.get();//ожидает ввода символа программа завершается.
  4838.  
  4839.     return 0;
  4840. }
  4841.  
  4842.     lua_pushstring(L, "yes");
  4843.     size_t len;// len длина строки.
  4844.     const char *s = lua_tolstring(L, -1, &len);
  4845.     cout << s<<"\n " << endl;
  4846.     cout << len << endl;
  4847.  
  4848.  
  4849.     lua_pushstring(L, "yes");
  4850.     lua_copy(L, -1, -2);//копировать из одной позиции в другую.
  4851.     cout << lua_tostring(L, -2);
  4852.  
  4853.  
  4854.  
  4855. //эта функция берет значение из стека (по индексу -1),
  4856.             //и использует его в качестве ключа для поиска по таблице, которая
  4857.             //находится в стеке по индексу i, в случае если находит, добавляет в
  4858.             //стек пару ключ - значение, следующие в таблице после ключа находившегося в стеке
  4859.             //если больше нет значений, ф-я возвращает 0
  4860.             //lua_next используется для перебора элементов таблицы
  4861.  
  4862.     int n = lua_gettop(L);/* получаем количество элементов в стеке.*/
  4863.     cout <<"\nthe number on the stack = "  << n<<"\n";
  4864.     lua_settop(L, 0);// уст кол-во элементов в стеке. 0 - очистить стек.
  4865.  
  4866.     for (int i = 1; i <= n; ++i) {
  4867.         cout << lua_typename(L, i) << endl; }
  4868.  
  4869.  
  4870.  
  4871.  
  4872. int main(int argc, char *argv[]) {
  4873.  
  4874.     lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  4875.     luaL_openlibs(L);        /* opens the standard libraries */
  4876.  
  4877.     char buff[256];
  4878.     int error;
  4879.  
  4880.     while (fgets(buff, sizeof(buff), stdin) != NULL) {
  4881.         error = luaL_loadstring(L, buff) || lua_pcall(L, 0, 0, 0);
  4882.         if (error) {
  4883.             fprintf(stderr, "%s\n", lua_tostring(L, -1));
  4884.             lua_pop(L, 1);  /* pop error message from the stack */
  4885.         }
  4886.     }
  4887.  
  4888.     lua_close(L);// закрыть состояние
  4889.     cin.get();//ожидает ввода символа программа завершается.
  4890.  
  4891.     return 0;
  4892. }
  4893.  
  4894.  
  4895.  
  4896.  
  4897.  
  4898.  
  4899.       int getglobint (lua_State *L, const char *var) {
  4900.         int isnum, result;
  4901.         lua_getglobal(L, var);
  4902.         result = (int)lua_tointegerx(L, -1, &isnum);
  4903.         if (!isnum)
  4904.           error(L, "'%s' should be a number\n", var);
  4905.         lua_pop(L, 1);   /* remove result from the stack */
  4906.         return result;
  4907.       }
  4908.      
  4909.       void load (lua_State *L, const char *fname, int *w, int *h) {
  4910.         if (luaL_loadfile(L, fname) || lua_pcall(L, 0, 0, 0))
  4911.           error(L, "cannot run config. file: %s", lua_tostring(L, -1));
  4912.         *w = getglobint(L, "width");
  4913.         *h = getglobint(L, "height");
  4914.       }
  4915.  
  4916.  
  4917.  
  4918.  
  4919.   BLUE = {red = 0, green = 0, blue = 1.0}
  4920.       other color definitions
  4921.      
  4922.       background = BLUE
  4923.  
  4924.  
  4925.         lua_getglobal(L, "background");
  4926.         if (!lua_istable(L, -1))
  4927.           error(L, "'background' is not a table");
  4928.      
  4929.         red = getcolorfield(L, "red");
  4930.         green = getcolorfield(L, "green");
  4931.         blue = getcolorfield(L, "blue");
  4932.  
  4933.   /* assume that table is on the top of the stack */
  4934.       int getcolorfield (lua_State *L, const char *key) {
  4935.         int result, isnum;
  4936.         lua_pushstring(L, key);  /* push key */
  4937.         lua_gettable(L, -2);  /* get background[key] */
  4938.         result = (int)(lua_tonumberx(L, -1, &isnum) * MAX_COLOR);
  4939.         if (!isnum)
  4940.           error(L, "invalid component '%s' in color", key);
  4941.         lua_pop(L, 1);  /* remove number */
  4942.         return result;
  4943.       }
  4944.   struct ColorTable {
  4945.         char *name;
  4946.         unsigned char red, green, blue;
  4947.       } colortable[] = {
  4948.         {"WHITE",   MAX_COLOR, MAX_COLOR, MAX_COLOR},
  4949.         {"RED",     MAX_COLOR,         0,         0},
  4950.         {"GREEN",           0, MAX_COLOR,         0},
  4951.         {"BLUE",            0,         0, MAX_COLOR},
  4952.         other colors
  4953.         {NULL, 0, 0, 0}  /* sentinel */
  4954.       };
  4955.  
  4956.   WHITE = {red = 1.0, green = 1.0, blue = 1.0}
  4957.       RED   = {red = 1.0, green = 0,   blue = 0}
  4958.  
  4959.      /* assume that table is on top */
  4960.       void setcolorfield (lua_State *L, const char *index, int value) {
  4961.         lua_pushstring(L, index); /* key */
  4962.         lua_pushnumber(L, (double)value / MAX_COLOR);  /* value */
  4963.         lua_settable(L, -3);
  4964.       }
  4965.  
  4966.       void setcolor (lua_State *L, struct ColorTable *ct) {
  4967.         lua_newtable(L);                 /* creates a table */
  4968.         setcolorfield(L, "red", ct->red);
  4969.         setcolorfield(L, "green", ct->green);
  4970.         setcolorfield(L, "blue", ct->blue);
  4971.         lua_setglobal(L, ct->name);      /* 'name' = table */
  4972.       }
  4973.  
  4974.  
  4975.       int i = 0;
  4976.       while (colortable[i].name != NULL)
  4977.         setcolor(L, &colortable[i++]);
  4978.  
  4979.  
  4980.       void call_va (lua_State *L, const char *func,
  4981.                                   const char *sig, ...) {
  4982.         va_list vl;
  4983.         int narg, nres;  /* number of arguments and results */
  4984.      
  4985.         va_start(vl, sig);
  4986.         lua_getglobal(L, func);  /* push function */
  4987.      
  4988.         push and count arguments (Figure 28.6, “Pushing arguments for the generic call function”)
  4989.      
  4990.         nres = strlen(sig);  /* number of expected results */
  4991.      
  4992.         if (lua_pcall(L, narg, nres, 0) != 0)  /* do the call */
  4993.           error(L, "error calling '%s': %s", func,
  4994.                                              lua_tostring(L, -1));
  4995.      
  4996.         retrieve results (Figure 28.7, “Retrieving results for the generic call function”)
  4997.      
  4998.         va_end(vl);
  4999.       }
  5000. Figure 28.6. Pushing arguments for the generic call function
  5001.         for (narg = 0; *sig; narg++) {  /* repeat for each argument */
  5002.      
  5003.           /* check stack space */
  5004.           luaL_checkstack(L, 1, "too many arguments");
  5005.      
  5006.           switch (*sig++) {
  5007.      
  5008.             case 'd':  /* double argument */
  5009.               lua_pushnumber(L, va_arg(vl, double));
  5010.               break;
  5011.      
  5012.             case 'i':  /* int argument */
  5013.               lua_pushinteger(L, va_arg(vl, int));
  5014.               break;
  5015.      
  5016.             case 's':  /* string argument */
  5017.               lua_pushstring(L, va_arg(vl, char *));
  5018.               break;
  5019.      
  5020.             case '>':  /* end of arguments */
  5021.               goto endargs;  /* break the loop */
  5022.      
  5023.             default:
  5024.               error(L, "invalid option (%c)", *(sig - 1));
  5025.           }
  5026.      
  5027.         }
  5028.         endargs: Extending Your Application
  5029. 245
  5030. Figure 28.7. Retrieving results for the generic call function
  5031.         nres = -nres;  /* stack index of first result */
  5032.         while (*sig) {  /* repeat for each result */
  5033.           switch (*sig++) {
  5034.      
  5035.             case 'd': {  /* double result */
  5036.               int isnum;
  5037.               double n = lua_tonumberx(L, nres, &isnum);
  5038.               if (!isnum)
  5039.                 error(L, "wrong result type");
  5040.               *va_arg(vl, double *) = n;
  5041.               break;
  5042.             }
  5043.      
  5044.             case 'i': {  /* int result */
  5045.               int isnum;
  5046.               int n = lua_tointegerx(L, nres, &isnum);
  5047.               if (!isnum)
  5048.                 error(L, "wrong result type");
  5049.               *va_arg(vl, int *) = n;
  5050.               break;
  5051.             }
  5052.      
  5053.             case 's': {  /* string result */
  5054.               const char *s = lua_tostring(L, nres);
  5055.               if (s == NULL)
  5056.                 error(L, "wrong result type");
  5057.               *va_arg(vl, const char **) = s;
  5058.               break;
  5059.             }
  5060.      
  5061.             default:
  5062.               error(L, "invalid option (%c)", *(sig - 1));
  5063.           }
  5064.           nres++;
  5065.         }
  5066.  
  5067.  
  5068.  
  5069.  
  5070. function is minimal:
  5071.       static int l_sin (lua_State *L) {
  5072.         double d = luaL_checknumber(L, 1);
  5073.         lua_pushnumber(L, sin(d));
  5074.         return 1;  /* number of results */
  5075.       }
  5076.       static int l_dir (lua_State *L) {
  5077.         DIR *dir;
  5078.         struct dirent *entry;
  5079.         int i;
  5080.         const char *path = luaL_checkstring(L, 1);
  5081.      
  5082.         /* open directory */
  5083.         dir = opendir(path);
  5084.         if (dir == NULL) {  /* error opening the directory? */
  5085.           lua_pushnil(L);  /* return nil... */
  5086.           lua_pushstring(L, strerror(errno));  /* and error message */
  5087.           return 2;  /* number of results */
  5088.         }
  5089.      
  5090.         /* create result table */
  5091.         lua_newtable(L);
  5092.         i = 1;
  5093.         while ((entry = readdir(dir)) != NULL) {  /* for each entry */
  5094.           lua_pushinteger(L, i++);  /* push key */
  5095.           lua_pushstring(L, entry->d_name);  /* push value */
  5096.           lua_settable(L, -3);    /* table[i] = entry name */
  5097.         }
  5098.      
  5099.         closedir(dir);
  5100.         return 1;  /* table is already on top */
  5101.       }
  5102.  
  5103. static int l_dir (lua_State *L) {
  5104.          as before
  5105.       }
  5106.       static const struct luaL_Reg mylib [] = {
  5107.         {"dir", l_dir},
  5108.         {NULL, NULL}  /* sentinel */
  5109.       };
  5110.  
  5111.  
  5112.       int luaopen_mylib (lua_State *L) {
  5113.         luaL_newlib(L, mylib);
  5114.         return 1;
  5115.       }
  5116.       local mylib = require "mylib"
  5117.  
  5118.       int l_map (lua_State *L) {
  5119.         int i, n;
  5120.      
  5121.         /* 1st argument must be a table (t) */
  5122.         luaL_checktype(L, 1, LUA_TTABLE);
  5123.      
  5124.         /* 2nd argument must be a function (f) */
  5125.         luaL_checktype(L, 2, LUA_TFUNCTION);
  5126.      
  5127.         n = luaL_len(L, 1);  /* get size of table */
  5128.      
  5129.         for (i = 1; i <= n; i++) {
  5130.           lua_pushvalue(L, 2);   /* push f */
  5131.           lua_geti(L, 1, i);  /* push t[i] */
  5132.           lua_call(L, 1, 1);     /* call f(t[i]) */
  5133.           lua_seti(L, 1, i);  /* t[i] = result */
  5134.         }
  5135.      
  5136.         return 0;  /* no results */
  5137.       }
  5138.  
  5139. static int l_split (lua_State *L) {
  5140.         const char *s = luaL_checkstring(L, 1);      /* subject */
  5141.         const char *sep = luaL_checkstring(L, 2);  /* separator */
  5142.         const char *e;
  5143.         int i = 1;
  5144.      
  5145.         lua_newtable(L);  /* result table */
  5146.      
  5147.         /* repeat for each separator */
  5148.         while ((e = strchr(s, *sep)) != NULL) {
  5149.           lua_pushlstring(L, s, e - s);  /* push substring */
  5150.           lua_rawseti(L, -2, i++);   /* insert it in table */
  5151.           s = e + 1;  /* skip separator */
  5152.         }
  5153.      
  5154.         /* insert last substring */
  5155.         lua_pushstring(L, s);
  5156.         lua_rawseti(L, -2, i);
  5157.      
  5158.         return 1;  /* return the table */
  5159.       }
  5160.  
  5161.       static int str_upper (lua_State *L) {
  5162.         size_t l;
  5163.         size_t i;
  5164.         luaL_Buffer b;
  5165.         const char *s = luaL_checklstring(L, 1, &l);
  5166.         char *p = luaL_buffinitsize(L, &b, l);
  5167.         for (i = 0; i < l; i++)
  5168.           p[i] = toupper(uchar(s[i]));
  5169.         luaL_pushresultsize(&b, l);
  5170.         return 1;
  5171.       }
  5172. static int tconcat (lua_State *L) {
  5173.         luaL_Buffer b;
  5174.         int i, n;
  5175.         luaL_checktype(L, 1, LUA_TTABLE);
  5176.         n = luaL_len(L, 1);
  5177.         luaL_buffinit(L, &b);
  5178.         for (i = 1; i <= n; i++) {
  5179.           lua_geti(L, 1, i);  /* get string from table */
  5180.           luaL_addvalue(b);   /* add it to the buffer */
  5181.         }
  5182.         luaL_pushresult(&b);
  5183.         return 1;
  5184.       }
  5185.  
  5186. Статические переменные это реестр.
  5187.    /* store a string */
  5188.       lua_pushlightuserdata(L, (void *)&Key);  /* push address */
  5189.       lua_pushstring(L, myStr);  /* push value */
  5190.       lua_settable(L, LUA_REGISTRYINDEX);  /* registry[&Key] = myStr */
  5191.      
  5192.       /* retrieve a string */
  5193.       lua_pushlightuserdata(L, (void *)&Key);  /* push address */
  5194.       lua_gettable(L, LUA_REGISTRYINDEX);  /* retrieve value */
  5195.       myStr = lua_tostring(L, -1);  /* convert to string */
  5196. We will discuss light userdata in more detail in the section called “Light Userdata”.
  5197. To  simplify  the  use  of  variable  addresses  as  unique  keys,  Lua  5.2  introduced  two  new  functions:
  5198. lua_rawgetp and lua_rawsetp. They are similar to lua_rawgeti and lua_rawseti, but they
  5199. use C pointers (translated to light userdata) as keys. With them, we can write the previous code like this:
  5200.       static char Key = 'k';
  5201.      
  5202.       /* store a string */
  5203.       lua_pushstring(L, myStr);
  5204.       lua_rawsetp(L, LUA_REGISTRYINDEX, (void *)&Key);
  5205.      
  5206.       /* retrieve a string */
  5207.       lua_rawgetp(L, LUA_REGISTRYINDEX, (void *)&Key);
  5208.       myStr = lua_tostring(L, -1);
  5209. int t_tuple (lua_State  *L) {
  5210.         int op  =   luaL_optint(L,  10);
  5211.         if  (op ==  0)  {   /*  нет  аргументов?   */
  5212.                 int i;
  5213.                 /*  заталкивает  каждое    допустимое    верхнее  значение    в  стек    */
  5214.                 for (=   1;  !lua_isnone(L,  lua_upvalueindex(i));   i++)
  5215.                         lua_pushvalue(L,    lua_upvalueindex(i));
  5216.                 return  i   -   1;  /*  число  значений    в  стеке  */
  5217.         }
  5218.         else    {   /*  получает    поле    'op'    */
  5219.                 luaL_argcheck(L,    0   <   op, 1"index  out of  range");
  5220.                 if  (lua_isnone(L,  lua_upvalueindex(op)))
  5221.                         return  0;  /*  такого    поля    нет  */
  5222.                 lua_pushvalue(L,    lua_upvalueindex(op));
  5223.                 return  1;
  5224.         }
  5225. } int   t_new   (lua_State  *L) {
  5226.         lua_pushcclosure(L, t_tuple,    lua_gettop(L));
  5227.         return  1;
  5228. }
  5229. static  const   struct  luaL_Reg    tuplelib    []  =   {
  5230.         {"new", t_new},
  5231.         {NULLNULL}
  5232. };
  5233. int luaopen_tuple   (lua_State  *L) {
  5234.         luaL_newlib(L,  tuplelib);
  5235.         return  1;
  5236.  
  5237.  
  5238.  
  5239.  
  5240. INT lua_next ( lua_State * L, INT индекс);
  5241. получает ключ из стека и отправляет пару ключ-значение из таблицы по заданному индексу («следующая» пара после заданного ключа). Если в таблице больше нет элементов. Ключ имеет -2, а значение -1.
  5242.  
  5243.  lua_next возвращается 0 (и ничего не выдвигается).
  5244. Типичный обход выглядит так:
  5245.      / * таблица находится в стеке с индексом 't' * /
  5246.      lua_pushnil (L); / * первый ключ * /
  5247.      while (lua_next (L, t)! = 0) {
  5248.        / * использует 'ключ' (в индексе -2) и 'значение' (в индексе -1) * /
  5249.        printf ("% s -% s \ n",
  5250.               lua_typename (L, lua_type (L, -2)),
  5251.               lua_typename (L, lua_type (L, -1)));
  5252.        / * удаляет «значение»; держит «ключ» для следующей итерации * /
  5253.        lua_pop (L, 1);
  5254.      }
  5255. При обходе таблицы не вызывайте lua_tolstringнапрямую ключ, если только вы не знаете, что ключ на самом деле является строкой. Напомним, что изменяется значение по заданному индексу; это смущает следующий звонок . lua_tolstring lua_next
  5256.  
  5257. недействительными * lua_newuserdata ( lua_State * L, size_t размера);
  5258. Эта функция выделяет новый блок памяти с заданным размером, помещает в стек новые полные пользовательские данные с адресом блока и возвращает этот адрес.
  5259. Пользовательские данные представляют значения C в Lua. Полный UserData представляет собой блок памяти. Это объект (например, таблица): вы должны создать его, у него может быть свой собственный метатабль, и вы можете определить, когда он собирается. Полные пользовательские данные равны только себе (при необработанном равенстве).
  5260. Когда Lua собирает полные данные пользователя с gcметаметодом, Lua вызывает метаметод и помечает данные пользователя как завершенные. Когда эти пользовательские данные собираются снова, Lua освобождает соответствующую память.
  5261. недействительный lua_pushlightuserdata ( lua_State * L, недействительный * р);
  5262. Помещает легкие пользовательские данные в стек.
  5263. Пользовательские данные представляют значения C в Lua. Свет UserData представляет собой указатель. Это значение (например, число): вы не создаете его, у него нет индивидуального метатабора, и оно не собирается (как оно никогда не создавалось). Легкие пользовательские данные равны «любым» легким пользовательским данным с тем же C-адресом.
  5264.  
  5265. недействительными * lua_touserdata ( lua_State * L, INT индекс);
  5266. Если значение в данном приемлемом индексе является полными данными пользователя, возвращает адрес его блока. Если значение является легким userdata, возвращает его указатель. В противном случае возвращается NULL.
  5267.  
  5268.  
  5269.     //cout << lua_tostring(lua, 1)<< endl;
  5270.     lua_assert(lua_isstring);
  5271.     lua_pop(lua, 1);// удалить n элементы из стека.
  5272.  
  5273.  
  5274. cout << "\t " << lua_tostring(L, -4) << endl;
  5275.     cout << "\t " << lua_toboolean(L, -3) << endl;
  5276.     cout << "\t " << lua_tonumber(L, -2) << endl;
  5277.     cout << "\t " << lua_tonumber(L, -1) << endl;*/
  5278.  
  5279. static void stackDump(lua_State *L) {
  5280.     int i;
  5281.     int top = lua_gettop(L); /* глубина стека */
  5282.     for (i = 1; i <= top; i++) { /* повторить для каждого уровня */
  5283.         int t = lua_type(L, i); switch (t) {
  5284.         case LUA_TSTRING: { /* strings */ printf("'%s' ", lua_tostring(L, i)); break;   }
  5285.         case LUA_TBOOLEAN: { /* booleans */
  5286.             printf(lua_toboolean(L, i) ? "true " : "false "); break;
  5287.         case LUA_TNUMBER: { /* numbers */ printf("%g ", lua_tonumber(L, i)); break; }
  5288.  
  5289.         default: { /* other values */
  5290.             printf("%s ", lua_typename(L, t)); break;  }
  5291.                  printf(" "); /* put a separator */     }       }
  5292.     }
  5293.     printf("\n"); /* end the listing */
  5294.     return;
  5295. }
  5296. int main(int argc, char *argv[]) {
  5297.  
  5298.     lua_State *L = luaL_newstate();
  5299.     luaL_openlibs(L);//открыть все стандартные библиотеки lua.
  5300.     luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. Файл в котором все происходит.
  5301.     lua_pushboolean(L, 1);
  5302.     lua_pushnumber(L, 10);
  5303.     lua_pushnil(L);
  5304.     lua_pushstring(L, "hello");
  5305.     stackDump(L);   /* true 10 nil 'hello' */
  5306.     lua_pushvalue(L, -4);// копировать элемент в стеке -1.
  5307.     stackDump(L);   /* true 10 nil 'hello' true */
  5308.     lua_replace(L, 3);// снимает значение с вершины стека и устанавливает его как значение элемента с заданным индексом.
  5309.     stackDump(L);   /* true 10 true 'hello' */
  5310.     lua_settop(L, 6);
  5311.     stackDump(L);   /* true 10 true 'hello' nil nil */
  5312.     lua_remove(L, -3);
  5313.     stackDump(L);/* true 10 true nil nil */
  5314.     lua_settop(L, -5);
  5315.     stackDump(L);   /* true */
  5316.  
  5317.     lua_close(L);// закрыть состояние
  5318.     cin.get();//ожидает ввода символа программа завершается.
  5319.     return 0;
  5320. }
  5321.  
  5322.  
  5323. int main(int argc, char *argv[]) {
  5324. constexpr char* LUA_FILE = R"(
  5325.  function Return4()
  5326.   return 4
  5327. end
  5328.  )";
  5329.         lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  5330.         luaL_dostring(L, LUA_FILE);
  5331.         lua_getglobal(L, "Return4");
  5332.  
  5333.         if (lua_iscfunction(L, -1)) {
  5334.  
  5335.             lua_pcall(L, 0, 1, 0);
  5336.  
  5337.             lua_Number number = lua_tonumber(L, -1);// получить 10 из стека 1
  5338.             cout << (int)number << endl;
  5339.         }
  5340.         lua_close(L);
  5341.    
  5342. return 0;
  5343. }
  5344.  
  5345.  
  5346. #include<iostream>
  5347. #include<string>
  5348. #include <stdio.h>
  5349. #include <string>
  5350. #include"lua/lua.hpp"
  5351. using namespace std;
  5352.  
  5353. int main(int argc, char *argv[]) {
  5354. lua_State *lua = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией
  5355.  выделения памяти на основе стандартной функции C realloc и затем устанавливает "тревожную" (panic) функцию,
  5356.  которая печатает сообщение об ошибке к стандартному выводу ошибки в случае фатальных (неустранимых) ошибок.
  5357.  Возвращает новое состояние или значение NULL, если есть ошибка выделения памяти.*/
  5358.     luaL_dostring(lua, "x = 2");/*отправляет строку- переменную = 2 в стек. Функция определяется как следующий макрос */
  5359.     lua_getglobal(lua, "x");// получить значение x
  5360.     if (lua_isnumber(lua, 1)) {//  если 1 позиция в стеке число.
  5361.         int number = lua_tonumber(lua, 1);
  5362.         cout <<"x = "<< number;
  5363.     }
  5364.     return 0;
  5365. }
  5366.     lua_pushcfunction(L, getst);//уст указатель на функцию C++ и создает внутри Lua
  5367.     lua_setglobal(L, "getst"); //получает значение из стека и уст значение global name.
  5368.     luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
  5369.     //lua_pcall(L, 0, 0, 0);// вызов функции в lua файле.
  5370.  
  5371. #include<iostream>
  5372. #include"lua/lua.hpp"
  5373. using namespace std;
  5374. int main() {
  5375.     lua_State *lua = luaL_newstate();
  5376.     luaL_openlibs(lua);//открыть все стандартные библиотеки lua.
  5377.     luaL_dofile(lua, "main.lua");// Загружает и запускает заданный файл. Файл в котором все происходит.
  5378.     lua_pcall(lua, 0, 0, 0);// вызов функции в lua файле.  1 параметр кол-во передаваемых, кол-во возвращаемых, обработчик ошибок.
  5379.    
  5380.     lua_close(lua);// закрыть состояние
  5381.     cin.get();//ожидает ввода символа программа завершается.
  5382.  
  5383.     return 0;
  5384. }
  5385. lua
  5386. --print(2362)
  5387.  
  5388.  
  5389.  
  5390.  
  5391. int lua_sq(lua_State *L) {// передаем указатель на состояние.
  5392.     int x = lua_tonumber(L, 1); // получаем 1 элемент из стека.
  5393.     lua_pushnumber(L, x*x);// умножаем x и отправляет в стек.
  5394.     return 1;// вернуть 1.
  5395. }
  5396. int main() {
  5397.     lua_State *L = luaL_newstate();
  5398.     luaL_openlibs(L);//открыть все стандартные библиотеки lua.
  5399.     lua_register(L, "sq", lua_sq);// регистрируем функцию- имя состояние, имя функ в lua, имя функ тут.
  5400.     luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
  5401.     lua_pcall(L, 0, 0, 0);// вызов функции, передаем 2 параметра, возвращаем 1.
  5402.     lua_close(L);// закрыть состояние
  5403.     cin.get();//ожидает ввода символа программа завершается.
  5404. return 0;}
  5405.  
  5406. на Lua.
  5407.  
  5408. print(sq(2))
  5409.  
  5410. struct st
  5411. {
  5412.     int x;
  5413.  
  5414. };
  5415.  
  5416. int getst(lua_State *L) {// передаем указатель на состояние
  5417.     st* sp = (st*)lua_newuserdata(L, sizeof(sp));// выделяет памяти с заданным размером,
  5418.     //помещает в стек пользовательские данныеа и возвращает этот адрес.
  5419.     int x1;
  5420.     if (lua_isnumber(L, 1)) {//  если 1 позиция в стеке число.
  5421.          x1 = lua_tonumber(L, 1);} // получаем 1 элемент из стека.
  5422.     else x1 = 0;// что мы передим в getst(2), то будет в структуре
  5423.     sp->x = x1;
  5424.     return 1;// вернуть 1.
  5425. }
  5426. int main() {
  5427.     lua_State *L = luaL_newstate();
  5428.     luaL_openlibs(L);//открыть все стандартные библиотеки lua.
  5429.     lua_pushcfunction(L, getst);//уст указатель на функцию C++ и создает внутри Lua
  5430.     lua_setglobal(L, "getst"); //получает значение из стека и уст значение global name.
  5431.     luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
  5432.     //lua_pcall(L, 0, 0, 0);// вызов функции в lua файле.
  5433.     lua_getglobal(L, "sp");// получить значение глобальной переменной.
  5434.     st* sp = (st*)lua_touserdata(L, -1);// получить значение поля структруры из стека.
  5435.     cout << sp->x  << endl;//  
  5436.     lua_close(L);// закрыть состояние
  5437.     cin.get();//ожидает ввода символа программа завершается.
  5438. return 0;}
  5439.  
  5440. lua
  5441. sp=getst()
  5442. print(sp)—адрес памяти выводится
  5443.  
  5444.  
  5445.  
  5446. #include<iostream>
  5447. #include<string>
  5448. #include <stdio.h>
  5449. #include"lua/lua.hpp"
  5450. using namespace std;
  5451.  
  5452. int main() {
  5453.     lua_State *L = luaL_newstate();
  5454.     luaL_openlibs(L);//открыть все стандартные библиотеки lua.
  5455.        luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
  5456.     //lua_pcall(L, 0, 0, 0);// вызов функции в lua файле.
  5457.     lua_getglobal(L, "t");// получить значение глобальной переменной, таблица.
  5458.     lua_assert(lua_istable(L, 1));// проверить является 1 элемент стека таблицей
  5459.     lua_pushstring(L, "x");// отправить ключ x в стек.
  5460.     lua_gettable(L, 1);// получить значение по ключу из стека.
  5461.     lua_assert(lua_isnumber(L, 2));// проверить является значение 2 элемента стека число.  
  5462.     int x = lua_tonumber(L, 2);
  5463.     lua_getglobal(L, "t");// получить значение глобальной переменной таблица.
  5464.     lua_pushstring(L, "y");
  5465.     lua_gettable(L, 1);
  5466.     lua_assert(lua_isstring(L, 4));
  5467.     string y = lua_tostring(L, 4);
  5468.     lua_getglobal(L, "t");// получить значение глобальной переменной, таблицей.
  5469.     lua_getfield(L, 5, "z");// отправить ключ в таблицу.
  5470.     lua_assert(lua_isboolean(L, 5));
  5471.     bool z = lua_toboolean(L, 5);// получить булевое значение по ключу.
  5472.     lua_getglobal(L, "t");// получить значение глобальной переменной, таблицей.
  5473.     lua_pushstring(L, "dog");// отправить значение в таблицу.
  5474.     lua_setfield(L, 5, "a");// уст ключ для него.
  5475.     lua_getglobal(L, "t");// получить значение глобальной переменной, таблицей.
  5476.     lua_getfield(L, 5, "a");// отправить ключ в таблицу.
  5477.     lua_assert(lua_isstring(L, 5));
  5478.     string a = lua_tostring(L, -1);
  5479.     cout <<"x = "<<x <<"\ny = "<<y<<"\nz = "<< z << "\na = " << a <<endl;
  5480.     lua_close(L);// закрыть состояние
  5481.     cin.get();//ожидает ввода символа программа завершается.
  5482. return 0;}
  5483. lua
  5484.  
  5485. t= {x=23,y="yes",z=true}
  5486.  
  5487. struct strlua
  5488. {   int x;
  5489. strlua(int x){
  5490.     this->x = x;
  5491. }
  5492. void st(int x){
  5493.     this->x = x;
  5494. }
  5495.  
  5496. };
  5497. int LUA_new(lua_State *S) {
  5498.     strlua *p = new strlua(lua_tonumber(S, 1));
  5499.     lua_pushlightuserdata(S,p);
  5500.     return 0;
  5501. }
  5502. int LUA_set(lua_State *S){
  5503.   strlua *p = (strlua*)lua_touserdata(S,1);
  5504.   p->st(lua_tonumber(S, 1 ));
  5505.     return 0;
  5506. }
  5507. int main() {
  5508.     lua_State *S = luaL_newstate();
  5509.     luaL_openlibs(S);
  5510.     lua_register(S, "new", LUA_new);
  5511.     lua_register(S,"set", LUA_set);
  5512.     luaL_loadfile(S, "man.lua");
  5513.     lua_call(S, 0, 0);
  5514.     cin.get();
  5515.     return 0;
  5516.  
  5517. a=new(2)
  5518. b=set(3)
  5519. print(a)
  5520. print(b)
  5521. struct color{ char r,g,b;
  5522. };
  5523. void LUA_set(lua_State *S, string str, color *& pal) {
  5524.     lua_getglobal(S, str.c_str());
  5525.     lua_pushstring(S, "co");
  5526.     lua_gettable(S, -2);
  5527.     lua_call(S, 0, 4);
  5528.     pal[0] = *(color*)lua_touserdata(S, -4);
  5529.     pal[1] = *(color*)lua_touserdata(S, -3);
  5530.     pal[2] = *(color*)lua_touserdata(S, -2);
  5531.     pal[3] = *(color*)lua_touserdata(S, -1);
  5532.     lua_pop(S, 5);
  5533. }
  5534. int LUA_make(lua_State *S) {
  5535.     color *p = (color*