Exposer classe C++ dans Lua

Version imprimable

Plop,

Cela fait bientôt quelques heures que je m'arrache les cheveux à la recherche d'informations sur comment exposer une instance de classe c++ dans une script lua et pas moyen de trouver.
Je sais comment exposer une fonction statique, permettre au script Lua de construire une class c++ mais pas ce que je veux.

Ce que j'aimerais faire exactement c'est accèder une instance de LuaClass de façon globale depuis le script lua.
Le but c'est d'avoir quelque chose dans le genre bien que je ne soit pas sur de la syntaxe.

Code:

Plop.debug()

Merci d'avance,
Je rajoute quand même mon code au cas ou.

main.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# include "LuaScript.hpp"
# include "LuaClass.hpp"
 
int	main(int ac, char **av)
{
  (void)ac;
  (void)av;
  LuaScript   Test;
  LuaClass    Plop("Debug");
 
  Test.loadFile("files/test.lua");
  Test.call();
  return 0;
}

LuaScript.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include "LuaScript.hpp"
 
LuaScript::LuaScript()
{
  _state = luaL_newstate();
  luaL_openlibs(_state);
}
 
LuaScript::~LuaScript()
{
}
 
bool LuaScript::loadFile(std::string param)
{
  if (luaL_loadfile(_state, param.c_str()) != LUA_OK)
  {
    LuaError();
    return false;
  } else
    return true;
}
 
void LuaScript::call()
{
  if (lua_pcall(_state, 0, LUA_MULTRET, 0) != LUA_OK)
    LuaError();
}
 
void LuaScript::LuaError() const
{
  const char *message = lua_tostring(_state, -1);
  std::cout << message << std::endl;
  lua_pop(_state, 1);
}

LuaScript.hpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#ifndef LUA_LOADER_LUASCRIPT_HPP
#define LUA_LOADER_LUASCRIPT_HPP
 
# include       <lua5.2/lua.hpp>
# include       <string>
# include       <iostream>
 
class LuaScript
{
private:
  lua_State *_state;
 
public:
  LuaScript();
 
  ~LuaScript();
 
  bool loadFile(std::string);
 
  void  call();
 
  void LuaError() const;
 
};
 
#endif //LUA_LOADER_LUASCRIPT_HPP

LuaClass.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include "LuaClass.hpp"
 
LuaClass::LuaClass(std::string value)
{
  _value = value;
}
 
LuaClass::~LuaClass()
{
}
 
void LuaClass::debug() const
{
  std::cout << "Test : " << _value << std::endl;
}

LuaClass.hpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#ifndef LUA_LOADER_LUACLASS_HPP
#define LUA_LOADER_LUACLASS_HPP
 
# include   <iostream>
 
class LuaClass
{
private:
  std::string _value;
public:
  LuaClass(std::string);
 
  ~LuaClass();
 
  void debug() const;
};
 
#endif //LUA_LOADER_LUACLASS_HPP

Salut

À mon avis, il vaut mieux utiliser un binding comme https://github.com/ahupowerdns/luawrapper :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 // main.cpp
#include <LuaContext.hpp>
#include <fstream>
#include <iostream>
 
struct Hello {
    void sayHello() { std::cout << "Hello from C++\n"; } 
};
 
int main() {
    LuaContext lua;
    lua.registerFunction("sayHello", &Hello::sayHello);
 
    Hello myHello;
    lua.writeVariable("myHello", &myHello);  // exporte l'instance
    std::ifstream ifs("script.lua");
    lua.executeCode(ifs);
 
    return 0;
}

Code:

1
2
3
 -- script.lua
io.write(string.format("Hello from lua\n"))
myHello:sayHello()

Merci ça marche parfaitement !

Du coup voilà la fin du projet si jamais ça tente quelqu'un d'y jeter un coup d'oeil :
C'est pas le truc le plus propre du monde mais ça marche ^^

LuaScript.hpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#ifndef LUA_LOADER_LUASCRIPT_HPP
#define LUA_LOADER_LUASCRIPT_HPP
 
# include       <LuaClass.hpp>
# include       <string>
# include       <iostream>
# include       <fstream>
 
class LuaScript
{
private:
  LuaContext lua;
  std::ifstream ifs;
 
public:
  LuaScript();
 
  ~LuaScript();
 
  bool loadFile(std::string);
 
  void call();
 
  template<typename T>
  void registerClass(ILuaClass *param, std::string name)
  {
    param->registerFunction(lua);
    lua.writeVariable(name, *(static_cast<T*>(param)));
  }
 
};
 
#endif //LUA_LOADER_LUASCRIPT_HPP

LuaScript.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include "LuaScript.hpp"
 
LuaScript::LuaScript()
{
}
 
LuaScript::~LuaScript()
{
}
 
bool LuaScript::loadFile(std::string param)
{
  ifs.open(param.c_str());
  return ifs.is_open();
}
 
void LuaScript::call()
{
  lua.executeCode(ifs);
}

LuaClass.hpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#ifndef LUA_LOADER_LUACLASS_HPP
#define LUA_LOADER_LUACLASS_HPP
 
# include   <iostream>
# include   <LuaContext.hpp>
 
class ILuaClass
{
public:
  virtual ~ILuaClass() {};
 
  virtual void  registerFunction(LuaContext&) = 0;
};
 
class LuaClass : public ILuaClass
{
private:
  std::string _value;
public:
  LuaClass(std::string);
 
  ~LuaClass();
 
  void debug() const;
 
  virtual void  registerFunction(LuaContext&);
};
 
#endif //LUA_LOADER_LUACLASS_HPP

LuaClass.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include "LuaClass.hpp"
 
LuaClass::LuaClass(std::string value)
{
  _value = value;
}
 
LuaClass::~LuaClass()
{
}
 
void LuaClass::debug() const
{
  std::cout << "Test : " << _value << std::endl;
}
 
void LuaClass::registerFunction(LuaContext &lua)
{
  lua.registerFunction("debug", &LuaClass::debug);
}

main.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# include "LuaScript.hpp"
 
int main(int ac, char **av)
{
  (void) ac;
  (void) av;
  LuaScript   Test;
  LuaClass Plop("test");
 
  Test.loadFile("files/test.lua");
  Test.registerClass<LuaClass>(&Plop, "Plop");
  Test.call();
  return 0;
}

test.lua

Code:

1
2
io.write(string.format("Hello from lua\n"))
Plop:debug()

17/10/2016, 16h45
koala01
Salut,
Juste quelques petites remarques, pour te permettre de l'améliorer encore :
- Depuis C++11, les fichiers acceptent aussi les std::string... y a plus besoin de demander une chaine C style avec c_str()
- Les chaines de caractères sont décidément géniales, mais la copie est un processus qui prend énormément de temps... Afin d'éviter les copies inutiles, tu devrais les transmettre sous la forme d'une référence (éventuellment constante si la fonction appelée n'est pas destinée à la modifier)
- Plustôt que d'ouvrir un fichier dans une fonction, puis de le garder ouvert jusqu'à la fin (ce qui peut poser certains problèmes), sauvegarde peut être plutot le non de fichier (en faisant au besoin un test pour t'assurer qu'il s'ouvre), et ouvre le dans la (ou les) fonction(s) qui l'utilisent
- la fonction loadFile ne fait pas ce qu'elle prétend ; tu ferais bien de la renommer en quelque chose d'autre, qui indiquerait clairement que le but est de vérifier l'accessibilité du fichier
- Ta class LuaScript fini par avoir quatre responsabilités distinctes:
  1. tester l'accessibilité du fichier
  2. garder le fichier ouvert
  3. enregistrer les infos dans le fichier
  4. appeler l'exécution du script
  Ca fait au moins trois responsabilités de trop, en vertu du SRP