lua api c++

lua c++ api подготовка проекта
Начальная проверка

#include<iostream>
using namespace std;

int main(int argc, char *argv[]) {

return 0;
};


Проверка lua

#include<iostream>
#include"incude/lua.hpp"
using namespace std;

int main(int argc, char *argv[]) {

return 0;
};

lua api c++. Работа со стеком.

#include<iostream>
#include"lua/lua.hpp"
using namespace std;

//Стек(англ.stack — стопка; читается стэк) — абстрактный тип данных, представляющий собой список элементов,
//организованных по принципу LIFO(англ.last in — first out, «последний вошёл — первым вышел»)
int main(int argc, char *argv[]) {

    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    lua_pushnumber(L, 10);// отправить в стек число.
    lua_pushnumber(L, 20);// отправить в стек число.
    lua_pushnumber(L, 30);// отправить в стек число.
    int number = lua_tonumber(L, -3);// получить 10 из стека 1
    cout << number << endl;
    int number2 = lua_tonumber(L, -2);// получить 20 из стека 2
    cout << number2 << endl;
    int number3 = lua_tonumber(L, -1);// получить 30 из стека 3
    cout << number3 << endl;

    lua_close(L);// закрыть состояние
return 0;
};


lua c++ api. Работа со стеком. Полезность отрицательных индексов стека.

int main(int argc, char *argv[]) {lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/

    lua_pushnumber(L, 10);// 1
    lua_pushnumber(L, 20);// 2
    lua_pushnumber(L, 30);// 3
    /* стек выглядит так
    3 = 30    -1 = 30
    2 = 20    -2 = 20
    1 = 10    -3 = 10
    */
    cout << lua_tonumber(L, -1) << endl;// 30
    lua_pop(L, 1);// удалить n элементы из стека с его вершины. Если 3, выводится 0.
    cout << lua_tonumber(L, -1) << endl;// 20
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
    return 0;}


еще пример.

int checklua(lua_State *L, const char *file) {
    int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
    try {
        if (status == 0) {// если нет ошибки в файле.
            luaL_dofile(L, file);// запуск файла, в которым все происходит.
            return 0;
        }
        else {
            string x = lua_tostring(L, -1);
            throw x;
        }
    }
    catch (string x) {
        cout << x << endl;
        //luaL_error(L,"error");
    }
};

template <class T>
void pushlua(lua_State * L, const T & value) {// функция добавление любого значение в стек.
    if constexpr (std::is_same_v<T, std::string>)
        lua_pushstring(L, value.c_str());
    else if constexpr (std::is_array_v<T> && std::is_same_v<std::remove_extent_t<T>, char>)
        lua_pushstring(L, value);
    else if constexpr (std::is_same_v<T, int>)
        lua_pushinteger(L, value);
    else if constexpr (std::is_same_v<T, double>)
        lua_pushnumber(L, value);
    else if constexpr (std::is_same_v<T, bool>)
        lua_pushboolean(L, value);
    else
        std::cerr << "I do not know what to do :(" << std::endl;
};

void showstack(lua_State* L) {// вывести весь стек.
    int i = lua_gettop(L);/* получаем количество элементов в стеке.*/
    cout << "\n  the number on the stack = " << i << "\n\n\n";
    int j = (i) * -1-1;
    i = -1;
    for (i; i > j; i--) {
        int t = lua_type(L, i);
        cout << "\t " << i << "  " << (j - i) * -1 << "\t";
        if (LUA_TSTRING == t) {
            cout << lua_tostring(L, i) << endl;
        }
        if (LUA_TNUMBER == t) {
            double x = lua_tonumber(L, i);
            int x2 = (int)x;
            if (x == x2) { cout << x2 << endl; }
            else { cout << x << endl; }
        }
        if (LUA_TBOOLEAN == t) {
            cout << lua_toboolean(L, i) << endl;
        }
        if (LUA_TLIGHTUSERDATA == t) {
            cout << "LIGHTUSERDATA " << endl;
        }
        if (LUA_TTABLE == t) {
            cout << "LUA_TTABLE " << endl;
        }
        if (LUA_TFUNCTION == t) {
            cout << "LUA_TFUNCTION " << endl;
        }
        if (LUA_TUSERDATA == t) {
            cout << "LUA_TUSERDATA " << endl;
        }
        if (LUA_TNIL == t) {
            cout << "LUA_TNIL " << endl;
        }
    }
};

int main() {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    pushlua(L, 10);// отправить любое значение в стек.
    pushlua(L, 20);// отправить любое значение в стек.
    pushlua(L, 30);// отправить любое значение в стек.
    showstack(L);// вывести стек.

    cin.get();//ожидает ввода символа.

    pushlua(L, "a");// отправить любое значение в стек.
    pushlua(L, "b");// отправить любое значение в стек.
    pushlua(L, "c");// отправить любое значение в стек.
    showstack(L);// вывести стек.

    cin.get();//ожидает ввода символа.

    lua_pop(L, 4); //удалить 4 элемента из стека.

    showstack(L);// вывести стек.

    cin.get();//ожидает ввода символа.

Выводится.


  the number on the stack = 3


         -1  3  30
         -2  2  20
         -3  1  10


  the number on the stack = 6


         -1  6  c
         -2  5  b
         -3  4  a
         -4  3  30
         -5  2  20
         -6  1  10


  the number on the stack = 2


         -1  2  20
         -2  1  10


C:\Users\e\source\repos\Project1luaapi\Debug\Project1luaapi.exe (процесс 4608) завершает работу с кодом 0.
Чтобы закрыть это окно, нажмите любую клавишу…

lua c++ api. Получение значения переменных из lua.

#include<iostream>
#include<string>
#include"lua/lua.hpp"
using namespace std;
int main() {
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);
    luaL_dofile(L, "man.lua");
    lua_getglobal(L, "x");
    lua_getglobal(L, "y");
    lua_getglobal(L, "z");
    int x = lua_tonumber(L, 1);
    cout << x << endl;
    string y = lua_tostring(L, 2);
    cout << y << endl;
    bool z = lua_toboolean(L, 3);
    cout << z << endl;
    lua_close(L);
    return 0;

lua
x=3
y="jh"
z =false

lua c++ api. Получение значения переменных из lua с помощью отрицательных индексов стека.

int checklua(lua_State *L, const char *file) {
    int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
    try {
        if (status == 0) {// если нет ошибки в файле.
            luaL_dofile(L, file);// запуск файла, в которым все происходит.
            return 0;
        }
        else {
            string x = lua_tostring(L, -1);
            throw x;
        }
    }
    catch (string x) {
        cout << x << endl;
        //luaL_error(L,"error");
    }
};

int main() {int t;
    lua_State *L = luaL_newstate();
   checklua(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
    lua_getglobal(L, "x");// получить значение глобальной переменной x.

    t = lua_type(L, -1);
    if (LUA_TSTRING == t) { cout << "string x " << lua_tostring(L, -1) << endl; }
    else { cout << "not string  x " << endl; }

    lua_getglobal(L, "y");// получить значение глобальной переменной x.
    t = lua_type(L, -1);
    if (LUA_TSTRING == t) { cout << "string y " << lua_tostring(L, -1) << endl; }
    else { cout << "not string  y " << endl; }

    int n = lua_gettop(L);/* получаем количество элементов в стеке.*/
    cout <<"\nthe number on the stack = "  << n<<"\n";
    lua_settop(L, 0);// уст кол-во элементов в стеке. 0 - очистить стек.

       n = lua_gettop(L);/* получаем количество элементов в стеке.*/
    cout << "\nthe number on the stack = " << n << "\n";

    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.

    return 0;
}

Lua
y="i str"
x=23

выводится.

not string  x
string y i str

the number on the stack = 3

the number on the stack = 0


lua c++ api. Функции вывода элементов из стека и добавление лобого значение в стек.


int checklua(lua_State *L, const char *file) {
    int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
    try {
        if (status == 0) {// если нет ошибки в файле.
            luaL_dofile(L, file);// запуск файла, в которым все происходит.
            return 0;
        }
        else {
            string x = lua_tostring(L, -1);
            throw x;
        }
    }
    catch (string x) {
        cout << x << endl;
        //luaL_error(L,"error");
    }
};
int main() {
    lua_State *L = luaL_newstate();
    checklua(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
   pushlua(L, "yes");// отправить любое значение в стек.
    pushlua(L,true);// отправить любое значение в стек.
    pushlua(L,100);// отправить любое значение в стек.
    pushlua(L,33.23);// отправить любое значение в стек.
    pushlua(L, "no");// отправить любое значение в стек.
    pushlua(L, 202);// отправить любое значение в стек.
    showstack(L);
    lua_pushvalue(L, 3);// отправляет копию элемент на вершину стека.
    showstack(L);
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
    return 0;
};


Выводится на экран.


  the number on the stack = 6


         6  202
         5  no
         4  33.23
         3  100
         2  1
         1  yes

  the number on the stack = 7


         7  100
         6  202
         5  no
         4  33.23
         3  100
         2  1
         1  yes



lua c++ api. Функции вывода элементов через отрицательные индексы из стека и добавление лобого значение в стек.

int checklua(lua_State *L, const char *file) {
    int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
    try {
        if (status == 0) {// если нет ошибки в файле.
            luaL_dofile(L, file);// запуск файла, в которым все происходит.
            return 0;
        }
        else {
            string x = lua_tostring(L, -1);
            throw x;
        }
    }
    catch (string x) {
        cout << x << endl;
        //luaL_error(L,"error");
    }
};

int main() {
    lua_State *L = luaL_newstate();
    pushlua(L, "yes");// отправить любое значение в стек.
    pushlua(L, true);// отправить любое значение в стек.
    pushlua(L, 100);// отправить любое значение в стек.
    pushlua(L, 33.23);// отправить любое значение в стек.
   pushlua(L, "no");// отправить любое значение в стек.
    pushlua(L, 202);// отправить любое значение в стек.
    showstack(L);
    lua_pushvalue(L, -3);// отправляет копию элемент на вершину стека.
    showstack(L);
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}


Выводится

  the number on the stack = 6


         -1  202
         -2  no
         -3  33.23
         -4  100
         -5  1
         -6  yes

  the number on the stack = 7


         -1  33.23
         -2  202
         -3  no
         -4  33.23
         -5  100
         -6  1
         -7  yes


lua c++ api. Получение значения переменных из lua,  обработка ошибок в lua.


int checklua(lua_State *L, const char *file) {
    int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
    try {if (status == 0) {// если нет ошибки в файле.
            luaL_dofile(L, file);// запуск файла, в которым все происходит.
    return 0;}
    else {  string x =lua_tostring(L, -1);
    throw x;    }
    }
    catch (string x) {
        cout << x << endl;
        //luaL_error(L,"error");
    }
};

int main() {
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);
    checklua(L, "main.lua");
    lua_getglobal(L, "x");
    int x = lua_tonumber(L, -1);

    cout << x << endl;
    lua_close(L);
    return 0;
};

Lua

X=23


lua c++ api. Получение значение переменной любого типа из lua.

using namespace std;

int checklua(lua_State *L, const char *file) {
    int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
    try {if (status == 0) {// если нет ошибки в файле.
            luaL_dofile(L, file);// запуск файла, в которым все происходит.
    return 0;}
    else {  string x =lua_tostring(L, -1);
    throw x;    }
    }
    catch (string x) {
        cout << x << endl;
        //luaL_error(L,"error");
    }
};

int main(int argc, char *argv[]) {

    lua_State *L = luaL_newstate();
    luaL_openlibs(L);//открыть все стандартные библиотеки lua.
    checklua(lua, "main.lua");// Загружает и запускает заданный файл. Файл в котором все происходит.
    lua_getglobal(L, "x");// получить значение x
    if (lua_isnumber(L, 1)) {//  если 1 позиция в стеке число.
        int number = lua_tonumber(L, 1);// получить число.
        cout << "number x = " << number << endl;}

    else if (lua_isstring(L, 1)) {//  если 1 позиция в стеке строка.
        string str = lua_tostring(L, 1);// получить строка.
        cout << "string x = " << str << endl;}

    else if (lua_isboolean(L, 1)) {//  если 1 позиция в стеке булевая переменная.
        bool bo = lua_toboolean(L, 1);// получить булевая переменная.
        cout << "bool x = " << bo << endl;}
    else {  cout << "not x " <<endl;}
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
return 0;
}

Lua
 x=false



lua c++ api. Узнать тип переменной.

int main() {
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);//открыть все стандартные библиотеки lua.
    checklua(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
    lua_getglobal(L, "x");// получить значение глобальной переменной x.
    int t = lua_type(L, 1); /* LUA_TNIL, LUA_TNUMBER, LUA_TBOOLEAN, LUA_TSTRING, LUA_TTABLE, LUA_TFUNCTION, LUA_TUSERDATA, LUA_TTHREAD,
    и LUA_TLIGHTUSERDATA.*/
    if (LUA_TSTRING == t){
        cout << "string x " << lua_tostring(L, 1) << endl;  }
    if (LUA_TNUMBER == t) {
        double x = lua_tonumber(L, 1);
        int x2 = (int)x;
        if (x==x2){ cout << "number int x "<<x2 << endl;}
        else {cout << "number double x "<< x << endl;   }   }
    if (LUA_TBOOLEAN == t) {    cout << "bool x = " << lua_toboolean(L, 1) << endl;
    }
    if (LUA_TNIL == t) { // если x нет.
        cout << "not x " << endl;   }
    lua_close(L);// закрыть состояние

    cin.get();//ожидает ввода символа программа завершается.

    return 0;
}

Lua
x=20.1

lua api. Определение типа переменной в lua через структуру.

using namespace std;
struct st{ string str; int x2; double x; bool bo;
double copyx = x; int copyx2 = x2; bool bo2 = bo;// это нужно,чтобы, избежать вывода мусор.
st(){}
st(string str) {
    this->str = str;}
st(int x2) {
    this->x2 = x2;}
st(double x) {
    this->x = x;}
st(bool bo) {
    this->bo = bo;}
void show() {
    if (str != "") {
        cout << str << endl;    };
    if (x != copyx) {
        cout << x << endl;  };
    if (x2 != copyx2) {
        cout << x2 << endl; };
    if (bo != bo2) {
    cout << bo << endl; };};
};

st getvar(lua_State *lua, const char *var ) {
    lua_getglobal(lua, var);// получить значение x
    st s;
    if (LUA_TSTRING == lua_type(lua, -1)) {// если  строка.
        s.str = lua_tostring(lua, -1);
        lua_pop(lua, 1);
        return s;   }
    if (LUA_TNUMBER == lua_type(lua, -1)) {// значение число.
        double x = lua_tonumber(lua, -1);
        int x2 = (int)x;
        if (x == x2) { s.x2=x2;
        lua_pop(lua, 1);
        return s;       }
        else {  s.x=x;
        lua_pop(lua, 1);
        return s;   }
    }

    if (LUA_TBOOLEAN == lua_type(lua, -1)) {// значение булевая переменная.
        s.bo = lua_toboolean(lua, 1);
        lua_pop(lua, 1);
        return s;
    }

    if (LUA_TNIL == lua_type(lua, -1)) { { cout << "not x " << endl; }
    }
}


int checklua(lua_State *L, const char *file) {
    int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
    try {if (status == 0) {// если нет ошибки в файле.
            luaL_dofile(L, file);// запуск файла, в которым все происходит.
    return 0;}
    else {  string x =lua_tostring(L, -1);
    throw x;    }
    }
    catch (string x) {
        cout << x << endl;
        //luaL_error(L,"error");
    }
};

int main(int argc, char *argv[]) {

    lua_State *L = luaL_newstate();
    luaL_openlibs(L);//открыть все стандартные библиотеки lua.
    checklua(L, "main.lua");// Загружает и запускает заданный файл. Файл в котором все происходит.
    st t = getvar(L, "y");
    t.show();
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}

Lua


x =10.3
y="hi lua"
z=true



Отправка в стек любого значение.

void pushtolua(lua_State *L, const char* v) {
    lua_pushstring(L, v);
}

void pushtolua(lua_State *L, int v) {
    lua_pushinteger(L, v);
}

void pushtolua(lua_State *L, double v) {
    lua_pushnumber(L, v);
}

void pushtolua(lua_State *L, bool v) {
    lua_pushboolean(L, v);
}

int main(int argc, char *argv[]) {
    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    checkerror(L, LUA);//Функция проверка на ошибки.
    pushlua(L, 10);
    pushlua(L, 10.20);
    pushlua(L, "10");
    pushlua(L, true);
    showstack(L);

    lua_close(L);

    return 0;
}

lua c++ api. Присвовение значение переменной в lua.

int main(int argc, char *argv[]) {

    lua_State *L = luaL_newstate();
    luaL_openlibs(L);//открыть все стандартные библиотеки lua.
    lua_pushinteger(L, 30);// отправить целое число в стек.
    lua_setglobal(L, "c");// уст значение переменной в lua.
    checklua(L, "main.lua");// Загружает и запускает заданный файл. Файл в котором все происходит.
    lua_pcall(L, 0, 0, 0);// вызов функции в lua файле. 1 параметр кол-во передаваемых, кол-во возвращаемых, обработчик ошибок.
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}

Lua

print(c)

выводится 30.


lua c++ api. функция вывода ключей и значений таблицы.

int pri(lua_State *L, const char t[] ) {// передаем указатель на состояние.
    lua_getglobal(L, t);// получить значение глобальной переменной, таблица.
    lua_assert(lua_istable(L, -1));// проверить является 1 элемент стека таблицей.
    if (LUA_TTABLE == lua_type(L, -1)) {// это таблица.
    lua_pushnil(L);//кладем на вершину стека NULL
  while (lua_next(L, 1) != 0) {/* получает ключ из стека и отправляет пару ключ - значение из таблицы.
      Ключ имеет - 2, а значение - 1.*/
        if (LUA_TSTRING == lua_type(L, -2)) {// если ключ строка.
        if (LUA_TNUMBER == lua_type(L, -1)) {// значение число.
        cout << "key " << lua_tostring(L, -2) << " value " << lua_tonumber(L, -1) << endl;}
        lua_pop(L, 1);// удалить n элементы из стека.
        }
    }
}
return 1;// вернуть 1.
};
int main() {
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);
    checklua(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
    pri(L,"t");// вывести ключи и значения таблицы.
    lua_pcall(L, 0, 0, 0);// вызов функции в lua файле. 1 параметр кол-во передаваемых, кол-во возвращаемых, обработчик ошибок.
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
    return 0;}

lua

t= {x=10, y=20, z=30}
t1= {x=1, y=2, z=3}

выводится.
key y value 20
key x value 10
key z value 30


lua c++ api. Функции вывода ключей и значений таблицы, добавление ключа и значение в таблицу.

int checklua(lua_State *L, const char *file) {
    int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
    try {
        if (status == 0) {// если нет ошибки в файле.
            //luaL_dofile(L, file);// запуск файла, в которым все происходит.
            return 0;
        }
        else {
            string x = lua_tostring(L, -1);
            throw x;
            return 0;
        }
    }
    catch (string x) {
        cout << x << endl;
        return 0;
        //luaL_error(L,"error");
    }
};

int pri(lua_State *L, const char t[]) {// передаем указатель на состояние.
    lua_getglobal(L, t);// получить значение глобальной переменной, таблица.
    lua_assert(lua_istable(L, -1));// проверить является 1 элемент стека таблицей.
    if (LUA_TTABLE == lua_type(L, -1)) {// это таблица.
        lua_pushnil(L);//кладем на вершину стека NULL
        while (lua_next(L, 1) != 0) {/* получает ключ из стека и отправляет пару ключ - значение из таблицы.
            Ключ имеет - 2, а значение - 1.*/
            if (LUA_TSTRING == lua_type(L, -2)) {// если ключ строка.
                if (LUA_TNUMBER == lua_type(L, -1)) {// значение число.
                    cout << "key " << lua_tostring(L, -2) << " value " << lua_tonumber(L, -1) << endl;
                }
                lua_pop(L, 1);// удалить n элементы из стека.
            }
        }
    }cout << "\n";
    return 1;// вернуть 1.
}

int addtab(lua_State *L, const char t[], const char key[], int value) {// передаем указатель на состояние.
    lua_getglobal(L, t);// получить значение глобальной переменной, таблицей.
    lua_pushnumber(L, value);// отправить значение в таблицу..
    lua_setfield(L, -2, key);// уст ключ для него.
    lua_getglobal(L, t);// получить значение глобальной переменной, таблицей.
    lua_getfield(L, -1, key);// отправить ключ в таблицу.
    return 0;// вернуть 1.
}
int main() {
    lua_State *L = luaL_newstate();
    //checklua(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.

    luaL_dofile(L, "main.lua");// запуск файла, в которым все происходит.
    pri(L, "t");// вывести ключи и значения таблицы.
    addtab(L, "t", "a", 1000);// уст ключ и значение для таблицы
    pri(L, "t");// вывести ключи и значения таблицы.
    addtab(L, "t", "b", 99);// уст ключ и значение для таблицы
    pri(L, "t");// вывести ключи и значения таблицы.
    lua_pcall(L, 0, 0, 0);// вызов функции в lua файле. 1 параметр кол-во передаваемых, кол-во возвращаемых, обработчик ошибок.
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}


lua

t= {x=10, y=20, z=30}
t1= {x=1, y=2, z=3}

выводится.

key z value 30
key y value 20
key x value 10

key z value 30
key y value 20
key x value 10
key a value 1000

key x value 10
key z value 30
key a value 1000
key b value 99
key y value 20

вариант 2.


void getstack(lua_State* L, int pos) {
    if (LUA_TSTRING == lua_type(L, pos)) {
        cout << lua_tostring(L, pos);
    }
    if (LUA_TNUMBER == lua_type(L, pos)) {
        double x = lua_tonumber(L, pos);
        int x2 = (int)x;
        if (x == x2) { cout << x2; }
        else { cout << x; }
    }
    if (LUA_TBOOLEAN == lua_type(L, pos)) {
        cout << (lua_toboolean(L, pos) ? "true " : "false ");
    }
    if (LUA_TNIL == lua_type(L, pos)) {
        cout << "not /n";
    }
    if (LUA_TTABLE == lua_type(L, pos)) {
        cout << "LUA_TTABLE " << endl;
    }
    if (LUA_TFUNCTION == lua_type(L, pos)) {
        cout << "LUA_TFUNCTION " << endl;
    }
    if (LUA_TLIGHTUSERDATA == lua_type(L, pos)) {
        cout << "LIGHTUSERDATA " << endl;
    }
    if (LUA_TTABLE == lua_type(L, pos)) {
        cout << "LUA_TTABLE " << endl;
    }
    if (LUA_TFUNCTION == lua_type(L, pos)) {
        cout << "LUA_TFUNCTION " << endl;
    }
    if (LUA_TUSERDATA == lua_type(L, pos)) {
        cout << "LUA_TUSERDATA " << endl;
    }
    if (LUA_TNIL == lua_type(L, pos)) { // если x нет.
        cout << "nill " << endl;
    }
};
int pri(lua_State* L, const char t[]) {// передаем указатель на состояние.
    lua_getglobal(L, t);// получить значение глобальной переменной, таблица.
    lua_assert(lua_istable(L, -1));// проверить является 1 элемент стека таблицей.
    if (LUA_TTABLE == lua_type(L, -1)) {// это таблица.
        lua_pushnil(L);//кладем на вершину стека NULL
        while (lua_next(L, 1) != 0) {/* получает ключ из стека и отправляет пару ключ - значение из таблицы.
            Ключ имеет - 2, а значение - 1.*/
            cout << "key "; getstack(L, -2); cout << " value "; getstack(L, -1); cout << endl;
            lua_pop(L, 1);// удалить n элементы из стека.
        }

    }
return 0;// вернуть 1.
};
int main() {
    lua_State* L = luaL_newstate();
    luaL_openlibs(L);
    luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
    pri(L, "t");// вывести ключи и значения таблицы.
    lua_close(L);// закрыть состояние
    return 0;
};





lua c++ api. Работа с таблицей.

int main() {
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);//открыть все стандартные библиотеки lua.
    checklua(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
    lua_getglobal(L, "t");// получить значение глобальной переменной, таблица.
    lua_assert(lua_istable(L, 1));// проверить является 1 элемент стека таблицей.
    lua_pushstring(L, "x");// отправить ключ x в стек.
    lua_gettable(L, 1);// получить значение по ключу из стека.
    lua_assert(lua_isnumber(L, 2));// проверить является значение 2 элемента стека число.
    int x = lua_tonumber(L, 2);
    lua_getglobal(L, "t");// получить значение глобальной переменной таблица.
    lua_pushstring(L, "y");
    lua_gettable(L, 1);
    lua_assert(lua_isstring(L, 4));
    string y = lua_tostring(L, 4);
    lua_getglobal(L, "t");// получить значение глобальной переменной, таблицей.
    lua_getfield(L, 5, "z");// отправить ключ в таблицу.
    lua_assert(lua_isboolean(L, 5));
    bool z = lua_toboolean(L, 5);// получить булевое значение по ключу.
    lua_getglobal(L, "t");// получить значение глобальной переменной, таблицей.
    lua_pushstring(L, "dog");// отправить значение в таблицу.
    lua_setfield(L, 5, "a");// уст ключ для него.
    lua_getglobal(L, "t");// получить значение глобальной переменной, таблицей.
    lua_getfield(L, 5, "a");// отправить ключ в таблицу.
    lua_assert(lua_isstring(L, 5));
    string a = lua_tostring(L, -1);
    cout << "x = " << x << "\ny = " << y << "\nz = " << z << "\na = " << a << endl;
    lua_close(L);// закрыть состояние

    cin.get();//ожидает ввода символа программа завершается.

    return 0;
}

Lua

t= {x=300,y="ok you y",z=true}


lua c++ api. Работа с таблицей 2.


int main() {
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);//открыть все стандартные библиотеки lua.
    checklua(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
    lua_getglobal(L, "t");// получить значение глобальной переменной, таблица.
    lua_assert(lua_istable(L, 1));// проверить является 1 элемент стека таблицей.
    lua_pushstring(L, "x");// отправить ключ x в стек.
    lua_gettable(L, 1);{// получить значение по ключу из стека.
    int t = lua_type(L, 2); /*Возвращает тип значения в указанном допустимом индексе или LUA_TNONE для недопустимого индекса
    (то есть индекса для «пустой» позиции стека). Типы возвращаемых lua_type кодируются с помощью следующих констант,
    определенных в lua.h: LUA_TNIL, LUA_TNUMBER, LUA_TBOOLEAN, LUA_TSTRING, LUA_TTABLE, LUA_TFUNCTION, LUA_TUSERDATA, LUA_TTHREAD,
    и LUA_TLIGHTUSERDATA.*/
    switch (t) {
    case LUA_TSTRING:// если строка.
        cout << "string x "<< lua_tostring(L, 2) << endl;
        break;
    case LUA_TBOOLEAN:// если булевая.
        cout <<"bool x = "<< lua_toboolean(L, 2)<<  endl;
        break;
    case LUA_TNUMBER:  // если число.
        cout << "number x = "<< lua_tonumber(L, 2) << endl;
        break;
    case LUA_TNIL:  // если x нет.
        cout << "not x " << endl;
        break;
    default:  // иначе.
        cout <<"other x = "<< lua_typename(L, t) << endl;
        break;  } }
    lua_close(L);// закрыть состояние

    cin.get();//ожидает ввода символа программа завершается.

    return 0;
}

Lua

t= {x="20"}


lua c++ api. Работа с таблицей. Извлечение из таблицы ключа и значение.


int pri(lua_State *lua) {// передаем указатель на состояние.

    if (LUA_TTABLE == lua_type(lua, 1)) {// это таблица.
        lua_pushnil(lua);//кладем на вершину стека NULL
        while (lua_next(lua, 1) !=0) {/* получает ключ из стека и отправляет пару ключ - значение из таблицы
          по заданному индексу(«следующая» пара после заданного ключа). Если в таблице больше нет элементов.
          Ключ имеет - 2, а значение - 1.*/
        if (LUA_TSTRING == lua_type(lua, -2)) {// если ключ строка.
            if (LUA_TNUMBER == lua_type(lua, -1)) {// значение число.
                cout << "key " << lua_tostring(lua, -2) << " value " << lua_tonumber(lua, -1) << endl;}

            if (LUA_TSTRING == lua_type(lua, -1)) {// значение строка.
            cout << "key " << lua_tostring(lua, -2) << " value " << lua_tostring(lua, -1) << endl; }
            lua_pop(lua, 1);// удалить n элементы из стека.
        }}
}
    return 1;// вернуть 1.
}
int main() {
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);//открыть все стандартные библиотеки lua.
    lua_register(L, "pri", pri);// регистрируем функцию- имя состояние, имя функ в lua, имя функ тут.
    checklua(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
    lua_pcall(L, 0, 0, 0);// вызов функции в lua файле. 1 параметр кол-во передаваемых, кол-во возвращаемых, обработчик ошибок.
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}

Lua

t={z="kj", x=23, y="dog",a=30,b=33}
pri(t)



lua c++ api работа с таблицей. Функция принимающую таблицу для изменения значений ключей.

#include<iostream>
#include<string>
#include<vector>

#include"include/lua.hpp"
using namespace std;

int pri(lua_State *L) {// передаем указатель на состояние.

    vector<string>v; // вектор для хранение ключей таблиции.
    if (LUA_TNUMBER != lua_type(L, 2)) {//проверка, второй аргумент является числом.
    cout << "bad second argument in function " << endl;
    return 1;   };
    int n = lua_tonumber(L, 2);
    if (LUA_TTABLE == lua_type(L, 1)) {
        cout << "\nthis is table \n" << endl;
        lua_pushnil(L);//кладем на вершину стека NULL.
        while (lua_next(L, 1) != 0) {// получает ключ из стека и отправляет пару ключ - значение из таблицы.

            if (LUA_TSTRING == lua_type(L, -2)) {// значение число.
                cout << "key " << lua_tostring(L, -2) << " value ";
                v.push_back(lua_tostring(L, -2));
                double x = lua_tonumber(L, -1);
                int x2 = (int)x;
                if (x == x2) {// int
                    cout << "number int  " << x2 << endl;   }
                else { cout << "number double " << x << endl; }
                lua_pop(L, 1);// удалить n элементы из стека.
            }
        }
    }
    else {  cout << "NOT table " << endl;
        if (LUA_TSTRING == lua_type(L, 1)) {
            cout << "this string " << lua_tostring(L, 1) << endl;   }
        if (LUA_TNUMBER == lua_type(L, 1)) {
            double x = lua_tonumber(L, 1);
            int x2 = (int)x;
            if (x == x2) { cout << "this number int " << x2 << endl; }
            else { cout << "this number double this " << x << endl; }
        }
        if (LUA_TBOOLEAN == lua_type(L, 1)) { cout << "this bool " << lua_toboolean(L, 1) << endl; }
        if (LUA_TNIL == lua_type(L, 1)) { // если нет.
            cout << "Nothing was passed.  " << endl;}
    }
    for (auto i : v){
        const char* x = i.c_str(); // из строки массив char.
        lua_getglobal(L, "t");// получить значение глобальной переменной, таблицей.
        lua_pushinteger(L, n);// отправить значение в таблицу.
        lua_setfield(L, 1, x);// уст ключ для него.
        lua_getglobal(L, "t");// получить значение глобальной переменной, таблицей.
        lua_getfield(L, 1, x);// отправить ключ в таблицу.
}
    return 1;// вернуть 1.
}
int main() {
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);//открыть все стандартные библиотеки lua.
    lua_register(L, "pri", pri);// регистрируем функцию- имя состояние, имя функ в lua, имя функ тут.
    checklua(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
    lua_pcall(L, 0, 0, 0);// вызов функции в lua файле. 1 параметр кол-во передаваемых, кол-во возвращаемых, обработчик ошибок.
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}


Lua

t={x=1, y=2 ,a=3,b=4}
a=nil

for k,v in pairs(t) do
    print(k,v)
end
pri(a,100)

    print("\n After \n")
for k,v in pairs(t) do
    print(k,v)
end


lua c++ api. Отправить таблицу с ключами и значением в lua.


int checklua(lua_State *L, const char *file) {
    int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
    try {
        if (status == 0) {// если нет ошибки в файле.
            luaL_dofile(L, file);// запуск файла, в которым все происходит.
            return 0;
        }
        else {
            string x = lua_tostring(L, -1);
            throw x;
        }
    }
    catch (string x) {
        cout << x << endl;
        //luaL_error(L,"error");
    }
};
int main() {
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);
    lua_newtable(L); /*создать пустую таблицу */

    lua_pushstring(L, "key x"); /* отправить ключ в стек */
    lua_pushstring(L, "value x"); /* отправить значение ключа в стек. */
    lua_rawset(L, -3); /*Сохраняет пару в таблице */
    lua_pushstring(L, "key y"); /* */
    lua_pushstring(L, "value y"); /*  */
    lua_rawset(L, -3); /*Сохраняет пару в таблице */
    lua_setglobal(L, "foo");// уст имя таблицы в lua.

    checklua(L, "main.lua");
    lua_close(L);
    return 0;
};

Lua

print(foo)
for k,v in pairs(foo) do
print(k.." "..v)
end

выводит

table: 013154E0
key x value x
key y value y

еще так можно.

void addkeyintab(lua_State *L, const char* key, const char* value){

    lua_pushstring(L, key); /* отправить ключ в стек */
    lua_pushstring(L, value); /* отправить значение ключа в стек. */
    lua_rawset(L, -3); /*Сохраняет пару в таблице */
}
void addkeyintab(lua_State *L, const char* key, int value) {

    lua_pushstring(L, key); /* отправить ключ в стек */
    lua_pushinteger(L, value); /* отправить значение ключа в стек. */
    lua_rawset(L, -3); /*Сохраняет пару в таблице */
}
int main() {lua_State *L = luaL_newstate();
    luaL_openlibs(L);
    lua_newtable(L); /*создать пустую таблицу */
    addkeyintab(L, "key y", "10"); /*добавить ключ и значение в таблицу */
    addkeyintab(L, "key x", 10); /*добавить ключ и значение в таблицу */
    lua_setglobal(L, "foo");// уст имя таблицы в lua.

    checklua(L, "main.lua");
    showstack(L);// вывести стек.
    lua_close(L);
    return 0;
};

Lua

print(foo)
for k,v in pairs(foo) do
print(k.." "..v)
end

Выводится

table: 00855520
key x 10
key y 10

  the number on the stack = 0


lua c++ api. Запуск lua файла.

#include"include/lua.hpp"

using namespace std;

int checklua(lua_State *L, const char *file) {
    int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
    try {
        if (status == 0) {// если нет ошибки в файле.
            luaL_dofile(L, file);// запуск файла, в которым все происходит.
            return 0;
        }
        else {
            string x = lua_tostring(L, -1);
            throw x;
        }
    }
    catch (string x) {
        cout << x << endl;
        //luaL_error(L,"error");
    }
};


int main(int argc, char *argv[]) {

    lua_State *L = luaL_newstate();
    luaL_openlibs(L);//открыть все стандартные библиотеки lua.
    checklua(L, "main.lua");// Загружает и запускает заданный файл. Файл в котором все происходит.
    lua_pcall(L, 0, 0, 0);// вызов функции в lua файле. 1 параметр кол-во передаваемых, кол-во возвращаемых, обработчик ошибок.
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
return 0;
}

Lua
a = 3
b = 6
c= a+b
print(c)

lua c++ api. Регистрация новой C функции в lua.

int q(lua_State *L) {// передаем указатель на состояние.
    int x = lua_tonumber(L, 1); // получаем 1 элемент из стека.
    x = x * x;
   //cout << x << endl;
    lua_pushnumber(L, x);// умножаем x и отправляет в стек.
    return 1;// вернуть 1.
}
int main() {
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);//открыть все стандартные библиотеки lua.
    lua_register(L, "q", q);// регистрируем функцию- имя состояние, имя функ в lua, имя функ тут.
    checklua(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
    lua_pcall(L, 0, 0, 0);// вызов функции в lua файле. 1 параметр кол-во передаваемых, кол-во возвращаемых, обработчик ошибок.
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
    return 0;}

lua
x = q(2)
print(x)



lua c++ api. Регистрация C функции в lua.


int foo(lua_State *L) {

    int x= lua_tonumber(L, -1);
    cout << x << endl;
    return 0; /* number of results */
}
int main(int argc, char *argv[]) {

    lua_State *L = luaL_newstate();
    luaL_openlibs(L);//открыть все стандартные библиотеки lua.
    lua_register(L, "foo", foo);// регистрируем функцию- имя состояние, имя функ в lua, имя функ тут.

    checklua(L, "main.lua");
    lua_pcall(L, 0, 0, 0);// вызов функции в lua файле. 1 параметр кол-во передаваемых, кол-во возвращаемых, обработчик ошибок.
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}


Lua
foo(2)

lua c++ api. Запуск C функции в lua.


int checklua(lua_State *L, const char *file) {
    int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
    try {if (status == 0) {// если нет ошибки в файле.
            luaL_dofile(L, file);// запуск файла, в которым все происходит.
    return 0;}
    else {  string x =lua_tostring(L, -1);
    throw x;    }
    }
    catch (string x) {
        cout << x << endl;
        //luaL_error(L,"error");
    }
};
int foo(lua_State *L) {
    cout << "hi foo c++" << endl;
    return 0;
}
int main() {
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);
    checklua(L, "main.lua");
    lua_pushcfunction(L, foo);// отправить c функцию в стек.
    lua_pcall(L, 0, 0, 0);// вызвать функцию foo.
    lua_close(L);
    return 0;
};


Lua

Foo()


lua c++ api. Запуск функции на lua, с возвращаемыми параметрами.

int main() {
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);//открыть все стандартные библиотеки lua.
    checklua(L, "main.lua");
    lua_getglobal(L, "pri");// получаем из lua функцию pri.
    lua_pushnumber(L, 5);// отправляем в стек число.
    lua_pushnumber(L, 10);// отправляем в стек число.

    lua_pcall(L, 2, 1, 0);// вызов функции, передаем 2 параметра, возвращаем 1.
    cout << lua_tonumber(L, 1) << endl;// получаем из стека возвращаемое значение из функции.
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.

    return 0;
}

Lua

function pri(x,y)
sum = x+y
return sum
end


lua c++ api. Вызов определенной функции из lua.

int main() {
    lua_State *L = luaL_newstate();
    int x = 5, y = 6;
    luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
    lua_getglobal(L, "f"); /* вызываемая функция */
    lua_pushnumber(L, x); /* поместить на стек 1-й аргумент */
    lua_pushnumber(L, y); /* поместить на стек 2-й аргумент */
    if (lua_pcall(L, 2, 1, 0) != 0) {/* вызвать функцию (2 аргумента, 1 результат) */
        luaL_error(L, "error running function 'f': %s", lua_tostring(L, -1));}/* получить результат */
    cout << lua_tonumber(L, -1) << "\n";
    lua_pop(L, 1);
    lua_close(L);
    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}

Lua

function f(x, y)
    return (x*y)
end


lua c++ api. Функция, принимающая переменное количество аргументов.

//Эта функция может принимать переменное число параметров через L
int pri(lua_State * L) {// передаем указатель на состояние.
    int n = lua_gettop(L);/* получаем количество параметров переданных в функцию.
    Возвращает индекс верхнего элемента в стеке. Поскольку индексы начинаются с 1, этот результат
    равен количеству элементов в стеке (и поэтому 0 означает пустой стек).*/
    cout <<"count elements "<< n << endl;
    for (int i = 1; i <= n; ++i) {
    int t = lua_type(L, i); /* LUA_TNIL, LUA_TNUMBER, LUA_TBOOLEAN, LUA_TSTRING, LUA_TTABLE, LUA_TFUNCTION, LUA_TUSERDATA, LUA_TTHREAD,
       и LUA_TLIGHTUSERDATA.*/
    if (LUA_TSTRING == t) {
            cout <<i << " string = " << lua_tostring(L, i) << endl;}
    if (LUA_TNUMBER == t) {
            double x = lua_tonumber(L, i);
            int x2 = (int)x;
            if (x == x2) { cout << i<<" number int = " << x2 << endl; }
            else { cout << i<<" number double = " << x << endl; }}
    if (LUA_TBOOLEAN == t) {cout <<i<< " bool = " << lua_toboolean(L, i) << endl;   }

    }
    return 1;// вернуть 1.
}
int main() {
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);//открыть все стандартные библиотеки lua.
    lua_register(L, "pri", pri);// регистрируем функцию- имя состояние, имя функ в lua, имя функ тут.
    checklua(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
    lua_pcall(L, 0, 0, 0);// вызов функции в lua файле. 1 параметр кол-во передаваемых, кол-во возвращаемых, обработчик ошибок.
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}

Lua

pri(2,"youtube", false, 6,"end",5.236, true)



lua c++ api. мета таблицы.


void addkeyintab(lua_State *L, const char* key, int value) {
    lua_pushstring(L, key); /* отправить ключ в стек */
    lua_pushinteger(L, value); /* отправить значение ключа в стек. */
    lua_rawset(L, -3); /*Сохраняет пару в таблице */
}
struct vec{ static int vector(lua_State* L) {// методы классы должны быть статик.
        lua_newtable(L); //создать новую таблицу.
        addkeyintab(L, "x", 0);// установить значение ключа таблицы.
        luaL_getmetatable(L, "mt");// получить мета таблицу.
        lua_setmetatable(L, -2);
        return 1;   }

    static int __add(lua_State* L)  {
        lua_pushstring(L, "x");
        lua_gettable(L, -3);
        int firts = lua_tonumber(L, -1);

        lua_pushstring(L, "x");
        lua_gettable(L, -3);
        int second = lua_tonumber(L, -1);

        vec::vector(L);// вывоз метода обнулиние таблицы суммы ключей.
        lua_pushstring(L, "z");// ключ таблицы со значение ее суммы.
        lua_pushnumber(L, firts + second);// сумму отправить в стек как ключ таблицы.
        lua_rawset(L, -3);// уст таблицу без мета.методов.
        return 1;
    }
};

const char * LUA_FILE = R"(
        v1 = vector()   -- v1 is a table
        v2 = vector() -- v2 is a table
        v1.x = 5  v2.x = 18
        v3 = v1 + v2
        result = v3.z)";
int main(){lua_State* L = luaL_newstate();

lua_pushcfunction(L, vec::vector);
lua_setglobal(L, "vector");

luaL_newmetatable(L, "mt");
lua_pushstring(L, "__add");
lua_pushcfunction(L, vec::__add);
lua_settable(L, -3);

luaL_dostring(L, LUA_FILE);

lua_getglobal(L, "result");
cout << "result = " <<lua_tonumber(L, -1)<< endl;
lua_close(L);
}


lua c++ api. мета таблицы 2.


struct Sprite { int x;// структура.

    Sprite() : x(0) {}//конструктор по умолчанию.

    ~Sprite() { cout << "destror "<< this << endl; }

    void set(int x) {this->x = x;}// уст значение x.

    void show() {
        printf("sprite(%p): x = %d\n", this, x);
    }
};

int create(lua_State* L) {// создать структуру.
    void* st = lua_newuserdata(L, sizeof(Sprite));// выделить память под польз.данные отправить в стек.
    new (st) Sprite();//выделить память под новый объект класса.
    luaL_getmetatable(L, "mt");// получить мета таблицу.
    lua_setmetatable(L, -2);// уст мета таблицу.
    return 1;
};

int set(lua_State* L) {
    Sprite* sprite = (Sprite*)lua_touserdata(L, -2);// получить польз.данные.
    int x = lua_tonumber(L, -1);
    sprite->set(x);// вызов метода класса, уст значение x
    return 0;
};

int show(lua_State* L) {
    Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
    sprite->show();
    return 0;
};
int DestroySprite(lua_State* L) {
    Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
    sprite->~Sprite();
    return 0;
};

const char* LUA_FILE = R"(
        sprite = create()
        set( sprite, 5 )
        show( sprite )
        set( sprite, 12 )
        show( sprite )
        sprite2 = create()
        set( sprite2, 33 )
        show( sprite2 )
        )";

int main() {lua_State* L = luaL_newstate();

    luaL_newmetatable(L, "mt");// создать метп таблицу.
    lua_pushstring(L, "__gc");// отправить в стек сборщик мусора.
    lua_pushcfunction(L, DestroySprite);// установить значение ключа, как вызов деструктор.
    lua_settable(L, -3);// установить таблицу.

    lua_pushcfunction(L, create);// отправить ключ как функцию в стек.
    lua_setglobal(L, "create");
    lua_pushcfunction(L, set);// отправить ключ как функцию в стек.
    lua_setglobal(L, "set");
    lua_pushcfunction(L, show);// отправить ключ как функцию в стек.
    lua_setglobal(L, "show");

    luaL_dostring(L, LUA_FILE);

    lua_close(L);
}


lua c++ api. мета таблицы 3.


static int numberOfSpritesExisting = 0;

struct Sprite
{
    int x;
    int y;

    Sprite() : x(0), y(0)
    {
        numberOfSpritesExisting++;
    }

    ~Sprite()
    {
        numberOfSpritesExisting--;
    }

    void Move(int velX, int velY)
    {
        x += velX;
        y += velY;
    }

    void Draw()
    {
        printf("sprite(%p): x = %d, y = %d\n", this, x, y);
    }
};

int CreateSprite(lua_State* L){
    void* pointerToASprite = lua_newuserdata(L, sizeof(Sprite));
    new (pointerToASprite) Sprite();
    luaL_getmetatable(L, "SpriteMetaTable");
    lua_assert(lua_istable(L, -1));
    lua_setmetatable(L, -2);
    return 1;
};

int DestroySprite(lua_State* L){
    Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
    sprite->~Sprite();
    return 0;
};

int MoveSprite(lua_State* L){
    Sprite* sprite = (Sprite*)lua_touserdata(L, -3);
    lua_Number velX = lua_tonumber(L, -2);
    lua_Number velY = lua_tonumber(L, -1);
    sprite->Move((int)velX, (int)velY);
    return 0;
};

int DrawSprite(lua_State* L){
    Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
    sprite->Draw();
    return 0;
};

const char* LUA_FILE = R"(
    sprite = Sprite.new()
    sprite:Move( 5, 7 )     -- Sprite.Move( sprite, 5, 7 )
    sprite:Draw()
    sprite:Move( 1, 2 )
    sprite:Draw()
    sprite2 = Sprite.new()
    sprite2:Move( 3, 3 )
    sprite2:Draw()
        -- sprite   -> sprite is a userdatum
        --      has a metatable called SpriteMetaTable
        --          dont have Move(), use the __index metamethod
        --          __index metamethod is a table which is Sprite
        --          Sprite has a field called Move(), invoke that
        --          Move() is a c function
        --          invoke, pass the userdatum as the first parameter.
        )";


int main() {
    lua_State* L = luaL_newstate();

    lua_newtable(L);
    int spriteTableIdx = lua_gettop(L);
    lua_pushvalue(L, spriteTableIdx);
    lua_setglobal(L, "Sprite");

    lua_pushcfunction(L, CreateSprite);
    lua_setfield(L, -2, "new");
    lua_pushcfunction(L, MoveSprite);
    lua_setfield(L, -2, "Move");
    lua_pushcfunction(L, DrawSprite);
    lua_setfield(L, -2, "Draw");

    luaL_newmetatable(L, "SpriteMetaTable");
    lua_pushstring(L, "__gc");
    lua_pushcfunction(L, DestroySprite);
    lua_settable(L, -3);

    lua_pushstring(L, "__index");
    lua_pushvalue(L, spriteTableIdx);
    lua_settable(L, -3);

    luaL_dostring(L, LUA_FILE);
    lua_close(L);

    lua_assert(numberOfSpritesExisting == 0);
    return 0;
}


lua c++ api. мета таблицы 4.


static int numberOfSpritesExisting = 0;

struct Sprite {
    int x;
    int y;

    Sprite() : x(0), y(0)
    {
        numberOfSpritesExisting++;
    }

    ~Sprite()
    {
        numberOfSpritesExisting--;
    }

    void Move(int velX, int velY)
    {
        x += velX;
        y += velY;
    }

    void Draw()
    {
        printf("sprite(%p): x = %d, y = %d\n", this, x, y);
    }
};

auto CreateSprite = [](lua_State* L) -> int
{
    void* pointerToASprite = lua_newuserdata(L, sizeof(Sprite));
    new (pointerToASprite) Sprite();
    luaL_getmetatable(L, "mt");
    lua_assert(lua_istable(L, -1));
    lua_setmetatable(L, -2);
    return 1;
};

auto DestroySprite = [](lua_State* L) -> int
{
    Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
    sprite->~Sprite();
    return 0;
};

auto MoveSprite = [](lua_State* L) -> int
{
    Sprite* sprite = (Sprite*)lua_touserdata(L, -3);
    lua_Number velX = lua_tonumber(L, -2);
    lua_Number velY = lua_tonumber(L, -1);
    sprite->Move((int)velX, (int)velY);
    return 0;
};

auto DrawSprite = [](lua_State* L) -> int
{
    Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
    sprite->Draw();
    return 0;
};

auto SpriteIndex = [](lua_State* L) -> int
{
    lua_assert(lua_isuserdata(L, -2));
    lua_assert(lua_isstring(L, -1));

    Sprite* sprite = (Sprite*)lua_touserdata(L, -2);
    const char* index = lua_tostring(L, -1);
    if (strcmp(index, "x") == 0)
    {
        lua_pushnumber(L, sprite->x);
        return 1;
    }
    else if (strcmp(index, "y") == 0)
    {
        lua_pushnumber(L, sprite->y);
        return 1;
    }
    else
    {
        lua_getglobal(L, "Sprite");
        lua_pushstring(L, index);
        lua_rawget(L, -2);
        return 1;
    }
};

const char* LUA_FILE = R"(
    sprite = Sprite.new()
    sprite:Move( 6, 7 )     -- Sprite.Move( sprite, 6, 7 )
    sprite:Draw()
    temp_x = sprite.x
    )";
int main(){
    lua_State* L = luaL_newstate();

    lua_newtable(L);
    int spriteTableIdx = lua_gettop(L);
    lua_pushvalue(L, spriteTableIdx);
    lua_setglobal(L, "Sprite");

    lua_pushcfunction(L, CreateSprite);
    lua_setfield(L, -2, "new");
    lua_pushcfunction(L, MoveSprite);
    lua_setfield(L, -2, "Move");
    lua_pushcfunction(L, DrawSprite);
    lua_setfield(L, -2, "Draw");

    luaL_newmetatable(L, "mt");
    lua_pushstring(L, "__gc");
    lua_pushcfunction(L, DestroySprite);
    lua_settable(L, -3);

    lua_pushstring(L, "__index");
    lua_pushcfunction(L, SpriteIndex);
    lua_settable(L, -3);

    int doResult = luaL_dostring(L, LUA_FILE);
    if (doResult != LUA_OK)
    {
        printf("Error: %s\n", lua_tostring(L, -1));
    }

    lua_getglobal(L, "temp_x");
    lua_Number temp_x = lua_tonumber(L, -1);
    lua_assert(temp_x == 6);

    lua_close(L);

    lua_assert(numberOfSpritesExisting == 0);
}


lua c++ api. Функции для работы с указателем.

struct st { int number =10;
    int *x = &number;
    st() { this->x = *&x; }
    st(int number) { this->number = *&number; }
};
int create(lua_State* L) {//Функция создания объекта структуры.
   int x = lua_tonumber(L, -1);
   void *s = lua_newuserdata(L, sizeof(st));/*Эта функция выделяет новый блок памяти с заданным размером,*/
   new(s) st(x);  luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при
     заданном приемлемом индексе.*/
   lua_setmetatable(L, 1);//получает таблицу из стека и уст ее в качестве  новой метатаблицы для значения с заданным допустимым индексом.
    return 1;
};

int show(lua_State* L) {
    st *s = (st*)lua_touserdata(L, -1);;// получаем польз. данные.
    cout << "andress " << &(s->x) <<" value " << *(s->x)<<endl;// адрес памяти
    s->~st();//вызов метода деструктор.
    return 0;
};

int checklua(lua_State *L, const char *file) {
    int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
    try {if (status == 0) {// если нет ошибки в файле.
            luaL_dofile(L, file);// запуск файла, в которым все происходит.
    return 0;}
    else {  string x =lua_tostring(L, -1);
    throw x;    }
    }
    catch (string x) {
        cout << x << endl;
        //luaL_error(L,"error");
    }
};

int main() {lua_State* L = luaL_newstate();
    lua_newtable(L);
    lua_pushcfunction(L, create);//уст указатель на функцию C++ и создает внутри Lua
    lua_setglobal(L, "get"); //получает значение из стека и уст значение global name.
    lua_pushcfunction(L, show);
    lua_setglobal(L, "show"); //получает значение из стека и уст значение global name.
    luaL_newmetatable(L, "mt");/*int luaL_newmetatable (lua_State * L, const    char * t); */
    lua_settable(L, 2);
    checklua(L, "main.lua");// Загружает и запускает заданный файл. файл в котором все происходит.
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}



lua c++ api. Работа с указателем.

int get_point_number(lua_State *L) {// передаем указатель на состояние
    int s = 10;//значение переменной по умолчанию.
    int *a = &s;// указатель на переменную.
    (int*)lua_newuserdata(L, sizeof(a));// выделяет памяти с заданным размером,
    //помещает в стек пользовательские данные и возвращает этот адрес.
    if (LUA_TNUMBER == lua_type(L, 1)) {
        double x = lua_tonumber(L, 1);
        int x2 = (int)x;
        if (x == x2) { lua_pushinteger(L, x);// отправить в стек целое число.
            cout << "this number int " << x2 << endl;       }
        else { cout << "this number double this " << x << endl;
        lua_pushnumber(L, x);   }
    }
    else {  cout <<"the default number  "<< s  << endl;
        lua_pushinteger(L, s);}
    return 2;// вернуть 2.
}
int getpoint(lua_State *L) {// передаем указатель на состояние
    if (LUA_TUSERDATA == lua_type(L, 1)) {// если это польз. данные.
        void *x = lua_touserdata(L, 1);/*Если значение в данном приемлемом индексе является полными данными пользователя,
 возвращает адрес его блока. Если значение является легким userdata, возвращает его указатель. В противном случае возвращается NULL.*/
        cout << "address point " << x << endl;  }
    return 1;// вернуть 1.
}
int main() {
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);//открыть все стандартные библиотеки lua.
    lua_pushcfunction(L, get_point_number);//уст указатель на функцию C++ и создает внутри Lua
    lua_setglobal(L, "getpointnum"); //получает значение из стека и уст значение global name.
    lua_pushcfunction(L, getpoint);//уст указатель на функцию C++ и создает внутри Lua
    lua_setglobal(L, "getpoint"); //получает значение из стека и уст значение global name.
    luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
    lua_pcall(L, 0, 0, 0);// вызов функции в lua файле.
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}

Lua

adress, num =getpointnum(5.3)
--print(adress, num ) --адрес памяти выводится
getpoint(adress)

легкие польз.данные.

int main() {
    lua_State* L = luaL_newstate(); luaL_openlibs(L);
    checkerror(L, LUA);
    lua_State* L1 = lua_newthread(L);
    int ret = 3;
    void *key = &ret;
    cout << key << endl;
    lua_pushlightuserdata(L, key);  /*отправить адресс, который является ключом в стек. */
       const void *v = lua_topointer(L,-1);
       cout << v << endl;
    return 0;
};

Вызывает функцию в защищенном режиме.
Оба nargs и nresults имеют то же значение, что и в lua_call. Если при звонке ошибок нет, lua_pcall ведет себя точно так же lua_call. Однако, если есть какая-либо ошибка, lua_pcall она перехватывает ее, помещает в стек одно значение (сообщение об ошибке) и возвращает код ошибки. Мол lua_call, lua_pcall всегда удаляет функцию и ее аргументы из стека.
Если errfunc равно 0, то сообщение об ошибке, возвращаемое в стеке, является точно исходным сообщением об ошибке. В противном случае errfunc это индекс стека функции обработчика ошибок . (В текущей реализации этот индекс не может быть псевдоиндексом.) В случае ошибок времени выполнения эта функция будет вызываться с сообщением об ошибке, а ее возвращаемое значение будет сообщением, возвращаемым в стеке lua_pcall.
Как правило, функция обработчика ошибок используется для добавления дополнительной отладочной информации к сообщению об ошибке, такой как трассировка стека. Такая информация не может быть собрана после возврата lua_pcall, так как к тому времени стек уже размотан.
lua_pcall Функция возвращает 0 в случае успеха или один из следующих кодов ошибок (определены в lua.h):
LUA_ERRRUN: ошибка во время выполнения.
LUA_ERRMEM: ошибка выделения памяти. Для таких ошибок Lua не вызывает функцию обработчика ошибок.
LUA_ERRERR: ошибка при запуске функции обработчика ошибок.





api lua c++. Реализация ООП через функции. Структура конструктор по умолчанию.

int checklua(lua_State *L, const char *file) {
    int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
    try {
        if (status == 0) {// если нет ошибки в файле.
            luaL_dofile(L, file);// запуск файла, в которым все происходит.
            return 0;
        }
        else {
            string x = lua_tostring(L, -1);
            throw x;
        }
    }
    catch (string x) {
        cout << x << endl;
        //luaL_error(L,"error");
    }
};
struct a {  int x = 30;
a() { this->x = x; }//конструктор по умолчанию
    void show() { cout << "x = " << x << endl; }
~a() { cout << "destory object " << this << endl << endl; }
};
int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
    a* st = (a*)lua_touserdata(L, -1);/* Если значение в данном приемлемом индексе является полными данными пользователя.*/
    st->~a();//вызов метода деструктор.
    return 0;};

int create(lua_State* L) {//Функция создания объекта структуры.
    void* st = lua_newuserdata(L, sizeof(a));/*Эта функция выделяет новый блок памяти с заданным размером,*/
    new (st) a();// Выделить память под польз. данные.
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    lua_setmetatable(L, 1);//получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
    return 1;};

int show(lua_State* L) {
    a* st = (a*)lua_touserdata(L, -1);// получаем польз. данные.
    st->show();// вызов метода.
    return 0;};

int main() {
    lua_State* L = luaL_newstate();
    lua_newtable(L);
    lua_pushcfunction(L, create);//уст указатель на функцию C++ и создает внутри Lua
    lua_setglobal(L, "get"); //получает значение из стека и уст значение global name.
    lua_pushcfunction(L, show);
    lua_setglobal(L, "show"); //получает значение из стека и уст значение global name.
    luaL_newmetatable(L, "mt");/*int luaL_newmetatable (lua_State * L, const char * t); */
    lua_pushstring(L, "__gc");
    lua_pushcfunction(L, destroy);
    lua_settable(L, 2);
    checklua(L, "main.lua");
    showstack(L);// вывести стек.
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
return 0;}

lua
a= get()
show(a)

передача польз. Данных.

struct a {  int x = 3010;
a() { this->x = x; }//конструктор по умолчанию
    void show() { cout << "x = " << x << endl; }
};

int create(lua_State* L) {//    Функция создания объекта структуры.
    void* st = lua_newuserdata(L, sizeof(a));/*Эта функция выделяет новый блок памяти с заданным размером,*/
    new (st) a();// Выделить память под польз. данные.
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    lua_setmetatable(L, 1);//получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
    return 1;};

int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
    a* st = (a*)lua_touserdata(L, 1);/* Если значение в данном приемлемом индексе является полными данными пользователя.*/
    st->~a();//вызов метода деструктор.
    return 0;};

int show(lua_State* L) {
    a* st = (a*)lua_touserdata(L, -1);
    st->show();
    return 0;};

int main() {
    lua_State* L = luaL_newstate();
    lua_newtable(L);
    lua_pushcfunction(L, create);//уст указатель на функцию C++ и создает внутри Lua
    lua_setglobal(L, "get"); //получает значение из стека и уст значение global name.
    lua_pushcfunction(L, show);
    lua_setglobal(L, "show"); //получает значение из стека и уст значение global name.
    luaL_newmetatable(L, "mt");/*int luaL_newmetatable (lua_State * L, const char * t); */
    lua_pushstring(L, "__gc");
    lua_pushcfunction(L, destroy);
    lua_settable(L, 2);
    luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
return 0;
}
Lua

a = get()
show(a)




api lua c++. Реализация ООП через функции 2. Структура конструктор по умолчанию.

struct a {
    int x = 10;
    a() { cout << "create object " << this << endl; }//конструктор по умолчанию

    void show() { cout << "\nobject - " << this << "\tx = " << x <<"\n\n"; }//вывести значение x на экран.

    ~a() { cout << "destory object " << this << endl << endl; }//вызов деструктора.
};

int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
    cout << "destroy " << endl;
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    a** st = (a**)lua_touserdata(L, -2); // получаем польз. данные.
    //a *b = &**st;
    //b->~a();//вызов метода деструктор.
    delete *st;
    return 0;

};
int create(lua_State* L) {//    Функция создания объекта структуры.
    luaL_newmetatable(L, "mt");// создать мета таблицу.
    lua_pushstring(L, "__gc");// отправить в стек сборщик мусора.
    lua_pushcfunction(L, destroy);// установить значение ключа, как вызов деструктор.

    lua_settable(L, -3);// установить таблицу.
    a** c = (a**)lua_newuserdata(L, sizeof(a*));/*Эта функция выделяет новый блок памяти с заданным размером,*/
    *c = new a();
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/

    lua_setmetatable(L, -2); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.

return 1;
};
int show(lua_State* L) {
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    a** st = (a**)lua_touserdata(L, -2);// получаем польз. данные.
    a *b = &**st;
    b->show();// вызов метода.
    return 0;
};

int main() {
    lua_State* L = luaL_newstate();
    lua_register(L, "create", create );//уст указатель на функцию C++ и создает внутри Lua
    lua_register(L, "show", show); //получает значение из стека и уст значение global name.
    lua_register(L, "__gc", destroy); //получает значение из стека и уст значение global name.
    luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.

    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}


lua
a= create()
show(a)


Выводится
create object 0152FD78

object - 0152FD78       x = 10

destroy
destory object 0152FD78




api lua c++. Реализация ООП через функции 2. 2 класса. Структура конструктор по умолчанию.


struct a {
    int x = 10;
    a() { cout << "create object " << this << endl; }//конструктор по умолчанию

    void show() { cout << "\nobject - " << this << "\tx = " << x << "\n\n"; }//вывести значение x на экран.
    void get() { cout << "\nget "<< "\n\n"; }//вывести значение x на экран.

    ~a() { cout << "destory object " << this << endl << endl; }//вызов деструктора.
};
struct b {
    int y = 10;
    b() { cout << "create object b" << this << endl; }//конструктор по умолчанию

    void get() { cout << "\ngeta " << "\n\n"; }//вывести значение x на экран.

    ~b() { cout << "destory object " << this << endl << endl; }//вызов деструктора.
};
int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
    cout << "destroy " << endl;
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    a** st = (a**)lua_touserdata(L, -2); // получаем польз. данные.
    //a *b = &**st;
    //b->~a();//вызов метода деструктор.
    delete *st;
    return 0;

};
int create(lua_State* L) {//    Функция создания объекта структуры.
    luaL_newmetatable(L, "mt");// создать мета таблицу.
    lua_pushstring(L, "__gc");// отправить в стек сборщик мусора.
    lua_pushcfunction(L, destroy);// установить значение ключа, как вызов деструктор.

    lua_settable(L, -3);// установить таблицу.
    a** c = (a**)lua_newuserdata(L, sizeof(a*));/*Эта функция выделяет новый блок памяти с заданным размером,*/
    *c = new a();
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/

    lua_setmetatable(L, -2); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.

return 1;
};
int create1(lua_State* L) {//   Функция создания объекта структуры.
    luaL_newmetatable(L, "mt");// создать мета таблицу.
    lua_pushstring(L, "__gc");// отправить в стек сборщик мусора.
    lua_pushcfunction(L, destroy);// установить значение ключа, как вызов деструктор.

    lua_settable(L, -3);// установить таблицу.
    b** c = (b**)lua_newuserdata(L, sizeof(b*));/*Эта функция выделяет новый блок памяти с заданным размером,*/
    *c = new b();
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/

    lua_setmetatable(L, -2); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.

    return 1;
};
int show(lua_State* L) {
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    a** st = (a**)lua_touserdata(L, -2);// получаем польз. данные.
    a *b = &**st;
    b->show();// вызов метода.
    return 0;
};
int get(lua_State* L) {
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    a** st = (a**)lua_touserdata(L, -2);// получаем польз. данные.
    a *b = &**st;
    b->get();// вызов метода.
    return 0;
};

int geta(lua_State* L) {
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    b** st = (b**)lua_touserdata(L, -2);// получаем польз. данные.
    b *c = &**st;
    c->get();// вызов метода.
    return 0;
};

int main() {
    lua_State* L = luaL_newstate();
    lua_register(L, "create", create);//уст указатель на функцию C++ и создает внутри Lua
    lua_register(L, "create1", create1);//уст указатель на функцию C++ и создает внутри Lua
    lua_register(L, "show", show); //получает значение из стека и уст значение global name.
    lua_register(L, "get", get); //получает значение из стека и уст значение global name.
    lua_register(L, "geta", geta); //получает значение из стека и уст значение global name.
    lua_register(L, "__gc", destroy); //получает значение из стека и уст значение global name.
    luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.

    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}





lua
a1 = create()
show(a1)
get(a1)
a2 = create1()
show(a2)
geta(a2)
a3 = create()
show(a3)

Выводится


create object 0157AE00

object - 0157AE00       x = 10


get

create object b01582220

object - 01582220       x = 10


geta

create object 0157FDA0

object - 0157FDA0       x = 10

destroy
destory object 0157FDA0

destroy
destory object 01582220

destroy
destory object 0157AE00





api lua c++. Реализация ООП через функции. Структура, конструктор с парамертами.

struct a {  int x = 10;
a() { this->x = x; cout << "create object " << this << endl;}//конструктор по умолчанию

a(int x) { this->x = x; cout << "create object " << this << endl; }//конструктор с параметрами.
void show() { cout << "\nobject - " << this << "\nx = " << x << endl; }//вывести значение x на экран.

~a() { cout << "destory object " << this << endl << endl; }//вызов деструктора.
};
int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
    a* st = (a*)lua_touserdata(L, -1);/* Если значение в данном приемлемом индексе является полными данными пользователя.*/
    st->~a();//вызов метода деструктор.
    return 0;};

int create(lua_State* L) {//    Функция создания объекта структуры.
    void* st = lua_newuserdata(L, sizeof(a));/*Эта функция выделяет новый блок памяти с заданным размером,*/

    if (LUA_TNUMBER == lua_type(L, -2)) {// значение число.
        int x = lua_tointeger(L, -2);
        new (st) a(x);// Выделить память под польз. данные.
        luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
        lua_setmetatable(L, -2);//получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
    }
    else {  new (st) a();// Выделить память под польз. данные.
        luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
        lua_setmetatable(L, -2);};//получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
    return 1;};

int show(lua_State* L) {
    a* st = (a*)lua_touserdata(L, -1);// получаем польз. данные.
    st->show();// вызов метода.
    return 0;};

int main() {
    lua_State* L = luaL_newstate();
    lua_newtable(L);
    lua_pushcfunction(L, create);//уст указатель на функцию C++ и создает внутри Lua
    lua_setglobal(L, "get"); //получает значение из стека и уст значение global name.
    lua_pushcfunction(L, show);
    lua_setglobal(L, "show"); //получает значение из стека и уст значение global name.
    luaL_newmetatable(L, "mt");/*int luaL_newmetatable (lua_State * L, const char * t); */
    lua_pushstring(L, "__gc");
    lua_pushcfunction(L, destroy);
    lua_settable(L, -3);
    luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
return 0;
}

Lua
a1 = get()
show(a1)
a2 = get(2)
show(a2)
a3 = get(3)
show(a3)

struct a {
    int x = 10;
    a() { cout << "create object " << this << endl; }//конструктор по умолчанию

    void show() { cout << "\nobject - " << this << "\tx = " << x <<"\n\n"; }//вывести значение x на экран.

    ~a() { cout << "destory object " << this << endl << endl; }//вызов деструктора.
};

int create(lua_State* L) {//    Функция создания объекта структуры.
    a** c = (a**)lua_newuserdata(L, sizeof(a*));/*Эта функция выделяет новый блок памяти с заданным размером,*/
    *c = new a();
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    lua_setmetatable(L, -1); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.

return 1;
};
 int show(lua_State* L) {
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/

    a** st = (a**)lua_touserdata(L, -2);// получаем польз. данные.
    (*st)->show();// вызов метода.
    a *b = &**st;
    b->show();// вызов метода.
    return 0;
};

int main() {
    lua_State* L = luaL_newstate();
    lua_register(L, "create", create );//уст указатель на функцию C++ и создает внутри Lua
    lua_register(L, "show", show); //получает значение из стека и уст значение global name.
    luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}

Вариант 2.


struct a{int x=0;
  a() : x() { cout <<"create object "<< this << endl; }//конструктор по умолчанию

    void set(int x){this->x = x;}//уст значение x.

    void show() {cout << "object - " << this << " x = " << x << endl;}
    //вывести значение x на экран.
    ~a() {cout <<"destory object "<< this << endl;  }//вызов деструктора.
};

int create(lua_State* L){// Функция создания объекта структуры.
    void* pointerToAa = lua_newuserdata(L, sizeof(a));/*Эта функция выделяет новый блок памяти с заданным размером,
помещает в стек новые полные пользовательские данные с адресом блока и возвращает этот адрес. Пользовательские данные
представляют значения C в Lua. Полный UserData представляет собой блок памяти. Это объект (например, таблица):
вы должны создать его, у него может быть свой собственный метатабль, и вы можете определить, когда он собирается.
Полные пользовательские данные равны только себе (при необработанном равенстве). Когда Lua собирает полные данные
пользователя с gcметаметодом, Lua вызывает метаметод и помечает данные пользователя как завершенные.
Когда эти пользовательские данные собираются снова, Lua освобождает соответствующую память.*/
    new (pointerToAa) a();// Выделить память под польз. данные.
    luaL_getmetatable(L, "aMetaTable"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.
    Если индекс не является действительным, или если значение не имеет метатаблицы, функция возвращает 0 и не отправляет ничего в стеке.*/
    lua_assert(lua_istable(L, 2));//ловит исключения если ли условия ложное.
    lua_setmetatable(L, 1);//получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
    return 1;
};

int destroy(lua_State* L){// Функция вызывает деструктор для объекта.
    a* st = (a*)lua_touserdata(L, 1);/* Если значение в данном приемлемом индексе является полными данными пользователя,
    возвращает адрес его блока. Если значение является легким userdata, возвращает его указатель.В противном случае возвращается NULL.*/
    st->~a();//вызов метода деструктор.
    return 0;};

int set(lua_State* L){
    a* st = (a*)lua_touserdata(L, 1);
    lua_Number x = lua_tonumber(L, 2);
    st->set((int)x);
    return 0;};

int show(lua_State* L){
    a* st = (a*)lua_touserdata(L, 1);
    st->show();
    return 0;};

int index(lua_State* L){
    lua_assert(lua_isuserdata(L, 1));
    lua_assert(lua_isstring(L, 2));

    a* st = (a*)lua_touserdata(L, 1);
    const char* index = lua_tostring(L, 2);
    if (strcmp(index, "x") == 0){
        lua_pushnumber(L, st->x);
        return 1;   }
    else{lua_getglobal(L, "a");
        lua_pushstring(L, index);
        lua_rawget(L, 3);// Аналогично lua_settable, но делает необработанное назначение(т.Е.Без метаметодов).
        return 1;   }
};

int newindex(lua_State* L){
    lua_assert(lua_isuserdata(L, -3));
    lua_assert(lua_isstring(L, -2));//
    a* st = (a*)lua_touserdata(L, -3);
    const char* index = lua_tostring(L, -2);
    if (strcmp(index, "x") == 0){
        st->x = (int)lua_tonumber(L, -1);   }
    else{lua_assert(false); }
    return 0;
};

int main() {
    lua_State* L = luaL_newstate();
    lua_newtable(L);
    int stTableIdx = lua_gettop(L);
    lua_pushvalue(L, stTableIdx);// отправляет копию элемента с заданным допустимым индексом в стек.
    lua_setglobal(L, "a");// Установить значение глобальной переменной.

    lua_pushcfunction(L, create);/* отправляет функцию C в стек. функция получает указатель на функцию C и отправляет в стек
     значение типа Lua, function которое при вызове вызывает соответствующую функцию C.   Любая функция, которая должна быть
     зарегистрирована в Lua, должна следовать правильному протоколу, чтобы получать свои параметры и возвращать свои результаты*/
    lua_setfield(L, 1, "new");/*(lua_State * L, int index, const char * k); Соответствует ли t[k] = v, где t значение данного
    заданного допустимого индекса и vзначение в верхней части стека. Эта функция извлекает значение из стека. Как и в Lua,
    эта функция может запускать метаметод для события «newindex» (см. §2.8 ). уст ключ для new.   */
    lua_pushcfunction(L, set);
    lua_setfield(L, 1, "set");
    lua_pushcfunction(L, show);
    lua_setfield(L, 1, "show");

    luaL_newmetatable(L, "aMetaTable");/*int luaL_newmetatable (lua_State * L, const char * t); Если в реестре уже есть ключ t,
     возвращает 0. В противном случае создает новую таблицу, которая будет использоваться в качестве метатаблицы
     для пользовательских данных, добавляет ее в реестр с ключом tnameи возвращает 1. В обоих случаях помещает в стек
     окончательное значение, связанное с t реестром.*/
    lua_pushstring(L, "__gc");
    lua_pushcfunction(L, destroy);
    lua_settable(L, 2);

    lua_pushstring(L, "__index");
    lua_pushcfunction(L, index);
    lua_settable(L, 2);

    lua_pushstring(L, "__newindex");
    lua_pushcfunction(L, newindex);
    lua_settable(L, 2);

    int x = luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.

    if (x == LUA_OK) {  lua_close(L);// если поллучилось открыть файл.
        cin.get();}//ожидает ввода символа программа завершается.

    else {  cout << "Error: "<<lua_tostring(L, -1)<<endl;
        lua_close(L);// закрыть состояние
        cin.get();//ожидает ввода символа программа завершается.
        return 0;   }
}
Lua
st = a.new()
--st:show()
st:set(100)
st:show()
st1 = a.new()
st1:set(200)
st1:show()



выделение памяти.

struct ArenaAllocator
{
    void* m_begin;
    void* m_end;
    char* m_curr;


    ArenaAllocator(void* begin, void* end) :
        m_begin(begin),
        m_end(end),
        m_curr(static_cast<char*>(m_begin) )
    {   }

    void* Allocate(size_t sizeBytes){
        assert(m_curr + sizeBytes < m_end);
        printf("-- allocated from the freelist --\n");
        void* ptr = m_curr;
        m_curr += sizeBytes;
        return ptr;
    }

    void DeAllocate(void* ptr, size_t osize)    {
        assert(ptr != nullptr);     //can't decallocate null!!!
        printf("DeAllocated %d bytes\n", (int)osize);
    }

    void* ReAllocate(void* ptr, size_t osize, size_t nsize){
        printf("ReAllocated %d bytes\n", (int)nsize);
        void* newPtr = Allocate(nsize);
        memcpy(newPtr, ptr, osize);
        DeAllocate(ptr, osize);
        return newPtr;
    }

    static void *l_alloc(void *ud, void *ptr, size_t osize, size_t nsize) {
        ArenaAllocator * pool = static_cast<ArenaAllocator *>(ud);
        if (nsize == 0)
        {
            if (ptr != nullptr)
            {
                pool->DeAllocate(ptr, osize);
            }
            return NULL;
        }
        else
        {
            if (ptr == nullptr)
            {
                return pool->Allocate(nsize);
            }
            else
            {
                return pool->ReAllocate(ptr, osize, nsize);
            }
        }
    }
};
int main() {
    constexpr int pool_size = 1024 * 10;
    char memory[pool_size];
    ArenaAllocator pool(memory, &memory[pool_size-1]);

    lua_State *L = lua_newstate(ArenaAllocator::l_alloc, &pool);
    //luaL_openlibs(L);
    assert(L != nullptr);
    lua_close(L);
    //cin.get();//ожидает ввода символа программа завершается.
    return 0;
}



Нативнный код, позволяет писать lua скрипт в cpp файле, мы можем вносит в него изменения не переключаясь на lua файл, однако изменения, требуют собрать проект заново.

Определение типа переменной и вывод ее на экран.

void showstack(lua_State* L) {
    int i = lua_gettop(L);/* получаем количество элементов в стеке.*/
    cout << "\n  the number on the stack = " << i << "\n\n\n";
    int j = (i) * -1-1;
    i = -1;
    for (i; i > j; i--) {
        int t = lua_type(L, i);
        cout << "\t " << i << "  " << (j - i) * -1 << "\t";
        if (LUA_TSTRING == t) {
            cout << lua_tostring(L, i) << endl;
        }
        if (LUA_TNUMBER == t) {
            double x = lua_tonumber(L, i);
            int x2 = (int)x;
            if (x == x2) { cout << x2 << endl; }
            else { cout << x << endl; }
        }
        if (LUA_TBOOLEAN == t) {cout << "LUA_TBOOLEAN "<< lua_toboolean(L, i) << endl;      }

        if (LUA_TLIGHTUSERDATA == t) {  cout << "LIGHTUSERDATA " << endl;       }

       if (LUA_TTABLE == t) {   cout << "LUA_TTABLE " << endl;  }

        if (LUA_TFUNCTION == t) {   cout << "LUA_TFUNCTION " << endl;   }

        if (LUA_TUSERDATA == t) {cout << "LUA_TUSERDATA " << endl;  }

        if (LUA_TTHREAD == t) { cout << "LUA_TTHREAD " << endl;     }

        if (LUA_TNIL == t) {cout << "LUA_TNIL " << endl;        }
    }
};

void getvar(lua_State* L, const char* var) {
    lua_getglobal(L, var);// получить значение глобальной переменной x.
    if (LUA_TSTRING == lua_type(L, -1)) {
        cout << "string " << var << " = " << lua_tostring(L, -1);
    }
    if (LUA_TNUMBER == lua_type(L, -1)) {
        double x = lua_tonumber(L, -1);
        int x2 = (int)x;
        if (x == x2) { cout << "number int " << var << " = " << x2; }
        else { cout << "number double " << var << " = " << x; }
    }
    if (LUA_TBOOLEAN == lua_type(L, -1)) {
        cout << "bool " << var << " = " << (lua_toboolean(L, -1) ? "true " : "false ");
    }
    if (LUA_TTABLE == lua_type(L, -1)) {
        cout << "LUA_TTABLE " << var << " = " << endl;
    }
    if (LUA_TFUNCTION == lua_type(L, -1)) {
        cout << "LUA_TFUNCTION " << var << " = " << endl;
    }
    if (LUA_TNIL == lua_type(L, -1)) { // если var нет.
        cout << "not " << var;
    }
    cout << endl;
};

void getstack(lua_State* L, int pos) {// Посмотреть позицию в стеке.
    if (LUA_TSTRING == lua_type(L, pos)) {
        cout << lua_tostring(L, pos);
    }
    if (LUA_TNUMBER == lua_type(L, pos)) {
        double x = lua_tonumber(L, pos);
        int x2 = (int)x;
        if (x == x2) { cout << x2; }
        else { cout << x; }
    }
    if (LUA_TBOOLEAN == lua_type(L, pos)) {
        cout << (lua_toboolean(L, pos) ? "true " : "false ");
    }
    if (LUA_TTABLE == lua_type(L, pos)) {
        cout << "LUA_TTABLE " << endl;
    }
    if (LUA_TLIGHTUSERDATA == lua_type(L, pos)) {
        cout << "LIGHTUSERDATA " << endl;
    }
    if (LUA_TTABLE == lua_type(L, pos)) {
        cout << "LUA_TTABLE " << endl;
    }
    if (LUA_TFUNCTION == lua_type(L, pos)) {
        cout << "LUA_TFUNCTION " << endl;
    }
    if (LUA_TUSERDATA == lua_type(L, pos)) {
        cout << "LUA_TUSERDATA " << endl;
    }
    if (LUA_TTHREAD == lua_type(L, pos)) {
        cout << "LUA_TTHREAD " << endl;
    }
    if (LUA_TNIL == lua_type(L, pos)) {
        cout << "nill " << endl;// если NILL.
    }
};

int checkerror(lua_State* L, const char* file) {
    int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
    try {
        if (luaL_dostring(L, file) == LUA_OK) {
            return 0;
        }
        else {
            string x = lua_tostring(L, -1);
            throw x;
            return 0;
        }
    }
    catch (string x) {
        cout << x << endl;
        //luaL_error(L,"error");
        return 0;
    }
};

template <class T>//любое значение отправить в стек.
void pushlua(lua_State * L, const T & value) {
    if constexpr (std::is_same_v<T, std::string>)
        lua_pushstring(L, value.c_str());
    else if constexpr (std::is_array_v<T> && std::is_same_v<std::remove_extent_t<T>, char>)
        lua_pushstring(L, value);
    else if constexpr (std::is_same_v<T, int>)
        lua_pushinteger(L, value);
    else if constexpr (std::is_same_v<T, double>)
        lua_pushnumber(L, value);
    else if constexpr (std::is_same_v<T, bool>)
        lua_pushboolean(L, value);
    else
        std::cerr << "I do not know what to do :(" << std::endl;
};
template <class t1, class t2>
void addkeyintab(lua_State* L, t1 key, t2 value) {
    /* Устанавливает реальное значение t[i] = value  как value, без вызова метаметода. t это таблица, i - любым числом, отличным от nil и NaN,
    а value - значение. Данная функция возвращает table. */
    if (std::is_same_v<t1, const char*> && std::is_same_v<t2, int>) {
        cout << "key string " << key << " int " << value << endl;
        const char* key1 = (const char*)key;
        int value1 = (int)value;
        lua_pushstring(L, key1); /* отправить ключ в стек */
        lua_pushinteger(L, value1); /* отправить значение ключа в стек. */
        lua_rawset(L, -3);  } /*Сохраняет пару в таблице */

    else if (std::is_same_v<t1, int> && std::is_same_v<t2, const char*>) {
        cout << "key int " << key << " string " << value << endl;
        int key1 = (int)key;
        const char* value1 = (const char*)value;
        lua_pushinteger(L, key1); /* отправить ключ в стек */
        lua_pushstring(L, value1); /* отправить значение ключа в стек. */
        lua_rawset(L, -3);  } /*Сохраняет пару в таблице */

    else if (std::is_same_v<t1, const char*> && std::is_same_v<t2, const char*>) {
        cout << "key string " << key << " value string " << value << endl;
        const char* key1 = (const char*)key;
        const char* value1 = (const char*)value;
        lua_pushstring(L, key1); /* отправить ключ в стек */
        lua_pushstring(L, value1); /* отправить значение ключа в стек. */
        lua_rawset(L, -3);} /*Сохраняет пару в таблице */

    else if (std::is_same_v<t1, int> && std::is_same_v<t2, int>) {
        cout << "key int " << key << " value int " << value << endl;
        int key1 = (int)key;
        int value1 = (int)value;
        lua_pushinteger(L, key1); /* отправить ключ в стек */
        lua_pushinteger(L, value1); /* отправить значение ключа в стек. */
        lua_rawset(L, -3); /*Сохраняет пару в таблице */
    }
};

int main(int argc, char *argv[]) {
    const char* LUA = R"(
x = true
)";
    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    checkerror(L, LUA);//Функция проверка на ошибки.
    getvar(L, "x");

    lua_close(L);

    return 0;


Присвоение значения переменной через отправку в стек.

int main(int argc, char *argv[]) {
    const char* LUA = R"(
print(c)

)";
    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    pushlua(L, 12);
    lua_setglobal(L, "c");// уст значение переменной в lua.
    checkerror(L, LUA);//Функция проверка на ошибки.

    lua_close(L);

    return 0;
}


Вызов функции в нативном коде через получение переменной.

int main(int argc, char *argv[]) {
const char* LUA = R"(
  function foo()
   return 4
  end )";
    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    checkerror(L, LUA);//Функция проверка на ошибки.
    lua_getglobal(L, "foo");

    if (lua_isfunction(L, -1)) {
        lua_pcall(L, 0, 1, 0);
        cout << lua_tonumber(L, -1) << endl;    }
    lua_close(L);
    return 0;
}

Вызов функции в нативном коде через присвоение.

int foo(lua_State *L) {
    cout << "hi foo c++" << endl;
    return 0;
};

int main(int argc, char *argv[]) {
    const char* LUA = R"(
foo()

)";
    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_pushcfunction(L, foo);// отправить c функцию в стек.

    lua_setglobal(L, "foo");// уст для переменной значение в виде функции.

    checkerror(L, LUA);//Функция проверка на ошибки.

    lua_close(L);

    return 0;
};

Вызов функции в нативном коде через отправку в таблицу.

int foo(lua_State *L) {
    cout << "hi foo c++" << endl;
    return 0;
}

int main(int argc, char *argv[]) {
    const char* LUA = R"(
foo()
)";
    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_newtable(L); /*создать пустую таблицу */
    lua_pushcfunction(L, foo);// отправить c функцию в стек как ключ.
    lua_setglobal(L, "foo");// уст для переменой(ключ) значение в новой пустой таблицы в виде функции.

    checkerror(L, LUA);//Функция проверка на ошибки.

    lua_close(L);

    return 0;
};


Вызов функции с параметром в нативном коде через отправку в таблицу.

int foo(lua_State *L) {
    int x = lua_tointeger(L, -1);
    pushlua(L, x * 2);

return 1;
}

int main(int argc, char *argv[]) {
    const char* LUA = R"(
g=foo(12)
print(g)
)";
    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_newtable(L); /*создать пустую таблицу */
    lua_pushcfunction(L, foo);// отправить c функцию в стек.
    lua_setglobal(L, "foo");// уст для переменой(ключ) значение в новой пустой таблицы в виде функции.

    checkerror(L, LUA);//Функция проверка на ошибки.

    lua_close(L);

    return 0;
};

Таблица в стеке, добавления в нее элементов.

int main(int argc, char *argv[]) {
    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_newtable(L);
    lua_pushstring(L, "key");
    lua_pushnumber(L, 100);
    lua_rawset(L,-3);

    lua_pushstring(L, "key");
    lua_gettable(L, -2);
   cout << lua_tonumber(L,-1) << endl; //Функция 100.

    lua_close(L);

    return 0;
};

Вариант 2.

int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_newtable(L);
    lua_pushnumber(L, 100);
    lua_setfield(L, -2, "key");// уст в таблицу ключ - key со значение 100.

    pushlua(L, "key");
    lua_gettable(L, -2);
    getlaststack(L); //Функция 100.

    lua_close(L);

    return 0;
};

Добавление следующего ключа со значением в таблицу.

int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_newtable(L);

    pushlua(L, "key");
    pushlua(L, 100);
    lua_rawset(L, -3);// table["key"] = 100.

    pushlua(L, "a");
    pushlua(L, 6);
    lua_rawset(L, -3);// table["a"] = 6.


    pushlua(L, "a");
    lua_gettable(L, -2);
    getlaststack(L); // 6.

    lua_close(L);

    return 0;
};


Функция добавление в таблицу нового ключа со значением.

template <class t1, class t2>
void addkeyintab(lua_State* L, t1 key, t2 value) {
    /* Устанавливает реальное значение t[i] = value  как value, без вызова метаметода. t это таблица, i - любым числом, отличным от nil и NaN,
    а value - значение. Данная функция возвращает table. */
    if (std::is_same_v<t1, const char*> && std::is_same_v<t2, int>) {
        cout << "key string " << key << " value int " << value << endl;
        const char* key1 = (const char*)key;
        int value1 = (int)value;
        lua_pushstring(L, key1); /* отправить ключ в стек */
        lua_pushinteger(L, value1); /* отправить значение ключа в стек. */
        lua_rawset(L, -3);  } /*Сохраняет пару в таблице */

    else if (std::is_same_v<t1, int> && std::is_same_v<t2, const char*>) {
        cout << "key int " << key << " value string " << value << endl;
        int key1 = (int)key;
        const char* value1 = (const char*)value;
        lua_pushinteger(L, key1); /* отправить ключ в стек */
        lua_pushstring(L, value1); /* отправить значение ключа в стек. */
        lua_rawset(L, -3);  } /*Сохраняет пару в таблице */

    else if (std::is_same_v<t1, const char*> && std::is_same_v<t2, const char*>) {
        cout << "key string " << key << " value string " << value << endl;
        const char* key1 = (const char*)key;
        const char* value1 = (const char*)value;
        lua_pushstring(L, key1); /* отправить ключ в стек */
        lua_pushstring(L, value1); /* отправить значение ключа в стек. */
        lua_rawset(L, -3);} /*Сохраняет пару в таблице */

    else if (std::is_same_v<t1, int> && std::is_same_v<t2, int>) {
        cout << "key int " << key << " value int " << value << endl;
        int key1 = (int)key;
        int value1 = (int)value;
        lua_pushinteger(L, key1); /* отправить ключ в стек */
        lua_pushinteger(L, value1); /* отправить значение ключа в стек. */
        lua_rawset(L, -3); /*Сохраняет пару в таблице */
    }
};
int main(int argc, char *argv[]) {
const char* LUA = R"(
print(foo)
for k,v in pairs(foo) do
print(k.." "..v)
end

 )";
    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_newtable(L); /*создать пустую таблицу */
    addkeyintab(L, "a", " 10 z "); /*добавить ключ и значение в таблицу */
    addkeyintab(L, "x1", 99); /*добавить ключ и значение в таблицу */
    addkeyintab(L, 100, 10); /*добавить ключ и значение в таблицу */
    addkeyintab(L, 100, "y"); /*добавить ключ и значение в таблицу */
    lua_setglobal(L, "foo");// уст имя таблицы в lua.
    cout << "\n" << endl;
    checkerror(L, LUA);//Функция проверка на ошибки.

    lua_close(L);
    return 0;
};

Выводится.
key string a value string  10 z
key string x1 int 99
key int 100 value int 10
key int 100 string y


table: 009F0830
100 y
x1 99
a  10 z

C:\Users\e\source\repos\Project1luaapi\Debug\Project1luaapi.exe (процесс 6000) завершает работу с кодом 0.
Чтобы закрыть это окно, нажмите любую клавишу…



Функция возвращает таблицу с ключами в качестве функциями.

int square(lua_State* L) {//    Функция создания объекта структуры.
    cout << lua_tonumber(L,-1)*2 << endl;
    return 0;
};
int cube(lua_State* L) {//  Функция создания объекта структуры.
    cout << lua_tonumber(L, -1) * 3 << endl;
    return 0;
};


int create(lua_State* L) {//    Функция создания объекта структуры.
    lua_newtable(L);
    lua_pushcfunction(L, square);
    lua_setfield(L, -2, "square");
    lua_pushcfunction(L, cube);
    lua_setfield(L, -2, "cube");
    return 1;
};

int main(int argc, char* argv[]) {
const char* LUA = R"(

a = create()
a.square(5) --10
a.square(10)--20
a.cube(4)--12
a.cube(6)--18
print(a)
)";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_pushcfunction(L, create);/* отправляет функцию C в стек. функция получает указатель на функцию C и отправляет в стек*/
    lua_setglobal(L, "create");

    checkerror(L, LUA);//Функция проверка на ошибки.

    lua_close(L);

    return 0;
};


Вывод всех ключей и значений неизвестной таблицы.

int pri(lua_State* L, const char t[]) {
    lua_getglobal(L, t);// получить значение глобальной переменной, таблица.
    lua_pushvalue(L, -1);
    lua_pushnil(L);
    while (lua_next(L, -2)) {
        lua_pushvalue(L, -2);
        cout << "key "; getstack(L, -1); cout << " value "; getstack(L, -2); cout << endl;
        lua_pop(L, 2);
    }
    lua_pop(L, 1);
    return 0;
};
int main() {
    const char* LUA = R"(
t= {x=10, y=20, z=30}
)";

    lua_State* L = luaL_newstate();
    luaL_openlibs(L);

    checkerror(L, LUA);//Функция проверка на ошибки.
    pri(L, "t");// вывести ключи и значения таблицы.

    lua_close(L);// закрыть состояние
    return 0;
};

Сохранение всех ключей таблицы в реестре.

int pritab(lua_State* L, const char t[]) {
    int x = 0;
    lua_getglobal(L, t);// получить значение глобальной переменной, таблица.
    lua_pushvalue(L, -1);
    lua_pushnil(L);
    while (lua_next(L, -2)) {
    //. cout << " key ";
        lua_pushvalue(L, -2);
        lua_rawseti(L, LUA_REGISTRYINDEX, x);
        //getstack(L, -2);
        lua_pushvalue(L, -2);
        //cout << "key "; getstack(L, -1); cout << " value "; getstack(L, -2); cout << endl;
        lua_pop(L, 2);
        x++;
    }
    lua_pop(L, 1);
    pushlua(L, x);
    return 1;
};
int main() {
    const char* LUA = R"(
t= {x=10, y=20, z=30}
)";

    lua_State* L = luaL_newstate();
    luaL_openlibs(L);

    checkerror(L, LUA);//Функция проверка на ошибки.
    pritab(L, "t");// вывести ключи и значения таблицы.
    int len = lua_tointeger(L,-1);
    for (int i = 0; i < len; i++){
    lua_rawgeti(L, LUA_REGISTRYINDEX, i);/* вернуть значение для ключа в реестр. */
    cout << "key "; getstack(L, -1);  cout << endl;}
    lua_close(L);// закрыть состояние
    return 0;
};

Вывод всех значений ключей из реестра.

int pritab(lua_State* L, const char t[]) {
    int x = 0;
    lua_getglobal(L, t);// получить значение глобальной переменной, таблица.
    lua_pushvalue(L, -1);
    lua_pushnil(L);
    while (lua_next(L, -2)) {
        //. cout << " key ";
        lua_pushvalue(L, -2);
        lua_rawseti(L, LUA_REGISTRYINDEX, x);
        //getstack(L, -2);
        lua_pushvalue(L, -2);
        //cout << "key "; getstack(L, -1); cout << " value "; getstack(L, -2); cout << endl;
        lua_pop(L, 2);
        x++;
    }
    lua_pop(L, 1);
    pushlua(L, x);
    return 1;
};
int main() {
    const char* LUA = R"(
t= {x=10, y=20, z=30}
)";

    lua_State* L = luaL_newstate();
    luaL_openlibs(L);

    checkerror(L, LUA);//Функция проверка на ошибки.
    pritab(L, "t");// вывести ключи и значения таблицы.
    int len = lua_tointeger(L, -1);
    lua_pop(L, 1);
    for (int i = 0; i < len; i++) {
        lua_rawgeti(L, LUA_REGISTRYINDEX, i);/* вернуть значение для ключа в реестр. */

        cout << "key "; getstack(L, -1);

        lua_getglobal(L, "t");
        lua_pushvalue(L, -2);
        lua_gettable(L, -4);
        cout << " value "; getstack(L, -1);  cout << endl;
        lua_pop(L, 3);

    }
    lua_close(L);// закрыть состояние
    return 0;
};


Отправить в стек таблицу.

int rettab(lua_State* L) {// Функция отправить в стек таблицу.
    lua_newtable(L);
    for (int i = 1; i < 10; i++){
    pushlua(L, i);
    pushlua(L, i*10);
    lua_rawset(L, -3);
    }
    return 1;
};

int main(int argc, char* argv[]) {
    const char* LUA = R"(

a = rettab()
print(a[3]) --30
)";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_pushcfunction(L, rettab);/* отправляет функцию C в стек. функция получает указатель на функцию C и отправляет в стек*/
    lua_setglobal(L, "rettab");

    checkerror(L, LUA);//Функция проверка на ошибки.

    lua_close(L);

    return 0;
};

Отправить таблицу в функцию.

int readtab(lua_State* L) {// Функция отправить в стек таблицу.
    if (LUA_TTABLE == lua_type(L, -1)) {

        lua_pushinteger(L, 1);

        lua_gettable(L, -2);
        int x = lua_tointeger(L, -1);
        getstack(L, -1); cout << endl;
        lua_pop(L, 1);
        lua_pushinteger(L, 2);
        lua_gettable(L, -2);
        int y = lua_tointeger(L, -1);
        getstack(L, -1); cout << endl;
        lua_pop(L, 1);
        lua_pushinteger(L, 3);
        lua_gettable(L, -2);
        int z = lua_tointeger(L, -1);
        getstack(L, -1); cout << endl;
        lua_pop(L, 1);

    }
    return 0;
};

int main(int argc, char* argv[]) {
    const char* LUA = R"(
t = {10,20,30}
 readtab(t)
)";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_pushcfunction(L, readtab);/* отправляет функцию C в стек. функция получает указатель на функцию C и отправляет в стек*/
    lua_setglobal(L, "readtab");

    checkerror(L, LUA);//Функция проверка на ошибки.

    lua_close(L);

    return 0;
};


Модуль с. Писать модули для lua на c++.

int q(lua_State* L) {
    int d = lua_tonumber(L, -1);
    pushlua(L, d * 2);
    return 1; /*число умножено на 2*/
}
int foo(lua_State * L) {
    int d = lua_tonumber(L, -1);
    pushlua(L, d * 3);
    return 1; /*число умножено на 3*/
}
 struct luaL_Reg mylib[] = {
    { "q", q },{ "foo", foo }, { NULL, NULL } /*регистрация функций, на вершину отправим NULL NULL*/
};

int lua_lib(lua_State * L) {
    luaL_newlib(L, mylib);/*void luaL_newlib (lua_State * L, const luaL_Reg lib []); Создает новую таблицу и
      регистрирует там свои функции в списке lib. Это реализовано в виде следующего макроса:
  (luaL_newlibtable (L, lib), luaL_setfuncs (L, l, 0))
  Массив lib должен быть фактическим массивом, а не указателем на него.*/
  return 1;
}

int main(int argc, char* argv[]) {
    const char* LUA = R"(
 mylib = require 'mylib'
print(mylib.q(2))
print(mylib.foo(2)) )";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    luaL_requiref(L, "mylib", lua_lib, 1);/* модуль. void luaL_requiref (lua_State * L, const char * modname,
 lua_CFunction cfunc, int glb); Если modname еще нет, package.loaded, вызывает функцию cfunc со строкой modname
 в качестве аргумента и устанавливает результат вызова package.loaded[modname], как если бы эта функция была вызвана
 require. Если glb это правда, также сохраняет модуль в глобальном modname. Оставляет копию модуля в стеке.*/
    checkerror(L, LUA);//Функция проверка на ошибки.

    return 0;
};


Реестр глобальная таблица.


int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    pushlua(L, 9);//отправить значение для ключа 12.
    lua_rawseti(L, LUA_REGISTRYINDEX, 12);// отправить ключ в реестре. установить ключ со значение в реестр.

    lua_rawgeti(L, LUA_REGISTRYINDEX, 12);/* вернуть значение для ключа в реестр. */
    getlaststack(L);// 9

    lua_close(L);

    return 0;
};


Реестр передача значение между функциями.

int show(lua_State* L) {
    lua_rawgeti(L, LUA_REGISTRYINDEX, 12);/* вернуть значение для ключа в реестр. */
    getlaststack(L);// 100
    return 0;
};
int create(lua_State * L) {//   Функция создания объекта структуры.
    pushlua(L, 100);//отправить значение для ключа 12.
    lua_rawseti(L, LUA_REGISTRYINDEX, 12);// отправить ключ в реестре. установить ключ со значение в реестр.
    return 0;
};

int main(int argc, char* argv[]) {
    const char* LUA = R"(
create()
show()
)";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_newtable(L);
    lua_pushcfunction(L, create);
    lua_setglobal(L, "create");// уст глоб имя в таблице как С функцию.

    lua_pushcfunction(L, show);
    lua_setglobal(L, "show");

    checkerror(L, LUA);//Функция проверка на ошибки.

    lua_close(L);

    return 0;
};


Реестр, отправка и получение значение по уникальному ключу. В качестве ключей ссылка на псевдоиндекс.


int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    int ref = luaL_ref(L, LUA_REGISTRYINDEX); /*Возвращает ссылку - это уникальный целочисленный ключ. Для значения в реестре*/

    pushlua(L, 9);//отправить значение для ключа ref.
    lua_rawseti(L, LUA_REGISTRYINDEX, ref);// установить ключ со значение в реестр.

    pushlua(L, ref);
    lua_rawgeti(L, LUA_REGISTRYINDEX, ref);/* вернуть значение для ключа в реестр. */
    getlaststack(L);// 9

    lua_close(L);

    return 0;
};


Работа в реестр. Отправка значение переменной в реестр, получение из него.

int main(int argc, char* argv[]) {
    const char* LUA = R"(
x=4
 )";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    checkerror(L, LUA);//Функция проверка на ошибки.
    lua_getglobal(L, "x");
    int ref = luaL_ref(L, LUA_REGISTRYINDEX); /*Создает и возвращает ссылку в таблице в индексе t для объекта на вершине стека(и извлекает объект).
    Ссылка - это уникальный целочисленный ключ. Пока вы не добавляете вручную целочисленные ключи в таблицу t, вы luaL_ref гарантируете уникальность возвращаемого ключа. Вы можете получить объект, на который ссылается ссылка r, вызывая lua_rawgeti(L, t, r).
Функция luaL_unref освобождает ссылку и связанный с ней объект.
    Если объект на вершине стека равен нулю, luaL_ref возвращает константу LUA_REFNIL. Константа LUA_NOREF
гарантированно будет отличаться от любой ссылки, возвращаемой luaL_ref.*/


    lua_rawgeti(L, LUA_REGISTRYINDEX, ref);
    cout <<"x = "<< lua_tonumber(L, -1) << endl;
    lua_rawseti(L, LUA_REGISTRYINDEX, ref);/*
    Функции, которые API предоставляет для работы с массивами:

    void lua_rawgeti (lua_State * L, int index, int key);
    void lua_rawseti (lua_State * L, int index, int key); Описание lua_rawgeti и lua_rawseti немного сбивает с толку,
    поскольку включает в себя два индекса:
    index указывает, где таблица находится в стеке;
    key относится к тому, где элемент находится в таблице.
    Вызов lua_rawgeti(L, t, key) эквивалентен последовательности lua_pushnumber (L, ключ); lua_rawget (L, t);

    когда t положительно (в противном случае вы должны компенсировать новый элемент в стеке).
    Вызов lua_rawseti(L, t, key)(опять же для t положительного) эквивалентен
    lua_pushnumber (L, ключ);
    lua_insert (L, -2); // поставить `ключ 'ниже предыдущего значения
    lua_rawset (L, t); Обратите внимание, что обе функции используют необработанные операции.
    Они быстрее и, в любом случае, таблицы, используемые в качестве массивов, редко используют метаметоды.
     В качестве конкретного примера использования этих функций мы могли бы переписать тело цикла
     из нашей предыдущей l_dirфункции из

        lua_pushnumber (L, i ++); // ключ  /
        lua_pushstring (L, entry-> d_name); / значение /
    lua_settable(L, -3);
                                           */
    luaL_unref(L, LUA_REGISTRYINDEX, ref); // удалить значение по ключу ref.
    cout << lua_tonumber(L, -1) << endl;

    lua_close(L);

    return 0;
};


Выводится.

x = 4
0

Вариант 2.

int main(int argc, char* argv[]) {
    const char* LUA = R"(
x=4
 )";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    checkerror(L, LUA);//Функция проверка на ошибки.
    int ref = luaL_ref(L, LUA_REGISTRYINDEX); /*Создает и возвращает ссылку в таблице в индексе t для объекта на вершине стека(и извлекает объект).*/

    lua_getglobal(L, "x");

    lua_rawseti(L, LUA_REGISTRYINDEX, ref);/* установить в таблице*/

    lua_rawgeti(L, LUA_REGISTRYINDEX, ref);/* получить значение по ключу */
    cout << "x = " ;
    getlaststack(L);

//  luaL_unref(L, LUA_REGISTRYINDEX, ref); // удалить значение по ключу ref.

    lua_rawgeti(L, LUA_REGISTRYINDEX, ref);/*              */
    getlaststack(L);

    lua_close(L);

    return 0;
};


Уникальность ключа в реестре, обеспечивается адресом в памяти переменной.
Использовать lua_settable и lua_gettable.

int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    static char Key = 'k';// лучше стастик переменная.

    lua_pushlightuserdata(L, &Key);  /* отправить адрес памяти переменной в стек */
    lua_pushstring(L, &Key);  /* отправить значение в стек */
    lua_settable(L, LUA_REGISTRYINDEX);  /* уст ключа и значение таблице реестре.  */

    lua_pushlightuserdata(L, &Key);  /*отправить адрес, который является ключом в стек. */
    lua_gettable(L, LUA_REGISTRYINDEX);  /* получить таблицу и значение ключа будет в -1 */
    cout << lua_tostring(L, -1) << endl;// k

    lua_close(L);
    return 0;
};


Реестр способен хранить польз. данные, ключ может их адрес в пямяти.

int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    static char Key = 'k';// лучше стастик переменная.

    lua_pushlightuserdata(L, &Key);  /* отправить адресс в стек */
    lua_rawsetp(L, LUA_REGISTRYINDEX,  &Key);/* Имеет ли эквивалент t[k] = v, где t таблица,
 k указатель, представленный в виде легких пользовательских данных, и v значение в верхней части стека.
 Эта функция извлекает значение из стека. Не вызывает метаметоды.*/

    lua_pushlightuserdata(L, &Key);  /*отправить адресс, который является ключом в стек. */
    lua_rawgetp(L, LUA_REGISTRYINDEX, &Key); /* получить таблицу и значение ключа будет в -1 */

    char* k = (char*)lua_touserdata(L, -1);// получить польз.данные.
    cout << k <<" adress "<< &k << endl;// k.

    lua_close(L);
    return 0;
};

int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

     int Key = 100;// лучше стастик переменная.

    lua_pushlightuserdata(L, &Key);  /* отправить адресс в стек */
    lua_rawsetp(L, LUA_REGISTRYINDEX, &Key);/* Имеет ли эквивалент t[k] = v, где t таблица,
 k указатель, представленный в виде легких пользовательских данных, и v значение в верхней части стека.
 Эта функция извлекает значение из стека. Не вызывает метаметоды.*/

    lua_pushlightuserdata(L, &Key);  /*отправить адресс, который является ключом в стек. */
    lua_rawgetp(L, LUA_REGISTRYINDEX, &Key); /* получить таблицу и значение ключа будет в -1 */

    int* k = (int*)lua_touserdata(L, -1);// получить польз.данные.
    cout << *k << " adress " << &k << endl;// 100.

    lua_close(L);
    return 0;
};

Реестр адрес переменной k ключ.

int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    static char k = 'key';// лучше стастик переменная она выступает ключом в реестре.

    int i = 5;
    lua_pushlightuserdata(L, &i);  /* отправить адрес памяти числа 5 в стек */
    lua_rawsetp(L, LUA_REGISTRYINDEX, &k);  /* уст ключ в реестре адрес k.
 void lua_rawsetp (lua_State * L, int index, const void * p);  Записывает ли эквивалент t[p] = v,
где t таблица с заданным индексом, p как легкие пользовательские данные и v является значением в верхней части стека.

Эта функция извлекает значение из стека. Назначение является необработанным,  */

    lua_pushlightuserdata(L, &i);  /*отправить адрес памяти, который является ключом в стек.*/

    lua_rawgetp(L, LUA_REGISTRYINDEX, &k);/* получить значение по ключу адрес k*/
    int* number = (int*)lua_touserdata(L, -1);// получить польз.данные.

    cout << *number << " adress " << number << endl;// 5.


    lua_close(L);
    return 0;
};

Реестр. Передача значение из функции в ключ возвращаемой таблицы.

int show(lua_State* L) {
    luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
    lua_pushstring(L, "key");//отправить key, чтобы получить ref
    lua_gettable(L, -2);
    int ref = lua_tonumber(L, -1);
    lua_rawgeti(L, LUA_REGISTRYINDEX, ref);/* получить значение по ключу ref.*/

    getlaststack(L);
    return 0;
};
int create(lua_State * L) {//   Функция создания объекта структуры.
    lua_gettable(L, -3);// получить глоб. таблицу.
    luaL_newmetatable(L, "mt");// создать мета таблицу.
    lua_pushcfunction(L, show);
    lua_setfield(L, -2, "show");// ключ таблицы является функцией.
    int ref = luaL_ref(L, LUA_REGISTRYINDEX);// получить уникальный ключ.
    pushlua(L, 5);// значение для ключа. mt.ref = 5.
    lua_rawseti(L, LUA_REGISTRYINDEX, ref); /* уст ключ со значением 5 в реестре адрес. */

    lua_setmetatable(L, -2); //уст метатаблицу.

    lua_gettable(L, -2);// получить таблицу.
    luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/

    lua_pushstring(L, "key");// это ключ для получение ref.
    lua_pushnumber(L, ref);
    lua_rawset(L, -3);

    luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
    return 1;
};

int main(int argc, char* argv[]) {
    const char* LUA = R"(
a = create()
a.show()
)";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_newtable(L);
    lua_pushcfunction(L, create);
    lua_setglobal(L, "create");// уст глоб имя в таблице как С функцию.


    checkerror(L, LUA);//Функция проверка на ошибки.

    lua_close(L);

    return 0;
};

Реестр. Передача числа из функции в ключ возвращаемой таблицы с помощью мета таблицы.

int show(lua_State* L) {
    luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
    lua_pushstring(L, "key");//отправить key, чтобы получить ref
    lua_gettable(L, -2);
    int ref = lua_tonumber(L, -1);
    lua_rawgeti(L, LUA_REGISTRYINDEX, ref);/* получить значение по ключу ref.*/

    getlaststack(L);
    return 0;
};
int create(lua_State * L) {//
    int k = lua_tointeger(L, -1);
    lua_gettable(L, -4);// получить глоб. таблицу.
    luaL_newmetatable(L, "mt");// создать мета таблицу.
    lua_pushcfunction(L, show);
    lua_setfield(L, -2, "show");// ключ таблицы является функцией.
    int ref = luaL_ref(L, LUA_REGISTRYINDEX);// получить уникальный ключ.

    pushlua(L, k);// значение для ключа. mt.ref = 5.
    lua_rawseti(L, LUA_REGISTRYINDEX, ref); /* уст ключ со значением 5 в реестре адрес. */

    lua_setmetatable(L, -2); //уст метатаблицу.

    lua_gettable(L, -3);// получить таблицу.
    luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/

    lua_pushstring(L, "key");// это ключ для получение ref.
    lua_pushnumber(L, ref);
    lua_rawset(L, -3);

    luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
    return 1;
};

int main(int argc, char* argv[]) {
    const char* LUA = R"(
a = create(6)
a.show()
)";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_newtable(L);
    lua_pushcfunction(L, create);
    lua_setglobal(L, "create");// уст глоб имя в таблице как С функцию.


    checkerror(L, LUA);//Функция проверка на ошибки.

    lua_close(L);

    return 0;
};


Реестр хранить мета таблицу с польз.данными.

int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    luaL_newmetatable(L, "mt");// создать мета таблицу.
    luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/

    lua_pushstring(L, "key");// это ключ для получение 5.

    a** c = (a * *)lua_newuserdata(L, sizeof(a*));/*Эта функция выделяет новый блок памяти с заданным размером,*/
    *c = new a();

    lua_rawsetp(L, LUA_REGISTRYINDEX, "mt");  /* уст ключ в реестре адрес k.  */


    lua_pushstring(L, "key");// это ключ для получение объекта.*/
    lua_rawgetp(L, LUA_REGISTRYINDEX, "mt");/* получить значение по ключу key объект*/

    a** st = (a** )lua_touserdata(L, -1);// получаем польз. данные.
    a * b = &**st;
    b->show();// вызов метода.

    b->~a();//вызов метода деструктор.

    lua_close(L);
    return 0;
};

Реестр и метатаблицы, реализация ооп через таблицу с функциями.

struct a {  int x = 10;
    a() { cout << "create object " << this << endl; }//конструктор по умолчанию

    void show() { cout << "\nobject - " << this << "\tx = " << x << "\n\n"; }//вывести значение x на экран.

    ~a() { cout << "destory object " << this << endl << endl; }//вызов деструктора.
};


int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
    lua_pushstring(L, "key");// это ключ для получение объекта.*/
    lua_rawgetp(L, LUA_REGISTRYINDEX, "mt");/* получить значение (объект) по ключу key */
    a** st = (a * *)lua_touserdata(L, -1);// получаем польз. данные.
    a * b = &**st;
    b->~a();//вызов метода деструктор.
    return 0;
};

int show(lua_State * L) {
    lua_pushstring(L, "key");// это ключ для получение объекта.*/
    lua_rawgetp(L, LUA_REGISTRYINDEX, "mt");/* получить значение (объект) по ключу key */
    a** st = (a * *)lua_touserdata(L, -1);// получаем польз. данные.
    a * b = &**st;
    b->show();// вызов метода.
    return 0;
};
int create(lua_State * L) {//   Функция создания объекта структуры.
    lua_newtable(L);
    luaL_newmetatable(L, "mt");// создать мета таблицу.
    lua_pushcfunction(L, destroy);
    lua_setfield(L, -2, "__gc");

    lua_pushstring(L, "key");// это ключ для получение объекта.

    a** c = (a * *)lua_newuserdata(L, sizeof(a*));/*Эта функция выделяет новый блок памяти с заданным размером,*/
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    *c = new a();
    lua_setmetatable(L, -2); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.

    lua_rawsetp(L, LUA_REGISTRYINDEX, "mt");  /* уст ключ в реестре адрес k.  */
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    lua_pushcfunction(L, show);
    lua_setfield(L, -2, "show");

    return 1;
};

int main(int argc, char* argv[]) {
    const char* LUA = R"(

a = create()
a.show()

)";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_pushcfunction(L, create);
    lua_setglobal(L, "create");//уст указатель на функцию C++ и создает внутри Lua

    checkerror(L, LUA);//Функция проверка на ошибки.

    lua_close(L);

    return 0;
};


Метатаблица, передача значение между функциями.


int show(lua_State* L) {
    luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
    lua_pushstring(L, "key");//отправить key, чтобы получить ref
    lua_gettable(L, -2);
    cout << lua_tonumber(L, -1) << " == 5" << endl;//должно быть 5.
    return 0;
};
int create(lua_State * L) {//   Функция создания объекта структуры.
    luaL_newmetatable(L, "mt");// создать мета таблицу.
    luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/

    lua_pushstring(L, "key");// это ключ для получение 5.
    lua_pushnumber(L, 5);// значение ключа key это 5.
    lua_settable(L, -3);// установить таблицу.
    return 1;
};

int main(int argc, char* argv[]) {
    const char* LUA = R"(
create()
show()
)";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_newtable(L);
    lua_pushcfunction(L, create);
    lua_setglobal(L, "create");// уст глоб имя в таблице как С функцию.

    lua_pushcfunction(L, show);
    lua_setglobal(L, "show");

    checkerror(L, LUA);//Функция проверка на ошибки.

    lua_close(L);

    return 0;
};


Метатаблица, передача польз.данных(объекта структуры) между функциями.


struct a {
    int x = 10;
    a() { cout << "create object " << this << endl; }//конструктор по умолчанию

    void show() { cout << "\nobject - " << this << "\tx = " << x << "\n\n"; }//вывести значение x на экран.

    ~a() { cout << "destory object " << this << endl << endl; }//вызов деструктора.
};

int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
    cout << "destroy " << endl;
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    a** st = (a * *)lua_touserdata(L, -2); // получаем польз. данные.
    a * b = &**st;
    b->~a();//вызов метода деструктор.
    return 0;

};

int show(lua_State* L) {
    luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
    lua_pushstring(L, "key");//отправить key, чтобы получить объект.
    lua_gettable(L, -2);
    a** st = (a * *)lua_touserdata(L, -1);// получаем польз. данные.
    a * b = &**st;
    b->show();// вызов метода.
    b->~a();//вызов метода деструктор.

    return 0;
};
int create(lua_State * L) {//   Функция создания объекта структуры.
    luaL_newmetatable(L, "mt");// создать мета таблицу.
    luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/

    lua_pushstring(L, "key");// это ключ для получение 5.

    a** c = (a **)lua_newuserdata(L, sizeof(a*));/*Эта функция выделяет новый блок памяти с заданным размером,*/
    *c = new a();

    lua_settable(L, -3);// установить таблицу.
    return 1;
};

int main(int argc, char* argv[]) {
    const char* LUA = R"(
create()
show()
)";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_newtable(L);
    lua_pushcfunction(L, create);
    lua_setglobal(L, "create");// уст глоб имя в таблице как С функцию.

    lua_pushcfunction(L, show);
    lua_setglobal(L, "show");

    checkerror(L, LUA);//Функция проверка на ошибки.

    lua_close(L);

    return 0;
};









int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
    cout << "destroy " << endl;
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    a** st = (a * *)lua_touserdata(L, -2); // получаем польз. данные.
    a *b = &**st;

    b->~a();//вызов метода деструктор.
    return 0;

};

int show(lua_State * L) {

    cout << "show " << endl;
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    cout << lua_type(L,-2) << endl;
    //a** st = (a * *)lua_touserdata(L, -2);// получаем польз. данные.
    //a * b = &**st;
    //b->show();// вызов метода.
    return 0;
};
    //lua_newtable(L);
    //luaL_newmetatable(L, "mt");// создать мета таблицу.
    //pushlua(L, "__gc");
    //lua_pushcfunction(L, destroy);
    //lua_settable(L, -3); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.

int create(lua_State* L) {//    Функция создания объекта структуры.
    lua_newtable(L);
    luaL_newmetatable(L, "mt");// создать мета таблицу.
    lua_pushcfunction(L, destroy);
    lua_setfield(L, -2, "__gc");

    a** c = (a * *)lua_newuserdata(L, sizeof(a*));/*Эта функция выделяет новый блок памяти с заданным размером,*/
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    *c = new a();
    lua_setmetatable(L, -2); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.

    lua_gettable(L, -3);
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/

   lua_pushcfunction(L, show);
    lua_setfield(L, -2, "show");
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/

    return 1;
};

int main(int argc, char* argv[]) {
const char* LUA = R"(

a= create()
a.show()

)";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_pushcfunction(L, create);
    lua_setglobal(L, "create");//уст указатель на функцию C++ и создает внутри Lua

    checkerror(L, LUA);//Функция проверка на ошибки.

    lua_close(L);

    return 0;
};



По указателю.
int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
    cout << "destroy " << endl;
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    a* st = (a* )lua_touserdata(L, -2); // получаем польз. данные.

    st->~a();//вызов метода деструктор.
    return 0;
};

int create(lua_State * L) {//   Функция создания объекта структуры.
    lua_newtable(L);
    luaL_newmetatable(L, "mt");// создать мета таблицу.
    pushlua(L, "__gc");
    lua_pushcfunction(L, destroy);
    lua_settable(L, -3); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.


    a* c = (a *)lua_newuserdata(L, sizeof(a));/*Эта функция выделяет новый блок памяти с заданным размером,*/
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    c = new a();
    lua_setmetatable(L, -2); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.

    return 1;
};


Через реестр.

struct a {
    int x = 10;
    a() { cout << "create object " << this << endl; }//конструктор по умолчанию

    void show() { cout << "\nobject - " << this << "\tx = " << x << "\n\n"; }//вывести значение x на экран.

    ~a() { cout << "destory object " << this << endl << endl; }//вызов деструктора.
};

int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
    cout << "destroy " << endl;
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    a** st = (a * *)lua_touserdata(L, -2); // получаем польз. данные.
    a *b = &**st;

    b->~a();//вызов метода деструктор.


    return 0;

};

int show(lua_State * L) {

luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/

    lua_pushstring(L, "key");
    lua_gettable(L, -2);
    cout << lua_tonumber(L, -1)<<"ref \n";
    int ref = 3;
    pushlua(L, ref);
    lua_rawgetp(L, LUA_REGISTRYINDEX, &ref);/* получить значение по ключу адрес k*/

    //getlaststack(L);
cout << lua_type(L,-1) << endl;
//  a** st = (a * *)lua_touserdata(L, -1);// получаем польз. данные.
//  a * b = &**st;
//  b->show();// вызов метода.
    return 0;
};
int create(lua_State* L) {//    Функция создания объекта структуры.
    lua_gettable(L, -3);
    luaL_newmetatable(L, "mt");// создать мета таблицу.
    lua_pushcfunction(L, destroy);
    lua_setfield(L, -2, "__gc");

    lua_pushcfunction(L, show);
    lua_setfield(L, -2, "show");
    int ref = luaL_ref(L, LUA_REGISTRYINDEX);

    //luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    a** c = (a * *)lua_newuserdata(L, sizeof(a*));/*Эта функция выделяет новый блок памяти с заданным размером,*/
    *c = new a();
    lua_rawsetp(L, LUA_REGISTRYINDEX, &ref);  /* уст ключ в реестре адрес k.  */

    lua_setmetatable(L, -2); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.

    lua_gettable(L, -2);
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/

    lua_pushcfunction(L, show);
    lua_setfield(L, -2, "show");
    lua_pushstring(L, "key");
    lua_pushnumber(L, ref);
    lua_rawset(L, -3);

    cout << ref<<" kkmj\n";

    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    return 1;
};

int main(int argc, char* argv[]) {
const char* LUA = R"(

a= create()
a.show()

)";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_newtable(L);
    lua_pushcfunction(L, create);
    lua_setglobal(L, "create");//уст указатель на функцию C++ и создает внутри Lua

    checkerror(L, LUA);//Функция проверка на ошибки.

    lua_close(L);

    return 0;
};

Реестр. Передача значение между функциями через метатаблицу.

int show(lua_State * L) {
    luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
    lua_pushstring(L, "key");//отправить key, чтобы получить ref
    lua_gettable(L, -2);
    int ref = lua_tonumber(L, -1);
    lua_rawgetp(L, LUA_REGISTRYINDEX, &ref);/* получить значение по ключу ref.*/
    cout << lua_tonumber(L, -1) << " value 5" << endl;//должно быть 5.
    return 0;
};
int create(lua_State * L) {//   Функция создания объекта структуры.
    lua_gettable(L, -3);// получить глоб. таблицу.
    luaL_newmetatable(L, "mt");// создать мета таблицу.
    int ref = luaL_ref(L, LUA_REGISTRYINDEX);// получить уникальный ключ.
    pushlua(L, 5);// отправить значение для ключа. mt.ref = 5.
    lua_rawsetp(L, LUA_REGISTRYINDEX, &ref); /* уст ключ со значением 5 в реестре адрес. */

    lua_pushstring(L, "key");// это ключ для получение ref.
    lua_pushnumber(L, ref);

    lua_setmetatable(L, -2); //уст метатаблицу.
    luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
    return 1;
};

int main(int argc, char* argv[]) {
    const char* LUA = R"(
create()
show()
)";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_newtable(L);
    lua_pushcfunction(L, create);
    lua_setglobal(L, "create");// уст глоб имя в таблице как С функцию.

    lua_pushcfunction(L, show);
    lua_setglobal(L, "show");

    checkerror(L, LUA);//Функция проверка на ошибки.

    lua_close(L);

    return 0;
};

Выводится.
5 value 5

C:\Users\e\source\repos\Project1luaapi\Debug\Project1luaapi.exe (процесс 2764) завершает работу с кодом 0.
Чтобы закрыть это окно, нажмите любую клавишу…

Реестр. Передача в функцию числа, возвращаем из другой функции.

int show(lua_State* L) {
    luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/

    pushlua(L, "key");
    lua_gettable(L, -2);
    int ref = lua_tonumber(L, -1);
    cout << "in func show regis key " << ref  << endl;
    lua_rawgetp(L, LUA_REGISTRYINDEX, &ref);/* получить значение по ключу ref.*/

    cout << lua_tonumber(L, -1) << " value 5" << endl;//должно быть 5.
    return 0;
};
int create(lua_State * L) {//   Функция создания объекта структуры.
    int k = lua_tonumber(L, -1);
    cout << k << endl;// 5
    int ref = luaL_ref(L, LUA_REGISTRYINDEX);// получить уникальный ключ.
    cout <<"in func create regis key " << ref  << endl;

    luaL_newmetatable(L, "mt");// создать мета таблицу.
    luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
    lua_gettable(L, -2);// получить глоб. таблицу.
    pushlua(L, k);// значение для ключа. mt.ref = 5.
    lua_rawsetp(L, LUA_REGISTRYINDEX, &k); /* уст ключ со значением 5 в реестре адрес. */
    lua_setmetatable(L, -2); //уст метатаблицу.
    luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
    pushlua(L, "key");// это ключ для получение ref.
    pushlua(L, ref);
    lua_settable(L, -3);
return 1;
};

int main(int argc, char* argv[]) {
    const char* LUA = R"(
create(5)
show()
)";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_newtable(L);
    lua_pushcfunction(L, create);
    lua_setglobal(L, "create");// уст глоб имя в таблице как С функцию.

    lua_pushcfunction(L, show);
    lua_setglobal(L, "show");

    checkerror(L, LUA);//Функция проверка на ошибки.

    lua_close(L);

    return 0;
};
Выводится.
5
in func create regis key 3
in func show regis key 3
5 value 5

C:\Users\e\source\repos\Project1luaapi\Debug\Project1luaapi.exe (процесс 5912) завершает работу с кодом 0.
Чтобы закрыть это окно, нажмите любую клавишу…


test1.lua
x = 1
function hi()
    print("hi1");
    print(x);
end
hi()
test2.lua
x =2
function hi()
    print("hi2");
    print(x);
end
hi()


int main(int argc, char *argv[]) {

    lua_State* L = luaL_newstate();
    luaL_openlibs(L);

    const char* file1 = "test1.lua";
    const char* file2 = "test2.lua";

    //We load the file
    luaL_loadfile(L, file1);
    //Create _ENV tables
    lua_newtable(L);
    //Create metatable
    lua_newtable(L);
    //Get the global table
    lua_getglobal(L, "_G");
    lua_setfield(L, -2, "__index");
    //Set global as the metatable
    lua_setmetatable(L, -2);
    //Push to registry with a unique name.
    //I feel like these 2 steps could be merged or replaced but I'm not sure how
    lua_setfield(L, LUA_REGISTRYINDEX, "test1");
    //Retrieve it.
    lua_getfield(L, LUA_REGISTRYINDEX, "test1");
    //Set the upvalue (_ENV)
    lua_setupvalue(L, 1, 1);
    //Run chunks
    lua_pcall(L, 0, LUA_MULTRET, 0);

    //Repeat
    luaL_loadfile(L, file2);
    lua_newtable(L);
    lua_newtable(L);
    lua_getglobal(L, "_G");
    lua_setfield(L, -2, "__index");
    lua_setmetatable(L, -2);
    lua_setfield(L, LUA_REGISTRYINDEX, "test2");
    lua_getfield(L, LUA_REGISTRYINDEX, "test2");
    lua_setupvalue(L, 1, 1);
    lua_pcall(L, 0, LUA_MULTRET, 0);

    //Retrieve the table containing the functions of the chunk
    lua_getfield(L, LUA_REGISTRYINDEX, "test1");
    //Get the function we want to call
    lua_getfield(L, -1, "hi");
    //Call it
    lua_call(L, 0, 0);
    //Repeat
    lua_getfield(L, LUA_REGISTRYINDEX, "test2");
    lua_getfield(L, -1, "hi");
    lua_call(L, 0, 0);
    lua_getfield(L, LUA_REGISTRYINDEX, "test2");
    lua_getfield(L, -1, "hi");
    lua_call(L, 0, 0);
    lua_getfield(L, LUA_REGISTRYINDEX, "test1");
    lua_getfield(L, -1, "hi");
    lua_call(L, 0, 0);


    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.

    return 0;
}


Замыкание.

struct Sprite
    {
        int x;
        int y;

        Sprite() : x(0), y(0) {}
        ~Sprite() {}

        void Move(int velX, int velY)
        {
            x += velX;
            y += velY;
        }

        void Draw()
        {
            printf("sprite(%p): x = %d, y = %d\n", this, x, y);
        }
    };

    struct SpriteManager
    {
        std::vector<Sprite*> m_sprites;
        int numberOfSpritesExisting = 0;
        int numberOfSpritesMade = 0;

        void LookAfterSprite(Sprite* sprite)
        {
            numberOfSpritesExisting++;
            numberOfSpritesMade++;
            m_sprites.push_back(sprite);
        }

        void ForgetSprite(Sprite* sprite)
        {
            int i = 0;
            for (auto& s : m_sprites)
            {
                if (s == sprite)
                {
                    numberOfSpritesExisting--;
                    m_sprites.erase(m_sprites.begin() + i);
                    return;
                }
                i++;
            }
        }
    };

    SpriteManager spriteManager;

    int CreateSprite(lua_State* L){
        SpriteManager* sm = (SpriteManager*)lua_touserdata(L, lua_upvalueindex(1));
        lua_assert(sm);

        void* pointerToASprite = lua_newuserdata(L, sizeof(Sprite));
        new (pointerToASprite) Sprite();
        luaL_getmetatable(L, "SpriteMetaTable");
        lua_assert(lua_istable(L, -1));
        lua_setmetatable(L, -2);

        lua_newtable(L);
        lua_setuservalue(L, 1);

        sm->LookAfterSprite((Sprite*)pointerToASprite);

        return 1;
    };

    int DestroySprite(lua_State* L){
        SpriteManager* sm = (SpriteManager*)lua_touserdata(L, lua_upvalueindex(1));
        lua_assert(sm);

        Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
        sm->ForgetSprite(sprite);
        sprite->~Sprite();
        return 0;
    };

    int MoveSprite(lua_State* L){
        Sprite* sprite = (Sprite*)lua_touserdata(L, -3);
        lua_Number velX = lua_tonumber(L, -2);
        lua_Number velY = lua_tonumber(L, -1);
        sprite->Move((int)velX, (int)velY);
        return 0;
    };

    int DrawSprite(lua_State* L){
        Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
        sprite->Draw();
        return 0;
    };

    int SpriteIndex(lua_State* L){
        lua_assert(lua_isuserdata(L, -2));  //1
        lua_assert(lua_isstring(L, -1));    //2

        Sprite* sprite = (Sprite*)lua_touserdata(L, -2);
        const char* index = lua_tostring(L, -1);
        if (strcmp(index, "x") == 0)
        {
            lua_pushnumber(L, sprite->x);
            return 1;
        }
        else if (strcmp(index, "y") == 0)
        {
            lua_pushnumber(L, sprite->y);
            return 1;
        }
        else
        {
            lua_getuservalue(L, 1);
            lua_pushvalue(L, 2);
            lua_gettable(L, -2);
            if (lua_isnil(L, -1))
            {
                lua_getglobal(L, "Sprite");
                lua_pushstring(L, index);
                lua_rawget(L, -2);
            }
            return 1;
        }
    };

    int SpriteNewIndex(lua_State* L){
        lua_assert(lua_isuserdata(L, -3));  //1
        lua_assert(lua_isstring(L, -2));    //2
                                        // -1 - value we want to set    //3

        Sprite* sprite = (Sprite*)lua_touserdata(L, -3);
        const char* index = lua_tostring(L, -2);
        if (strcmp(index, "x") == 0)
        {
            sprite->x = (int)lua_tonumber(L, -1);
        }
        else if (strcmp(index, "y") == 0)
        {
            sprite->y = (int)lua_tonumber(L, -1);
        }
        else
        {
            lua_getuservalue(L, 1); //1
            lua_pushvalue(L, 2);    //2
            lua_pushvalue(L, 3);    //3
            lua_settable(L, -3);    //1[2] = 3
        }

        return 0;
    };

int main(int argc, char *argv[]) {
    const char* LUA_FILE = R"(
        sprite = Sprite.new()
        sprite:Move( 6, 7 )     -- Sprite.Move( sprite, 6, 7 )
        sprite:Draw()
        sprite.y = 10
        sprite.zzz = 99
        sprite.x = sprite.zzz
        sprite:Draw()
        Sprite.new()
        Sprite.new()
        )";

    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_newtable(L);
    int spriteTableIdx = lua_gettop(L);
    lua_pushvalue(L, spriteTableIdx);
    lua_setglobal(L, "Sprite");

    constexpr int NUMBER_OF_UPVALUES = 1;
    lua_pushlightuserdata(L, &spriteManager);
    lua_pushcclosure(L, CreateSprite, NUMBER_OF_UPVALUES);
    lua_setfield(L, -2, "new");
    lua_pushcfunction(L, MoveSprite);
    lua_setfield(L, -2, "Move");
    lua_pushcfunction(L, DrawSprite);
    lua_setfield(L, -2, "Draw");

    luaL_newmetatable(L, "SpriteMetaTable");
    lua_pushstring(L, "__gc");
    lua_pushlightuserdata(L, &spriteManager);
    lua_pushcclosure(L, DestroySprite, NUMBER_OF_UPVALUES);
    lua_settable(L, -3);

    lua_pushstring(L, "__index");
    lua_pushcfunction(L, SpriteIndex);
    lua_settable(L, -3);

    lua_pushstring(L, "__newindex");
    lua_pushcfunction(L, SpriteNewIndex);
    lua_settable(L, -3);

    int doResult = luaL_dostring(L, LUA_FILE);
    if (doResult != LUA_OK)
    {
        printf("Error: %s\n", lua_tostring(L, -1));
    }

    lua_close(L);

    lua_assert(spriteManager.numberOfSpritesExisting == 0);
    lua_assert(spriteManager.numberOfSpritesMade == 3);

    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}


struct Sprite
    {
        int x;

        Sprite() : x(0) {}
        ~Sprite() {}

        void Move(int velX)
        {
            x += velX;
        }

        void Draw()
        {
            printf("sprite(%p): x = %d\n", this, x);
        }
    };

    struct SpriteManager
    {
        std::vector<Sprite*> m_sprites;
        void ForgetSprite(Sprite* sprite)
        {
            int i = 0;
            for (auto& s : m_sprites)
            {
                if (s == sprite){
                    m_sprites.erase(m_sprites.begin() + i);
                    return;
                }
                i++;
            }
        }
    };

SpriteManager sp;

    int CreateSprite(lua_State* L){

        SpriteManager* sm = (SpriteManager*)lua_touserdata(L, lua_upvalueindex(1));
        void* pointerToASprite = lua_newuserdata(L, sizeof(Sprite));
        new (pointerToASprite) Sprite();
        luaL_getmetatable(L, "mt");
        lua_setmetatable(L, -2);
        lua_newtable(L);
        lua_setuservalue(L, 1);
        return 1;
    };

    int DestroySprite(lua_State* L){
        SpriteManager* sm = (SpriteManager*)lua_touserdata(L, lua_upvalueindex(1));
        Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
        sm->ForgetSprite(sprite);
        sprite->~Sprite();
        return 0;
    };

    int DrawSprite(lua_State* L){
        Sprite* sprite = (Sprite*)lua_touserdata(L, -2);
        sprite->Move(lua_tonumber(L, -1));
        sprite->Draw();
        return 0;
    };

    int SpriteIndex(lua_State* L){

        Sprite* sprite = (Sprite*)lua_touserdata(L, -2);
        const char* index = lua_tostring(L, -1);
            lua_getuservalue(L, 1);
            lua_pushvalue(L, 2);
            lua_gettable(L, -2);

            lua_getglobal(L, "sprite");
            lua_pushstring(L, index);
            lua_rawget(L, -2);

            return 1;
    };


int main(int argc, char *argv[]) {
    const char* LUA_FILE = R"(
        sp = sprite.new()
        sp:draw(6)
        )";

    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_newtable(L);
    lua_pushvalue(L, 1);
    lua_setglobal(L, "sprite");

    lua_pushlightuserdata(L, &sp);
    lua_pushcclosure(L, CreateSprite, 1);
    lua_setfield(L, -2, "new");
    lua_pushcfunction(L, DrawSprite);
    lua_setfield(L, -2, "draw");

    luaL_newmetatable(L, "mt");
    lua_pushstring(L, "__gc");
    lua_pushlightuserdata(L, &sp);
    lua_pushcclosure(L, DestroySprite, 1);
    lua_settable(L, -3);

    lua_pushstring(L, "__index");
    lua_pushcfunction(L, SpriteIndex);
    lua_settable(L, -3);
    luaL_dostring(L, LUA_FILE);

    lua_close(L);

    cin.get();//ожидает ввода символа программа завершается.
    return 0;
};


Замыкание 2.

struct Sprite
    {
        int x;

        Sprite() : x(0) {}
        ~Sprite() {}

        void Move(int velX)
        {
            x += velX;
        }

        void Draw()
        {
            printf("sprite(%p): x = %d\n", this, x);
        }
    };

    struct SpriteManager
    {
        std::vector<Sprite*> m_sprites;
        void ForgetSprite(Sprite* sprite)
        {
            int i = 0;
            for (auto& s : m_sprites)
            {
                if (s == sprite){
                    m_sprites.erase(m_sprites.begin() + i);
                    return;
                }
                i++;
            }
        }
    };
    int pri(lua_State* L) { cout << "pri " << endl;
    return 0;
    }
SpriteManager sp;

    int CreateSprite(lua_State* L){
        SpriteManager* sm = (SpriteManager*)lua_touserdata(L, lua_upvalueindex(1));
        void* pointerToASprite = lua_newuserdata(L, sizeof(Sprite));
        new (pointerToASprite) Sprite();
        luaL_getmetatable(L, "mt");
        lua_setmetatable(L, -2);
        lua_newtable(L);
        lua_setuservalue(L, 1);
        return 1;
    };

    int DestroySprite(lua_State* L){
        SpriteManager* sm = (SpriteManager*)lua_touserdata(L, lua_upvalueindex(1));
        Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
        sm->ForgetSprite(sprite);
        sprite->~Sprite();
        return 0;
    };

    int DrawSprite(lua_State* L){
        Sprite* sprite = (Sprite*)lua_touserdata(L, -2);
        sprite->Move(lua_tonumber(L, -1));
        sprite->Draw();
        return 0;
    };

    int SpriteIndex(lua_State* L){

        Sprite* sprite = (Sprite*)lua_touserdata(L, -2);
        const char* index = lua_tostring(L, -1);
            lua_getuservalue(L, 1);
            lua_pushvalue(L, 2);
            lua_gettable(L, -2);

            lua_getglobal(L, "sprite");
            lua_pushstring(L, index);
            lua_rawget(L, -2);

            return 1;
    };


int main(int argc, char *argv[]) {
    const char* LUA_FILE = R"(
        sp = sprite.new()
        sp:draw(6)
        )";

    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_newtable(L);
    lua_pushvalue(L, 1);
    lua_setglobal(L, "sprite");

    lua_pushlightuserdata(L, &sp);
    lua_pushcclosure(L, CreateSprite, 1);
    lua_setfield(L, -2, "new");
    lua_pushcfunction(L, DrawSprite);
    lua_setfield(L, -2, "draw");

    luaL_newmetatable(L, "mt");
    lua_pushstring(L, "__gc");
    lua_pushlightuserdata(L, &sp);
    lua_pushcclosure(L, DestroySprite, 1);
    lua_settable(L, -3);

    lua_pushstring(L, "__index");
    lua_pushcfunction(L, SpriteIndex);
    lua_settable(L, -3);
    luaL_dostring(L, LUA_FILE);

    lua_close(L);

    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}

Замыкание 3

struct Sprite
{
    int x;

    Sprite() : x(0) { cout << " sp" << endl; }
    ~Sprite() { cout << " des " << endl; }

};


int pri(lua_State* L) {
    cout << "pri " << endl;
    return 0;
}

int CreateSprite(lua_State* L) {
    void* pointerToASprite = lua_newuserdata(L, sizeof(Sprite));
    new (pointerToASprite) Sprite();
    luaL_getmetatable(L, "mt");
    lua_setmetatable(L, -2);
    lua_newtable(L);
    lua_setuservalue(L, 1);
    return 1;
};

int DestroySprite(lua_State* L) {
    Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
    sprite->~Sprite();
    return 0;
};


int main(int argc, char *argv[]) {
    const char* LUA_FILE = R"(
        sp = sprite.new()
        )";

    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_newtable(L);
    lua_pushvalue(L, 1);
    lua_setglobal(L, "sprite");

    lua_pushinteger(L, 2);
    lua_pushcclosure(L, CreateSprite, 1);
    lua_setfield(L, -2, "new");

    luaL_newmetatable(L, "mt");
    lua_pushstring(L, "__gc");

    lua_pushinteger(L, 2);
    lua_pushcclosure(L, DestroySprite, 1);
    lua_settable(L, -3);

    luaL_dostring(L, LUA_FILE);

    lua_close(L);

    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}

Замыкание 4.

int pri(lua_State* L) {
    showstack(L);
    cout << "pri " << endl;
    return 0;
}

int CreateSprite(lua_State* L) {
    cout << "cre " << endl;
    lua_gettable(L, -2);
    lua_setuservalue(L, 1);
    return 1;
};

int main(int argc, char *argv[]) {
    const char* LUA_FILE = R"(
        sp = sprite.new()
        )";

    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_newtable(L);
    lua_pushvalue(L, 1);
    lua_setglobal(L, "sprite");

    lua_pushinteger(L, 2);
    lua_pushcclosure(L, pri, 1);
    lua_setfield(L, -2, "new");

    luaL_dostring(L, LUA_FILE);
    lua_close(L);

    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}

Замыкание 5.

static int newcounter(lua_State *L) {
    cout << lua_tonumber(L, -1) << endl;
    cout << " new" << endl;
    int val = lua_tointeger(L, lua_upvalueindex(1));
    lua_pushinteger(L, 1);  /* new value */
    lua_copy(L, -1, lua_upvalueindex(1));  /* update upvalue */
    return 1;
}
static int counter(lua_State *L) {
    cout << "coun " << endl;
    lua_pushinteger(L, 10);
    lua_pushcclosure(L, newcounter, 1);
    return 1;  /* return new value */
}


int main(int argc, char *argv[]) {
    const char* LUA = R"(
 c1 = counter()
    print(c1(), c1(), c1())   --> 1    2    3
     -- c2 = newcounter()
      --print(c2(), c2(), c1())   --> 1    2    4

        )";

    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    //lua_newtable(L);

    //lua_pushnumber(L, 142);
    lua_register(L,"counter", counter);// отправить c функцию в стек.
    luaL_dostring(L, LUA);
    //lua_pushnumber(L, 142);
  lua_pushcclosure(L, newcounter, 1);

//  lua_settable(L, -3);

    lua_pcall(L, 0, 0, 0);// вызвать функцию foo.

    lua_close(L);

    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}


Замыкание 6.


static int newcounter(lua_State *L) {
    int val = lua_tointeger(L, lua_upvalueindex(1));/*Возвращает псевдоиндекс, который представляет
    i-ковою внешнюю локальную переменную (upvalue) выполняемой функции.*/
    lua_pushinteger(L, ++val);  /*  новое  значение    */
    lua_pushvalue(L, -1);   /*дублирует    его  */
    lua_replace(L, lua_upvalueindex(1));/*  обновляет  верхнее  значение*/
    return 1;
}
static int counter(lua_State *L) {
    lua_pushinteger(L, 0);
    lua_pushcclosure(L, newcounter, 1);
    return 1;  /* return new value */
}

int main(int argc, char *argv[]) {
    const char* LUA = R"(
   c1 = counter()
   print(c1(), c1(), c1())   --> 1    2    3
   )";

    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_register(L,"counter", counter);// отправить c функцию в стек.
    checkerror(L, LUA);

    lua_pushcclosure(L, newcounter, 1);/* Помещает в стек новое C замыкание. При создании C функций, можно увязать
с ней некоторые значения, таким образом создавая C замыкания (closure); затем эти значения будут доступны функции
каждый раз при её вызове. Для связывания значений с C функцией, вначале эти значения помещаются в стек
(когда имеется несколько значений, первое значение помещается первым). Затем вызывается lua_pushcclosure для
создания и помещения в стек C функции, с аргументом n, сообщающим сколько значений будет связано с этой функцией.
lua_pushcclosure также выводит из стека эти значения. Макс значением для n является 255. При n равным нулю,
эта функция создает легкую C функцию, которая является просто указателем на C функцию. В этом случае, она никогда
не вызывает ошибку памяти.*/

    lua_close(L);
    return 0;

};

Замыкание 7.


int newcounter(lua_State* L) {
    int val = lua_tointeger(L, lua_upvalueindex(1));/*Возвращает псевдоиндекс, который представляет
    i-ковою внешнюю локальную переменную (upvalue) выполняемой функции.*/
    lua_pushinteger(L, val++);  /*  новое  значение    */
    lua_pushvalue(L, -1);   /*дублирует    его  */
    lua_replace(L, lua_upvalueindex(1));/*  обновляет верхнее значение. снимает значение с вершины стека
                и устанавливает его как значение элемента с заданным индексом.*/
    return 1;
}
int counter(lua_State * L) {
    lua_pushinteger(L, 1);
    lua_pushcclosure(L, newcounter, 1);/* Помещает в стек новое C замыкание. При создании C функций, можно увязать
с ней некоторые значения, таким образом создавая C замыкания (closure); затем эти значения будут доступны функции
каждый раз при её вызове. Для связывания значений с C функцией, вначале эти значения помещаются в стек
(когда имеется несколько значений, первое значение помещается первым). Затем вызывается lua_pushcclosure для
создания и помещения в стек C функции, с аргументом n, сообщающим сколько значений будет связано с этой функцией.
lua_pushcclosure также выводит из стека эти значения. Макс значением для n является 255. При n равным нулю,
эта функция создает легкую C функцию, которая является просто указателем на C функцию. В этом случае, она никогда
не вызывает ошибку памяти.*/

    return 1;  /* return new value */
}

int main(int argc, char* argv[]) {
    const char* LUA = R"(
   c = counter()
   print(c(), c(), c())   --> 1    2    3
   )";

    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_register(L, "counter", counter);// отправить c функцию в стек.
    checkerror(L, LUA);


    lua_close(L);
    return 0;

};




luaL_setfuncs

int foo1(lua_State * L){
    cout << "foo1 " << endl;
    return 0;
}

int foo2(lua_State * L) {
    cout << "foo2 " << endl;
    return 0;
}

void RegisterFoo(lua_State * L){
    luaL_Reg sFooRegs[] =
    {
        { "foo1", foo1 },
        { "foo2", foo2 },
        { NULL, NULL }
    };

    luaL_newmetatable(L, "luaL_Foo");

    // Register the C functions _into_ the metatable we just created.
    luaL_setfuncs(L, sFooRegs, 0);/*    void luaL_setfuncs(lua_State * L, const luaL_Reg * l, int nup);
    Регистрирует все функции в массиве l(см.luaL_Reg) В таблице на вершине стека(ниже необязательных
    значений повышений).Когда nupне ноль, все функции создаются с nup общими значениями повышения, которые
    должны быть предварительно помещены в стек поверх таблицы библиотеки. Эти значения выталкиваются
    из стека после регистрации.*/

    lua_pushvalue(L, -1);
    lua_setfield(L, -1, "__index");

    lua_setglobal(L, "Foo");
}
int main(int argc, char *argv[]) {
    const char* LUA = R"(
Foo.foo1()
Foo.foo2()
   )";

    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    RegisterFoo(L);
    checkerror(L, LUA);

    lua_close(L);
    return 0;
};

Еще пример.


int foo1(lua_State* L) {
    int val = lua_tointeger(L, lua_upvalueindex(1));/*Возвращает псевдоиндекс, который представляет
   i-ковою внешнюю локальную переменную (upvalue) выполняемой функции.*/
    cout << "foo " << val << endl;
    return 0;
};

int foo2(lua_State* L) {
    int val = lua_tointeger(L, lua_upvalueindex(1));/*Возвращает псевдоиндекс, который представляет
i-ковою внешнюю локальную переменную (upvalue) выполняемой функции.*/
    cout << "foo2 " << val << endl;
    return 0;
};

void RegisterFoo(lua_State* L) {
    luaL_Reg sFooRegs[] =
    {
        { "foo1", foo1 },
        { "foo2", foo2 },
        { NULL, NULL }
    };

    luaL_newmetatable(L, "luaL_Foo");

    lua_pushinteger(L, 1);
    // Register the C functions _into_ the metatable we just created.
    luaL_setfuncs(L, sFooRegs, 1);/* void luaL_setfuncs(lua_State * L, const luaL_Reg * l, int nup);
    Регистрирует все функции в массиве l) В таблице на вершине стека(ниже необязательных
    значений повышений).Когда nupне ноль, все функции создаются с nup общими значениями повышения, которые
    должны быть предварительно помещены в стек поверх таблицы библиотеки. Эти значения выталкиваются
    из стека после регистрации.*/

    lua_pushvalue(L, -1);
    lua_setfield(L, -1, "__index");

    lua_setglobal(L, "Foo");
}

int main(int argc, char* argv[]) {
    const char* LUA = R"(
Foo.foo1()
Foo.foo2()
   )";

    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    RegisterFoo(L);
    checkerror(L, LUA);

    lua_close(L);

    return 0;
};

Мета метод _index

int main(int argc, char* argv[]) {
const char* LUA = R"(
foo={} foo.key="value"
bar = setmetatable({},{__index=foo},print("index\n") )
print(bar.key)-- value
)";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    checkerror(L, LUA);//Функция проверка на ошибки.
    lua_close(L);

    return 0;
};



Потоки. Многопоточность — это принцип построения программы, при котором несколько блоков могут выполняться одновременно и не мешать друг другу.


Lua. Это по сути однопоточная система.
lua_State * lua_newthread ( lua_State * L);
Создает новый поток, помещает его в стек и возвращает указатель на объект lua_State, представляющий этот новый поток. Новое состояние, возвращаемое этой функцией, совместно использует с исходным состоянием все глобальные объекты (например, таблицы), но имеет независимый стек выполнения.
Не существует явной функции для закрытия или уничтожения потока. Потоки подлежат сборке мусора, как и любой объект Lua.

Без вызова потока. Вызов функции в одном потоке.

int foo(lua_State* L) {
    cout << " func foo c++ " << L << endl;
    return 0;
};

int main(int argc, char* argv[]) {
    const char* LUA = R"(
foo()

)";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_State* L1 = lua_newthread(L);
    lua_pushcfunction(L, foo);// отправить c функцию в стек.
    showstack(L); cout <<  endl;
    lua_setglobal(L, "foo");// уст для переменной значение в виде функции.
        luaL_dostring(L, LUA);
    cout <<"\n";
    showstack(L);
    cout << "\n adrees L  "<<  L << "\n adrees L1 "<< L1 << "\n";
    lua_close(L);

    return 0;
};

Эта функция возвращает указатель на lua_State, представляющее новой поток, а также отправить новой поток в стек как значение типа "thread". Например, после выполнения оператора L1 = lua_newthread(L);
у нас будет два потока, L1 и L, которые будут внутренне ссылаться на одно и то же состояние Lua. Каждый поток обладает собственным стеком.
Новый поток L1 начинает с пустого стека; у старого потока L есть новый поток на вершине стека:
printf("%d\n", lua_gettop(L1)); --> 0
printf("%s\n", luaL_typename(L, -1)); --> thread

За исключением главноого, все потоки подвержены сборке мусора, как и любой другой объект Lua. Когда вы создаете новый поток, то значение, которое отправляется в стек, гарантирует, что эта поток не
является мусором. Вы никогда не должны использовать поток, который должным образом не привязан к состоянию. (Главный поток внутренне привязан с самого начала, поэтому о нем можно не беспокоиться.)


Функция вызвается в 2 потоках.

int main(int argc, char* argv[]) {
    const char* LUA = R"(
foo()

)";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_State* L1 = lua_newthread(L);
    lua_pushcfunction(L, foo);// отправить c функцию в стек.
    showstack(L); cout << "\n";

    lua_setglobal(L, "foo");// уст для переменной значение в виде функции.
    luaL_dostring(L, LUA);
    showstack(L1);  cout << "\n";// Стек потока L1 пуст.
    luaL_dostring(L1, LUA);
    cout << "\n adrees L  " << L << "\n adrees L1 " << L1 << "\n";
    lua_close(L);

    return 0;
};

Вариант 2

int main(int argc, char* argv[]) {
    const char* LUA = R"(
foo()

)";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_State* L1 = lua_newthread(L);
    lua_pushcfunction(L, foo);// отправить c функцию в стек.
    showstack(L); cout <<"\n";

    lua_setglobal(L, "foo");// уст для переменной значение в виде функции.
    luaL_dostring(L, LUA);
    lua_xmove(L, L1, 1);// Снимает с L1 элементов передает L.
    showstack(L1);  cout << "\n";
    luaL_dostring(L1, LUA);
    cout << "\n adrees L  "<<  L << "\n adrees L1 "<< L1 << "\n";
    lua_close(L);

    return 0;
};

Запуск 2 функций в 2 потоках.

const char* LUA = R"(
function foo()
for i = 1, 3 do
print(" func foo "..i.."\n")
end     end

function main()
for i = 1, 3 do
print(" func main "..i.."\n")
end  end
)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_State* L1 = lua_newthread(L);
    checkerror(L, LUA);
    lua_getglobal(L, "main");
    lua_pcall(L, 0, 0, 0);// запустить функцию main в потоке L.

    lua_getglobal(L1, "foo");// запустить функцию foo в потоке L1.
    lua_pcall(L1, 0, 0, 0);

    lua_close(L);
    return 0;
};



Функции выполняются поочередно в двух потоках.

Для запуска выполнения сопрограммы мы используем lua_resume так же, как мы используем lua_pcall: мы заталкиваем функцию для вызова, заталкиваем ее аргументы и вызываем lua_resume,
 передавая в narg число аргументов. (Параметр from — это нить, которая совершает вызов.) Данное поведение также очень похоже на lua_pcall, но с тремя отличиями.

Во-первых, у lua_resume нет параметра для числа требуемых  результатов; она всегда возвращает все значения из вызванной функции.

Во-вторых, у нее нет параметра для обработчика сообщений; ошибка не раскручивает стек, поэтому после нее вы можете изучить стек.

 В-третьих, если выполняемая функция уступает управление, то lua_resume возвращает особый код LUA_YIELD и оставляет поток в состоянии, из которого она может быть возобновлена позже.

Когда lua_resume возвращает LUA_YIELD, видимая часть стека потока содержит только значения, переданные yield. Вызов lua_gettop вернет число выработанных значений. Для перемещения этих значений
В другой потоке мы можем использовать lua_xmove. Чтобы возобновить приостановленный поток, мы вновь вызываем lua_resume. При таких вызовах Lua считает, что все значения в стеке должны быть возвращены вызовом yield. Например, если вы не трогаете стек потока между возвращением из lua_resume и следующим возобновлением, то yield вернет именно те значения, которые он выработал при уступке управления. Обычно мы запускаем сопрограмму с функцией Lua в качестве ее тела. Эта функция Lua может вызывать другие функции, и любая из этих функций порой может уступать управление, завершая вызов lua_resume.


int my_yield(lua_State* L) {
    return lua_yield(L, 0);/*Эта функция должна вызываться только как возвращаемое выражение функции C следующим образом:
    return lua_yield(L, res); Когда функция C вызывает lua_yield таким образом, запущенная сопрограмма приостанавливает
    свое выполнение, и вызов lua_resume этой запущенной процедуры возвращается. Параметр res - это число значений из стека,
    которые передаются как результаты lua_resume.*/
};
const char* LUA = R"(
function foo()
print(" func foo \n")
end

function main()
for i = 1, 3 do
print(" func main "..i.."\n")
my_yield()
end  end
)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_State* L1 = lua_newthread(L);
    cout << "\n";
    lua_register(L, "my_yield", my_yield);
    checkerror(L, LUA);
    lua_getglobal(L, "main");
    while (true) {
        int ret = lua_resume(L, L1, 0); /* Запускает и продолжает сопрограмму в данном потоке L.
    вы отправляйте в стек главную функцию и её аргументы; затем вызываете lua_resume,nargs - кол-во аргументов.
    Вызов возвращается, когда приостанавливается или завершается. При возвращении, стек содержит все значения,
    переданные в lua_yield, или возвращенныеции. Чтобы продолжить сопрограмму, вы удаляете все результаты
    из последнего lua_yield, отправьте в её стек только значения, передаваемые в качестве результатов из yield, и
    затем вызываете lua_resume.   Параметр L представляет сопрограмму, которая продолжает L. */
        if (ret == LUA_YIELD) {
            lua_getglobal(L1, "foo");
            lua_pcall(L1, 0, 0, 0);
        }
        else if (ret == 0) {

            break;
        }
    };

    lua_close(L);
    return 0;
};

1.

Функции выполняются поочередно в двух потоках с передачей значение в main.

int my_yield(lua_State* L) {
    return lua_yield(L, 0);/*Эта функция должна вызываться только как возвращаемое выражение функции C следующим образом:
    return lua_yield(L, res); Когда функция C вызывает lua_yield таким образом, запущенная сопрограмма приостанавливает
    свое выполнение, и вызов lua_resume этой запущенной процедуры возвращается. Параметр res - это число значений из стека,
    которые передаются как результаты lua_resume.*/
};

const char* LUA = R"(
function foo()
print(" func foo \n")
end

function main(n)
for i = 1, 3 do
print(" func main "..n.."\n")
my_yield()
end  end
)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_State* L1 = lua_newthread(L);

    lua_register(L, "my_yield", my_yield);// регистрация функций.
    checkerror(L, LUA);
    lua_getglobal(L, "main");// получить функцию.
    lua_pushinteger(L, 10); // передаем в функцию main 10.
    while (true) {
        int ret = lua_resume(L, L1, 1); /* Запускает и продолжает сопрограмму в данном потоке L.
    вы отправляйте в стек главную функцию и её аргументы; затем вызываете lua_resume,nargs - кол-во аргументов.
    Вызов возвращается, когда приостанавливается или завершается. При возвращении, стек содержит все значения,
    переданные в lua_yield, или возвращенные. Чтобы продолжить сопрограмму, вы удаляете все результаты
    из последнего lua_yield, отправьте в её стек только значения, передаваемые в качестве результатов из yield, и
    затем вызываете lua_resume.   Параметр L представляет сопрограмму, которая продолжает L. */
        if (ret == LUA_YIELD) {
            lua_getglobal(L1, "foo");
            lua_pcall(L1, 0, 0, 0);
        }
        else if (ret == 0) {

            break;
        }
    };

    lua_close(L);
    return 0;
};

2.
Функции выполняются поочередно в двух потоках с передачей значение из main в foo.

const char* LUA = R"(
function foo(x)
x=x*10
print(" func foo "..x.."\n")
end

function main()
for i = 1, 3 do
print(" func main "..i.."\n")
my_yield(i)
end  end
)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_State* L1 = lua_newthread(L);

    lua_register(L, "my_yield", my_yield);// регистрация функций.
    checkerror(L, LUA);
    lua_getglobal(L, "main");// получить функцию.
    while (true) {
        int ret = lua_resume(L, L1, 0);

        if (ret == LUA_YIELD) {
            lua_getglobal(L1, "foo");
            lua_xmove(L, L1, 1);/*перемещает значение Lua между двумя стеками в
            одном и том же состоянии.*/
            lua_pcall(L1, 1, 0, 0);
        }
        else if (ret == 0) {/*Когда функция lua_resume возвращается, стек содержит все значения,
        переданные в lua_yield, или все значения, возвращенные телом функции.*/
        //showstack(L);
            break;
        }
    };

    lua_close(L);
    return 0;
};

3.
int my_yield(lua_State* L) {

    lua_State* L1 = lua_newthread(L);
    lua_pushthread(L1);

    return lua_yield(L, 0);/*Эта функция должна вызываться только как возвращаемое выражение функции C следующим образом:
    return lua_yield(L, res); Когда функция C вызывает lua_yield таким образом, запущенная сопрограмма приостанавливает
    свое выполнение, и вызов lua_resume этой запущенной процедуры возвращается. Параметр res - это число значений из стека,
    которые передаются как результаты lua_resume.*/
};
const char* LUA = R"(
function foo()
print(" func foo \n")
end

function main()
for i = 1, 3 do
print(" func main "..i.."\n")
my_yield(foo)
end  end
)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_register(L, "my_yield", my_yield);
    cout << "\n";
    checkerror(L, LUA);
    lua_getglobal(L, "main");
    while (true) {
        int ret = lua_resume(L, NULL, 0); /* Запускает и продолжает сопрограмму в данном потоке L. */
        if (ret == LUA_YIELD) {
            lua_State* L1 = lua_tothread(L, -1);

            lua_getglobal(L1, "foo");
            lua_pcall(L1, 0, 0, 0);
        }
        else if (ret == 0) {

            break;
        }
    };

    lua_close(L);
    return 0;
};



Функции выполняются поочередно в двух потоках с передачей значение в main из main в foo.

const char* LUA = R"(
function foo(x)
x=x*10
print(" func foo "..x.."\n")
end

function main(n)
for i = 1, 3 do
print(" func main "..n.."\n")
my_yield(i)
end  end
)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_State* L1 = lua_newthread(L);

    lua_register(L, "my_yield", my_yield);// регистрация функций.
    checkerror(L, LUA);
    lua_getglobal(L, "main");// получить функцию.
    lua_pushinteger(L, 10); // передаем в функцию main 10.

    while (true) {
        int ret = lua_resume(L, L1, 1); /* Запускает и продолжает сопрограмму в данном потоке L.
    вы отправляйте в стек главную функцию и её аргументы; затем вызываете lua_resume,nargs - кол-во аргументов.
    Вызов возвращается, когда приостанавливается или завершается. При возвращении, стек содержит все значения,
    переданные в lua_yield, или возвращенные. Чтобы продолжить сопрограмму, вы удаляете все результаты
    из последнего lua_yield, отправьте в её стек только значения, передаваемые в качестве результатов из yield, и
    затем вызываете lua_resume.   Параметр L представляет сопрограмму, которая продолжает L. */

        if (ret == LUA_YIELD) {
            lua_getglobal(L1, "foo");
            lua_xmove(L, L1, 1);/*перемещает значение Lua между двумя стеками в
            одном и том же состоянии.*/
            lua_pcall(L1, 1, 0, 0);
        }
        else if (ret == 0) {/*Когда функция lua_resume возвращается, стек содержит все значения,
        переданные в lua_yield, или все значения, возвращенные телом функции.*/
        //showstack(L);
            break;
        }
    };

    lua_close(L);
    return 0;
};

Функции выполняются поочередно в двух потоках. Вернуть значений из lua_yield.

int my_yield(lua_State* L) {
    return lua_yield(L, 1);/*Эта функция должна вызываться только как возвращаемое выражение функции C следующим образом:
    return lua_yield(L, res); Когда функция C вызывает lua_yieldтаким образом, запущенная сопрограмма приостанавливает
    свое выполнение, и вызов lua_resume этой запущенной процедуры возвращается. Параметр res - это число значений из стека,
    которые передаются как результаты lua_resume.*/
};

const char* LUA = R"(
function foo()
x=10
print(" func foo "..x.."\n")
end

function main()
for i = 1, 3 do
print(" func main "..i.."\n")
my_yield(i)
end  end
)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_State* L1 = lua_newthread(L);

    lua_register(L, "my_yield", my_yield);// регистрация функций.
    checkerror(L, LUA);
    lua_getglobal(L, "main");// получить функцию.
    while (true) {
        int ret = lua_resume(L, L1, 0);

        if (ret == LUA_YIELD) {
            lua_xmove(L, L1, 1);// отравить значение из yield потока L в стек L1.
            lua_getglobal(L1, "foo");
            lua_pcall(L1, 0, 0, 0);
        }
        else if (ret == 0) {/*Когда функция lua_resume возвращается, стек содержит все значения,
        переданные в lua_yield, или все значения, возвращенные телом функции.*/

            break;
        }
    };

showstack(L1);

    lua_close(L);
    return 0;
};


Функции выполняются поочередно в двух потоках с передачей значение в main из main в foo. Вернуть значений из lua_yield.

int my_yield(lua_State* L) {
    return lua_yield(L, 0);/*Эта функция должна вызываться только как возвращаемое выражение функции C следующим образом:
    return lua_yield(L, res); Когда функция C вызывает lua_yield таким образом, запущенная сопрограмма приостанавливает
    свое выполнение, и вызов lua_resume этой запущенной процедуры возвращается. Параметр res - это число значений из стека,
    которые передаются как результаты lua_resume.*/
};

const char* LUA = R"(
function foo(x1)
x= x1 * 10
print(" func foo "..x.."\n")
return x
end

function main(n)
for i = 1, 3 do
print(" func main "..n.."\n")
my_yield(i)
end  end
)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_State* L1 = lua_newthread(L);

    lua_register(L, "my_yield", my_yield);// регистрация функций.
    checkerror(L, LUA);
    lua_getglobal(L, "main");// получить функцию.
    lua_pushinteger(L, 10);
    while (true) {
        int ret = lua_resume(L, L1, 1); /* Запускает и продолжает сопрограмму в данном потоке L.
    вы отправляйте в стек главную функцию и её аргументы; затем вызываете lua_resume,nargs - кол-во аргументов.
    Вызов возвращается, когда приостанавливается или завершается. При возвращении, стек содержит все значения,
    переданные в lua_yield, или возвращенныеции. Чтобы продолжить сопрограмму, вы удаляете все результаты
    из последнего lua_yield, отправьте в её стек только значения, передаваемые в качестве результатов из yield, и
    затем вызываете lua_resume.   Параметр L представляет сопрограмму, которая продолжает L. */

        if (ret == LUA_YIELD) {
            cout << "\n res from func my_yield "<< lua_tointeger(L, -1) << "\n\n";/*Когда lua_resume возвращает LUA_YIELD,
             стек потока содержит значения, переданные yield. число выработанных значений.*/
            lua_getglobal(L1, "foo");
            lua_xmove(L, L1, 1);/*перемещает значение Lua между двумя стеками в
            одном и том же состоянии.*/
            lua_pcall(L1, 1, 0, 0);

        }
        else if (ret == 0) {/*Когда функция lua_resume возвращается, стек содержит все значения,
        переданные в lua_yield, или все значения, возвращенные телом функции.*/
            break;
        }
    };

    lua_close(L);
    return 0;
};

Вариант 2.

int my_yield(lua_State* L) {
    return lua_yield(L, 0);/*Эта функция должна вызываться только как возвращаемое выражение функции C следующим образом:
    return lua_yield(L, res); Когда функция C вызывает lua_yieldтаким образом, запущенная сопрограмма приостанавливает
    свое выполнение, и вызов lua_resume этой запущенной процедуры возвращается. Параметр res - это число значений из стека,
    которые передаются как результаты lua_resume.*/
};

const char* LUA = R"(
function foo(x1)
x= x1 * 10
print(" func foo "..x.."\n")
return x
end

function main(n)
for i = 1, 3 do
print(" func main "..n.."\n")
my_yield(i)
end  end
)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_State* L1 = lua_newthread(L);

    lua_register(L, "my_yield", my_yield);// регистрация функций.
    checkerror(L, LUA);
    lua_getglobal(L, "main");// получить функцию.
    lua_pushinteger(L, 10);
    while (true) {
        int ret = lua_resume(L, L1, 1); /* Запускает и продолжает сопрограмму в данном потоке L.
    вы отправляйте в стек главную функцию и её аргументы; затем вызываете lua_resume,nargs - кол-во аргументов.
    Вызов возвращается, когда приостанавливается или завершается. При возвращении, стек содержит все значения,
    переданные в lua_yield, или возвращенныеции. Чтобы продолжить сопрограмму, вы удаляете все результаты
    из последнего lua_yield, отправьте в её стек только значения, передаваемые в качестве результатов из yield, и
    затем вызываете lua_resume.   Параметр L представляет сопрограмму, которая продолжает L. */

        if (ret == LUA_YIELD) {
            cout << "\n res from func my_yield " << lua_tointeger(L, -1) << "\n\n";/*Когда lua_resume возвращает LUA_YIELD,
             стек потока содержит значения, переданные yield. число выработанных значений.*/
            lua_xmove(L, L1, 1);/*перемещает значение Lua между двумя стеками в
            одном и том же состоянии.*/
            lua_pop(L, 1);
            lua_getglobal(L1, "foo");
            lua_xmove(L, L1, 1);/*перемещает значение Lua между двумя стеками в
            одном и том же состоянии.*/
            lua_pcall(L1, 1, 0, 0);
        }
        else if (ret == 0) {/*Когда функция lua_resume возвращается, стек содержит все значения,
        переданные в lua_yield, или все значения, возвращенные телом функции.*/
            break;
        }

    };
   showstack(L1);
    lua_close(L);
    return 0;
};


Функции main и foo с циклом for, выполняются поочередно в двух потоках.

int my_yield2(lua_State* L) {
    return lua_yield(L, 0);/*Эта функция должна вызываться только как возвращаемое выражение функции C следующим образом:
    return lua_yield(L, res); Когда функция C вызывает lua_yieldтаким образом, запущенная сопрограмма приостанавливает
    свое выполнение, и вызов lua_resume этой запущенной процедуры возвращается. Параметр res - это число значений из стека,
    которые передаются как результаты lua_resume.*/
};


int my_yield(lua_State* L) {
    return lua_yield(L, 0);/*Эта функция должна вызываться только как возвращаемое выражение функции C следующим образом:
    return lua_yield(L, res); Когда функция C вызывает lua_yieldтаким образом, запущенная сопрограмма приостанавливает
    свое выполнение, и вызов lua_resume этой запущенной процедуры возвращается. Параметр res - это число значений из стека,
    которые передаются как результаты lua_resume.*/
};

const char* LUA = R"(
function foo()
for i = 1, 3 do
print(" func foo "..i.."\n")
my_yield2(i)
end
end

function main()
for i = 1, 3 do
print(" func main "..i.."\n")
my_yield(i)
end  end
)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_State* L1 = lua_newthread(L);

    lua_register(L, "my_yield", my_yield);// регистрация функций.
    lua_register(L, "my_yield2", my_yield2);// регистрация функций.
    checkerror(L, LUA);
    lua_getglobal(L, "main");// получить функцию.

    while (true) {
        int ret = lua_resume(L, L1, 0); /* Запускает и продолжает сопрограмму в данном потоке L.
                                        Параметр L представляет сопрограмму, которая продолжает L. */
        if (ret == LUA_YIELD) {
            lua_getglobal(L1, "foo");
            lua_resume(L1, L, 0);
        }
        else if (ret == 0) {/*Когда функция lua_resume возвращается, стек содержит все значения,
        переданные в lua_yield, или все значения, возвращенные телом функции.*/
            break;
        }

    };
    lua_close(L);
    return 0;
};


Функции main и foo с циклом for, выполняются поочередно в двух потоках с поочередным приостановлением.

int my_yield(lua_State* L) {
    return lua_yield(L, 0);/*Эта функция должна вызываться только как возвращаемое выражение функции C следующим образом:
    return lua_yield(L, res); Когда функция C вызывает lua_yield таким образом, запущенная сопрограмма приостанавливает
    свое выполнение, и вызов lua_resume этой запущенной процедуры возвращается. Параметр res - это число значений из стека,
    которые передаются как результаты lua_resume.*/
};

const char* LUA = R"(
function main()
for i = 1, 3 do
print(" func main "..i.."\n")
my_yield()
end  end
function foo()
for i = 1, 3 do
print(" func foo "..i.."\n")
my_yield()
end end

)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывае�