-- Definition of the Lua function that will be called from the C++ code:

function Add (a, b)
    print("[Lua] Called Add(" .. a .. ", " .. b .. ")")
    return a + b
end

// The Lua-provided function will be called in main():

#include <iostream>
#include <format>

extern "C"
{
#include <lua.h>
#include <lualib.h>
#include <lauxlib.h>
}

int main (int argc, char* argv[])
{    
    const auto L = luaL_newstate();
    
    // Opening (only) the basic Lua library (for print() in the Lua script).
    // (See comment on the next section for more details on this.)
    luaL_requiref(L, "_G", luaopen_base, 1);
    lua_pop(L, 1);
    
    // Load & Run the Lua code:
    //
    // Note: Loading alone won't make any globals or functions from a Lua file available;
    //       we must first also execute the loaded chunk (Lua has helper to combine these steps).
    //
    // Again: I left out any checks of the results; recommended only for demonstration purposes!
    luaL_loadfile(L, argv[1]);       // Load (argument = filepath).
    lua_pcall(L, 0, LUA_MULTRET, 0); // Run loaded chunk.
    
    // Find (and push onto the stack) the Lua function that should be called later:
    const char* LuaFunctionName = "Add";
    int type = lua_getglobal(L, LuaFunctionName);

    // Check and call the function (maybe):
    if (lua_isnoneornil(L, -1))
    {
        std::cout << std::format("Nothing with the name '{0}' was found!", LuaFunctionName) << std::endl;
    }
    else if (lua_isfunction(L, -1))
    {
        // Define the argument values:
        double FirstValue  = 2.4;
        double SecondValue = 3.1;
        
        // Push the values as Lua numbers on the stack, so that the Lua function can pop it as
        // its parameters 'a' and 'b' (pay attention to the order, it's a stack, after all!).
        lua_pushnumber(L, FirstValue);
        lua_pushnumber(L, SecondValue);
        
        // Call the Lua function: 2 Parameters, 1 Return Value expected, 0 (error) message handler:
        int ParamCount  = 2;
        int RetValCount = 1;

        if (lua_pcall(L, ParamCount, RetValCount, 0) == LUA_OK)
        {
            std::cout << std::format("[C++] Called Lua function '{0}({1}, {2})' -> Return Value: {3}",\
                "Add", FirstValue, SecondValue, (double)lua_tonumber(L, -1)) << std::endl;
            
            lua_pop(L, RetValCount); // Keep the stack tidy: Pop all returned values from the stack again.
        }
        else
        {
            std::string em = lua_tostring(L, -1);
            std::cout << em << std::endl;
        }
    }
    else
    {
        std::cout << std::format("Something with the name '{0}' was found, but it's not a Lua function, but of type '{1}'!",\
            LuaFunctionName, lua_typename(L, type)) << std::endl;
    }

    lua_close(L);

    return 0;
}

-- Lua script that calls the C++-provided function:

arguments = { 1, 2, 3 }
result    = Sum(arguments[1], arguments[2], arguments[3])

print("[Lua] Calling a C++ function with these arguments: (" .. table.concat(arguments, ", ") .. ")")
print("[Lua] The result of the C++ function call is: " .. result)

// The C++ program that defines the function for the Lua code
// (and also invokes the Lua script which then calls that function...)

#include <iostream>

extern "C"
{
#include <lua.h>
#include <lualib.h>
#include <lauxlib.h>
}

//------------------------------
// Definition of the C++ function that can be called from the Lua script:

int CppSumFunction (lua_State* L)
{
    // Get the index of the top of the stack (which is also the current size of the stack and
    // the number of arguments passed to the function (remember that Lua starts counting with 1!).
    int NumberOfArguments = lua_gettop(L);
    
    double sum = 0;
    
    // Get every argument from the stack and add it to the sum:
    // (Once more: Remember that Lua starts counting [its stack elements] with 1!)
    for (int i = 1; i <= NumberOfArguments; i++)
    {
        // Imagine that we start with a fresh/empty stack, using the absolute index
        // (i.e. from the bottom, so using 1, 2, etc. is correct):
        sum += lua_tonumber(L, i);
        
        // But: lua_to* is type unsafe; prefer luaL_check* functions.
    }
    
    // Push the return value(s) onto the stack:
    // The count of pushes must match the number of returned values by this function!
    lua_pushnumber(L, sum); 
    
    std::cout << "[C++] Host function has been called (by Lua)" << std::endl;
    
    // The return value of the function must be the amount of actual return values
    // that will be pushed onto the stack for Lua (= number of arguments passed back to Lua):
    return 1; // In this case it's just 1 value: The value of 'sum'.
}

//------------------------------
// Setting up the Lua state and invoking the Lua script (provided as an filepath argument):

int main (int argc, char* argv[])
{    
    const auto L = luaL_newstate();
    
    /*
        Open specific Lua libraries, so that a Lua script can use several functions
        (For example: print() requires Lua's basic standard library to be loaded.)
        
        Helpful:
        - https://stackoverflow.com/a/57190353
        - https://www.lua.org/manual/5.4/manual.html#6 ("6 – The Standard Libraries"):
          "[...] Alternatively, the host program can open them individually by using luaL_requiref [...]"
        
        One reason to be so specific (instead of simply calling luaL_openlibs()),
        is to reduce the possible attack vector/surface by preventing that a user script can
        do or call things that we don't want it (e.g. access to the filesystem).
        
        Note: Things changed with Lua 5.1; many older tips on the internet don't work anymore with version 5.4.7.
    */
    
    luaL_requiref(L, "_G", luaopen_base, 1);            // Lua's Basic Library.
    lua_pop(L, 1);
    
    luaL_requiref(L, LUA_TABLIBNAME, luaopen_table, 1); // Lua's Table library.
    lua_pop(L, 1);
    
    // Register the C++ function with Lua (under a different name for Lua):
    lua_register(L, "Sum", CppSumFunction);
    
    // Call the Lua code (first argument to main = filepath to the script):
    luaL_dofile (L, argv[1]);

    lua_close(L);
	
	return 0;
}

#include <lua.h>
#include <lauxlib.h>

static int l_multiply_by_ten (lua_State* L)
{
    double number = luaL_checknumber(L, 1);
    lua_pushnumber(L, number * 10);
    return 1;
}

// ...

int luaopen_nativefunc (lua_State* L)
{
    // A C struct array to hold the info about the functions to be exported:
    // (luaL_Reg is defined by Lua)
    static const struct luaL_Reg NativeFunctions [] =
    {
         { "multiply_by_ten", l_multiply_by_ten }, // = function name (in Lua); pointer to the function.
         // ...
         { NULL, NULL } // A luaL_Reg array must end with a sentinel entry: both values must be NULL.
    };
    
    luaL_register(L, "nativelib", NativeFunctions);
        // "nativelib" will be a global variable for holding the functions (a Lua callback table).
    return 1;
}

require "nativefunc" -- Import (see note below!)

-- Alternatives (not recommended! https://www.lua.org/manual/5.4/manual.html#pdf-package.loadlib)
-- Not ISO C; not available on all platforms; insecure; low-level; bypasses package/module system.
--     lib = package.loadlib("./nativefunc.dll", "luaopen_nativefunc")
--     lib();
-- or:
--     package.loadlib("./nativefunc.dll", "luaopen_nativefunc")()

r = nativelib.multiply_by_ten(2) -- Use
print(r)