C++ “GCC元组”；“不完整类型的无效使用”；

我的代码如下：

#include <tuple>
#include <utility> 
#include <iostream>

template<int ...> struct seq {};
template<int N, int ...S> struct gens : gens<N - 1, N - 1, S...> {};
template<int ...S> struct gens<0, S...> { typedef seq<S...> type; };

template<typename ValueType>
bool get_value(ValueType& value, int index) {
    //just for test
    value = 100;
    return true;
}


template<>
bool get_value(const char*& value, int index) {
    //just for test
    value = "Hello?";
    return true;
}

template<int index, std::size_t remaining, typename... Args>
struct arg_helper {
    inline static bool
    get_args(std::tuple<Args...>& t) {
        if (get_value(std::get<index>(t), index)) {
            return arg_helper<index + 1, remaining - 1, Args...>::get_args(t);
        }
        else {
            return false;
        }
        return true;
    }
};


template<std::size_t index, typename... Args>
struct arg_helper<index, 0, Args... > {
    inline static bool
    get_args(std::tuple<Args...>& t) {
        return true;
    }
};


template<typename R, typename... Args, int ...S>
void callFunc(R(func)(Args...), seq<S...>, std::tuple<Args...>& tup) {
    func(std::get<S>(tup) ...);
}

template<typename R, typename... Args>
void TestFunc(R(func)(Args...)) {
    std::tuple<Args...> tup;

    arg_helper<0, sizeof ...(Args), Args...>::get_args(tup);

    callFunc(func, typename gens<sizeof...(Args)>::type(), tup);
}

static void FuncA(int test, const char* str) {
    std::cout << "test func" << test << str << std::endl;
}


int main() {
    TestFunc(FuncA);
    return 0;
}

#包括
#包括
#包括
模板结构seq{}；
模板结构gens:gens{}；
模板结构gens{typedef seq type；}；
模板
bool get_值（ValueType&value，int索引）{
//只是为了测试
数值=100；
返回true；
}
模板
bool get_值（常量字符*&值，整数索引）{
//只是为了测试
value=“你好？”；
返回true；
}
模板
结构参数辅助程序{
内联静态布尔
获取参数（std:：tuple）
它可以在gcc上运行，但似乎对MSVC2013不起作用。这似乎是因为您的非类型模板参数中的
int
和
size\t
不匹配。将它们全部更改为
size\t
，您就可以：



#包括
#包括
#包括
模板结构seq{}；
模板结构gens:gens{}；
模板结构gens{typedef seq type；}；
模板
bool get_值（值类型和值、大小索引）{
//只是为了测试
数值=100；
返回true；
}
模板
布尔获取值（常量字符*&值，大小索引）{
//只是为了测试
value=“你好？”；
返回true；
}
模板
结构参数辅助程序{
静态布尔
获取参数（std:：tuple&t）{
if（获取_值（标准：：获取（t），索引））{
return-arg\u-helper:：get\u-args（t）；
}
否则{
返回false；
}
返回true；
}
};
模板
结构参数辅助程序{
静态布尔
获取参数（std:：tuple&t）{
返回true；
}
};
模板
void callFunc（R（func）（Args…，seq，std:：tuple&tup）{
func（std:：get（tup）…）；
}
模板
void TestFunc（R（func）（参数…）{
std:：tuple-tup；
arg\u helper:：get\u args（tup）；
callFunc（func，typename gens:：type（），tup）；
}
void FuncA（int测试，常量字符*str）{
std:：cout您得到的完整错误消息是什么？@NathanOliver可以在这里尝试。有点离题，但是：请确保，因为这些不会过载。假设您要实现另一个模板函数，该函数重载
bool get_值（ValueType&value，int-index）
，比如
bool get_值（ValueType*&value，int-index）
。对于使用类型为
char*
的第一个参数调用
get\u value
，我们希望在重载解析中选择专门化
bool get\u value（const char*&value，int index）
，但这取决于重载的基本模板函数定义的出现顺序（
bool get_值（const T*&…，size_T…
），看似更通用的泛型函数可能比完全专用的函数更合适。基本模板重载
bool get_值（const T*&…，size_T…）
被视为重载解析中的最佳匹配，只有在选择此选项后，编译器才会查看所选基本模板函数的可能模板规范。这里的寓意是，您最好让专门化成为一个好的旧非模板函数（删除
模板
）。这里可能也值得一提：没有理由让（完全专用的函数）
get\u value（const char*&value，size\t index）
成为模板专用化：它也可以是非模板函数。
arg_helper<0, sizeof ...(Args), Args...>::get_args(tup);

#include <tuple>
#include <utility> 
#include <iostream>

template<size_t ...> struct seq {};
template<size_t N, size_t ...S> struct gens : gens<N - 1, N - 1, S...> {};
template<size_t ...S> struct gens<0, S...> { typedef seq<S...> type; };

template<typename ValueType>
bool get_value(ValueType& value, size_t index) {
    //just for test
    value = 100;
    return true;
}


template<>
bool get_value(const char*& value, size_t index) {
    //just for test
    value = "Hello?";
    return true;
}

template<size_t index, std::size_t remaining, typename... Args>
struct arg_helper {
    static bool
    get_args(std::tuple<Args...>& t) {
        if (get_value(std::get<index>(t), index)) {
            return arg_helper<index + 1, remaining - 1, Args...>::get_args(t);
        }
        else {
            return false;
        }
        return true;
    }
};

template<std::size_t index, typename... Args>
struct arg_helper<index, 0, Args... > {
    static bool
    get_args(std::tuple<Args...>& t) {
        return true;
    }
};


template<typename R, typename... Args, size_t ...S>
void callFunc(R(func)(Args...), seq<S...>, std::tuple<Args...>& tup) {
    func(std::get<S>(tup) ...);
}

template<typename R, typename... Args>
void TestFunc(R(func)(Args...)) {
    std::tuple<Args...> tup;

    arg_helper<0, sizeof ...(Args), Args...>::get_args(tup);

    callFunc(func, typename gens<sizeof...(Args)>::type(), tup);
}

void FuncA(int test, const char* str) {
    std::cout << "test func" << test << str << std::endl;
}


int main() {
    TestFunc(FuncA);
    return 0;
}