How to destruct C++ class inside package.preload function - c++

Question

I'm using C++ classes in Lua which I wrapped using SWIG.
Since I'm using a single Lua_State, I would like to be able to free variables in a specific chunk of Lua script without calling lua_close(L).
I decided to use package.preload['name'] so a chunk can be accessed from other chunk by using require 'name' when needed.
And I was told that the variables inside package.preload function are freed after I do the following:
package.preload['name'] = nil
package.loaded['name'] = nil
However, it seems my custom C++ classes are not destructed even after this.
Here's my full example code:
In Main.cpp
#include "Main.h"
int main()
{
lua_State *L = luaL_newstate();
luaL_openlibs(L);
luaopen_my(L);
lua_settop(L, 0);
luaL_dostring(L, "package.preload['test'] = function ()\n"
"local test = {}\n"
"local class = my.Class()\n"
"return test\n"
"end\n");
luaL_dostring(L, "require 'test'");
luaL_dostring(L, "package.preload['test'] = nil\n"
"package.loaded['test'] = nil\n");
}
In Main.h
#include "lua.hpp"
extern "C"
{
int luaopen_my(lua_State *L);
}
int main();
In MyBindings.h
#include "Main.h"
class Class
{
public:
Class()
{
std::cout << "Class Constructed" << std::endl;
};
~Class()
{
std::cout << "Class Destructed" << std::endl;
};
};
In MyBindings.i (SWIG interface to generate MyBindings.cpp)
%module my
%{
#include "MyBindings.h"
%}
%include <stl.i>
%include <typemaps.i>
%include "MyBindings.h"
Result :
Class Constructed
Why is class destructor not called and how to correctly destruct classes and variables inside package.preload function?

Answer 1

I cannot reproduce your problem but you have other shortcomings in your code, most notably the absence of header guards. The file Main.h is not necessary and even less so in the MyBindings.h file because it doesn't make use of it. I don't know which compiler you are using but void main() is not valid C++, the standard dictates int main().
Main.cpp
#include "lua.hpp"
extern "C" int luaopen_my(lua_State *L);
int main() {
lua_State *L = luaL_newstate();
luaL_openlibs(L);
luaopen_my(L);
lua_settop(L, 0);
luaL_dostring(L, "package.preload['test'] = function ()\n"
"local test = {}\n"
"local class = my.Class()\n"
"return test\n"
"end\n");
luaL_dostring(L, "require 'test'");
luaL_dostring(L, "package.preload['test'] = nil\n"
"package.loaded['test'] = nil\n");
lua_close(L);
}
MyBindings.h
#pragma once
#include <iostream>
class Class
{
public:
Class()
{
std::cout << "Class Constructed" << std::endl;
};
~Class()
{
std::cout << "Class Destructed" << std::endl;
};
};
MyBindings.i
%module my
%{
#include "MyBindings.h"
%}
%include "MyBindings.h"
Example invocation:
$ swig -c++ -lua MyBindings.i
$ clang++ -Wall -Wextra -Wpedantic -I /usr/include/lua5.2 -fPIC -shared MyBindings_wrap.cxx -o my.so -llua5.2
$ clang++ -Wall -Wextra -Wpedantic -I /usr/include/lua5.2 -L . Main.cpp -l:my.so -llua5.2
$ LD_LIBRARY_PATH=. ./a.out
Class Constructed
Class Destructed
Also you should note that Lua is a garbage collected language, i.e. destructors will run when the garbage collector thinks it is necessary. You can run the garbage collector manually using lua_gc in C or using collectgarbage in Lua but I strongly advise against running the garbage collector manually as this usually impacts performance negatively (even though you ran it manually hoping to increase performance). It only pays off to use the garbage collector manually when you are running in an environment with very limited memory and you have just pruned a table or something like that.
Anyway, I have prepared an example in Lua for you using the my.so module compiled above.
local my = require("my")
local x = my.Class()
print("Info: Deleting x")
x = nil
print("Info: Collecting garbage")
collectgarbage()
print("Info: Done :-)")
$ lua5.2 test.lua
Class Constructed
Info: Deleting x
Info: Collecting garbage
Class Destructed
Info: Done :-)

Answer 2

You can always call the d'tor explicitly byt obj.~class().
If you are using external classes in Lua wrapper, I'm not sire they can follow the correct nested d'tor paradigm which exists in C++.