virtual pure function with template, how to make it valid

I come to such a scenario: 1. Need to define a interface 2. The interface's param's type and count is specify at run-time\n So, I need a template function, and as a interface, it should be virtual, but it's invalid by compiler, is there some way out? Sample code:

struct none
{};

template<typename T>
struct stru_result
{
   int  result_code;
   T    result;

   stru_result() :result_code(0)
   {}
   stru_result(const int& code) :result_code(code)
   {}
   stru_result(const int&code, const T& res) :result_code(code), result(res)
   {}
   stru_result(stru_result&& res) 
   {
      result_code = res.result_code;
      result = std::move(res.result);
   }
   stru_result(const stru_result& res)
   {
      result_code = res.result_code;
      result = res.result;
   }
   void operator = (const stru_result& res)
   {
      result_code = res.result_code;
      result = res.result;
   }
 };

 template<>
 struct stru_result<none>
 {
   int result_code;
   stru_result():result_code(0)
   {}
   stru_result(const int& code):result_code(code)
   {}
 };

class itest
{
public:
    template<typename T, typename ...Args>
    virtual int get_reply_atall(std::tuple<stru_result<T>, stru_result<Args>...>& aoTuple) = 0;
};

class ctest : public itest
{
public:
    ctest() {}
    ~ctest() {}

    template<typename T, typename ...Args>
    int get_reply_atall(std::tuple<stru_result<T>, stru_result<Args>...>& aoTuple) ;
};

template<typename T, typename...Args>
int ctest::get_reply_atall(std::tuple<stru_result<T>, stru_result<Args>...>& aoTuple)
{
    std::tuple<stru_result<T>> firstTuple;
    get_reply_atall<T>(firstTuple);

    std::tuple<stru_result<Args>...> resTuple;
    get_reply_atall(resTuple);

    aoTuple = std::tuple_cat(firstTuple, resTuple);
    return 0;
}

template<>
int ctest::get_reply_atall<int>(std::tuple<stru_result<int>>& aoTuple)
{
    stru_result<int> res = stru_result<int>(0, 1);
    aoTuple = std::make_tuple(res, res);
    return 0;
}

template<>
int ctest::get_reply_atall<char*>(std::tuple<stru_result<char*>>& aoTuple)
{
    char* ptr = "test";
    stru_result<char*> res = stru_result<char*>(0, ptr);
    aoTuple = std::make_tuple(res);
    return 0;
}