Создание шаблона для конкретной строки в функции

Объявление должно быть таким:

template<class T>
T GetGlobal(const std::string& name);

А для реализации я бы создал шаблон структуры и использовал бы специализации как карту от типа к функции.

#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;
}

Если ваш компилятор поддерживает C++ 17, вы можете использовать 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;
}

Примечание. Чтобы включить C++ 17 в Visual Studio, щелкните свой проект правой кнопкой мыши и выберите «Свойства». Затем перейдите в C / C++ -> Язык -> Стандарт языка C++ и выберите /std:c++17 или /std:c++latest.

Обновлять

Если вы не можете или не хотите использовать C++ 17, вот другой подход, который не использует никаких «новых» функций, даже без шаблонов:

void get_lua_value(string& value)
{
    value = lua_to_string(luaState, -1);
}

void get_lua_value(int& value)
{
    value = lua_to_int(luaState, -1);
}

Добавьте по одной из этих перегрузок для каждого типа. Затем вы можете просто вызвать get_lua_value(), и разрешение перегрузки сделает всю работу за вас:

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;
}

Я думаю, в этом случае у вас должна быть общая декларация и специализированные реализации. Вы не можете просто «переключить функцию» на основе T в этой единственной строке. Рассмотрим этот пример:

#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;
}

У вас будет почти идентичная функция GetGlobal, отличающаяся только одной строчкой. Если вы хотите сократить количество повторений, у вас может быть шаблон для преобразования только в тип C++ (принимая luaState в качестве аргумента), а затем, возможно, шаблон GetGlobal, который вызывает соответствующий вариант шаблона

Оказывается, я пытался сделать это немного сложнее, чем мне нужно: Я сделал функцию GetGlobal совершенно не заботящейся о том, какой тип она пытается получить:

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;
}

Затем я определил шаблон для lua_to<T>(int stack_index) и сделал каждую специализацию для него отдельной функцией:

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));
}

Пока он работает как для std::string, так и для int, что, похоже, означает, что он будет работать и для других типов.