Advertisement
egor230

lua api c++

Feb 19th, 2019
502
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 461.42 KB | None
  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.     pushlua(L, 10);
  634.     pushlua(L, 10.20);
  635.     pushlua(L, "10");
  636.     pushlua(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. int main() {
  1860.     lua_State* L = luaL_newstate(); luaL_openlibs(L);
  1861.     checkerror(L, LUA);
  1862.     lua_State* L1 = lua_newthread(L);
  1863.     int ret = 3;
  1864.     void *key = &ret;
  1865.     cout << key << endl;
  1866.     lua_pushlightuserdata(L, key);  /*отправить адресс, который является ключом в стек. */
  1867.        const void *v = lua_topointer(L,-1);
  1868.        cout << v << endl;
  1869.     return 0;
  1870. };
  1871.  
  1872. Вызывает функцию в защищенном режиме.
  1873. Оба nargs и nresults имеют то же значение, что и в lua_call. Если при звонке ошибок нет, lua_pcall ведет себя точно так же lua_call. Однако, если есть какая-либо ошибка, lua_pcall она перехватывает ее, помещает в стек одно значение (сообщение об ошибке) и возвращает код ошибки. Мол lua_call, lua_pcall всегда удаляет функцию и ее аргументы из стека.
  1874. Если errfunc равно 0, то сообщение об ошибке, возвращаемое в стеке, является точно исходным сообщением об ошибке. В противном случае errfunc это индекс стека функции обработчика ошибок . (В текущей реализации этот индекс не может быть псевдоиндексом.) В случае ошибок времени выполнения эта функция будет вызываться с сообщением об ошибке, а ее возвращаемое значение будет сообщением, возвращаемым в стеке lua_pcall.
  1875. Как правило, функция обработчика ошибок используется для добавления дополнительной отладочной информации к сообщению об ошибке, такой как трассировка стека. Такая информация не может быть собрана после возврата lua_pcall, так как к тому времени стек уже размотан.
  1876. lua_pcall Функция возвращает 0 в случае успеха или один из следующих кодов ошибок (определены в lua.h):
  1877. LUA_ERRRUN: ошибка во время выполнения.
  1878. LUA_ERRMEM: ошибка выделения памяти. Для таких ошибок Lua не вызывает функцию обработчика ошибок.
  1879. LUA_ERRERR: ошибка при запуске функции обработчика ошибок.
  1880.  
  1881.  
  1882.  
  1883.  
  1884.  
  1885. api lua c++. Реализация ООП через функции. Структура конструктор по умолчанию.
  1886.  
  1887. int checklua(lua_State *L, const char *file) {
  1888.     int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
  1889.     try {
  1890.         if (status == 0) {// если нет ошибки в файле.
  1891.             luaL_dofile(L, file);// запуск файла, в которым все происходит.
  1892.             return 0;
  1893.         }
  1894.         else {
  1895.             string x = lua_tostring(L, -1);
  1896.             throw x;
  1897.         }
  1898.     }
  1899.     catch (string x) {
  1900.         cout << x << endl;
  1901.         //luaL_error(L,"error");
  1902.     }
  1903. };
  1904. struct a {  int x = 30;
  1905. a() { this->x = x; }//конструктор по умолчанию
  1906.     void show() { cout << "x = " << x << endl; }    
  1907. ~a() { cout << "destory object " << this << endl << endl; }
  1908. };
  1909. int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
  1910.     a* st = (a*)lua_touserdata(L, -1);/* Если значение в данном приемлемом индексе является полными данными пользователя.*/
  1911.     st->~a();//вызов метода деструктор.
  1912.     return 0;};
  1913.  
  1914. int create(lua_State* L) {//Функция создания объекта структуры.
  1915.     void* st = lua_newuserdata(L, sizeof(a));/*Эта функция выделяет новый блок памяти с заданным размером,*/
  1916.     new (st) a();// Выделить память под польз. данные.
  1917.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  1918.     lua_setmetatable(L, 1);//получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
  1919.     return 1;};
  1920.  
  1921. int show(lua_State* L) {
  1922.     a* st = (a*)lua_touserdata(L, -1);// получаем польз. данные.
  1923.     st->show();// вызов метода.
  1924.     return 0;};
  1925.  
  1926. int main() {
  1927.     lua_State* L = luaL_newstate();
  1928.     lua_newtable(L);
  1929.     lua_pushcfunction(L, create);//уст указатель на функцию C++ и создает внутри Lua
  1930.     lua_setglobal(L, "get"); //получает значение из стека и уст значение global name.
  1931.     lua_pushcfunction(L, show);
  1932.     lua_setglobal(L, "show"); //получает значение из стека и уст значение global name.
  1933.     luaL_newmetatable(L, "mt");/*int luaL_newmetatable (lua_State * L, const char * t); */
  1934.     lua_pushstring(L, "__gc");
  1935.     lua_pushcfunction(L, destroy);
  1936.     lua_settable(L, 2);
  1937.     checklua(L, "main.lua");
  1938.     showstack(L);// вывести стек.
  1939.     lua_close(L);// закрыть состояние
  1940.     cin.get();//ожидает ввода символа программа завершается.
  1941. return 0;}
  1942.  
  1943. lua
  1944. a= get()
  1945. show(a)
  1946.  
  1947. передача польз. Данных.
  1948.  
  1949. struct a {  int x = 3010;
  1950. a() { this->x = x; }//конструктор по умолчанию
  1951.     void show() { cout << "x = " << x << endl; }
  1952. };
  1953.  
  1954. int create(lua_State* L) {//    Функция создания объекта структуры.
  1955.     void* st = lua_newuserdata(L, sizeof(a));/*Эта функция выделяет новый блок памяти с заданным размером,*/
  1956.     new (st) a();// Выделить память под польз. данные.
  1957.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  1958.     lua_setmetatable(L, 1);//получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
  1959.     return 1;};
  1960.  
  1961. int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
  1962.     a* st = (a*)lua_touserdata(L, 1);/* Если значение в данном приемлемом индексе является полными данными пользователя.*/
  1963.     st->~a();//вызов метода деструктор.
  1964.     return 0;};
  1965.  
  1966. int show(lua_State* L) {
  1967.     a* st = (a*)lua_touserdata(L, -1);
  1968.     st->show();
  1969.     return 0;};
  1970.  
  1971. int main() {
  1972.     lua_State* L = luaL_newstate();
  1973.     lua_newtable(L);
  1974.     lua_pushcfunction(L, create);//уст указатель на функцию C++ и создает внутри Lua
  1975.     lua_setglobal(L, "get"); //получает значение из стека и уст значение global name.
  1976.     lua_pushcfunction(L, show);
  1977.     lua_setglobal(L, "show"); //получает значение из стека и уст значение global name.
  1978.     luaL_newmetatable(L, "mt");/*int luaL_newmetatable (lua_State * L, const char * t); */
  1979.     lua_pushstring(L, "__gc");
  1980.     lua_pushcfunction(L, destroy);
  1981.     lua_settable(L, 2);
  1982.     luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
  1983.     lua_close(L);// закрыть состояние
  1984.     cin.get();//ожидает ввода символа программа завершается.
  1985. return 0;
  1986. }
  1987. Lua
  1988.  
  1989. a = get()
  1990. show(a)
  1991.  
  1992.  
  1993.  
  1994.  
  1995. api lua c++. Реализация ООП через функции 2. Структура конструктор по умолчанию.
  1996.  
  1997. struct a {
  1998.     int x = 10;
  1999.     a() { cout << "create object " << this << endl; }//конструктор по умолчанию
  2000.  
  2001.     void show() { cout << "\nobject - " << this << "\tx = " << x <<"\n\n"; }//вывести значение x на экран.
  2002.  
  2003.     ~a() { cout << "destory object " << this << endl << endl; }//вызов деструктора.
  2004. };
  2005.  
  2006. int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
  2007.     cout << "destroy " << endl;
  2008.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  2009.     a** st = (a**)lua_touserdata(L, -2); // получаем польз. данные.
  2010.     //a *b = &**st;
  2011.     //b->~a();//вызов метода деструктор.
  2012.     delete *st;
  2013.     return 0;
  2014.  
  2015. };
  2016. int create(lua_State* L) {//    Функция создания объекта структуры.
  2017.     luaL_newmetatable(L, "mt");// создать мета таблицу.
  2018.     lua_pushstring(L, "__gc");// отправить в стек сборщик мусора.
  2019.     lua_pushcfunction(L, destroy);// установить значение ключа, как вызов деструктор.
  2020.  
  2021.     lua_settable(L, -3);// установить таблицу.
  2022.     a** c = (a**)lua_newuserdata(L, sizeof(a*));/*Эта функция выделяет новый блок памяти с заданным размером,*/
  2023.     *c = new a();
  2024.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  2025.  
  2026.     lua_setmetatable(L, -2); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
  2027.  
  2028. return 1;
  2029. };
  2030. int show(lua_State* L) {
  2031.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  2032.     a** st = (a**)lua_touserdata(L, -2);// получаем польз. данные.
  2033.     a *b = &**st;
  2034.     b->show();// вызов метода.  
  2035.     return 0;
  2036. };
  2037.  
  2038. int main() {
  2039.     lua_State* L = luaL_newstate();
  2040.     lua_register(L, "create", create );//уст указатель на функцию C++ и создает внутри Lua
  2041.     lua_register(L, "show", show); //получает значение из стека и уст значение global name.
  2042.     lua_register(L, "__gc", destroy); //получает значение из стека и уст значение global name.
  2043.     luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
  2044.  
  2045.     lua_close(L);// закрыть состояние
  2046.     cin.get();//ожидает ввода символа программа завершается.
  2047.     return 0;
  2048. }
  2049.  
  2050.  
  2051. lua
  2052. a= create()
  2053. show(a)
  2054.  
  2055.  
  2056. Выводится
  2057. create object 0152FD78
  2058.  
  2059. object - 0152FD78       x = 10
  2060.  
  2061. destroy
  2062. destory object 0152FD78
  2063.  
  2064.  
  2065.  
  2066.  
  2067. api lua c++. Реализация ООП через функции 2. 2 класса. Структура конструктор по умолчанию.
  2068.  
  2069.  
  2070. struct a {
  2071.     int x = 10;
  2072.     a() { cout << "create object " << this << endl; }//конструктор по умолчанию
  2073.  
  2074.     void show() { cout << "\nobject - " << this << "\tx = " << x << "\n\n"; }//вывести значение x на экран.
  2075.     void get() { cout << "\nget "<< "\n\n"; }//вывести значение x на экран.
  2076.  
  2077.     ~a() { cout << "destory object " << this << endl << endl; }//вызов деструктора.
  2078. };
  2079. struct b {
  2080.     int y = 10;
  2081.     b() { cout << "create object b" << this << endl; }//конструктор по умолчанию
  2082.  
  2083.     void get() { cout << "\ngeta " << "\n\n"; }//вывести значение x на экран.
  2084.  
  2085.     ~b() { cout << "destory object " << this << endl << endl; }//вызов деструктора.
  2086. };
  2087. int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
  2088.     cout << "destroy " << endl;
  2089.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  2090.     a** st = (a**)lua_touserdata(L, -2); // получаем польз. данные.
  2091.     //a *b = &**st;
  2092.     //b->~a();//вызов метода деструктор.
  2093.     delete *st;
  2094.     return 0;
  2095.  
  2096. };
  2097. int create(lua_State* L) {//    Функция создания объекта структуры.
  2098.     luaL_newmetatable(L, "mt");// создать мета таблицу.
  2099.     lua_pushstring(L, "__gc");// отправить в стек сборщик мусора.
  2100.     lua_pushcfunction(L, destroy);// установить значение ключа, как вызов деструктор.
  2101.  
  2102.     lua_settable(L, -3);// установить таблицу.
  2103.     a** c = (a**)lua_newuserdata(L, sizeof(a*));/*Эта функция выделяет новый блок памяти с заданным размером,*/
  2104.     *c = new a();
  2105.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  2106.  
  2107.     lua_setmetatable(L, -2); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
  2108.  
  2109. return 1;
  2110. };
  2111. int create1(lua_State* L) {//   Функция создания объекта структуры.
  2112.     luaL_newmetatable(L, "mt");// создать мета таблицу.
  2113.     lua_pushstring(L, "__gc");// отправить в стек сборщик мусора.
  2114.     lua_pushcfunction(L, destroy);// установить значение ключа, как вызов деструктор.
  2115.  
  2116.     lua_settable(L, -3);// установить таблицу.
  2117.     b** c = (b**)lua_newuserdata(L, sizeof(b*));/*Эта функция выделяет новый блок памяти с заданным размером,*/
  2118.     *c = new b();
  2119.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  2120.  
  2121.     lua_setmetatable(L, -2); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
  2122.  
  2123.     return 1;
  2124. };
  2125. int show(lua_State* L) {
  2126.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  2127.     a** st = (a**)lua_touserdata(L, -2);// получаем польз. данные.
  2128.     a *b = &**st;
  2129.     b->show();// вызов метода.  
  2130.     return 0;
  2131. };
  2132. int get(lua_State* L) {
  2133.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  2134.     a** st = (a**)lua_touserdata(L, -2);// получаем польз. данные.
  2135.     a *b = &**st;
  2136.     b->get();// вызов метода.   
  2137.     return 0;
  2138. };
  2139.  
  2140. int geta(lua_State* L) {
  2141.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  2142.     b** st = (b**)lua_touserdata(L, -2);// получаем польз. данные.
  2143.     b *c = &**st;
  2144.     c->get();// вызов метода.   
  2145.     return 0;
  2146. };
  2147.  
  2148. int main() {
  2149.     lua_State* L = luaL_newstate();
  2150.     lua_register(L, "create", create);//уст указатель на функцию C++ и создает внутри Lua
  2151.     lua_register(L, "create1", create1);//уст указатель на функцию C++ и создает внутри Lua
  2152.     lua_register(L, "show", show); //получает значение из стека и уст значение global name.
  2153.     lua_register(L, "get", get); //получает значение из стека и уст значение global name.
  2154.     lua_register(L, "geta", geta); //получает значение из стека и уст значение global name.
  2155.     lua_register(L, "__gc", destroy); //получает значение из стека и уст значение global name.
  2156.     luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
  2157.  
  2158.     lua_close(L);// закрыть состояние
  2159.     cin.get();//ожидает ввода символа программа завершается.
  2160.     return 0;
  2161. }
  2162.  
  2163.  
  2164.  
  2165.  
  2166.  
  2167. lua
  2168. a1 = create()
  2169. show(a1)
  2170. get(a1)
  2171. a2 = create1()
  2172. show(a2)
  2173. geta(a2)
  2174. a3 = create()
  2175. show(a3)
  2176.  
  2177. Выводится
  2178.  
  2179.  
  2180. create object 0157AE00
  2181.  
  2182. object - 0157AE00       x = 10
  2183.  
  2184.  
  2185. get
  2186.  
  2187. create object b01582220
  2188.  
  2189. object - 01582220       x = 10
  2190.  
  2191.  
  2192. geta
  2193.  
  2194. create object 0157FDA0
  2195.  
  2196. object - 0157FDA0       x = 10
  2197.  
  2198. destroy
  2199. destory object 0157FDA0
  2200.  
  2201. destroy
  2202. destory object 01582220
  2203.  
  2204. destroy
  2205. destory object 0157AE00
  2206.  
  2207.  
  2208.  
  2209.  
  2210.  
  2211. api lua c++. Реализация ООП через функции. Структура, конструктор с парамертами.
  2212.  
  2213. struct a {  int x = 10;
  2214. a() { this->x = x; cout << "create object " << this << endl;}//конструктор по умолчанию
  2215.  
  2216. a(int x) { this->x = x; cout << "create object " << this << endl; }//конструктор с параметрами.
  2217. void show() { cout << "\nobject - " << this << "\nx = " << x << endl; }//вывести значение x на экран.
  2218.  
  2219. ~a() { cout << "destory object " << this << endl << endl; }//вызов деструктора.
  2220. };
  2221. int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
  2222.     a* st = (a*)lua_touserdata(L, -1);/* Если значение в данном приемлемом индексе является полными данными пользователя.*/
  2223.     st->~a();//вызов метода деструктор.
  2224.     return 0;};
  2225.  
  2226. int create(lua_State* L) {//    Функция создания объекта структуры.
  2227.     void* st = lua_newuserdata(L, sizeof(a));/*Эта функция выделяет новый блок памяти с заданным размером,*/
  2228.        
  2229.     if (LUA_TNUMBER == lua_type(L, -2)) {// значение число.
  2230.         int x = lua_tointeger(L, -2);
  2231.         new (st) a(x);// Выделить память под польз. данные.
  2232.         luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  2233.         lua_setmetatable(L, -2);//получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
  2234.     }
  2235.     else {  new (st) a();// Выделить память под польз. данные.
  2236.         luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  2237.         lua_setmetatable(L, -2);};//получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
  2238.     return 1;};
  2239.  
  2240. int show(lua_State* L) {
  2241.     a* st = (a*)lua_touserdata(L, -1);// получаем польз. данные.
  2242.     st->show();// вызов метода.
  2243.     return 0;};
  2244.  
  2245. int main() {
  2246.     lua_State* L = luaL_newstate();
  2247.     lua_newtable(L);
  2248.     lua_pushcfunction(L, create);//уст указатель на функцию C++ и создает внутри Lua
  2249.     lua_setglobal(L, "get"); //получает значение из стека и уст значение global name.
  2250.     lua_pushcfunction(L, show);
  2251.     lua_setglobal(L, "show"); //получает значение из стека и уст значение global name.
  2252.     luaL_newmetatable(L, "mt");/*int luaL_newmetatable (lua_State * L, const char * t); */
  2253.     lua_pushstring(L, "__gc");
  2254.     lua_pushcfunction(L, destroy);
  2255.     lua_settable(L, -3);
  2256.     luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
  2257.     lua_close(L);// закрыть состояние
  2258.     cin.get();//ожидает ввода символа программа завершается.
  2259. return 0;
  2260. }
  2261.  
  2262. Lua
  2263. a1 = get()
  2264. show(a1)
  2265. a2 = get(2)
  2266. show(a2)
  2267. a3 = get(3)
  2268. show(a3)
  2269.  
  2270. struct a {
  2271.     int x = 10;
  2272.     a() { cout << "create object " << this << endl; }//конструктор по умолчанию
  2273.  
  2274.     void show() { cout << "\nobject - " << this << "\tx = " << x <<"\n\n"; }//вывести значение x на экран.
  2275.  
  2276.     ~a() { cout << "destory object " << this << endl << endl; }//вызов деструктора.
  2277. };
  2278.  
  2279. int create(lua_State* L) {//    Функция создания объекта структуры.
  2280.     a** c = (a**)lua_newuserdata(L, sizeof(a*));/*Эта функция выделяет новый блок памяти с заданным размером,*/
  2281.     *c = new a();
  2282.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  2283.     lua_setmetatable(L, -1); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
  2284.  
  2285. return 1;
  2286. };
  2287.  int show(lua_State* L) {
  2288.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  2289.  
  2290.     a** st = (a**)lua_touserdata(L, -2);// получаем польз. данные.
  2291.     (*st)->show();// вызов метода.
  2292.     a *b = &**st;
  2293.     b->show();// вызов метода.
  2294.     return 0;
  2295. };
  2296.  
  2297. int main() {
  2298.     lua_State* L = luaL_newstate();
  2299.     lua_register(L, "create", create );//уст указатель на функцию C++ и создает внутри Lua
  2300.     lua_register(L, "show", show); //получает значение из стека и уст значение global name.
  2301.     luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
  2302.     lua_close(L);// закрыть состояние
  2303.     cin.get();//ожидает ввода символа программа завершается.
  2304.     return 0;
  2305. }
  2306.  
  2307. Вариант 2.
  2308.  
  2309.  
  2310. struct a{int x=0;
  2311.   a() : x() { cout <<"create object "<< this << endl; }//конструктор по умолчанию
  2312.  
  2313.     void set(int x){this->x = x;}//уст значение x.
  2314.  
  2315.     void show() {cout << "object - " << this << " x = " << x << endl;}
  2316.     //вывести значение x на экран.
  2317.     ~a() {cout <<"destory object "<< this << endl;  }//вызов деструктора.
  2318. };
  2319.  
  2320. int create(lua_State* L){// Функция создания объекта структуры.
  2321.     void* pointerToAa = lua_newuserdata(L, sizeof(a));/*Эта функция выделяет новый блок памяти с заданным размером,
  2322. помещает в стек новые полные пользовательские данные с адресом блока и возвращает этот адрес. Пользовательские данные
  2323. представляют значения C в Lua. Полный UserData представляет собой блок памяти. Это объект (например, таблица):
  2324. вы должны создать его, у него может быть свой собственный метатабль, и вы можете определить, когда он собирается.
  2325. Полные пользовательские данные равны только себе (при необработанном равенстве). Когда Lua собирает полные данные
  2326. пользователя с gcметаметодом, Lua вызывает метаметод и помечает данные пользователя как завершенные.
  2327. Когда эти пользовательские данные собираются снова, Lua освобождает соответствующую память.*/
  2328.     new (pointerToAa) a();// Выделить память под польз. данные.
  2329.     luaL_getmetatable(L, "aMetaTable"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.
  2330.     Если индекс не является действительным, или если значение не имеет метатаблицы, функция возвращает 0 и не отправляет ничего в стеке.*/
  2331.     lua_assert(lua_istable(L, 2));//ловит исключения если ли условия ложное.
  2332.     lua_setmetatable(L, 1);//получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
  2333.     return 1;
  2334. };
  2335.  
  2336. int destroy(lua_State* L){// Функция вызывает деструктор для объекта.
  2337.     a* st = (a*)lua_touserdata(L, 1);/* Если значение в данном приемлемом индексе является полными данными пользователя,
  2338.     возвращает адрес его блока. Если значение является легким userdata, возвращает его указатель.В противном случае возвращается NULL.*/
  2339.     st->~a();//вызов метода деструктор.
  2340.     return 0;};
  2341.  
  2342. int set(lua_State* L){
  2343.     a* st = (a*)lua_touserdata(L, 1);
  2344.     lua_Number x = lua_tonumber(L, 2);
  2345.     st->set((int)x);
  2346.     return 0;};
  2347.  
  2348. int show(lua_State* L){
  2349.     a* st = (a*)lua_touserdata(L, 1);
  2350.     st->show();
  2351.     return 0;};
  2352.  
  2353. int index(lua_State* L){
  2354.     lua_assert(lua_isuserdata(L, 1));
  2355.     lua_assert(lua_isstring(L, 2));
  2356.  
  2357.     a* st = (a*)lua_touserdata(L, 1);
  2358.     const char* index = lua_tostring(L, 2);
  2359.     if (strcmp(index, "x") == 0){
  2360.         lua_pushnumber(L, st->x);
  2361.         return 1;   }
  2362.     else{lua_getglobal(L, "a");
  2363.         lua_pushstring(L, index);
  2364.         lua_rawget(L, 3);// Аналогично lua_settable, но делает необработанное назначение(т.Е.Без метаметодов).
  2365.         return 1;   }
  2366. };
  2367.  
  2368. int newindex(lua_State* L){
  2369.     lua_assert(lua_isuserdata(L, -3));
  2370.     lua_assert(lua_isstring(L, -2));//
  2371.     a* st = (a*)lua_touserdata(L, -3);
  2372.     const char* index = lua_tostring(L, -2);
  2373.     if (strcmp(index, "x") == 0){
  2374.         st->x = (int)lua_tonumber(L, -1);   }
  2375.     else{lua_assert(false); }
  2376.     return 0;
  2377. };
  2378.  
  2379. int main() {
  2380.     lua_State* L = luaL_newstate();
  2381.     lua_newtable(L);
  2382.     int stTableIdx = lua_gettop(L);
  2383.     lua_pushvalue(L, stTableIdx);// отправляет копию элемента с заданным допустимым индексом в стек.
  2384.     lua_setglobal(L, "a");// Установить значение глобальной переменной.
  2385.  
  2386.     lua_pushcfunction(L, create);/* отправляет функцию C в стек. функция получает указатель на функцию C и отправляет в стек
  2387.      значение типа Lua, function которое при вызове вызывает соответствующую функцию C.   Любая функция, которая должна быть
  2388.      зарегистрирована в Lua, должна следовать правильному протоколу, чтобы получать свои параметры и возвращать свои результаты*/
  2389.     lua_setfield(L, 1, "new");/*(lua_State * L, int index, const char * k); Соответствует ли t[k] = v, где t значение данного
  2390.     заданного допустимого индекса и vзначение в верхней части стека. Эта функция извлекает значение из стека. Как и в Lua,
  2391.     эта функция может запускать метаметод для события «newindex» (см. §2.8 ). уст ключ для new.   */
  2392.     lua_pushcfunction(L, set);
  2393.     lua_setfield(L, 1, "set");
  2394.     lua_pushcfunction(L, show);
  2395.     lua_setfield(L, 1, "show");
  2396.  
  2397.     luaL_newmetatable(L, "aMetaTable");/*int luaL_newmetatable (lua_State * L, const char * t); Если в реестре уже есть ключ t,
  2398.      возвращает 0. В противном случае создает новую таблицу, которая будет использоваться в качестве метатаблицы
  2399.      для пользовательских данных, добавляет ее в реестр с ключом tnameи возвращает 1. В обоих случаях помещает в стек
  2400.      окончательное значение, связанное с t реестром.*/
  2401.     lua_pushstring(L, "__gc");
  2402.     lua_pushcfunction(L, destroy);
  2403.     lua_settable(L, 2);
  2404.  
  2405.     lua_pushstring(L, "__index");
  2406.     lua_pushcfunction(L, index);
  2407.     lua_settable(L, 2);
  2408.  
  2409.     lua_pushstring(L, "__newindex");
  2410.     lua_pushcfunction(L, newindex);
  2411.     lua_settable(L, 2);
  2412.  
  2413.     int x = luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
  2414.  
  2415.     if (x == LUA_OK) {  lua_close(L);// если поллучилось открыть файл.
  2416.         cin.get();}//ожидает ввода символа программа завершается.
  2417.    
  2418.     else {  cout << "Error: "<<lua_tostring(L, -1)<<endl;
  2419.         lua_close(L);// закрыть состояние
  2420.         cin.get();//ожидает ввода символа программа завершается.
  2421.         return 0;   }
  2422. }
  2423. Lua
  2424. st = a.new()
  2425. --st:show()
  2426. st:set(100)
  2427. st:show()
  2428. st1 = a.new()
  2429. st1:set(200)   
  2430. st1:show()
  2431.  
  2432.  
  2433.  
  2434. выделение памяти.
  2435.  
  2436. struct ArenaAllocator
  2437. {
  2438.     void* m_begin;
  2439.     void* m_end;
  2440.     char* m_curr;
  2441.  
  2442.  
  2443.     ArenaAllocator(void* begin, void* end) :
  2444.         m_begin(begin),
  2445.         m_end(end),
  2446.         m_curr(static_cast<char*>(m_begin) )
  2447.     {   }
  2448.  
  2449.     void* Allocate(size_t sizeBytes){
  2450.         assert(m_curr + sizeBytes < m_end);
  2451.         printf("-- allocated from the freelist --\n");
  2452.         void* ptr = m_curr;
  2453.         m_curr += sizeBytes;
  2454.         return ptr;
  2455.     }
  2456.  
  2457.     void DeAllocate(void* ptr, size_t osize)    {
  2458.         assert(ptr != nullptr);     //can't decallocate null!!!
  2459.         printf("DeAllocated %d bytes\n", (int)osize);
  2460.     }
  2461.  
  2462.     void* ReAllocate(void* ptr, size_t osize, size_t nsize){
  2463.         printf("ReAllocated %d bytes\n", (int)nsize);
  2464.         void* newPtr = Allocate(nsize);
  2465.         memcpy(newPtr, ptr, osize);
  2466.         DeAllocate(ptr, osize);
  2467.         return newPtr;
  2468.     }
  2469.  
  2470.     static void *l_alloc(void *ud, void *ptr, size_t osize, size_t nsize) {
  2471.         ArenaAllocator * pool = static_cast<ArenaAllocator *>(ud);
  2472.         if (nsize == 0)
  2473.         {
  2474.             if (ptr != nullptr)
  2475.             {
  2476.                 pool->DeAllocate(ptr, osize);
  2477.             }
  2478.             return NULL;
  2479.         }
  2480.         else
  2481.         {
  2482.             if (ptr == nullptr)
  2483.             {
  2484.                 return pool->Allocate(nsize);
  2485.             }
  2486.             else
  2487.             {
  2488.                 return pool->ReAllocate(ptr, osize, nsize);
  2489.             }
  2490.         }
  2491.     }
  2492. };
  2493. int main() {
  2494.     constexpr int pool_size = 1024 * 10;
  2495.     char memory[pool_size];
  2496.     ArenaAllocator pool(memory, &memory[pool_size-1]);
  2497.  
  2498.     lua_State *L = lua_newstate(ArenaAllocator::l_alloc, &pool);
  2499.     //luaL_openlibs(L);
  2500.     assert(L != nullptr);
  2501.     lua_close(L);
  2502.     //cin.get();//ожидает ввода символа программа завершается.  
  2503.     return 0;
  2504. }
  2505.  
  2506.  
  2507.  
  2508. Нативнный код, позволяет писать lua скрипт в cpp файле, мы можем вносит в него изменения не переключаясь на lua файл, однако изменения, требуют собрать проект заново.
  2509.  
  2510. Определение типа переменной и вывод ее на экран.
  2511.  
  2512. void showstack(lua_State* L) {
  2513.     int i = lua_gettop(L);/* получаем количество элементов в стеке.*/
  2514.     cout << "\n  the number on the stack = " << i << "\n\n\n";
  2515.     int j = (i) * -1-1;
  2516.     i = -1;
  2517.     for (i; i > j; i--) {
  2518.         int t = lua_type(L, i);
  2519.         cout << "\t " << i << "  " << (j - i) * -1 << "\t";
  2520.         if (LUA_TSTRING == t) {
  2521.             cout << lua_tostring(L, i) << endl;
  2522.         }
  2523.         if (LUA_TNUMBER == t) {
  2524.             double x = lua_tonumber(L, i);
  2525.             int x2 = (int)x;
  2526.             if (x == x2) { cout << x2 << endl; }
  2527.             else { cout << x << endl; }
  2528.         }
  2529.         if (LUA_TBOOLEAN == t) {cout << "LUA_TBOOLEAN "<< lua_toboolean(L, i) << endl;      }
  2530.  
  2531.         if (LUA_TLIGHTUSERDATA == t) {  cout << "LIGHTUSERDATA " << endl;       }
  2532.        
  2533.        if (LUA_TTABLE == t) {   cout << "LUA_TTABLE " << endl;  }
  2534.  
  2535.         if (LUA_TFUNCTION == t) {   cout << "LUA_TFUNCTION " << endl;   }
  2536.  
  2537.         if (LUA_TUSERDATA == t) {cout << "LUA_TUSERDATA " << endl;  }
  2538.  
  2539.         if (LUA_TTHREAD == t) { cout << "LUA_TTHREAD " << endl;     }
  2540.  
  2541.         if (LUA_TNIL == t) {cout << "LUA_TNIL " << endl;        }
  2542.     }
  2543. };
  2544.  
  2545. void getvar(lua_State* L, const char* var) {
  2546.     lua_getglobal(L, var);// получить значение глобальной переменной x.
  2547.     if (LUA_TSTRING == lua_type(L, -1)) {
  2548.         cout << "string " << var << " = " << lua_tostring(L, -1);
  2549.     }
  2550.     if (LUA_TNUMBER == lua_type(L, -1)) {
  2551.         double x = lua_tonumber(L, -1);
  2552.         int x2 = (int)x;
  2553.         if (x == x2) { cout << "number int " << var << " = " << x2; }
  2554.         else { cout << "number double " << var << " = " << x; }
  2555.     }
  2556.     if (LUA_TBOOLEAN == lua_type(L, -1)) {
  2557.         cout << "bool " << var << " = " << (lua_toboolean(L, -1) ? "true " : "false ");
  2558.     }
  2559.     if (LUA_TTABLE == lua_type(L, -1)) {
  2560.         cout << "LUA_TTABLE " << var << " = " << endl;
  2561.     }
  2562.     if (LUA_TFUNCTION == lua_type(L, -1)) {
  2563.         cout << "LUA_TFUNCTION " << var << " = " << endl;
  2564.     }
  2565.     if (LUA_TNIL == lua_type(L, -1)) { // если var нет.
  2566.         cout << "not " << var;
  2567.     }
  2568.     cout << endl;
  2569. };
  2570.  
  2571. void getstack(lua_State* L, int pos) {// Посмотреть позицию в стеке.
  2572.     if (LUA_TSTRING == lua_type(L, pos)) {
  2573.         cout << lua_tostring(L, pos);
  2574.     }
  2575.     if (LUA_TNUMBER == lua_type(L, pos)) {
  2576.         double x = lua_tonumber(L, pos);
  2577.         int x2 = (int)x;
  2578.         if (x == x2) { cout << x2; }
  2579.         else { cout << x; }
  2580.     }
  2581.     if (LUA_TBOOLEAN == lua_type(L, pos)) {
  2582.         cout << (lua_toboolean(L, pos) ? "true " : "false ");
  2583.     }
  2584.     if (LUA_TTABLE == lua_type(L, pos)) {
  2585.         cout << "LUA_TTABLE " << endl;
  2586.     }
  2587.     if (LUA_TLIGHTUSERDATA == lua_type(L, pos)) {
  2588.         cout << "LIGHTUSERDATA " << endl;
  2589.     }
  2590.     if (LUA_TTABLE == lua_type(L, pos)) {
  2591.         cout << "LUA_TTABLE " << endl;
  2592.     }
  2593.     if (LUA_TFUNCTION == lua_type(L, pos)) {
  2594.         cout << "LUA_TFUNCTION " << endl;
  2595.     }
  2596.     if (LUA_TUSERDATA == lua_type(L, pos)) {
  2597.         cout << "LUA_TUSERDATA " << endl;
  2598.     }
  2599.     if (LUA_TTHREAD == lua_type(L, pos)) {
  2600.         cout << "LUA_TTHREAD " << endl;
  2601.     }
  2602.     if (LUA_TNIL == lua_type(L, pos)) {
  2603.         cout << "nill " << endl;// если NILL.
  2604.     }
  2605. };
  2606.  
  2607. int checkerror(lua_State* L, const char* file) {
  2608.     int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
  2609.     try {
  2610.         if (luaL_dostring(L, file) == LUA_OK) {
  2611.             return 0;
  2612.         }
  2613.         else {
  2614.             string x = lua_tostring(L, -1);
  2615.             throw x;
  2616.             return 0;
  2617.         }
  2618.     }
  2619.     catch (string x) {
  2620.         cout << x << endl;
  2621.         //luaL_error(L,"error");
  2622.         return 0;
  2623.     }
  2624. };
  2625.  
  2626. template <class T>//любое значение отправить в стек.
  2627. void pushlua(lua_State * L, const T & value) {
  2628.     if constexpr (std::is_same_v<T, std::string>)
  2629.         lua_pushstring(L, value.c_str());
  2630.     else if constexpr (std::is_array_v<T> && std::is_same_v<std::remove_extent_t<T>, char>)
  2631.         lua_pushstring(L, value);
  2632.     else if constexpr (std::is_same_v<T, int>)
  2633.         lua_pushinteger(L, value);
  2634.     else if constexpr (std::is_same_v<T, double>)
  2635.         lua_pushnumber(L, value);
  2636.     else if constexpr (std::is_same_v<T, bool>)
  2637.         lua_pushboolean(L, value);
  2638.     else
  2639.         std::cerr << "I do not know what to do :(" << std::endl;
  2640. };
  2641. template <class t1, class t2>
  2642. void addkeyintab(lua_State* L, t1 key, t2 value) {
  2643.     /* Устанавливает реальное значение t[i] = value  как value, без вызова метаметода. t это таблица, i - любым числом, отличным от nil и NaN,
  2644.     а value - значение. Данная функция возвращает table. */
  2645.     if (std::is_same_v<t1, const char*> && std::is_same_v<t2, int>) {
  2646.         cout << "key string " << key << " int " << value << endl;
  2647.         const char* key1 = (const char*)key;
  2648.         int value1 = (int)value;
  2649.         lua_pushstring(L, key1); /* отправить ключ в стек */
  2650.         lua_pushinteger(L, value1); /* отправить значение ключа в стек. */
  2651.         lua_rawset(L, -3);  } /*Сохраняет пару в таблице */
  2652.  
  2653.     else if (std::is_same_v<t1, int> && std::is_same_v<t2, const char*>) {
  2654.         cout << "key int " << key << " string " << value << endl;
  2655.         int key1 = (int)key;
  2656.         const char* value1 = (const char*)value;
  2657.         lua_pushinteger(L, key1); /* отправить ключ в стек */
  2658.         lua_pushstring(L, value1); /* отправить значение ключа в стек. */
  2659.         lua_rawset(L, -3);  } /*Сохраняет пару в таблице */
  2660.  
  2661.     else if (std::is_same_v<t1, const char*> && std::is_same_v<t2, const char*>) {
  2662.         cout << "key string " << key << " value string " << value << endl;
  2663.         const char* key1 = (const char*)key;
  2664.         const char* value1 = (const char*)value;
  2665.         lua_pushstring(L, key1); /* отправить ключ в стек */
  2666.         lua_pushstring(L, value1); /* отправить значение ключа в стек. */
  2667.         lua_rawset(L, -3);} /*Сохраняет пару в таблице */
  2668.  
  2669.     else if (std::is_same_v<t1, int> && std::is_same_v<t2, int>) {
  2670.         cout << "key int " << key << " value int " << value << endl;
  2671.         int key1 = (int)key;
  2672.         int value1 = (int)value;
  2673.         lua_pushinteger(L, key1); /* отправить ключ в стек */
  2674.         lua_pushinteger(L, value1); /* отправить значение ключа в стек. */
  2675.         lua_rawset(L, -3); /*Сохраняет пару в таблице */
  2676.     }
  2677. };
  2678.  
  2679. int main(int argc, char *argv[]) {
  2680.     const char* LUA = R"(
  2681. x = true
  2682. )";
  2683.     lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  2684.     luaL_openlibs(L);
  2685.     checkerror(L, LUA);//Функция проверка на ошибки.
  2686.     getvar(L, "x");
  2687.  
  2688.     lua_close(L);
  2689.  
  2690.     return 0;
  2691.  
  2692.  
  2693. Присвоение значения переменной через отправку в стек.
  2694.  
  2695. int main(int argc, char *argv[]) {
  2696.     const char* LUA = R"(
  2697. print(c)
  2698.  
  2699. )";
  2700.     lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  2701.     luaL_openlibs(L);
  2702.     pushlua(L, 12);
  2703.     lua_setglobal(L, "c");// уст значение переменной в lua.
  2704.     checkerror(L, LUA);//Функция проверка на ошибки.
  2705.  
  2706.     lua_close(L);
  2707.  
  2708.     return 0;
  2709. }
  2710.  
  2711.  
  2712. Вызов функции в нативном коде через получение переменной.
  2713.  
  2714. int main(int argc, char *argv[]) {
  2715. const char* LUA = R"(
  2716.  function foo()
  2717.   return 4
  2718.  end )";
  2719.     lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  2720.     luaL_openlibs(L);  
  2721.     checkerror(L, LUA);//Функция проверка на ошибки.
  2722.     lua_getglobal(L, "foo");
  2723.    
  2724.     if (lua_isfunction(L, -1)) {
  2725.         lua_pcall(L, 0, 1, 0);
  2726.         cout << lua_tonumber(L, -1) << endl;    }
  2727.     lua_close(L);
  2728.     return 0;
  2729. }
  2730.  
  2731. Вызов функции в нативном коде через присвоение.
  2732.  
  2733. int foo(lua_State *L) {
  2734.     cout << "hi foo c++" << endl;
  2735.     return 0;
  2736. };
  2737.  
  2738. int main(int argc, char *argv[]) {
  2739.     const char* LUA = R"(
  2740. foo()
  2741.  
  2742. )";
  2743.     lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  2744.     luaL_openlibs(L);
  2745.     lua_pushcfunction(L, foo);// отправить c функцию в стек.
  2746.  
  2747.     lua_setglobal(L, "foo");// уст для переменной значение в виде функции.
  2748.  
  2749.     checkerror(L, LUA);//Функция проверка на ошибки.
  2750.  
  2751.     lua_close(L);
  2752.  
  2753.     return 0;
  2754. };
  2755.  
  2756. Вызов функции в нативном коде через отправку в таблицу.
  2757.  
  2758. int foo(lua_State *L) {
  2759.     cout << "hi foo c++" << endl;
  2760.     return 0;
  2761. }
  2762.  
  2763. int main(int argc, char *argv[]) {
  2764.     const char* LUA = R"(
  2765. foo()
  2766. )";
  2767.     lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  2768.     luaL_openlibs(L);
  2769.  
  2770.     lua_newtable(L); /*создать пустую таблицу */
  2771.     lua_pushcfunction(L, foo);// отправить c функцию в стек как ключ.
  2772.     lua_setglobal(L, "foo");// уст для переменой(ключ) значение в новой пустой таблицы в виде функции.
  2773.  
  2774.     checkerror(L, LUA);//Функция проверка на ошибки.
  2775.  
  2776.     lua_close(L);
  2777.  
  2778.     return 0;
  2779. };
  2780.  
  2781.  
  2782. Вызов функции с параметром в нативном коде через отправку в таблицу.
  2783.  
  2784. int foo(lua_State *L) {
  2785.     int x = lua_tointeger(L, -1);
  2786.     pushlua(L, x * 2);
  2787.  
  2788. return 1;
  2789. }
  2790.  
  2791. int main(int argc, char *argv[]) {
  2792.     const char* LUA = R"(
  2793. g=foo(12)
  2794. print(g)
  2795. )";
  2796.     lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  2797.     luaL_openlibs(L);
  2798.  
  2799.     lua_newtable(L); /*создать пустую таблицу */
  2800.     lua_pushcfunction(L, foo);// отправить c функцию в стек.
  2801.     lua_setglobal(L, "foo");// уст для переменой(ключ) значение в новой пустой таблицы в виде функции.
  2802.  
  2803.     checkerror(L, LUA);//Функция проверка на ошибки.
  2804.  
  2805.     lua_close(L);
  2806.  
  2807.     return 0;
  2808. };
  2809.  
  2810. Таблица в стеке, добавления в нее элементов.
  2811.  
  2812. int main(int argc, char *argv[]) {
  2813.     lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  2814.     luaL_openlibs(L);
  2815.     lua_newtable(L);
  2816.     lua_pushstring(L, "key");
  2817.     lua_pushnumber(L, 100);
  2818.     lua_rawset(L,-3);
  2819.  
  2820.     lua_pushstring(L, "key");
  2821.     lua_gettable(L, -2);
  2822.    cout << lua_tonumber(L,-1) << endl; //Функция 100.
  2823.  
  2824.     lua_close(L);
  2825.  
  2826.     return 0;
  2827. };
  2828.  
  2829. Вариант 2.
  2830.  
  2831. int main(int argc, char* argv[]) {
  2832.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  2833.     luaL_openlibs(L);
  2834.     lua_newtable(L);
  2835.     lua_pushnumber(L, 100);
  2836.     lua_setfield(L, -2, "key");// уст в таблицу ключ - key со значение 100.
  2837.  
  2838.     pushlua(L, "key");
  2839.     lua_gettable(L, -2);
  2840.     getlaststack(L); //Функция 100.
  2841.  
  2842.     lua_close(L);
  2843.  
  2844.     return 0;
  2845. };
  2846.  
  2847. Добавление следующего ключа со значением в таблицу.
  2848.  
  2849. int main(int argc, char* argv[]) {
  2850.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  2851.     luaL_openlibs(L);
  2852.     lua_newtable(L);
  2853.  
  2854.     pushlua(L, "key");
  2855.     pushlua(L, 100);
  2856.     lua_rawset(L, -3);// table["key"] = 100.
  2857.    
  2858.     pushlua(L, "a");
  2859.     pushlua(L, 6);
  2860.     lua_rawset(L, -3);// table["a"] = 6.
  2861.  
  2862.  
  2863.     pushlua(L, "a");
  2864.     lua_gettable(L, -2);
  2865.     getlaststack(L); // 6.
  2866.  
  2867.     lua_close(L);
  2868.  
  2869.     return 0;
  2870. };
  2871.  
  2872.  
  2873. Функция добавление в таблицу нового ключа со значением.
  2874.  
  2875. template <class t1, class t2>
  2876. void addkeyintab(lua_State* L, t1 key, t2 value) {
  2877.     /* Устанавливает реальное значение t[i] = value  как value, без вызова метаметода. t это таблица, i - любым числом, отличным от nil и NaN,
  2878.     а value - значение. Данная функция возвращает table. */
  2879.     if (std::is_same_v<t1, const char*> && std::is_same_v<t2, int>) {
  2880.         cout << "key string " << key << " value int " << value << endl;
  2881.         const char* key1 = (const char*)key;
  2882.         int value1 = (int)value;
  2883.         lua_pushstring(L, key1); /* отправить ключ в стек */
  2884.         lua_pushinteger(L, value1); /* отправить значение ключа в стек. */
  2885.         lua_rawset(L, -3);  } /*Сохраняет пару в таблице */
  2886.  
  2887.     else if (std::is_same_v<t1, int> && std::is_same_v<t2, const char*>) {
  2888.         cout << "key int " << key << " value string " << value << endl;
  2889.         int key1 = (int)key;
  2890.         const char* value1 = (const char*)value;
  2891.         lua_pushinteger(L, key1); /* отправить ключ в стек */
  2892.         lua_pushstring(L, value1); /* отправить значение ключа в стек. */
  2893.         lua_rawset(L, -3);  } /*Сохраняет пару в таблице */
  2894.  
  2895.     else if (std::is_same_v<t1, const char*> && std::is_same_v<t2, const char*>) {
  2896.         cout << "key string " << key << " value string " << value << endl;
  2897.         const char* key1 = (const char*)key;
  2898.         const char* value1 = (const char*)value;
  2899.         lua_pushstring(L, key1); /* отправить ключ в стек */
  2900.         lua_pushstring(L, value1); /* отправить значение ключа в стек. */
  2901.         lua_rawset(L, -3);} /*Сохраняет пару в таблице */
  2902.  
  2903.     else if (std::is_same_v<t1, int> && std::is_same_v<t2, int>) {
  2904.         cout << "key int " << key << " value int " << value << endl;
  2905.         int key1 = (int)key;
  2906.         int value1 = (int)value;
  2907.         lua_pushinteger(L, key1); /* отправить ключ в стек */
  2908.         lua_pushinteger(L, value1); /* отправить значение ключа в стек. */
  2909.         lua_rawset(L, -3); /*Сохраняет пару в таблице */
  2910.     }
  2911. };
  2912. int main(int argc, char *argv[]) {
  2913. const char* LUA = R"(
  2914. print(foo)
  2915. for k,v in pairs(foo) do
  2916. print(k.." "..v)
  2917. end
  2918.  
  2919. )";
  2920.     lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  2921.     luaL_openlibs(L);
  2922.  
  2923.     lua_newtable(L); /*создать пустую таблицу */
  2924.     addkeyintab(L, "a", " 10 z "); /*добавить ключ и значение в таблицу */
  2925.     addkeyintab(L, "x1", 99); /*добавить ключ и значение в таблицу */
  2926.     addkeyintab(L, 100, 10); /*добавить ключ и значение в таблицу */
  2927.     addkeyintab(L, 100, "y"); /*добавить ключ и значение в таблицу */
  2928.     lua_setglobal(L, "foo");// уст имя таблицы в lua.
  2929.     cout << "\n" << endl;
  2930.     checkerror(L, LUA);//Функция проверка на ошибки.
  2931.  
  2932.     lua_close(L);
  2933.     return 0;
  2934. };
  2935.  
  2936. Выводится.
  2937. key string a value string  10 z
  2938. key string x1 int 99
  2939. key int 100 value int 10
  2940. key int 100 string y
  2941.  
  2942.  
  2943. table: 009F0830
  2944. 100 y
  2945. x1 99
  2946. a  10 z
  2947.  
  2948. C:\Users\e\source\repos\Project1luaapi\Debug\Project1luaapi.exe (процесс 6000) завершает работу с кодом 0.
  2949. Чтобы закрыть это окно, нажмите любую клавишу…
  2950.  
  2951.  
  2952.  
  2953. Функция возвращает таблицу с ключами в качестве функциями.
  2954.  
  2955. int square(lua_State* L) {//    Функция создания объекта структуры.
  2956.     cout << lua_tonumber(L,-1)*2 << endl;
  2957.     return 0;
  2958. };
  2959. int cube(lua_State* L) {//  Функция создания объекта структуры.
  2960.     cout << lua_tonumber(L, -1) * 3 << endl;
  2961.     return 0;
  2962. };
  2963.  
  2964.  
  2965. int create(lua_State* L) {//    Функция создания объекта структуры.
  2966.     lua_newtable(L);
  2967.     lua_pushcfunction(L, square);  
  2968.     lua_setfield(L, -2, "square");
  2969.     lua_pushcfunction(L, cube);
  2970.     lua_setfield(L, -2, "cube");
  2971.     return 1;
  2972. };
  2973.  
  2974. int main(int argc, char* argv[]) {
  2975. const char* LUA = R"(
  2976.  
  2977. a = create()
  2978. a.square(5) --10
  2979. a.square(10)--20
  2980. a.cube(4)--12
  2981. a.cube(6)--18
  2982. print(a)
  2983. )";
  2984.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  2985.     luaL_openlibs(L);
  2986.    
  2987.     lua_pushcfunction(L, create);/* отправляет функцию C в стек. функция получает указатель на функцию C и отправляет в стек*/
  2988.     lua_setglobal(L, "create");
  2989.  
  2990.     checkerror(L, LUA);//Функция проверка на ошибки.
  2991.  
  2992.     lua_close(L);
  2993.  
  2994.     return 0;
  2995. };
  2996.  
  2997.  
  2998. Вывод всех ключей и значений неизвестной таблицы.
  2999.  
  3000. int pri(lua_State* L, const char t[]) {
  3001.     lua_getglobal(L, t);// получить значение глобальной переменной, таблица.
  3002.     lua_pushvalue(L, -1);
  3003.     lua_pushnil(L);
  3004.     while (lua_next(L, -2)) {
  3005.         lua_pushvalue(L, -2);
  3006.         cout << "key "; getstack(L, -1); cout << " value "; getstack(L, -2); cout << endl;
  3007.         lua_pop(L, 2);
  3008.     }
  3009.     lua_pop(L, 1);
  3010.     return 0;
  3011. };
  3012. int main() {
  3013.     const char* LUA = R"(
  3014. t= {x=10, y=20, z=30}
  3015. )";
  3016.  
  3017.     lua_State* L = luaL_newstate();
  3018.     luaL_openlibs(L);
  3019.  
  3020.     checkerror(L, LUA);//Функция проверка на ошибки.
  3021.     pri(L, "t");// вывести ключи и значения таблицы.  
  3022.  
  3023.     lua_close(L);// закрыть состояние
  3024.     return 0;
  3025. };
  3026.  
  3027. Сохранение всех ключей таблицы в реестре.
  3028.  
  3029. int pritab(lua_State* L, const char t[]) {
  3030.     int x = 0;
  3031.     lua_getglobal(L, t);// получить значение глобальной переменной, таблица.
  3032.     lua_pushvalue(L, -1);
  3033.     lua_pushnil(L);
  3034.     while (lua_next(L, -2)) {
  3035.     //. cout << " key ";
  3036.         lua_pushvalue(L, -2);
  3037.         lua_rawseti(L, LUA_REGISTRYINDEX, x);
  3038.         //getstack(L, -2);
  3039.         lua_pushvalue(L, -2);
  3040.         //cout << "key "; getstack(L, -1); cout << " value "; getstack(L, -2); cout << endl;
  3041.         lua_pop(L, 2);
  3042.         x++;
  3043.     }
  3044.     lua_pop(L, 1);
  3045.     pushlua(L, x);
  3046.     return 1;
  3047. };
  3048. int main() {
  3049.     const char* LUA = R"(
  3050. t= {x=10, y=20, z=30}
  3051. )";
  3052.  
  3053.     lua_State* L = luaL_newstate();
  3054.     luaL_openlibs(L);
  3055.  
  3056.     checkerror(L, LUA);//Функция проверка на ошибки.
  3057.     pritab(L, "t");// вывести ключи и значения таблицы.
  3058.     int len = lua_tointeger(L,-1);
  3059.     for (int i = 0; i < len; i++){
  3060.     lua_rawgeti(L, LUA_REGISTRYINDEX, i);/* вернуть значение для ключа в реестр. */
  3061.     cout << "key "; getstack(L, -1);  cout << endl;}
  3062.     lua_close(L);// закрыть состояние
  3063.     return 0;
  3064. };
  3065.  
  3066. Вывод всех значений ключей из реестра.
  3067.  
  3068. int pritab(lua_State* L, const char t[]) {
  3069.     int x = 0;
  3070.     lua_getglobal(L, t);// получить значение глобальной переменной, таблица.
  3071.     lua_pushvalue(L, -1);
  3072.     lua_pushnil(L);
  3073.     while (lua_next(L, -2)) {
  3074.         //. cout << " key ";
  3075.         lua_pushvalue(L, -2);
  3076.         lua_rawseti(L, LUA_REGISTRYINDEX, x);
  3077.         //getstack(L, -2);
  3078.         lua_pushvalue(L, -2);
  3079.         //cout << "key "; getstack(L, -1); cout << " value "; getstack(L, -2); cout << endl;
  3080.         lua_pop(L, 2);
  3081.         x++;
  3082.     }
  3083.     lua_pop(L, 1);
  3084.     pushlua(L, x);
  3085.     return 1;
  3086. };
  3087. int main() {
  3088.     const char* LUA = R"(
  3089. t= {x=10, y=20, z=30}
  3090. )";
  3091.  
  3092.     lua_State* L = luaL_newstate();
  3093.     luaL_openlibs(L);
  3094.  
  3095.     checkerror(L, LUA);//Функция проверка на ошибки.
  3096.     pritab(L, "t");// вывести ключи и значения таблицы.
  3097.     int len = lua_tointeger(L, -1);
  3098.     lua_pop(L, 1);
  3099.     for (int i = 0; i < len; i++) {
  3100.         lua_rawgeti(L, LUA_REGISTRYINDEX, i);/* вернуть значение для ключа в реестр. */
  3101.                
  3102.         cout << "key "; getstack(L, -1);
  3103.  
  3104.         lua_getglobal(L, "t");
  3105.         lua_pushvalue(L, -2);
  3106.         lua_gettable(L, -4);
  3107.         cout << " value "; getstack(L, -1);  cout << endl;
  3108.         lua_pop(L, 3);
  3109.  
  3110.     }
  3111.     lua_close(L);// закрыть состояние
  3112.     return 0;
  3113. };
  3114.  
  3115.  
  3116. Отправить в стек таблицу.
  3117.  
  3118. int rettab(lua_State* L) {// Функция отправить в стек таблицу.
  3119.     lua_newtable(L);
  3120.     for (int i = 1; i < 10; i++){
  3121.     pushlua(L, i);
  3122.     pushlua(L, i*10);
  3123.     lua_rawset(L, -3);
  3124.     }
  3125.     return 1;
  3126. };
  3127.  
  3128. int main(int argc, char* argv[]) {
  3129.     const char* LUA = R"(
  3130.  
  3131. a = rettab()
  3132. print(a[3]) --30
  3133. )";
  3134.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3135.     luaL_openlibs(L);
  3136.  
  3137.     lua_pushcfunction(L, rettab);/* отправляет функцию C в стек. функция получает указатель на функцию C и отправляет в стек*/
  3138.     lua_setglobal(L, "rettab");
  3139.  
  3140.     checkerror(L, LUA);//Функция проверка на ошибки.
  3141.  
  3142.     lua_close(L);
  3143.  
  3144.     return 0;
  3145. };
  3146.  
  3147. Отправить таблицу в функцию.
  3148.  
  3149. int readtab(lua_State* L) {// Функция отправить в стек таблицу.
  3150.     if (LUA_TTABLE == lua_type(L, -1)) {
  3151.  
  3152.         lua_pushinteger(L, 1);
  3153.  
  3154.         lua_gettable(L, -2);
  3155.         int x = lua_tointeger(L, -1);
  3156.         getstack(L, -1); cout << endl;
  3157.         lua_pop(L, 1);
  3158.         lua_pushinteger(L, 2);
  3159.         lua_gettable(L, -2);
  3160.         int y = lua_tointeger(L, -1);
  3161.         getstack(L, -1); cout << endl;
  3162.         lua_pop(L, 1);
  3163.         lua_pushinteger(L, 3);
  3164.         lua_gettable(L, -2);
  3165.         int z = lua_tointeger(L, -1);
  3166.         getstack(L, -1); cout << endl;
  3167.         lua_pop(L, 1);
  3168.  
  3169.     }
  3170.     return 0;
  3171. };
  3172.  
  3173. int main(int argc, char* argv[]) {
  3174.     const char* LUA = R"(
  3175. t = {10,20,30}
  3176. readtab(t)
  3177. )";
  3178.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3179.     luaL_openlibs(L);
  3180.  
  3181.     lua_pushcfunction(L, readtab);/* отправляет функцию C в стек. функция получает указатель на функцию C и отправляет в стек*/
  3182.     lua_setglobal(L, "readtab");
  3183.  
  3184.     checkerror(L, LUA);//Функция проверка на ошибки.
  3185.  
  3186.     lua_close(L);
  3187.  
  3188.     return 0;
  3189. };
  3190.  
  3191.  
  3192. Модуль с. Писать модули для lua на c++.
  3193.  
  3194. int q(lua_State* L) {
  3195.     int d = lua_tonumber(L, -1);
  3196.     pushlua(L, d * 2);
  3197.     return 1; /*число умножено на 2*/
  3198. }
  3199. int foo(lua_State * L) {
  3200.     int d = lua_tonumber(L, -1);
  3201.     pushlua(L, d * 3);
  3202.     return 1; /*число умножено на 3*/
  3203. }
  3204.  struct luaL_Reg mylib[] = {
  3205.     { "q", q },{ "foo", foo }, { NULL, NULL } /*регистрация функций, на вершину отправим NULL NULL*/
  3206. };
  3207.  
  3208. int lua_lib(lua_State * L) {
  3209.     luaL_newlib(L, mylib);/*void luaL_newlib (lua_State * L, const luaL_Reg lib []); Создает новую таблицу и
  3210.       регистрирует там свои функции в списке lib. Это реализовано в виде следующего макроса:
  3211.   (luaL_newlibtable (L, lib), luaL_setfuncs (L, l, 0))
  3212.   Массив lib должен быть фактическим массивом, а не указателем на него.*/
  3213.   return 1;
  3214. }
  3215.  
  3216. int main(int argc, char* argv[]) {
  3217.     const char* LUA = R"(
  3218. mylib = require 'mylib'
  3219. print(mylib.q(2))
  3220. print(mylib.foo(2)) )";
  3221.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3222.     luaL_openlibs(L);
  3223.  
  3224.     luaL_requiref(L, "mylib", lua_lib, 1);/* модуль. void luaL_requiref (lua_State * L, const char * modname,
  3225.  lua_CFunction cfunc, int glb); Если modname еще нет, package.loaded, вызывает функцию cfunc со строкой modname
  3226.  в качестве аргумента и устанавливает результат вызова package.loaded[modname], как если бы эта функция была вызвана
  3227.  require. Если glb это правда, также сохраняет модуль в глобальном modname. Оставляет копию модуля в стеке.*/
  3228.     checkerror(L, LUA);//Функция проверка на ошибки.
  3229.  
  3230.     return 0;
  3231. };
  3232.  
  3233.  
  3234. Реестр глобальная таблица.
  3235.  
  3236.  
  3237. int main(int argc, char* argv[]) {
  3238.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3239.     luaL_openlibs(L);
  3240.    
  3241.     pushlua(L, 9);//отправить значение для ключа 12.  
  3242.     lua_rawseti(L, LUA_REGISTRYINDEX, 12);// отправить ключ в реестре. установить ключ со значение в реестр.
  3243.  
  3244.     lua_rawgeti(L, LUA_REGISTRYINDEX, 12);/* вернуть значение для ключа в реестр. */
  3245.     getlaststack(L);// 9
  3246.  
  3247.     lua_close(L);
  3248.  
  3249.     return 0;
  3250. };
  3251.  
  3252.  
  3253. Реестр передача значение между функциями.
  3254.  
  3255. int show(lua_State* L) {
  3256.     lua_rawgeti(L, LUA_REGISTRYINDEX, 12);/* вернуть значение для ключа в реестр. */
  3257.     getlaststack(L);// 100
  3258.     return 0;
  3259. };
  3260. int create(lua_State * L) {//   Функция создания объекта структуры.
  3261.     pushlua(L, 100);//отправить значение для ключа 12.
  3262.     lua_rawseti(L, LUA_REGISTRYINDEX, 12);// отправить ключ в реестре. установить ключ со значение в реестр.
  3263.     return 0;
  3264. };
  3265.  
  3266. int main(int argc, char* argv[]) {
  3267.     const char* LUA = R"(
  3268. create()
  3269. show()
  3270. )";
  3271.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3272.     luaL_openlibs(L);
  3273.  
  3274.     lua_newtable(L);
  3275.     lua_pushcfunction(L, create);
  3276.     lua_setglobal(L, "create");// уст глоб имя в таблице как С функцию.
  3277.  
  3278.     lua_pushcfunction(L, show);
  3279.     lua_setglobal(L, "show");
  3280.  
  3281.     checkerror(L, LUA);//Функция проверка на ошибки.
  3282.  
  3283.     lua_close(L);
  3284.  
  3285.     return 0;
  3286. };
  3287.  
  3288.  
  3289. Реестр, отправка и получение значение по уникальному ключу. В качестве ключей ссылка на псевдоиндекс.
  3290.  
  3291.  
  3292. int main(int argc, char* argv[]) {
  3293.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3294.     luaL_openlibs(L);
  3295.    
  3296.     int ref = luaL_ref(L, LUA_REGISTRYINDEX); /*Возвращает ссылку - это уникальный целочисленный ключ. Для значения в реестре*/
  3297.  
  3298.     pushlua(L, 9);//отправить значение для ключа ref. 
  3299.     lua_rawseti(L, LUA_REGISTRYINDEX, ref);// установить ключ со значение в реестр.
  3300.  
  3301.     pushlua(L, ref);
  3302.     lua_rawgeti(L, LUA_REGISTRYINDEX, ref);/* вернуть значение для ключа в реестр. */
  3303.     getlaststack(L);// 9
  3304.  
  3305.     lua_close(L);
  3306.  
  3307.     return 0;
  3308. };
  3309.  
  3310.  
  3311. Работа в реестр. Отправка значение переменной в реестр, получение из него.
  3312.  
  3313. int main(int argc, char* argv[]) {
  3314.     const char* LUA = R"(
  3315. x=4
  3316. )";
  3317.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3318.     luaL_openlibs(L);
  3319.     checkerror(L, LUA);//Функция проверка на ошибки.
  3320.     lua_getglobal(L, "x");
  3321.     int ref = luaL_ref(L, LUA_REGISTRYINDEX); /*Создает и возвращает ссылку в таблице в индексе t для объекта на вершине стека(и извлекает объект).
  3322.     Ссылка - это уникальный целочисленный ключ. Пока вы не добавляете вручную целочисленные ключи в таблицу t, вы luaL_ref гарантируете уникальность возвращаемого ключа. Вы можете получить объект, на который ссылается ссылка r, вызывая lua_rawgeti(L, t, r).
  3323. Функция luaL_unref освобождает ссылку и связанный с ней объект.
  3324.     Если объект на вершине стека равен нулю, luaL_ref возвращает константу LUA_REFNIL. Константа LUA_NOREF
  3325. гарантированно будет отличаться от любой ссылки, возвращаемой luaL_ref.*/
  3326.  
  3327.  
  3328.     lua_rawgeti(L, LUA_REGISTRYINDEX, ref);
  3329.     cout <<"x = "<< lua_tonumber(L, -1) << endl;
  3330.     lua_rawseti(L, LUA_REGISTRYINDEX, ref);/*
  3331.     Функции, которые API предоставляет для работы с массивами:
  3332.  
  3333.     void lua_rawgeti (lua_State * L, int index, int key);
  3334.     void lua_rawseti (lua_State * L, int index, int key); Описание lua_rawgeti и lua_rawseti немного сбивает с толку,
  3335.     поскольку включает в себя два индекса:
  3336.     index указывает, где таблица находится в стеке;
  3337.     key относится к тому, где элемент находится в таблице.
  3338.     Вызов lua_rawgeti(L, t, key) эквивалентен последовательности lua_pushnumber (L, ключ); lua_rawget (L, t);
  3339.  
  3340.     когда t положительно (в противном случае вы должны компенсировать новый элемент в стеке).
  3341.     Вызов lua_rawseti(L, t, key)(опять же для t положительного) эквивалентен
  3342.     lua_pushnumber (L, ключ);
  3343.     lua_insert (L, -2); // поставить `ключ 'ниже предыдущего значения
  3344.     lua_rawset (L, t); Обратите внимание, что обе функции используют необработанные операции.
  3345.     Они быстрее и, в любом случае, таблицы, используемые в качестве массивов, редко используют метаметоды.
  3346.      В качестве конкретного примера использования этих функций мы могли бы переписать тело цикла
  3347.      из нашей предыдущей l_dirфункции из
  3348.  
  3349.         lua_pushnumber (L, i ++); // ключ  /
  3350.         lua_pushstring (L, entry-> d_name); / значение /
  3351.     lua_settable(L, -3);
  3352.                                            */
  3353.     luaL_unref(L, LUA_REGISTRYINDEX, ref); // удалить значение по ключу ref.
  3354.     cout << lua_tonumber(L, -1) << endl;
  3355.  
  3356.     lua_close(L);
  3357.  
  3358.     return 0;
  3359. };
  3360.  
  3361.  
  3362. Выводится.
  3363.  
  3364. x = 4
  3365. 0
  3366.  
  3367. Вариант 2.
  3368.  
  3369. int main(int argc, char* argv[]) {
  3370.     const char* LUA = R"(
  3371. x=4
  3372. )";
  3373.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3374.     luaL_openlibs(L);
  3375.     checkerror(L, LUA);//Функция проверка на ошибки.
  3376.     int ref = luaL_ref(L, LUA_REGISTRYINDEX); /*Создает и возвращает ссылку в таблице в индексе t для объекта на вершине стека(и извлекает объект).*/
  3377.  
  3378.     lua_getglobal(L, "x");
  3379.  
  3380.     lua_rawseti(L, LUA_REGISTRYINDEX, ref);/* установить в таблице*/
  3381.  
  3382.     lua_rawgeti(L, LUA_REGISTRYINDEX, ref);/* получить значение по ключу */
  3383.     cout << "x = " ;
  3384.     getlaststack(L);
  3385.  
  3386. //  luaL_unref(L, LUA_REGISTRYINDEX, ref); // удалить значение по ключу ref.
  3387.  
  3388.     lua_rawgeti(L, LUA_REGISTRYINDEX, ref);/*              */
  3389.     getlaststack(L);
  3390.  
  3391.     lua_close(L);
  3392.  
  3393.     return 0;
  3394. };
  3395.  
  3396.  
  3397. Уникальность ключа в реестре, обеспечивается адресом в памяти переменной.
  3398. Использовать lua_settable и lua_gettable.
  3399.  
  3400. int main(int argc, char* argv[]) {
  3401.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3402.     luaL_openlibs(L);
  3403.     static char Key = 'k';// лучше стастик переменная.
  3404.  
  3405.     lua_pushlightuserdata(L, &Key);  /* отправить адрес памяти переменной в стек */
  3406.     lua_pushstring(L, &Key);  /* отправить значение в стек */
  3407.     lua_settable(L, LUA_REGISTRYINDEX);  /* уст ключа и значение таблице реестре.  */
  3408.  
  3409.     lua_pushlightuserdata(L, &Key);  /*отправить адрес, который является ключом в стек. */
  3410.     lua_gettable(L, LUA_REGISTRYINDEX);  /* получить таблицу и значение ключа будет в -1 */
  3411.     cout << lua_tostring(L, -1) << endl;// k
  3412.  
  3413.     lua_close(L);
  3414.     return 0;
  3415. };
  3416.  
  3417.  
  3418. Реестр способен хранить польз. данные, ключ может их адрес в пямяти.
  3419.  
  3420. int main(int argc, char* argv[]) {
  3421.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3422.     luaL_openlibs(L);
  3423.  
  3424.     static char Key = 'k';// лучше стастик переменная.
  3425.  
  3426.     lua_pushlightuserdata(L, &Key);  /* отправить адресс в стек */
  3427.     lua_rawsetp(L, LUA_REGISTRYINDEX,  &Key);/* Имеет ли эквивалент t[k] = v, где t таблица,
  3428.  k указатель, представленный в виде легких пользовательских данных, и v значение в верхней части стека.
  3429.  Эта функция извлекает значение из стека. Не вызывает метаметоды.*/
  3430.    
  3431.     lua_pushlightuserdata(L, &Key);  /*отправить адресс, который является ключом в стек. */
  3432.     lua_rawgetp(L, LUA_REGISTRYINDEX, &Key); /* получить таблицу и значение ключа будет в -1 */
  3433.  
  3434.     char* k = (char*)lua_touserdata(L, -1);// получить польз.данные.
  3435.     cout << k <<" adress "<< &k << endl;// k.
  3436.    
  3437.     lua_close(L);
  3438.     return 0;
  3439. };
  3440.  
  3441. int main(int argc, char* argv[]) {
  3442.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3443.     luaL_openlibs(L);
  3444.  
  3445.      int Key = 100;// лучше стастик переменная.
  3446.  
  3447.     lua_pushlightuserdata(L, &Key);  /* отправить адресс в стек */
  3448.     lua_rawsetp(L, LUA_REGISTRYINDEX, &Key);/* Имеет ли эквивалент t[k] = v, где t таблица,
  3449.  k указатель, представленный в виде легких пользовательских данных, и v значение в верхней части стека.
  3450.  Эта функция извлекает значение из стека. Не вызывает метаметоды.*/
  3451.  
  3452.     lua_pushlightuserdata(L, &Key);  /*отправить адресс, который является ключом в стек. */
  3453.     lua_rawgetp(L, LUA_REGISTRYINDEX, &Key); /* получить таблицу и значение ключа будет в -1 */
  3454.  
  3455.     int* k = (int*)lua_touserdata(L, -1);// получить польз.данные.
  3456.     cout << *k << " adress " << &k << endl;// 100.
  3457.  
  3458.     lua_close(L);
  3459.     return 0;
  3460. };
  3461.  
  3462. Реестр адрес переменной k ключ.
  3463.  
  3464. int main(int argc, char* argv[]) {
  3465.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3466.     luaL_openlibs(L);
  3467.     static char k = 'key';// лучше стастик переменная она выступает ключом в реестре.
  3468.  
  3469.     int i = 5;
  3470.     lua_pushlightuserdata(L, &i);  /* отправить адрес памяти числа 5 в стек */
  3471.     lua_rawsetp(L, LUA_REGISTRYINDEX, &k);  /* уст ключ в реестре адрес k.
  3472.  void lua_rawsetp (lua_State * L, int index, const void * p);  Записывает ли эквивалент t[p] = v,
  3473. где t таблица с заданным индексом, p как легкие пользовательские данные и v является значением в верхней части стека.
  3474.  
  3475. Эта функция извлекает значение из стека. Назначение является необработанным,  */
  3476.  
  3477.     lua_pushlightuserdata(L, &i);  /*отправить адрес памяти, который является ключом в стек.*/
  3478.  
  3479.     lua_rawgetp(L, LUA_REGISTRYINDEX, &k);/* получить значение по ключу адрес k*/
  3480.     int* number = (int*)lua_touserdata(L, -1);// получить польз.данные.
  3481.  
  3482.     cout << *number << " adress " << number << endl;// 5.
  3483.  
  3484.  
  3485.     lua_close(L);
  3486.     return 0;
  3487. };
  3488.  
  3489. Реестр. Передача значение из функции в ключ возвращаемой таблицы.
  3490.  
  3491. int show(lua_State* L) {
  3492.     luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
  3493.     lua_pushstring(L, "key");//отправить key, чтобы получить ref
  3494.     lua_gettable(L, -2);
  3495.     int ref = lua_tonumber(L, -1);
  3496.     lua_rawgeti(L, LUA_REGISTRYINDEX, ref);/* получить значение по ключу ref.*/
  3497.  
  3498.     getlaststack(L);
  3499.     return 0;
  3500. };
  3501. int create(lua_State * L) {//   Функция создания объекта структуры.
  3502.     lua_gettable(L, -3);// получить глоб. таблицу.
  3503.     luaL_newmetatable(L, "mt");// создать мета таблицу.
  3504.     lua_pushcfunction(L, show);
  3505.     lua_setfield(L, -2, "show");// ключ таблицы является функцией.  
  3506.     int ref = luaL_ref(L, LUA_REGISTRYINDEX);// получить уникальный ключ.
  3507.     pushlua(L, 5);// значение для ключа. mt.ref = 5.
  3508.     lua_rawseti(L, LUA_REGISTRYINDEX, ref); /* уст ключ со значением 5 в реестре адрес. */
  3509.  
  3510.     lua_setmetatable(L, -2); //уст метатаблицу.
  3511.  
  3512.     lua_gettable(L, -2);// получить таблицу.
  3513.     luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
  3514.  
  3515.     lua_pushstring(L, "key");// это ключ для получение ref.
  3516.     lua_pushnumber(L, ref);
  3517.     lua_rawset(L, -3);
  3518.  
  3519.     luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
  3520.     return 1;
  3521. };
  3522.  
  3523. int main(int argc, char* argv[]) {
  3524.     const char* LUA = R"(
  3525. a = create()
  3526. a.show()
  3527. )";
  3528.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3529.     luaL_openlibs(L);
  3530.  
  3531.     lua_newtable(L);
  3532.     lua_pushcfunction(L, create);
  3533.     lua_setglobal(L, "create");// уст глоб имя в таблице как С функцию.
  3534.  
  3535.  
  3536.     checkerror(L, LUA);//Функция проверка на ошибки.
  3537.  
  3538.     lua_close(L);
  3539.  
  3540.     return 0;
  3541. };
  3542.  
  3543. Реестр. Передача числа из функции в ключ возвращаемой таблицы с помощью мета таблицы.
  3544.  
  3545. int show(lua_State* L) {
  3546.     luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
  3547.     lua_pushstring(L, "key");//отправить key, чтобы получить ref
  3548.     lua_gettable(L, -2);
  3549.     int ref = lua_tonumber(L, -1);
  3550.     lua_rawgeti(L, LUA_REGISTRYINDEX, ref);/* получить значение по ключу ref.*/
  3551.  
  3552.     getlaststack(L);
  3553.     return 0;
  3554. };
  3555. int create(lua_State * L) {//  
  3556.     int k = lua_tointeger(L, -1);
  3557.     lua_gettable(L, -4);// получить глоб. таблицу.
  3558.     luaL_newmetatable(L, "mt");// создать мета таблицу.
  3559.     lua_pushcfunction(L, show);
  3560.     lua_setfield(L, -2, "show");// ключ таблицы является функцией.  
  3561.     int ref = luaL_ref(L, LUA_REGISTRYINDEX);// получить уникальный ключ.
  3562.  
  3563.     pushlua(L, k);// значение для ключа. mt.ref = 5.
  3564.     lua_rawseti(L, LUA_REGISTRYINDEX, ref); /* уст ключ со значением 5 в реестре адрес. */
  3565.  
  3566.     lua_setmetatable(L, -2); //уст метатаблицу.
  3567.  
  3568.     lua_gettable(L, -3);// получить таблицу.
  3569.     luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
  3570.  
  3571.     lua_pushstring(L, "key");// это ключ для получение ref.
  3572.     lua_pushnumber(L, ref);
  3573.     lua_rawset(L, -3);
  3574.  
  3575.     luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
  3576.     return 1;
  3577. };
  3578.  
  3579. int main(int argc, char* argv[]) {
  3580.     const char* LUA = R"(
  3581. a = create(6)
  3582. a.show()
  3583. )";
  3584.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3585.     luaL_openlibs(L);
  3586.  
  3587.     lua_newtable(L);
  3588.     lua_pushcfunction(L, create);
  3589.     lua_setglobal(L, "create");// уст глоб имя в таблице как С функцию.
  3590.  
  3591.  
  3592.     checkerror(L, LUA);//Функция проверка на ошибки.
  3593.  
  3594.     lua_close(L);
  3595.  
  3596.     return 0;
  3597. };
  3598.  
  3599.  
  3600. Реестр хранить мета таблицу с польз.данными.
  3601.  
  3602. int main(int argc, char* argv[]) {
  3603.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3604.     luaL_openlibs(L);
  3605.  
  3606.     luaL_newmetatable(L, "mt");// создать мета таблицу.
  3607.     luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
  3608.  
  3609.     lua_pushstring(L, "key");// это ключ для получение 5.
  3610.  
  3611.     a** c = (a * *)lua_newuserdata(L, sizeof(a*));/*Эта функция выделяет новый блок памяти с заданным размером,*/
  3612.     *c = new a();
  3613.  
  3614.     lua_rawsetp(L, LUA_REGISTRYINDEX, "mt");  /* уст ключ в реестре адрес k.  */
  3615.    
  3616.  
  3617.     lua_pushstring(L, "key");// это ключ для получение объекта.*/
  3618.     lua_rawgetp(L, LUA_REGISTRYINDEX, "mt");/* получить значение по ключу key объект*/
  3619.    
  3620.     a** st = (a** )lua_touserdata(L, -1);// получаем польз. данные.
  3621.     a * b = &**st;
  3622.     b->show();// вызов метода.  
  3623.  
  3624.     b->~a();//вызов метода деструктор.
  3625.  
  3626.     lua_close(L);
  3627.     return 0;
  3628. };
  3629.  
  3630. Реестр и метатаблицы, реализация ооп через таблицу с функциями.
  3631.  
  3632. struct a {  int x = 10;
  3633.     a() { cout << "create object " << this << endl; }//конструктор по умолчанию
  3634.  
  3635.     void show() { cout << "\nobject - " << this << "\tx = " << x << "\n\n"; }//вывести значение x на экран.
  3636.  
  3637.     ~a() { cout << "destory object " << this << endl << endl; }//вызов деструктора.
  3638. };
  3639.  
  3640.  
  3641. int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
  3642.     lua_pushstring(L, "key");// это ключ для получение объекта.*/
  3643.     lua_rawgetp(L, LUA_REGISTRYINDEX, "mt");/* получить значение (объект) по ключу key */
  3644.     a** st = (a * *)lua_touserdata(L, -1);// получаем польз. данные.
  3645.     a * b = &**st;
  3646.     b->~a();//вызов метода деструктор.
  3647.     return 0;
  3648. };
  3649.  
  3650. int show(lua_State * L) {
  3651.     lua_pushstring(L, "key");// это ключ для получение объекта.*/
  3652.     lua_rawgetp(L, LUA_REGISTRYINDEX, "mt");/* получить значение (объект) по ключу key */
  3653.     a** st = (a * *)lua_touserdata(L, -1);// получаем польз. данные.
  3654.     a * b = &**st;
  3655.     b->show();// вызов метода.  
  3656.     return 0;
  3657. };
  3658. int create(lua_State * L) {//   Функция создания объекта структуры.
  3659.     lua_newtable(L);
  3660.     luaL_newmetatable(L, "mt");// создать мета таблицу.
  3661.     lua_pushcfunction(L, destroy);
  3662.     lua_setfield(L, -2, "__gc");
  3663.  
  3664.     lua_pushstring(L, "key");// это ключ для получение объекта.
  3665.  
  3666.     a** c = (a * *)lua_newuserdata(L, sizeof(a*));/*Эта функция выделяет новый блок памяти с заданным размером,*/
  3667.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  3668.     *c = new a();
  3669.     lua_setmetatable(L, -2); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
  3670.  
  3671.     lua_rawsetp(L, LUA_REGISTRYINDEX, "mt");  /* уст ключ в реестре адрес k.  */
  3672.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  3673.     lua_pushcfunction(L, show);
  3674.     lua_setfield(L, -2, "show");
  3675.  
  3676.     return 1;
  3677. };
  3678.  
  3679. int main(int argc, char* argv[]) {
  3680.     const char* LUA = R"(
  3681.  
  3682. a = create()
  3683. a.show()
  3684.  
  3685. )";
  3686.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3687.     luaL_openlibs(L);
  3688.  
  3689.     lua_pushcfunction(L, create);
  3690.     lua_setglobal(L, "create");//уст указатель на функцию C++ и создает внутри Lua
  3691.  
  3692.     checkerror(L, LUA);//Функция проверка на ошибки.
  3693.  
  3694.     lua_close(L);
  3695.  
  3696.     return 0;
  3697. };
  3698.  
  3699.  
  3700. Метатаблица, передача значение между функциями.
  3701.  
  3702.  
  3703. int show(lua_State* L) {
  3704.     luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
  3705.     lua_pushstring(L, "key");//отправить key, чтобы получить ref
  3706.     lua_gettable(L, -2);
  3707.     cout << lua_tonumber(L, -1) << " == 5" << endl;//должно быть 5.
  3708.     return 0;
  3709. };
  3710. int create(lua_State * L) {//   Функция создания объекта структуры.
  3711.     luaL_newmetatable(L, "mt");// создать мета таблицу.
  3712.     luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
  3713.  
  3714.     lua_pushstring(L, "key");// это ключ для получение 5.
  3715.     lua_pushnumber(L, 5);// значение ключа key это 5.
  3716.     lua_settable(L, -3);// установить таблицу.
  3717.     return 1;
  3718. };
  3719.  
  3720. int main(int argc, char* argv[]) {
  3721.     const char* LUA = R"(
  3722. create()
  3723. show()
  3724. )";
  3725.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3726.     luaL_openlibs(L);
  3727.  
  3728.     lua_newtable(L);
  3729.     lua_pushcfunction(L, create);
  3730.     lua_setglobal(L, "create");// уст глоб имя в таблице как С функцию.
  3731.  
  3732.     lua_pushcfunction(L, show);
  3733.     lua_setglobal(L, "show");
  3734.  
  3735.     checkerror(L, LUA);//Функция проверка на ошибки.
  3736.  
  3737.     lua_close(L);
  3738.  
  3739.     return 0;
  3740. };
  3741.  
  3742.  
  3743. Метатаблица, передача польз.данных(объекта структуры) между функциями.
  3744.  
  3745.  
  3746. struct a {
  3747.     int x = 10;
  3748.     a() { cout << "create object " << this << endl; }//конструктор по умолчанию
  3749.  
  3750.     void show() { cout << "\nobject - " << this << "\tx = " << x << "\n\n"; }//вывести значение x на экран.
  3751.  
  3752.     ~a() { cout << "destory object " << this << endl << endl; }//вызов деструктора.
  3753. };
  3754.  
  3755. int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
  3756.     cout << "destroy " << endl;
  3757.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  3758.     a** st = (a * *)lua_touserdata(L, -2); // получаем польз. данные.
  3759.     a * b = &**st;
  3760.     b->~a();//вызов метода деструктор.
  3761.     return 0;
  3762.  
  3763. };
  3764.  
  3765. int show(lua_State* L) {
  3766.     luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
  3767.     lua_pushstring(L, "key");//отправить key, чтобы получить объект.
  3768.     lua_gettable(L, -2);   
  3769.     a** st = (a * *)lua_touserdata(L, -1);// получаем польз. данные.
  3770.     a * b = &**st;
  3771.     b->show();// вызов метода.  
  3772.     b->~a();//вызов метода деструктор.
  3773.  
  3774.     return 0;
  3775. };
  3776. int create(lua_State * L) {//   Функция создания объекта структуры.
  3777.     luaL_newmetatable(L, "mt");// создать мета таблицу.
  3778.     luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
  3779.  
  3780.     lua_pushstring(L, "key");// это ключ для получение 5.
  3781.  
  3782.     a** c = (a **)lua_newuserdata(L, sizeof(a*));/*Эта функция выделяет новый блок памяти с заданным размером,*/
  3783.     *c = new a();
  3784.  
  3785.     lua_settable(L, -3);// установить таблицу.
  3786.     return 1;
  3787. };
  3788.  
  3789. int main(int argc, char* argv[]) {
  3790.     const char* LUA = R"(
  3791. create()
  3792. show()
  3793. )";
  3794.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3795.     luaL_openlibs(L);
  3796.  
  3797.     lua_newtable(L);
  3798.     lua_pushcfunction(L, create);
  3799.     lua_setglobal(L, "create");// уст глоб имя в таблице как С функцию.
  3800.  
  3801.     lua_pushcfunction(L, show);
  3802.     lua_setglobal(L, "show");
  3803.  
  3804.     checkerror(L, LUA);//Функция проверка на ошибки.
  3805.  
  3806.     lua_close(L);
  3807.  
  3808.     return 0;
  3809. };
  3810.  
  3811.  
  3812.  
  3813.  
  3814.  
  3815.  
  3816.  
  3817.  
  3818.  
  3819. int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
  3820.     cout << "destroy " << endl;
  3821.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  3822.     a** st = (a * *)lua_touserdata(L, -2); // получаем польз. данные.
  3823.     a *b = &**st;
  3824.  
  3825.     b->~a();//вызов метода деструктор.
  3826.     return 0;
  3827.  
  3828. };
  3829.  
  3830. int show(lua_State * L) {
  3831.  
  3832.     cout << "show " << endl;
  3833.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/ 
  3834.     cout << lua_type(L,-2) << endl;
  3835.     //a** st = (a * *)lua_touserdata(L, -2);// получаем польз. данные.
  3836.     //a * b = &**st;
  3837.     //b->show();// вызов метода.
  3838.     return 0;
  3839. };
  3840.     //lua_newtable(L);
  3841.     //luaL_newmetatable(L, "mt");// создать мета таблицу.
  3842.     //pushlua(L, "__gc");
  3843.     //lua_pushcfunction(L, destroy);
  3844.     //lua_settable(L, -3); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
  3845.  
  3846. int create(lua_State* L) {//    Функция создания объекта структуры.
  3847.     lua_newtable(L);
  3848.     luaL_newmetatable(L, "mt");// создать мета таблицу.
  3849.     lua_pushcfunction(L, destroy);
  3850.     lua_setfield(L, -2, "__gc");
  3851.    
  3852.     a** c = (a * *)lua_newuserdata(L, sizeof(a*));/*Эта функция выделяет новый блок памяти с заданным размером,*/
  3853.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  3854.     *c = new a();
  3855.     lua_setmetatable(L, -2); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
  3856.  
  3857.     lua_gettable(L, -3);
  3858.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  3859.  
  3860.    lua_pushcfunction(L, show);
  3861.     lua_setfield(L, -2, "show");
  3862.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  3863.  
  3864.     return 1;
  3865. };
  3866.  
  3867. int main(int argc, char* argv[]) {
  3868. const char* LUA = R"(
  3869.  
  3870. a= create()
  3871. a.show()
  3872.  
  3873. )";
  3874.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3875.     luaL_openlibs(L);
  3876.    
  3877.     lua_pushcfunction(L, create);
  3878.     lua_setglobal(L, "create");//уст указатель на функцию C++ и создает внутри Lua
  3879.  
  3880.     checkerror(L, LUA);//Функция проверка на ошибки.
  3881.  
  3882.     lua_close(L);
  3883.  
  3884.     return 0;
  3885. };
  3886.  
  3887.  
  3888.  
  3889. По указателю.
  3890. int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
  3891.     cout << "destroy " << endl;
  3892.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  3893.     a* st = (a* )lua_touserdata(L, -2); // получаем польз. данные.
  3894.  
  3895.     st->~a();//вызов метода деструктор.
  3896.     return 0;
  3897. };
  3898.  
  3899. int create(lua_State * L) {//   Функция создания объекта структуры.
  3900.     lua_newtable(L);
  3901.     luaL_newmetatable(L, "mt");// создать мета таблицу.
  3902.     pushlua(L, "__gc");
  3903.     lua_pushcfunction(L, destroy);
  3904.     lua_settable(L, -3); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
  3905.  
  3906.  
  3907.     a* c = (a *)lua_newuserdata(L, sizeof(a));/*Эта функция выделяет новый блок памяти с заданным размером,*/
  3908.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  3909.     c = new a();
  3910.     lua_setmetatable(L, -2); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
  3911.  
  3912.     return 1;
  3913. };
  3914.  
  3915.  
  3916. Через реестр.
  3917.  
  3918. struct a {
  3919.     int x = 10;
  3920.     a() { cout << "create object " << this << endl; }//конструктор по умолчанию
  3921.  
  3922.     void show() { cout << "\nobject - " << this << "\tx = " << x << "\n\n"; }//вывести значение x на экран.
  3923.  
  3924.     ~a() { cout << "destory object " << this << endl << endl; }//вызов деструктора.
  3925. };
  3926.  
  3927. int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
  3928.     cout << "destroy " << endl;
  3929.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  3930.     a** st = (a * *)lua_touserdata(L, -2); // получаем польз. данные.
  3931.     a *b = &**st;
  3932.  
  3933.     b->~a();//вызов метода деструктор.
  3934.  
  3935.  
  3936.     return 0;
  3937.  
  3938. };
  3939.  
  3940. int show(lua_State * L) {
  3941.  
  3942. luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/ 
  3943.  
  3944.     lua_pushstring(L, "key");
  3945.     lua_gettable(L, -2);
  3946.     cout << lua_tonumber(L, -1)<<"ref \n";
  3947.     int ref = 3;
  3948.     pushlua(L, ref);
  3949.     lua_rawgetp(L, LUA_REGISTRYINDEX, &ref);/* получить значение по ключу адрес k*/
  3950.  
  3951.     //getlaststack(L);
  3952. cout << lua_type(L,-1) << endl;
  3953. //  a** st = (a * *)lua_touserdata(L, -1);// получаем польз. данные.
  3954. //  a * b = &**st;
  3955. //  b->show();// вызов метода.  
  3956.     return 0;
  3957. };
  3958. int create(lua_State* L) {//    Функция создания объекта структуры.
  3959.     lua_gettable(L, -3);
  3960.     luaL_newmetatable(L, "mt");// создать мета таблицу.
  3961.     lua_pushcfunction(L, destroy);
  3962.     lua_setfield(L, -2, "__gc");
  3963.    
  3964.     lua_pushcfunction(L, show);
  3965.     lua_setfield(L, -2, "show");
  3966.     int ref = luaL_ref(L, LUA_REGISTRYINDEX);
  3967.  
  3968.     //luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  3969.     a** c = (a * *)lua_newuserdata(L, sizeof(a*));/*Эта функция выделяет новый блок памяти с заданным размером,*/
  3970.     *c = new a();
  3971.     lua_rawsetp(L, LUA_REGISTRYINDEX, &ref);  /* уст ключ в реестре адрес k.  */
  3972.  
  3973.     lua_setmetatable(L, -2); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
  3974.  
  3975.     lua_gettable(L, -2);
  3976.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  3977.  
  3978.     lua_pushcfunction(L, show);
  3979.     lua_setfield(L, -2, "show");
  3980.     lua_pushstring(L, "key");
  3981.     lua_pushnumber(L, ref);
  3982.     lua_rawset(L, -3);
  3983.  
  3984.     cout << ref<<" kkmj\n";
  3985.  
  3986.     luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
  3987.     return 1;
  3988. };
  3989.  
  3990. int main(int argc, char* argv[]) {
  3991. const char* LUA = R"(
  3992.  
  3993. a= create()
  3994. a.show()
  3995.  
  3996. )";
  3997.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  3998.     luaL_openlibs(L);
  3999.  
  4000.     lua_newtable(L);
  4001.     lua_pushcfunction(L, create);
  4002.     lua_setglobal(L, "create");//уст указатель на функцию C++ и создает внутри Lua
  4003.  
  4004.     checkerror(L, LUA);//Функция проверка на ошибки.
  4005.  
  4006.     lua_close(L);
  4007.  
  4008.     return 0;
  4009. };
  4010.  
  4011. Реестр. Передача значение между функциями через метатаблицу.
  4012.  
  4013. int show(lua_State * L) {
  4014.     luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
  4015.     lua_pushstring(L, "key");//отправить key, чтобы получить ref
  4016.     lua_gettable(L, -2);
  4017.     int ref = lua_tonumber(L, -1);
  4018.     lua_rawgetp(L, LUA_REGISTRYINDEX, &ref);/* получить значение по ключу ref.*/
  4019.     cout << lua_tonumber(L, -1) << " value 5" << endl;//должно быть 5.
  4020.     return 0;
  4021. };
  4022. int create(lua_State * L) {//   Функция создания объекта структуры.
  4023.     lua_gettable(L, -3);// получить глоб. таблицу.
  4024.     luaL_newmetatable(L, "mt");// создать мета таблицу.
  4025.     int ref = luaL_ref(L, LUA_REGISTRYINDEX);// получить уникальный ключ.
  4026.     pushlua(L, 5);// отправить значение для ключа. mt.ref = 5.
  4027.     lua_rawsetp(L, LUA_REGISTRYINDEX, &ref); /* уст ключ со значением 5 в реестре адрес. */
  4028.  
  4029.     lua_pushstring(L, "key");// это ключ для получение ref.
  4030.     lua_pushnumber(L, ref);
  4031.  
  4032.     lua_setmetatable(L, -2); //уст метатаблицу.
  4033.     luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
  4034.     return 1;
  4035. };
  4036.  
  4037. int main(int argc, char* argv[]) { 
  4038.     const char* LUA = R"(
  4039. create()
  4040. show()
  4041. )";
  4042.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  4043.     luaL_openlibs(L);
  4044.  
  4045.     lua_newtable(L);
  4046.     lua_pushcfunction(L, create);
  4047.     lua_setglobal(L, "create");// уст глоб имя в таблице как С функцию.
  4048.    
  4049.     lua_pushcfunction(L, show);
  4050.     lua_setglobal(L, "show");
  4051.  
  4052.     checkerror(L, LUA);//Функция проверка на ошибки.
  4053.  
  4054.     lua_close(L);
  4055.  
  4056.     return 0;
  4057. };
  4058.  
  4059. Выводится.
  4060. 5 value 5
  4061.  
  4062. C:\Users\e\source\repos\Project1luaapi\Debug\Project1luaapi.exe (процесс 2764) завершает работу с кодом 0.
  4063. Чтобы закрыть это окно, нажмите любую клавишу…
  4064.  
  4065. Реестр. Передача в функцию числа, возвращаем из другой функции.
  4066.  
  4067. int show(lua_State* L) {
  4068.     luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
  4069.    
  4070.     pushlua(L, "key");
  4071.     lua_gettable(L, -2);
  4072.     int ref = lua_tonumber(L, -1);
  4073.     cout << "in func show regis key " << ref  << endl;
  4074.     lua_rawgetp(L, LUA_REGISTRYINDEX, &ref);/* получить значение по ключу ref.*/
  4075.  
  4076.     cout << lua_tonumber(L, -1) << " value 5" << endl;//должно быть 5.
  4077.     return 0;
  4078. };
  4079. int create(lua_State * L) {//   Функция создания объекта структуры.
  4080.     int k = lua_tonumber(L, -1);
  4081.     cout << k << endl;// 5
  4082.     int ref = luaL_ref(L, LUA_REGISTRYINDEX);// получить уникальный ключ.
  4083.     cout <<"in func create regis key " << ref  << endl;
  4084.    
  4085.     luaL_newmetatable(L, "mt");// создать мета таблицу.
  4086.     luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
  4087.     lua_gettable(L, -2);// получить глоб. таблицу.
  4088.     pushlua(L, k);// значение для ключа. mt.ref = 5.
  4089.     lua_rawsetp(L, LUA_REGISTRYINDEX, &k); /* уст ключ со значением 5 в реестре адрес. */
  4090.     lua_setmetatable(L, -2); //уст метатаблицу.
  4091.     luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
  4092.     pushlua(L, "key");// это ключ для получение ref.
  4093.     pushlua(L, ref);
  4094.     lua_settable(L, -3);
  4095. return 1;
  4096. };
  4097.  
  4098. int main(int argc, char* argv[]) {
  4099.     const char* LUA = R"(
  4100. create(5)
  4101. show()
  4102. )";
  4103.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  4104.     luaL_openlibs(L);
  4105.  
  4106.     lua_newtable(L);
  4107.     lua_pushcfunction(L, create);
  4108.     lua_setglobal(L, "create");// уст глоб имя в таблице как С функцию.
  4109.  
  4110.     lua_pushcfunction(L, show);
  4111.     lua_setglobal(L, "show");
  4112.  
  4113.     checkerror(L, LUA);//Функция проверка на ошибки.
  4114.  
  4115.     lua_close(L);
  4116.  
  4117.     return 0;
  4118. };
  4119. Выводится.
  4120. 5
  4121. in func create regis key 3
  4122. in func show regis key 3
  4123. 5 value 5
  4124.  
  4125. C:\Users\e\source\repos\Project1luaapi\Debug\Project1luaapi.exe (процесс 5912) завершает работу с кодом 0.
  4126. Чтобы закрыть это окно, нажмите любую клавишу…
  4127.  
  4128.  
  4129. test1.lua
  4130. x = 1
  4131. function hi()
  4132.     print("hi1");
  4133.     print(x);
  4134. end
  4135. hi()
  4136. test2.lua
  4137. x =2
  4138. function hi()
  4139.     print("hi2");
  4140.     print(x);
  4141. end
  4142. hi()
  4143.  
  4144.  
  4145. int main(int argc, char *argv[]) {
  4146.  
  4147.     lua_State* L = luaL_newstate();
  4148.     luaL_openlibs(L);
  4149.  
  4150.     const char* file1 = "test1.lua";
  4151.     const char* file2 = "test2.lua";
  4152.  
  4153.     //We load the file
  4154.     luaL_loadfile(L, file1);
  4155.     //Create _ENV tables
  4156.     lua_newtable(L);
  4157.     //Create metatable
  4158.     lua_newtable(L);
  4159.     //Get the global table
  4160.     lua_getglobal(L, "_G");
  4161.     lua_setfield(L, -2, "__index");
  4162.     //Set global as the metatable
  4163.     lua_setmetatable(L, -2);
  4164.     //Push to registry with a unique name.
  4165.     //I feel like these 2 steps could be merged or replaced but I'm not sure how
  4166.     lua_setfield(L, LUA_REGISTRYINDEX, "test1");
  4167.     //Retrieve it.
  4168.     lua_getfield(L, LUA_REGISTRYINDEX, "test1");
  4169.     //Set the upvalue (_ENV)
  4170.     lua_setupvalue(L, 1, 1);
  4171.     //Run chunks
  4172.     lua_pcall(L, 0, LUA_MULTRET, 0);
  4173.  
  4174.     //Repeat
  4175.     luaL_loadfile(L, file2);
  4176.     lua_newtable(L);
  4177.     lua_newtable(L);
  4178.     lua_getglobal(L, "_G");
  4179.     lua_setfield(L, -2, "__index");
  4180.     lua_setmetatable(L, -2);
  4181.     lua_setfield(L, LUA_REGISTRYINDEX, "test2");
  4182.     lua_getfield(L, LUA_REGISTRYINDEX, "test2");
  4183.     lua_setupvalue(L, 1, 1);
  4184.     lua_pcall(L, 0, LUA_MULTRET, 0);
  4185.  
  4186.     //Retrieve the table containing the functions of the chunk
  4187.     lua_getfield(L, LUA_REGISTRYINDEX, "test1");
  4188.     //Get the function we want to call
  4189.     lua_getfield(L, -1, "hi");
  4190.     //Call it
  4191.     lua_call(L, 0, 0);
  4192.     //Repeat
  4193.     lua_getfield(L, LUA_REGISTRYINDEX, "test2");
  4194.     lua_getfield(L, -1, "hi");
  4195.     lua_call(L, 0, 0);
  4196.     lua_getfield(L, LUA_REGISTRYINDEX, "test2");
  4197.     lua_getfield(L, -1, "hi");
  4198.     lua_call(L, 0, 0);
  4199.     lua_getfield(L, LUA_REGISTRYINDEX, "test1");
  4200.     lua_getfield(L, -1, "hi");
  4201.     lua_call(L, 0, 0);
  4202.  
  4203.  
  4204.     lua_close(L);// закрыть состояние
  4205.     cin.get();//ожидает ввода символа программа завершается.
  4206.  
  4207.     return 0;
  4208. }
  4209.  
  4210.  
  4211. Замыкание.
  4212.  
  4213. struct Sprite
  4214.     {
  4215.         int x;
  4216.         int y;
  4217.  
  4218.         Sprite() : x(0), y(0) {}
  4219.         ~Sprite() {}
  4220.  
  4221.         void Move(int velX, int velY)
  4222.         {
  4223.             x += velX;
  4224.             y += velY;
  4225.         }
  4226.  
  4227.         void Draw()
  4228.         {
  4229.             printf("sprite(%p): x = %d, y = %d\n", this, x, y);
  4230.         }
  4231.     };
  4232.  
  4233.     struct SpriteManager
  4234.     {
  4235.         std::vector<Sprite*> m_sprites;
  4236.         int numberOfSpritesExisting = 0;
  4237.         int numberOfSpritesMade = 0;
  4238.  
  4239.         void LookAfterSprite(Sprite* sprite)
  4240.         {
  4241.             numberOfSpritesExisting++;
  4242.             numberOfSpritesMade++;
  4243.             m_sprites.push_back(sprite);
  4244.         }
  4245.  
  4246.         void ForgetSprite(Sprite* sprite)
  4247.         {
  4248.             int i = 0;
  4249.             for (auto& s : m_sprites)
  4250.             {
  4251.                 if (s == sprite)
  4252.                 {
  4253.                     numberOfSpritesExisting--;
  4254.                     m_sprites.erase(m_sprites.begin() + i);
  4255.                     return;
  4256.                 }
  4257.                 i++;
  4258.             }
  4259.         }
  4260.     };
  4261.  
  4262.     SpriteManager spriteManager;
  4263.  
  4264.     int CreateSprite(lua_State* L){
  4265.         SpriteManager* sm = (SpriteManager*)lua_touserdata(L, lua_upvalueindex(1));
  4266.         lua_assert(sm);
  4267.  
  4268.         void* pointerToASprite = lua_newuserdata(L, sizeof(Sprite));
  4269.         new (pointerToASprite) Sprite();
  4270.         luaL_getmetatable(L, "SpriteMetaTable");
  4271.         lua_assert(lua_istable(L, -1));
  4272.         lua_setmetatable(L, -2);
  4273.  
  4274.         lua_newtable(L);
  4275.         lua_setuservalue(L, 1);
  4276.  
  4277.         sm->LookAfterSprite((Sprite*)pointerToASprite);
  4278.  
  4279.         return 1;
  4280.     };
  4281.  
  4282.     int DestroySprite(lua_State* L){
  4283.         SpriteManager* sm = (SpriteManager*)lua_touserdata(L, lua_upvalueindex(1));
  4284.         lua_assert(sm);
  4285.  
  4286.         Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
  4287.         sm->ForgetSprite(sprite);
  4288.         sprite->~Sprite();
  4289.         return 0;
  4290.     };
  4291.  
  4292.     int MoveSprite(lua_State* L){
  4293.         Sprite* sprite = (Sprite*)lua_touserdata(L, -3);
  4294.         lua_Number velX = lua_tonumber(L, -2);
  4295.         lua_Number velY = lua_tonumber(L, -1);
  4296.         sprite->Move((int)velX, (int)velY);
  4297.         return 0;
  4298.     };
  4299.  
  4300.     int DrawSprite(lua_State* L){
  4301.         Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
  4302.         sprite->Draw();
  4303.         return 0;
  4304.     };
  4305.  
  4306.     int SpriteIndex(lua_State* L){
  4307.         lua_assert(lua_isuserdata(L, -2));  //1
  4308.         lua_assert(lua_isstring(L, -1));    //2
  4309.  
  4310.         Sprite* sprite = (Sprite*)lua_touserdata(L, -2);
  4311.         const char* index = lua_tostring(L, -1);
  4312.         if (strcmp(index, "x") == 0)
  4313.         {
  4314.             lua_pushnumber(L, sprite->x);
  4315.             return 1;
  4316.         }
  4317.         else if (strcmp(index, "y") == 0)
  4318.         {
  4319.             lua_pushnumber(L, sprite->y);
  4320.             return 1;
  4321.         }
  4322.         else
  4323.         {
  4324.             lua_getuservalue(L, 1);
  4325.             lua_pushvalue(L, 2);
  4326.             lua_gettable(L, -2);
  4327.             if (lua_isnil(L, -1))
  4328.             {
  4329.                 lua_getglobal(L, "Sprite");
  4330.                 lua_pushstring(L, index);
  4331.                 lua_rawget(L, -2);
  4332.             }
  4333.             return 1;
  4334.         }
  4335.     };
  4336.  
  4337.     int SpriteNewIndex(lua_State* L){
  4338.         lua_assert(lua_isuserdata(L, -3));  //1
  4339.         lua_assert(lua_isstring(L, -2));    //2
  4340.                                         // -1 - value we want to set    //3
  4341.  
  4342.         Sprite* sprite = (Sprite*)lua_touserdata(L, -3);
  4343.         const char* index = lua_tostring(L, -2);
  4344.         if (strcmp(index, "x") == 0)
  4345.         {
  4346.             sprite->x = (int)lua_tonumber(L, -1);
  4347.         }
  4348.         else if (strcmp(index, "y") == 0)
  4349.         {
  4350.             sprite->y = (int)lua_tonumber(L, -1);
  4351.         }
  4352.         else
  4353.         {
  4354.             lua_getuservalue(L, 1); //1
  4355.             lua_pushvalue(L, 2);    //2
  4356.             lua_pushvalue(L, 3);    //3
  4357.             lua_settable(L, -3);    //1[2] = 3
  4358.         }
  4359.  
  4360.         return 0;
  4361.     };
  4362.  
  4363. int main(int argc, char *argv[]) {
  4364.     const char* LUA_FILE = R"(
  4365.         sprite = Sprite.new()
  4366.         sprite:Move( 6, 7 )     -- Sprite.Move( sprite, 6, 7 )
  4367.         sprite:Draw()
  4368.         sprite.y = 10
  4369.         sprite.zzz = 99
  4370.         sprite.x = sprite.zzz
  4371.         sprite:Draw()
  4372.         Sprite.new()
  4373.         Sprite.new()
  4374.         )";
  4375.  
  4376.     lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  4377.     luaL_openlibs(L);
  4378.  
  4379.     lua_newtable(L);
  4380.     int spriteTableIdx = lua_gettop(L);
  4381.     lua_pushvalue(L, spriteTableIdx);
  4382.     lua_setglobal(L, "Sprite");
  4383.  
  4384.     constexpr int NUMBER_OF_UPVALUES = 1;
  4385.     lua_pushlightuserdata(L, &spriteManager);
  4386.     lua_pushcclosure(L, CreateSprite, NUMBER_OF_UPVALUES);
  4387.     lua_setfield(L, -2, "new");
  4388.     lua_pushcfunction(L, MoveSprite);
  4389.     lua_setfield(L, -2, "Move");
  4390.     lua_pushcfunction(L, DrawSprite);
  4391.     lua_setfield(L, -2, "Draw");
  4392.  
  4393.     luaL_newmetatable(L, "SpriteMetaTable");
  4394.     lua_pushstring(L, "__gc");
  4395.     lua_pushlightuserdata(L, &spriteManager);
  4396.     lua_pushcclosure(L, DestroySprite, NUMBER_OF_UPVALUES);
  4397.     lua_settable(L, -3);
  4398.  
  4399.     lua_pushstring(L, "__index");
  4400.     lua_pushcfunction(L, SpriteIndex);
  4401.     lua_settable(L, -3);
  4402.  
  4403.     lua_pushstring(L, "__newindex");
  4404.     lua_pushcfunction(L, SpriteNewIndex);
  4405.     lua_settable(L, -3);
  4406.  
  4407.     int doResult = luaL_dostring(L, LUA_FILE);
  4408.     if (doResult != LUA_OK)
  4409.     {
  4410.         printf("Error: %s\n", lua_tostring(L, -1));
  4411.     }
  4412.  
  4413.     lua_close(L);
  4414.  
  4415.     lua_assert(spriteManager.numberOfSpritesExisting == 0);
  4416.     lua_assert(spriteManager.numberOfSpritesMade == 3);
  4417.  
  4418.     cin.get();//ожидает ввода символа программа завершается.
  4419.     return 0;
  4420. }
  4421.  
  4422.  
  4423. struct Sprite
  4424.     {
  4425.         int x;
  4426.  
  4427.         Sprite() : x(0) {}
  4428.         ~Sprite() {}
  4429.  
  4430.         void Move(int velX)
  4431.         {
  4432.             x += velX;
  4433.         }
  4434.  
  4435.         void Draw()
  4436.         {
  4437.             printf("sprite(%p): x = %d\n", this, x);
  4438.         }
  4439.     };
  4440.  
  4441.     struct SpriteManager
  4442.     {
  4443.         std::vector<Sprite*> m_sprites;
  4444.         void ForgetSprite(Sprite* sprite)
  4445.         {
  4446.             int i = 0;
  4447.             for (auto& s : m_sprites)
  4448.             {
  4449.                 if (s == sprite){
  4450.                     m_sprites.erase(m_sprites.begin() + i);
  4451.                     return;
  4452.                 }
  4453.                 i++;
  4454.             }
  4455.         }
  4456.     };
  4457.  
  4458. SpriteManager sp;
  4459.  
  4460.     int CreateSprite(lua_State* L){
  4461.  
  4462.         SpriteManager* sm = (SpriteManager*)lua_touserdata(L, lua_upvalueindex(1));
  4463.         void* pointerToASprite = lua_newuserdata(L, sizeof(Sprite));
  4464.         new (pointerToASprite) Sprite();
  4465.         luaL_getmetatable(L, "mt");
  4466.         lua_setmetatable(L, -2);
  4467.         lua_newtable(L);
  4468.         lua_setuservalue(L, 1);
  4469.         return 1;
  4470.     };
  4471.  
  4472.     int DestroySprite(lua_State* L){
  4473.         SpriteManager* sm = (SpriteManager*)lua_touserdata(L, lua_upvalueindex(1));
  4474.         Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
  4475.         sm->ForgetSprite(sprite);
  4476.         sprite->~Sprite();
  4477.         return 0;
  4478.     };
  4479.    
  4480.     int DrawSprite(lua_State* L){
  4481.         Sprite* sprite = (Sprite*)lua_touserdata(L, -2);
  4482.         sprite->Move(lua_tonumber(L, -1));
  4483.         sprite->Draw();
  4484.         return 0;
  4485.     };
  4486.  
  4487.     int SpriteIndex(lua_State* L){
  4488.  
  4489.         Sprite* sprite = (Sprite*)lua_touserdata(L, -2);
  4490.         const char* index = lua_tostring(L, -1);
  4491.             lua_getuservalue(L, 1);
  4492.             lua_pushvalue(L, 2);
  4493.             lua_gettable(L, -2);
  4494.  
  4495.             lua_getglobal(L, "sprite");
  4496.             lua_pushstring(L, index);
  4497.             lua_rawget(L, -2);
  4498.            
  4499.             return 1;
  4500.     };
  4501.  
  4502.  
  4503. int main(int argc, char *argv[]) {
  4504.     const char* LUA_FILE = R"(
  4505.         sp = sprite.new()
  4506.         sp:draw(6)
  4507.         )";
  4508.  
  4509.     lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  4510.     luaL_openlibs(L);
  4511.  
  4512.     lua_newtable(L);
  4513.     lua_pushvalue(L, 1);
  4514.     lua_setglobal(L, "sprite");
  4515.  
  4516.     lua_pushlightuserdata(L, &sp);
  4517.     lua_pushcclosure(L, CreateSprite, 1);
  4518.     lua_setfield(L, -2, "new");
  4519.     lua_pushcfunction(L, DrawSprite);
  4520.     lua_setfield(L, -2, "draw");
  4521.  
  4522.     luaL_newmetatable(L, "mt");
  4523.     lua_pushstring(L, "__gc");
  4524.     lua_pushlightuserdata(L, &sp);
  4525.     lua_pushcclosure(L, DestroySprite, 1);
  4526.     lua_settable(L, -3);
  4527.  
  4528.     lua_pushstring(L, "__index");
  4529.     lua_pushcfunction(L, SpriteIndex);
  4530.     lua_settable(L, -3);
  4531.     luaL_dostring(L, LUA_FILE);
  4532.  
  4533.     lua_close(L);
  4534.    
  4535.     cin.get();//ожидает ввода символа программа завершается.
  4536.     return 0;
  4537. };
  4538.  
  4539.  
  4540. Замыкание 2.
  4541.  
  4542. struct Sprite
  4543.     {
  4544.         int x;
  4545.  
  4546.         Sprite() : x(0) {}
  4547.         ~Sprite() {}
  4548.  
  4549.         void Move(int velX)
  4550.         {
  4551.             x += velX;
  4552.         }
  4553.  
  4554.         void Draw()
  4555.         {
  4556.             printf("sprite(%p): x = %d\n", this, x);
  4557.         }
  4558.     };
  4559.  
  4560.     struct SpriteManager
  4561.     {
  4562.         std::vector<Sprite*> m_sprites;
  4563.         void ForgetSprite(Sprite* sprite)
  4564.         {
  4565.             int i = 0;
  4566.             for (auto& s : m_sprites)
  4567.             {
  4568.                 if (s == sprite){
  4569.                     m_sprites.erase(m_sprites.begin() + i);
  4570.                     return;
  4571.                 }
  4572.                 i++;
  4573.             }
  4574.         }
  4575.     };
  4576.     int pri(lua_State* L) { cout << "pri " << endl;
  4577.     return 0;
  4578.     }
  4579. SpriteManager sp;
  4580.  
  4581.     int CreateSprite(lua_State* L){
  4582.         SpriteManager* sm = (SpriteManager*)lua_touserdata(L, lua_upvalueindex(1));
  4583.         void* pointerToASprite = lua_newuserdata(L, sizeof(Sprite));
  4584.         new (pointerToASprite) Sprite();
  4585.         luaL_getmetatable(L, "mt");
  4586.         lua_setmetatable(L, -2);
  4587.         lua_newtable(L);
  4588.         lua_setuservalue(L, 1);
  4589.         return 1;
  4590.     };
  4591.  
  4592.     int DestroySprite(lua_State* L){
  4593.         SpriteManager* sm = (SpriteManager*)lua_touserdata(L, lua_upvalueindex(1));
  4594.         Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
  4595.         sm->ForgetSprite(sprite);
  4596.         sprite->~Sprite();
  4597.         return 0;
  4598.     };
  4599.    
  4600.     int DrawSprite(lua_State* L){
  4601.         Sprite* sprite = (Sprite*)lua_touserdata(L, -2);
  4602.         sprite->Move(lua_tonumber(L, -1));
  4603.         sprite->Draw();
  4604.         return 0;
  4605.     };
  4606.  
  4607.     int SpriteIndex(lua_State* L){
  4608.  
  4609.         Sprite* sprite = (Sprite*)lua_touserdata(L, -2);
  4610.         const char* index = lua_tostring(L, -1);
  4611.             lua_getuservalue(L, 1);
  4612.             lua_pushvalue(L, 2);
  4613.             lua_gettable(L, -2);
  4614.  
  4615.             lua_getglobal(L, "sprite");
  4616.             lua_pushstring(L, index);
  4617.             lua_rawget(L, -2);
  4618.            
  4619.             return 1;
  4620.     };
  4621.  
  4622.  
  4623. int main(int argc, char *argv[]) {
  4624.     const char* LUA_FILE = R"(
  4625.         sp = sprite.new()
  4626.         sp:draw(6)
  4627.         )";
  4628.  
  4629.     lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  4630.     luaL_openlibs(L);
  4631.  
  4632.     lua_newtable(L);
  4633.     lua_pushvalue(L, 1);
  4634.     lua_setglobal(L, "sprite");
  4635.  
  4636.     lua_pushlightuserdata(L, &sp);
  4637.     lua_pushcclosure(L, CreateSprite, 1);
  4638.     lua_setfield(L, -2, "new");
  4639.     lua_pushcfunction(L, DrawSprite);
  4640.     lua_setfield(L, -2, "draw");
  4641.  
  4642.     luaL_newmetatable(L, "mt");
  4643.     lua_pushstring(L, "__gc");
  4644.     lua_pushlightuserdata(L, &sp);
  4645.     lua_pushcclosure(L, DestroySprite, 1);
  4646.     lua_settable(L, -3);
  4647.  
  4648.     lua_pushstring(L, "__index");
  4649.     lua_pushcfunction(L, SpriteIndex);
  4650.     lua_settable(L, -3);
  4651.     luaL_dostring(L, LUA_FILE);
  4652.  
  4653.     lua_close(L);
  4654.    
  4655.     cin.get();//ожидает ввода символа программа завершается.
  4656.     return 0;
  4657. }
  4658.  
  4659. Замыкание 3
  4660.  
  4661. struct Sprite
  4662. {
  4663.     int x;
  4664.  
  4665.     Sprite() : x(0) { cout << " sp" << endl; }
  4666.     ~Sprite() { cout << " des " << endl; }
  4667.  
  4668. };
  4669.  
  4670.  
  4671. int pri(lua_State* L) {
  4672.     cout << "pri " << endl;
  4673.     return 0;
  4674. }
  4675.  
  4676. int CreateSprite(lua_State* L) {
  4677.     void* pointerToASprite = lua_newuserdata(L, sizeof(Sprite));
  4678.     new (pointerToASprite) Sprite();
  4679.     luaL_getmetatable(L, "mt");
  4680.     lua_setmetatable(L, -2);
  4681.     lua_newtable(L);
  4682.     lua_setuservalue(L, 1);
  4683.     return 1;
  4684. };
  4685.  
  4686. int DestroySprite(lua_State* L) {
  4687.     Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
  4688.     sprite->~Sprite();
  4689.     return 0;
  4690. };
  4691.  
  4692.  
  4693. int main(int argc, char *argv[]) {
  4694.     const char* LUA_FILE = R"(
  4695.         sp = sprite.new()
  4696.         )";
  4697.  
  4698.     lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  4699.     luaL_openlibs(L);
  4700.  
  4701.     lua_newtable(L);
  4702.     lua_pushvalue(L, 1);
  4703.     lua_setglobal(L, "sprite");
  4704.  
  4705.     lua_pushinteger(L, 2);
  4706.     lua_pushcclosure(L, CreateSprite, 1);
  4707.     lua_setfield(L, -2, "new");
  4708.  
  4709.     luaL_newmetatable(L, "mt");
  4710.     lua_pushstring(L, "__gc");
  4711.  
  4712.     lua_pushinteger(L, 2);
  4713.     lua_pushcclosure(L, DestroySprite, 1);
  4714.     lua_settable(L, -3);
  4715.  
  4716.     luaL_dostring(L, LUA_FILE);
  4717.  
  4718.     lua_close(L);
  4719.  
  4720.     cin.get();//ожидает ввода символа программа завершается.
  4721.     return 0;
  4722. }
  4723.  
  4724. Замыкание 4.
  4725.  
  4726. int pri(lua_State* L) {
  4727.     showstack(L);
  4728.     cout << "pri " << endl;
  4729.     return 0;
  4730. }
  4731.  
  4732. int CreateSprite(lua_State* L) {
  4733.     cout << "cre " << endl;
  4734.     lua_gettable(L, -2);
  4735.     lua_setuservalue(L, 1);
  4736.     return 1;
  4737. };
  4738.  
  4739. int main(int argc, char *argv[]) {
  4740.     const char* LUA_FILE = R"(
  4741.         sp = sprite.new()
  4742.         )";
  4743.  
  4744.     lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  4745.     luaL_openlibs(L);
  4746.  
  4747.     lua_newtable(L);
  4748.     lua_pushvalue(L, 1);
  4749.     lua_setglobal(L, "sprite");
  4750.    
  4751.     lua_pushinteger(L, 2);
  4752.     lua_pushcclosure(L, pri, 1);
  4753.     lua_setfield(L, -2, "new");
  4754.  
  4755.     luaL_dostring(L, LUA_FILE);
  4756.     lua_close(L);
  4757.  
  4758.     cin.get();//ожидает ввода символа программа завершается.
  4759.     return 0;
  4760. }
  4761.  
  4762. Замыкание 5.
  4763.  
  4764. static int newcounter(lua_State *L) {
  4765.     cout << lua_tonumber(L, -1) << endl;
  4766.     cout << " new" << endl;
  4767.     int val = lua_tointeger(L, lua_upvalueindex(1));
  4768.     lua_pushinteger(L, 1);  /* new value */
  4769.     lua_copy(L, -1, lua_upvalueindex(1));  /* update upvalue */
  4770.     return 1;
  4771. }
  4772. static int counter(lua_State *L) {
  4773.     cout << "coun " << endl;
  4774.     lua_pushinteger(L, 10);
  4775.     lua_pushcclosure(L, newcounter, 1);
  4776.     return 1;  /* return new value */
  4777. }
  4778.  
  4779.  
  4780. int main(int argc, char *argv[]) {
  4781.     const char* LUA = R"(
  4782. c1 = counter()
  4783.    print(c1(), c1(), c1())   --> 1    2    3
  4784.     -- c2 = newcounter()
  4785.      --print(c2(), c2(), c1())   --> 1    2    4
  4786.  
  4787.        )";
  4788.  
  4789.     lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  4790.     luaL_openlibs(L);
  4791.     //lua_newtable(L);
  4792.    
  4793.     //lua_pushnumber(L, 142);
  4794.     lua_register(L,"counter", counter);// отправить c функцию в стек.
  4795.     luaL_dostring(L, LUA);
  4796.     //lua_pushnumber(L, 142);
  4797.   lua_pushcclosure(L, newcounter, 1);
  4798.  
  4799. //  lua_settable(L, -3);
  4800.  
  4801.     lua_pcall(L, 0, 0, 0);// вызвать функцию foo.
  4802.  
  4803.     lua_close(L);
  4804.  
  4805.     cin.get();//ожидает ввода символа программа завершается.
  4806.     return 0;
  4807. }
  4808.  
  4809.  
  4810. Замыкание 6.
  4811.  
  4812.  
  4813. static int newcounter(lua_State *L) {
  4814.     int val = lua_tointeger(L, lua_upvalueindex(1));/*Возвращает псевдоиндекс, который представляет
  4815.     i-ковою внешнюю локальную переменную (upvalue) выполняемой функции.*/
  4816.     lua_pushinteger(L, ++val);  /*  новое  значение    */
  4817.     lua_pushvalue(L, -1);   /*дублирует    его  */
  4818.     lua_replace(L, lua_upvalueindex(1));/*  обновляет  верхнее  значение*/
  4819.     return 1;
  4820. }
  4821. static int counter(lua_State *L) {
  4822.     lua_pushinteger(L, 0);
  4823.     lua_pushcclosure(L, newcounter, 1);
  4824.     return 1;  /* return new value */
  4825. }
  4826.  
  4827. int main(int argc, char *argv[]) {
  4828.     const char* LUA = R"(
  4829.   c1 = counter()
  4830.   print(c1(), c1(), c1())   --> 1    2    3
  4831.   )";
  4832.  
  4833.     lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  4834.     luaL_openlibs(L);
  4835.  
  4836.     lua_register(L,"counter", counter);// отправить c функцию в стек.
  4837.     checkerror(L, LUA);
  4838.  
  4839.     lua_pushcclosure(L, newcounter, 1);/* Помещает в стек новое C замыкание. При создании C функций, можно увязать
  4840. с ней некоторые значения, таким образом создавая C замыкания (closure); затем эти значения будут доступны функции
  4841. каждый раз при её вызове. Для связывания значений с C функцией, вначале эти значения помещаются в стек
  4842. (когда имеется несколько значений, первое значение помещается первым). Затем вызывается lua_pushcclosure для
  4843. создания и помещения в стек C функции, с аргументом n, сообщающим сколько значений будет связано с этой функцией.
  4844. lua_pushcclosure также выводит из стека эти значения. Макс значением для n является 255. При n равным нулю,
  4845. эта функция создает легкую C функцию, которая является просто указателем на C функцию. В этом случае, она никогда
  4846. не вызывает ошибку памяти.*/
  4847.  
  4848.     lua_close(L);
  4849.     return 0;
  4850.  
  4851. };
  4852.  
  4853. Замыкание 7.
  4854.  
  4855.  
  4856. int newcounter(lua_State* L) {
  4857.     int val = lua_tointeger(L, lua_upvalueindex(1));/*Возвращает псевдоиндекс, который представляет
  4858.     i-ковою внешнюю локальную переменную (upvalue) выполняемой функции.*/
  4859.     lua_pushinteger(L, val++);  /*  новое  значение    */
  4860.     lua_pushvalue(L, -1);   /*дублирует    его  */
  4861.     lua_replace(L, lua_upvalueindex(1));/*  обновляет верхнее значение. снимает значение с вершины стека
  4862.                 и устанавливает его как значение элемента с заданным индексом.*/
  4863.     return 1;
  4864. }
  4865. int counter(lua_State * L) {
  4866.     lua_pushinteger(L, 1);
  4867.     lua_pushcclosure(L, newcounter, 1);/* Помещает в стек новое C замыкание. При создании C функций, можно увязать
  4868. с ней некоторые значения, таким образом создавая C замыкания (closure); затем эти значения будут доступны функции
  4869. каждый раз при её вызове. Для связывания значений с C функцией, вначале эти значения помещаются в стек
  4870. (когда имеется несколько значений, первое значение помещается первым). Затем вызывается lua_pushcclosure для
  4871. создания и помещения в стек C функции, с аргументом n, сообщающим сколько значений будет связано с этой функцией.
  4872. lua_pushcclosure также выводит из стека эти значения. Макс значением для n является 255. При n равным нулю,
  4873. эта функция создает легкую C функцию, которая является просто указателем на C функцию. В этом случае, она никогда
  4874. не вызывает ошибку памяти.*/
  4875.  
  4876.     return 1;  /* return new value */
  4877. }
  4878.  
  4879. int main(int argc, char* argv[]) {
  4880.     const char* LUA = R"(
  4881.   c = counter()
  4882.   print(c(), c(), c())   --> 1    2    3
  4883.   )";
  4884.  
  4885.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  4886.     luaL_openlibs(L);
  4887.  
  4888.     lua_register(L, "counter", counter);// отправить c функцию в стек.
  4889.     checkerror(L, LUA);
  4890.  
  4891.    
  4892.     lua_close(L);
  4893.     return 0;
  4894.  
  4895. };
  4896.  
  4897.  
  4898.  
  4899.  
  4900. luaL_setfuncs
  4901.  
  4902. int foo1(lua_State * L){
  4903.     cout << "foo1 " << endl;
  4904.     return 0;
  4905. }
  4906.  
  4907. int foo2(lua_State * L) {
  4908.     cout << "foo2 " << endl;
  4909.     return 0;
  4910. }
  4911.  
  4912. void RegisterFoo(lua_State * L){
  4913.     luaL_Reg sFooRegs[] =
  4914.     {
  4915.         { "foo1", foo1 },
  4916.         { "foo2", foo2 },
  4917.         { NULL, NULL }
  4918.     };
  4919.  
  4920.     luaL_newmetatable(L, "luaL_Foo");
  4921.  
  4922.     // Register the C functions _into_ the metatable we just created.
  4923.     luaL_setfuncs(L, sFooRegs, 0);/*    void luaL_setfuncs(lua_State * L, const luaL_Reg * l, int nup);
  4924.     Регистрирует все функции в массиве l(см.luaL_Reg) В таблице на вершине стека(ниже необязательных
  4925.     значений повышений).Когда nupне ноль, все функции создаются с nup общими значениями повышения, которые
  4926.     должны быть предварительно помещены в стек поверх таблицы библиотеки. Эти значения выталкиваются
  4927.     из стека после регистрации.*/   
  4928.    
  4929.     lua_pushvalue(L, -1);
  4930.     lua_setfield(L, -1, "__index");
  4931.  
  4932.     lua_setglobal(L, "Foo");
  4933. }
  4934. int main(int argc, char *argv[]) {
  4935.     const char* LUA = R"(
  4936. Foo.foo1()
  4937. Foo.foo2()
  4938.   )";
  4939.  
  4940.     lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  4941.     luaL_openlibs(L);
  4942.     RegisterFoo(L);
  4943.     checkerror(L, LUA);
  4944.  
  4945.     lua_close(L);
  4946.     return 0;
  4947. };
  4948.  
  4949. Еще пример.
  4950.  
  4951.  
  4952. int foo1(lua_State* L) {
  4953.     int val = lua_tointeger(L, lua_upvalueindex(1));/*Возвращает псевдоиндекс, который представляет
  4954.    i-ковою внешнюю локальную переменную (upvalue) выполняемой функции.*/
  4955.     cout << "foo " << val << endl;
  4956.     return 0;
  4957. };
  4958.  
  4959. int foo2(lua_State* L) {
  4960.     int val = lua_tointeger(L, lua_upvalueindex(1));/*Возвращает псевдоиндекс, который представляет
  4961. i-ковою внешнюю локальную переменную (upvalue) выполняемой функции.*/
  4962.     cout << "foo2 " << val << endl;
  4963.     return 0;
  4964. };
  4965.  
  4966. void RegisterFoo(lua_State* L) {
  4967.     luaL_Reg sFooRegs[] =
  4968.     {
  4969.         { "foo1", foo1 },
  4970.         { "foo2", foo2 },
  4971.         { NULL, NULL }
  4972.     };
  4973.  
  4974.     luaL_newmetatable(L, "luaL_Foo");
  4975.  
  4976.     lua_pushinteger(L, 1);
  4977.     // Register the C functions _into_ the metatable we just created.
  4978.     luaL_setfuncs(L, sFooRegs, 1);/* void luaL_setfuncs(lua_State * L, const luaL_Reg * l, int nup);
  4979.     Регистрирует все функции в массиве l) В таблице на вершине стека(ниже необязательных
  4980.     значений повышений).Когда nupне ноль, все функции создаются с nup общими значениями повышения, которые
  4981.     должны быть предварительно помещены в стек поверх таблицы библиотеки. Эти значения выталкиваются
  4982.     из стека после регистрации.*/
  4983.  
  4984.     lua_pushvalue(L, -1);
  4985.     lua_setfield(L, -1, "__index");
  4986.  
  4987.     lua_setglobal(L, "Foo");
  4988. }
  4989.  
  4990. int main(int argc, char* argv[]) {
  4991.     const char* LUA = R"(
  4992. Foo.foo1()
  4993. Foo.foo2()
  4994.   )";
  4995.  
  4996.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  4997.     luaL_openlibs(L);
  4998.     RegisterFoo(L);
  4999.     checkerror(L, LUA);
  5000.        
  5001.     lua_close(L);
  5002.  
  5003.     return 0;
  5004. };
  5005.  
  5006. Мета метод _index
  5007.  
  5008. int main(int argc, char* argv[]) {
  5009. const char* LUA = R"(
  5010. foo={} foo.key="value"
  5011. bar = setmetatable({},{__index=foo},print("index\n") )
  5012. print(bar.key)-- value
  5013. )";
  5014.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  5015.     luaL_openlibs(L);
  5016.     checkerror(L, LUA);//Функция проверка на ошибки.
  5017.     lua_close(L);
  5018.  
  5019.     return 0;
  5020. };
  5021.  
  5022.  
  5023.  
  5024. Потоки. Многопоточность — это принцип построения программы, при котором несколько блоков могут выполняться одновременно и не мешать друг другу.
  5025.  
  5026.  
  5027. Lua. Это по сути однопоточная система.
  5028. lua_State * lua_newthread ( lua_State * L);
  5029. Создает новый поток, помещает его в стек и возвращает указатель на объект lua_State, представляющий этот новый поток. Новое состояние, возвращаемое этой функцией, совместно использует с исходным состоянием все глобальные объекты (например, таблицы), но имеет независимый стек выполнения.
  5030. Не существует явной функции для закрытия или уничтожения потока. Потоки подлежат сборке мусора, как и любой объект Lua.
  5031.  
  5032. Без вызова потока. Вызов функции в одном потоке.
  5033.  
  5034. int foo(lua_State* L) {
  5035.     cout << " func foo c++ " << L << endl;
  5036.     return 0;
  5037. };
  5038.  
  5039. int main(int argc, char* argv[]) {
  5040.     const char* LUA = R"(
  5041. foo()
  5042.  
  5043. )";
  5044.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  5045.     luaL_openlibs(L);
  5046.     lua_State* L1 = lua_newthread(L);
  5047.     lua_pushcfunction(L, foo);// отправить c функцию в стек.
  5048.     showstack(L); cout <<  endl;
  5049.     lua_setglobal(L, "foo");// уст для переменной значение в виде функции.
  5050.         luaL_dostring(L, LUA);
  5051.     cout <<"\n";
  5052.     showstack(L);
  5053.     cout << "\n adrees L  "<<  L << "\n adrees L1 "<< L1 << "\n";
  5054.     lua_close(L);
  5055.  
  5056.     return 0;
  5057. };
  5058.  
  5059. Эта функция возвращает указатель на lua_State, представляющее новой поток, а также отправить новой поток в стек как значение типа "thread". Например, после выполнения оператора L1 = lua_newthread(L);
  5060. у нас будет два потока, L1 и L, которые будут внутренне ссылаться на одно и то же состояние Lua. Каждый поток обладает собственным стеком.
  5061. Новый поток L1 начинает с пустого стека; у старого потока L есть новый поток на вершине стека:
  5062. printf("%d\n", lua_gettop(L1)); --> 0
  5063. printf("%s\n", luaL_typename(L, -1)); --> thread
  5064.  
  5065. За исключением главноого, все потоки подвержены сборке мусора, как и любой другой объект Lua. Когда вы создаете новый поток, то значение, которое отправляется в стек, гарантирует, что эта поток не
  5066. является мусором. Вы никогда не должны использовать поток, который должным образом не привязан к состоянию. (Главный поток внутренне привязан с самого начала, поэтому о нем можно не беспокоиться.)
  5067.  
  5068.  
  5069. Функция вызвается в 2 потоках.
  5070.  
  5071. int main(int argc, char* argv[]) {
  5072.     const char* LUA = R"(
  5073. foo()
  5074.  
  5075. )";
  5076.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  5077.     luaL_openlibs(L);
  5078.     lua_State* L1 = lua_newthread(L);
  5079.     lua_pushcfunction(L, foo);// отправить c функцию в стек.
  5080.     showstack(L); cout << "\n";
  5081.  
  5082.     lua_setglobal(L, "foo");// уст для переменной значение в виде функции.
  5083.     luaL_dostring(L, LUA);
  5084.     showstack(L1);  cout << "\n";// Стек потока L1 пуст.
  5085.     luaL_dostring(L1, LUA);
  5086.     cout << "\n adrees L  " << L << "\n adrees L1 " << L1 << "\n";
  5087.     lua_close(L);
  5088.  
  5089.     return 0;
  5090. };
  5091.  
  5092. Вариант 2
  5093.  
  5094. int main(int argc, char* argv[]) {
  5095.     const char* LUA = R"(
  5096. foo()
  5097.  
  5098. )";
  5099.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  5100.     luaL_openlibs(L);
  5101.     lua_State* L1 = lua_newthread(L);
  5102.     lua_pushcfunction(L, foo);// отправить c функцию в стек.
  5103.     showstack(L); cout <<"\n";
  5104.    
  5105.     lua_setglobal(L, "foo");// уст для переменной значение в виде функции.
  5106.     luaL_dostring(L, LUA);
  5107.     lua_xmove(L, L1, 1);// Снимает с L1 элементов передает L.
  5108.     showstack(L1);  cout << "\n";
  5109.     luaL_dostring(L1, LUA);
  5110.     cout << "\n adrees L  "<<  L << "\n adrees L1 "<< L1 << "\n";
  5111.     lua_close(L);
  5112.  
  5113.     return 0;
  5114. };
  5115.  
  5116. Запуск 2 функций в 2 потоках.
  5117.  
  5118. const char* LUA = R"(
  5119. function foo()
  5120. for i = 1, 3 do
  5121. print(" func foo "..i.."\n")
  5122. end     end
  5123.  
  5124. function main()
  5125. for i = 1, 3 do
  5126. print(" func main "..i.."\n")
  5127. end  end
  5128. )";
  5129. int main(int argc, char* argv[]) {
  5130.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  5131.     luaL_openlibs(L);
  5132.     lua_State* L1 = lua_newthread(L);
  5133.     checkerror(L, LUA);
  5134.     lua_getglobal(L, "main");
  5135.     lua_pcall(L, 0, 0, 0);// запустить функцию main в потоке L.
  5136.    
  5137.     lua_getglobal(L1, "foo");// запустить функцию foo в потоке L1.
  5138.     lua_pcall(L1, 0, 0, 0);
  5139.  
  5140.     lua_close(L);
  5141.     return 0;
  5142. };
  5143.  
  5144.  
  5145.  
  5146. Функции выполняются поочередно в двух потоках.
  5147.  
  5148. Для запуска выполнения сопрограммы мы используем lua_resume так же, как мы используем lua_pcall: мы заталкиваем функцию для вызова, заталкиваем ее аргументы и вызываем lua_resume,
  5149.  передавая в narg число аргументов. (Параметр from — это нить, которая совершает вызов.) Данное поведение также очень похоже на lua_pcall, но с тремя отличиями.
  5150.  
  5151. Во-первых, у lua_resume нет параметра для числа требуемых  результатов; она всегда возвращает все значения из вызванной функции.
  5152.  
  5153. Во-вторых, у нее нет параметра для обработчика сообщений; ошибка не раскручивает стек, поэтому после нее вы можете изучить стек.
  5154.  
  5155.  В-третьих, если выполняемая функция уступает управление, то lua_resume возвращает особый код LUA_YIELD и оставляет поток в состоянии, из которого она может быть возобновлена позже.
  5156.  
  5157. Когда lua_resume возвращает LUA_YIELD, видимая часть стека потока содержит только значения, переданные yield. Вызов lua_gettop вернет число выработанных значений. Для перемещения этих значений
  5158. В другой потоке мы можем использовать lua_xmove. Чтобы возобновить приостановленный поток, мы вновь вызываем lua_resume. При таких вызовах Lua считает, что все значения в стеке должны быть возвращены вызовом yield. Например, если вы не трогаете стек потока между возвращением из lua_resume и следующим возобновлением, то yield вернет именно те значения, которые он выработал при уступке управления. Обычно мы запускаем сопрограмму с функцией Lua в качестве ее тела. Эта функция Lua может вызывать другие функции, и любая из этих функций порой может уступать управление, завершая вызов lua_resume.
  5159.  
  5160.  
  5161. int my_yield(lua_State* L) {
  5162.     return lua_yield(L, 0);/*Эта функция должна вызываться только как возвращаемое выражение функции C следующим образом:
  5163.     return lua_yield(L, res); Когда функция C вызывает lua_yield таким образом, запущенная сопрограмма приостанавливает
  5164.     свое выполнение, и вызов lua_resume этой запущенной процедуры возвращается. Параметр res - это число значений из стека,
  5165.     которые передаются как результаты lua_resume.*/
  5166. };
  5167. const char* LUA = R"(
  5168. function foo()
  5169. print(" func foo \n")
  5170. end
  5171.  
  5172. function main()
  5173. for i = 1, 3 do
  5174. print(" func main "..i.."\n")
  5175. my_yield()
  5176. end  end
  5177. )";
  5178. int main(int argc, char* argv[]) {
  5179.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  5180.     luaL_openlibs(L);
  5181.     lua_State* L1 = lua_newthread(L);
  5182.     cout << "\n";
  5183.     lua_register(L, "my_yield", my_yield);
  5184.     checkerror(L, LUA);
  5185.     lua_getglobal(L, "main");
  5186.     while (true) {
  5187.         int ret = lua_resume(L, L1, 0); /* Запускает и продолжает сопрограмму в данном потоке L.
  5188.     вы отправляйте в стек главную функцию и её аргументы; затем вызываете lua_resume,nargs - кол-во аргументов.
  5189.     Вызов возвращается, когда приостанавливается или завершается. При возвращении, стек содержит все значения,
  5190.     переданные в lua_yield, или возвращенныеции. Чтобы продолжить сопрограмму, вы удаляете все результаты
  5191.     из последнего lua_yield, отправьте в её стек только значения, передаваемые в качестве результатов из yield, и
  5192.     затем вызываете lua_resume.   Параметр L представляет сопрограмму, которая продолжает L. */
  5193.         if (ret == LUA_YIELD) {
  5194.             lua_getglobal(L1, "foo");
  5195.             lua_pcall(L1, 0, 0, 0);
  5196.         }
  5197.         else if (ret == 0) {
  5198.  
  5199.             break;
  5200.         }
  5201.     };
  5202.  
  5203.     lua_close(L);
  5204.     return 0;
  5205. };
  5206.  
  5207. 1.
  5208.  
  5209. Функции выполняются поочередно в двух потоках с передачей значение в main.
  5210.  
  5211. int my_yield(lua_State* L) {
  5212.     return lua_yield(L, 0);/*Эта функция должна вызываться только как возвращаемое выражение функции C следующим образом:
  5213.     return lua_yield(L, res); Когда функция C вызывает lua_yield таким образом, запущенная сопрограмма приостанавливает
  5214.     свое выполнение, и вызов lua_resume этой запущенной процедуры возвращается. Параметр res - это число значений из стека,
  5215.     которые передаются как результаты lua_resume.*/
  5216. };
  5217.  
  5218. const char* LUA = R"(
  5219. function foo()
  5220. print(" func foo \n")
  5221. end
  5222.  
  5223. function main(n)
  5224. for i = 1, 3 do
  5225. print(" func main "..n.."\n")
  5226. my_yield()
  5227. end  end
  5228. )";
  5229. int main(int argc, char* argv[]) {
  5230.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  5231.     luaL_openlibs(L);
  5232.     lua_State* L1 = lua_newthread(L);
  5233.  
  5234.     lua_register(L, "my_yield", my_yield);// регистрация функций.
  5235.     checkerror(L, LUA);
  5236.     lua_getglobal(L, "main");// получить функцию.
  5237.     lua_pushinteger(L, 10); // передаем в функцию main 10.
  5238.     while (true) {
  5239.         int ret = lua_resume(L, L1, 1); /* Запускает и продолжает сопрограмму в данном потоке L.
  5240.     вы отправляйте в стек главную функцию и её аргументы; затем вызываете lua_resume,nargs - кол-во аргументов.
  5241.     Вызов возвращается, когда приостанавливается или завершается. При возвращении, стек содержит все значения,
  5242.     переданные в lua_yield, или возвращенные. Чтобы продолжить сопрограмму, вы удаляете все результаты
  5243.     из последнего lua_yield, отправьте в её стек только значения, передаваемые в качестве результатов из yield, и
  5244.     затем вызываете lua_resume.   Параметр L представляет сопрограмму, которая продолжает L. */
  5245.         if (ret == LUA_YIELD) {
  5246.             lua_getglobal(L1, "foo");
  5247.             lua_pcall(L1, 0, 0, 0);
  5248.         }
  5249.         else if (ret == 0) {
  5250.  
  5251.             break;
  5252.         }
  5253.     };
  5254.  
  5255.     lua_close(L);
  5256.     return 0;
  5257. };
  5258.  
  5259. 2.
  5260. Функции выполняются поочередно в двух потоках с передачей значение из main в foo.
  5261.  
  5262. const char* LUA = R"(
  5263. function foo(x)
  5264. x=x*10
  5265. print(" func foo "..x.."\n")
  5266. end
  5267.  
  5268. function main()
  5269. for i = 1, 3 do
  5270. print(" func main "..i.."\n")
  5271. my_yield(i)
  5272. end  end
  5273. )";
  5274. int main(int argc, char* argv[]) {
  5275.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  5276.     luaL_openlibs(L);
  5277.     lua_State* L1 = lua_newthread(L);
  5278.  
  5279.     lua_register(L, "my_yield", my_yield);// регистрация функций.
  5280.     checkerror(L, LUA);
  5281.     lua_getglobal(L, "main");// получить функцию.
  5282.     while (true) {
  5283.         int ret = lua_resume(L, L1, 0);
  5284.  
  5285.         if (ret == LUA_YIELD) {
  5286.             lua_getglobal(L1, "foo");
  5287.             lua_xmove(L, L1, 1);/*перемещает значение Lua между двумя стеками в
  5288.             одном и том же состоянии.*/
  5289.             lua_pcall(L1, 1, 0, 0);
  5290.         }
  5291.         else if (ret == 0) {/*Когда функция lua_resume возвращается, стек содержит все значения,
  5292.         переданные в lua_yield, или все значения, возвращенные телом функции.*/
  5293.         //showstack(L);
  5294.             break;
  5295.         }
  5296.     };
  5297.  
  5298.     lua_close(L);
  5299.     return 0;
  5300. };
  5301.  
  5302. 3.
  5303. int my_yield(lua_State* L) {
  5304.  
  5305.     lua_State* L1 = lua_newthread(L);
  5306.     lua_pushthread(L1);
  5307.    
  5308.     return lua_yield(L, 0);/*Эта функция должна вызываться только как возвращаемое выражение функции C следующим образом:
  5309.     return lua_yield(L, res); Когда функция C вызывает lua_yield таким образом, запущенная сопрограмма приостанавливает
  5310.     свое выполнение, и вызов lua_resume этой запущенной процедуры возвращается. Параметр res - это число значений из стека,
  5311.     которые передаются как результаты lua_resume.*/
  5312. };
  5313. const char* LUA = R"(
  5314. function foo()
  5315. print(" func foo \n")
  5316. end
  5317.  
  5318. function main()
  5319. for i = 1, 3 do
  5320. print(" func main "..i.."\n")
  5321. my_yield(foo)
  5322. end  end
  5323. )";
  5324. int main(int argc, char* argv[]) {
  5325.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  5326.     luaL_openlibs(L);
  5327.     lua_register(L, "my_yield", my_yield);
  5328.     cout << "\n";
  5329.     checkerror(L, LUA);
  5330.     lua_getglobal(L, "main");
  5331.     while (true) {
  5332.         int ret = lua_resume(L, NULL, 0); /* Запускает и продолжает сопрограмму в данном потоке L. */
  5333.         if (ret == LUA_YIELD) {
  5334.             lua_State* L1 = lua_tothread(L, -1);
  5335.  
  5336.             lua_getglobal(L1, "foo");
  5337.             lua_pcall(L1, 0, 0, 0);
  5338.         }
  5339.         else if (ret == 0) {
  5340.  
  5341.             break;
  5342.         }
  5343.     };
  5344.  
  5345.     lua_close(L);
  5346.     return 0;
  5347. };
  5348.  
  5349.  
  5350.  
  5351. Функции выполняются поочередно в двух потоках с передачей значение в main из main в foo.
  5352.  
  5353. const char* LUA = R"(
  5354. function foo(x)
  5355. x=x*10
  5356. print(" func foo "..x.."\n")
  5357. end
  5358.  
  5359. function main(n)
  5360. for i = 1, 3 do
  5361. print(" func main "..n.."\n")
  5362. my_yield(i)
  5363. end  end
  5364. )";
  5365. int main(int argc, char* argv[]) {
  5366.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  5367.     luaL_openlibs(L);
  5368.     lua_State* L1 = lua_newthread(L);
  5369.  
  5370.     lua_register(L, "my_yield", my_yield);// регистрация функций.
  5371.     checkerror(L, LUA);
  5372.     lua_getglobal(L, "main");// получить функцию.
  5373.     lua_pushinteger(L, 10); // передаем в функцию main 10.
  5374.  
  5375.     while (true) {
  5376.         int ret = lua_resume(L, L1, 1); /* Запускает и продолжает сопрограмму в данном потоке L.
  5377.     вы отправляйте в стек главную функцию и её аргументы; затем вызываете lua_resume,nargs - кол-во аргументов.
  5378.     Вызов возвращается, когда приостанавливается или завершается. При возвращении, стек содержит все значения,
  5379.     переданные в lua_yield, или возвращенные. Чтобы продолжить сопрограмму, вы удаляете все результаты
  5380.     из последнего lua_yield, отправьте в её стек только значения, передаваемые в качестве результатов из yield, и
  5381.     затем вызываете lua_resume.   Параметр L представляет сопрограмму, которая продолжает L. */
  5382.  
  5383.         if (ret == LUA_YIELD) {
  5384.             lua_getglobal(L1, "foo");
  5385.             lua_xmove(L, L1, 1);/*перемещает значение Lua между двумя стеками в
  5386.             одном и том же состоянии.*/
  5387.             lua_pcall(L1, 1, 0, 0);
  5388.         }
  5389.         else if (ret == 0) {/*Когда функция lua_resume возвращается, стек содержит все значения,
  5390.         переданные в lua_yield, или все значения, возвращенные телом функции.*/
  5391.         //showstack(L);
  5392.             break;
  5393.         }
  5394.     };
  5395.  
  5396.     lua_close(L);
  5397.     return 0;
  5398. };
  5399.  
  5400. Функции выполняются поочередно в двух потоках. Вернуть значений из lua_yield.
  5401.  
  5402. int my_yield(lua_State* L) {
  5403.     return lua_yield(L, 1);/*Эта функция должна вызываться только как возвращаемое выражение функции C следующим образом:
  5404.     return lua_yield(L, res); Когда функция C вызывает lua_yieldтаким образом, запущенная сопрограмма приостанавливает
  5405.     свое выполнение, и вызов lua_resume этой запущенной процедуры возвращается. Параметр res - это число значений из стека,
  5406.     которые передаются как результаты lua_resume.*/
  5407. };
  5408.  
  5409. const char* LUA = R"(
  5410. function foo()
  5411. x=10
  5412. print(" func foo "..x.."\n")
  5413. end
  5414.  
  5415. function main()
  5416. for i = 1, 3 do
  5417. print(" func main "..i.."\n")
  5418. my_yield(i)
  5419. end  end
  5420. )";
  5421. int main(int argc, char* argv[]) {
  5422.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  5423.     luaL_openlibs(L);
  5424.     lua_State* L1 = lua_newthread(L);
  5425.  
  5426.     lua_register(L, "my_yield", my_yield);// регистрация функций.
  5427.     checkerror(L, LUA);
  5428.     lua_getglobal(L, "main");// получить функцию.
  5429.     while (true) {
  5430.         int ret = lua_resume(L, L1, 0);
  5431.  
  5432.         if (ret == LUA_YIELD) {
  5433.             lua_xmove(L, L1, 1);// отравить значение из yield потока L в стек L1.
  5434.             lua_getglobal(L1, "foo");
  5435.             lua_pcall(L1, 0, 0, 0);
  5436.         }
  5437.         else if (ret == 0) {/*Когда функция lua_resume возвращается, стек содержит все значения,
  5438.         переданные в lua_yield, или все значения, возвращенные телом функции.*/
  5439.  
  5440.             break;
  5441.         }
  5442.     };
  5443.        
  5444. showstack(L1);
  5445.  
  5446.     lua_close(L);
  5447.     return 0;
  5448. };
  5449.  
  5450.  
  5451. Функции выполняются поочередно в двух потоках с передачей значение в main из main в foo. Вернуть значений из lua_yield.
  5452.  
  5453. int my_yield(lua_State* L) {
  5454.     return lua_yield(L, 0);/*Эта функция должна вызываться только как возвращаемое выражение функции C следующим образом:
  5455.     return lua_yield(L, res); Когда функция C вызывает lua_yield таким образом, запущенная сопрограмма приостанавливает
  5456.     свое выполнение, и вызов lua_resume этой запущенной процедуры возвращается. Параметр res - это число значений из стека,
  5457.     которые передаются как результаты lua_resume.*/
  5458. };
  5459.  
  5460. const char* LUA = R"(
  5461. function foo(x1)
  5462. x= x1 * 10
  5463. print(" func foo "..x.."\n")
  5464. return x
  5465. end
  5466.  
  5467. function main(n)
  5468. for i = 1, 3 do
  5469. print(" func main "..n.."\n")
  5470. my_yield(i)
  5471. end  end
  5472. )";
  5473. int main(int argc, char* argv[]) {
  5474.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  5475.     luaL_openlibs(L);
  5476.     lua_State* L1 = lua_newthread(L);
  5477.  
  5478.     lua_register(L, "my_yield", my_yield);// регистрация функций.
  5479.     checkerror(L, LUA);
  5480.     lua_getglobal(L, "main");// получить функцию.
  5481.     lua_pushinteger(L, 10);
  5482.     while (true) {
  5483.         int ret = lua_resume(L, L1, 1); /* Запускает и продолжает сопрограмму в данном потоке L.
  5484.     вы отправляйте в стек главную функцию и её аргументы; затем вызываете lua_resume,nargs - кол-во аргументов.
  5485.     Вызов возвращается, когда приостанавливается или завершается. При возвращении, стек содержит все значения,
  5486.     переданные в lua_yield, или возвращенныеции. Чтобы продолжить сопрограмму, вы удаляете все результаты
  5487.     из последнего lua_yield, отправьте в её стек только значения, передаваемые в качестве результатов из yield, и
  5488.     затем вызываете lua_resume.   Параметр L представляет сопрограмму, которая продолжает L. */
  5489.  
  5490.         if (ret == LUA_YIELD) {
  5491.             cout << "\n res from func my_yield "<< lua_tointeger(L, -1) << "\n\n";/*Когда lua_resume возвращает LUA_YIELD,
  5492.              стек потока содержит значения, переданные yield. число выработанных значений.*/
  5493.             lua_getglobal(L1, "foo");
  5494.             lua_xmove(L, L1, 1);/*перемещает значение Lua между двумя стеками в
  5495.             одном и том же состоянии.*/
  5496.             lua_pcall(L1, 1, 0, 0);    
  5497.  
  5498.         }
  5499.         else if (ret == 0) {/*Когда функция lua_resume возвращается, стек содержит все значения,
  5500.         переданные в lua_yield, или все значения, возвращенные телом функции.*/
  5501.             break;
  5502.         }
  5503.     };
  5504.  
  5505.     lua_close(L);
  5506.     return 0;
  5507. };
  5508.  
  5509. Вариант 2.
  5510.  
  5511. int my_yield(lua_State* L) {
  5512.     return lua_yield(L, 0);/*Эта функция должна вызываться только как возвращаемое выражение функции C следующим образом:
  5513.     return lua_yield(L, res); Когда функция C вызывает lua_yieldтаким образом, запущенная сопрограмма приостанавливает
  5514.     свое выполнение, и вызов lua_resume этой запущенной процедуры возвращается. Параметр res - это число значений из стека,
  5515.     которые передаются как результаты lua_resume.*/
  5516. };
  5517.  
  5518. const char* LUA = R"(
  5519. function foo(x1)
  5520. x= x1 * 10
  5521. print(" func foo "..x.."\n")
  5522. return x
  5523. end
  5524.  
  5525. function main(n)
  5526. for i = 1, 3 do
  5527. print(" func main "..n.."\n")
  5528. my_yield(i)
  5529. end  end
  5530. )";
  5531. int main(int argc, char* argv[]) {
  5532.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  5533.     luaL_openlibs(L);
  5534.     lua_State* L1 = lua_newthread(L);
  5535.  
  5536.     lua_register(L, "my_yield", my_yield);// регистрация функций.
  5537.     checkerror(L, LUA);
  5538.     lua_getglobal(L, "main");// получить функцию.
  5539.     lua_pushinteger(L, 10);
  5540.     while (true) {
  5541.         int ret = lua_resume(L, L1, 1); /* Запускает и продолжает сопрограмму в данном потоке L.
  5542.     вы отправляйте в стек главную функцию и её аргументы; затем вызываете lua_resume,nargs - кол-во аргументов.
  5543.     Вызов возвращается, когда приостанавливается или завершается. При возвращении, стек содержит все значения,
  5544.     переданные в lua_yield, или возвращенныеции. Чтобы продолжить сопрограмму, вы удаляете все результаты
  5545.     из последнего lua_yield, отправьте в её стек только значения, передаваемые в качестве результатов из yield, и
  5546.     затем вызываете lua_resume.   Параметр L представляет сопрограмму, которая продолжает L. */
  5547.  
  5548.         if (ret == LUA_YIELD) {
  5549.             cout << "\n res from func my_yield " << lua_tointeger(L, -1) << "\n\n";/*Когда lua_resume возвращает LUA_YIELD,
  5550.              стек потока содержит значения, переданные yield. число выработанных значений.*/
  5551.             lua_xmove(L, L1, 1);/*перемещает значение Lua между двумя стеками в
  5552.             одном и том же состоянии.*/
  5553.             lua_pop(L, 1);
  5554.             lua_getglobal(L1, "foo");
  5555.             lua_xmove(L, L1, 1);/*перемещает значение Lua между двумя стеками в
  5556.             одном и том же состоянии.*/
  5557.             lua_pcall(L1, 1, 0, 0);
  5558.         }
  5559.         else if (ret == 0) {/*Когда функция lua_resume возвращается, стек содержит все значения,
  5560.         переданные в lua_yield, или все значения, возвращенные телом функции.*/
  5561.             break;
  5562.         }
  5563.        
  5564.     };
  5565.    showstack(L1);
  5566.     lua_close(L);
  5567.     return 0;
  5568. };
  5569.  
  5570.  
  5571. Функции main и foo с циклом for, выполняются поочередно в двух потоках.
  5572.  
  5573. int my_yield2(lua_State* L) {
  5574.     return lua_yield(L, 0);/*Эта функция должна вызываться только как возвращаемое выражение функции C следующим образом:
  5575.     return lua_yield(L, res); Когда функция C вызывает lua_yieldтаким образом, запущенная сопрограмма приостанавливает
  5576.     свое выполнение, и вызов lua_resume этой запущенной процедуры возвращается. Параметр res - это число значений из стека,
  5577.     которые передаются как результаты lua_resume.*/
  5578. };
  5579.  
  5580.  
  5581. int my_yield(lua_State* L) {
  5582.     return lua_yield(L, 0);/*Эта функция должна вызываться только как возвращаемое выражение функции C следующим образом:
  5583.     return lua_yield(L, res); Когда функция C вызывает lua_yieldтаким образом, запущенная сопрограмма приостанавливает
  5584.     свое выполнение, и вызов lua_resume этой запущенной процедуры возвращается. Параметр res - это число значений из стека,
  5585.     которые передаются как результаты lua_resume.*/
  5586. };
  5587.  
  5588. const char* LUA = R"(
  5589. function foo()
  5590. for i = 1, 3 do
  5591. print(" func foo "..i.."\n")
  5592. my_yield2(i)
  5593. end
  5594. end
  5595.  
  5596. function main()
  5597. for i = 1, 3 do
  5598. print(" func main "..i.."\n")
  5599. my_yield(i)
  5600. end  end
  5601. )";
  5602. int main(int argc, char* argv[]) {
  5603.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
  5604.     luaL_openlibs(L);
  5605.     lua_State* L1 = lua_newthread(L);
  5606.  
  5607.     lua_register(L, "my_yield", my_yield);// регистрация функций.
  5608.     lua_register(L, "my_yield2", my_yield2);// регистрация функций.  
  5609.     checkerror(L, LUA);
  5610.     lua_getglobal(L, "main");// получить функцию.
  5611.  
  5612.     while (true) {
  5613.         int ret = lua_resume(L, L1, 0); /* Запускает и продолжает сопрограмму в данном потоке L.
  5614.                                         Параметр L представляет сопрограмму, которая продолжает L. */
  5615.         if (ret == LUA_YIELD) {
  5616.             lua_getglobal(L1, "foo");
  5617.             lua_resume(L1, L, 0);
  5618.         }
  5619.         else if (ret == 0) {/*Когда функция lua_resume возвращается, стек содержит все значения,
  5620.         переданные в lua_yield, или все значения, возвращенные телом функции.*/
  5621.             break;
  5622.         }
  5623.  
  5624.     };
  5625.     lua_close(L);
  5626.     return 0;
  5627. };
  5628.  
  5629.  
  5630. Функции main и foo с циклом for, выполняются поочередно в двух потоках с поочередным приостановлением.
  5631.  
  5632. int my_yield(lua_State* L) {
  5633.     return lua_yield(L, 0);/*Эта функция должна вызываться только как возвращаемое выражение функции C следующим образом:
  5634.     return lua_yield(L, res); Когда функция C вызывает lua_yield таким образом, запущенная сопрограмма приостанавливает
  5635.     свое выполнение, и вызов lua_resume этой запущенной процедуры возвращается. Параметр res - это число значений из стека,
  5636.     которые передаются как результаты lua_resume.*/
  5637. };
  5638.  
  5639. const char* LUA = R"(
  5640. function main()
  5641. for i = 1, 3 do
  5642. print(" func main "..i.."\n")
  5643. my_yield()
  5644. end  end
  5645. function foo()
  5646. for i = 1, 3 do
  5647. print(" func foo "..i.."\n")
  5648. my_yield()
  5649. end end
  5650.  
  5651. )";
  5652. int main(int argc, char* argv[]) {
  5653.     lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывае