Templating for specific line in function - c++

Question

I'm writing a wrapper for embedded Lua, and I have a series of functions to retrieve global values from a lua_State. Since the function does almost the exact same thing for each (gets the global name with lua_getglobal(L, name), calls the appropriate lua_to___() function, and then pops the stack to return the lua_State to its original status), I figured there should be some way to do this with templates.
However, I can't seem to find a way to have that one specific line where the type matters be dependent on the type without writing completely separate functions for each type. While right now this function would only be three lines long, there are other similar functions that might be more complicated but with the same issue.
As of now, the functions look like this (this is within a class called LuaManager, which has a lua_State* member):
//Declaration
template<std::string>
std::string GetGlobal(const std::string & name);
template<int>
int GetGlobal(const std::string & name);
template<float>
float GetGlobal(const std::string & name);
template<bool>
bool GetGlobal(const std::string & name);
//Implementation
template<typename T>
T LuaManager::GetGlobal(const std::string & name)
{
lua_getglobal(luaState, name.c_str()); //push the global to the top of the stack
T value = lua_to____(luaState, -1); //store the value for return
lua_pop(luaState, 1); //return the stack to empty
return value;
}
Is there a way to be able to, for individual lines of code, specialize a template? Or am I misunderstanding what I should be using templates for?

Answer 1

The declaration should just be:
template<class T>
T GetGlobal(const std::string& name);
And for the implementation, I would create a struct template, and use the specialisations as a map from type to function.
#include <type_traits>
template<class>
struct lua_to;
template<>
struct lua_to<int> {
typedef int(*type)(decltype(luaState), int);
static constexpr const type value = lua_to_int;
};
template<>
struct lua_to<std::string> {
typedef std::string(*type)(decltype(luaState), int);
static constexpr const type value = lua_to_string;
};
// In this case, since this is so tedious, I would use a macro
#define MY_MODULE_DEFINE_LUA_TO(ctype, luatype) \
template<> \
struct lua_to<ctype> { \
typedef ctype(*type)(decltype(luaState), int); \
static constexpr const type value = lua_to_ ## luatype; \
};
MY_MODULE_DEFINE_LUA_TO(std::map, table);
MY_MODULE_DEFINE_LUA_TO(double, float);
#undef MY_MODULE_DEFINE_LUA_TO
template<class T>
T GetGlobal(const std::string& name) {
lua_getglobal(luaState, name); //push the global to the top of the stack
T value = lua_to<T>::value(luaState, -1); //store the value for return
lua_pop(luaState, 1); //return the stack to empty
return value;
}

Answer 2

If your compiler supports C++17, you can use if constexpr:
template<typename T>
T LuaManager::GetGlobal(const std::string & name)
{
lua_getglobal(luaState, name);
T value;
if constexpr (std::is_same_v<T, std::string>)
value = lua_to_string(luaState, -1); // I don't know the actual name of this function
else if (std::is_same_v<T, int>)
value = lua_to_int(luaState, -1);
else if (std::is_same_v<T, whatever>)
value = lua_to_whatever(luaState, -1);
// some other arbitrary type dependent code
else ... // other types
lua_pop(luaState, 1);
return value;
}
Note: To enable C++17 in Visual Studio, right click on your project and click on Properties. Then go to C/C++ -> Language -> C++ Language Standard and select /std:c++17 or /std:c++latest.
Update
If you cannot or don't want to use C++17, here is another approach that doesn't use any "new" features, even without templates:
void get_lua_value(string& value)
{
value = lua_to_string(luaState, -1);
}
void get_lua_value(int& value)
{
value = lua_to_int(luaState, -1);
}
Add one of these overloads for each type. Then you can just call get_lua_value() and overload resolution will do the job for you:
template<typename T>
T LuaManager::GetGlobal(const std::string& name)
{
lua_getglobal(luaState, name);
T value;
get_lua_value(value);
lua_pop(luaState, 1);
return value;
}

Answer 3

I think you should have a generic declaration and specialized implementations in that case. You can't just "switch the function" based on T on that one line. Consider this example:
#include <iostream>
// Generic declaration
template <typename T>
T doStuff(int arg);
// Specific definitions
template<>
int doStuff(int arg){
return arg + 1;
}
template<>
float doStuff(int arg){
return arg - 1;
}
int main(){
// Our templated function varies in return type,
// so you always have to explicitly specify which variant to use
// This WOULD NOT let compile infer what you want:
/* float test = doStuff(10) */ // ambiguous call
// This is OK
std::cout << doStuff<int>(10) << " " << doStuff<float>(10) << "\n";
return 0;
}
You will have an almost-identical GetGlobal function differing in just this one line. If you want to cut the repetition down, you could have a template for a conversion to a C++ type alone (taking a luaState as an arg), and then maybe templated GetGlobal that calls appropriate template variant

Answer 4

So turns out I was trying to make this a bit more complicated than I needed to:
I made the GetGlobal function not care at all about what type it was trying to get:
template<typename T>
T GetGlobal(const std::string & name)
{
lua_getglobal(luaState, name.c_str());
T value = lua_to<T>(-1);
lua_pop(luaState, 1);
return value;
}
And then I defined a template for lua_to<T>(int stack_index) and made each specialization for it use a different function:
template<typename T>
T lua_to(int stack_index);
template<>
int lua_to(int stack_index) {
return lua_tointeger(luaState, stack_index);
}
template<>
std::string lua_to(int stack_index) {
return std::string(lua_tostring(luaState, stack_index));
}
So far it works for both std::string and int, which seems to imply it will work for other types as well.