GCC元組「無效的使用不完全類型的」

Question

我有這樣一段代碼：海合會

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

它可以在MSVC2013運行，但編譯器錯誤就行了：

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

我是什麼做錯了？

BTW：我知道iterate over tuple 它可以在GCC運行，但對於MSVC2013

Answer 1

這似乎是因爲你不匹配你的非類型模板參數int和size_t似乎不起作用。改變它們遍佈於size_t和你沒事：

Demo (GCC)

Demo (Clang)

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