将std :: strings的std :: vector解析为任意类型的std :: tuple

Question

I'm writing a command-line interpreter. In the old C++03 days you had to declare a fixed prototype and then parse arguments inside it. But in C++11 we have variadic templates, so I wanted to write the code that will work with any function prototype and will automatically parse all arguments using std::stringstream.

So far, I got the following code:

#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <tuple>
#include <functional>

template <typename... Args>
class Command
{
public:
    Command(std::function<void(Args...)> callback, std::tuple<Args...> args)
        : callback(callback), args(args)
    {
    }
    void Execute(std::vector<std::string> call)
    {
        Parse(std::integral_constant<std::size_t, std::tuple_size<decltype(args)>::value - 1>{}, args, call);
        CallFunc(GenerateArgumentIndexPack<std::tuple_size<decltype(args)>::value>::Pack());
    }
private:
    std::function<void(Args...)> callback;
    std::tuple<Args...> args;

    template <typename T>
    void Fill(const std::string& input, T& output)
    {
        std::stringstream stream;
        stream << input;
        stream >> output;
    }

    template<std::size_t N, typename... Ts>
    void Parse(std::integral_constant<std::size_t, N>, std::tuple<Ts...>& info, std::vector<std::string>& tokens)
    {
        Fill(tokens[N], std::get<N>(info));
        Parse(std::integral_constant<std::size_t, N - 1>{}, info, tokens);
    }

    template<typename... Ts>
    void Parse(std::integral_constant<std::size_t, 0>, std::tuple<Ts...>& info, std::vector<std::string>& tokens)
    {
        Fill(tokens[0], std::get<0>(info));
    }

    template <std::size_t... ArgumentIndexes>
    struct ArgumentIndexPack {};

    template <std::size_t NumberOfArgumentIndexesToGenerate, std::size_t... GeneratedArgumentIndexes>
    struct GenerateArgumentIndexPack : GenerateArgumentIndexPack<NumberOfArgumentIndexesToGenerate - 1, NumberOfArgumentIndexesToGenerate - 1, GeneratedArgumentIndexes...> {};

    template <std::size_t... GeneratedArgumentIndexes>
    struct GenerateArgumentIndexPack<0, GeneratedArgumentIndexes...>
    {
        using Pack = ArgumentIndexPack<GeneratedArgumentIndexes...>;
    };

    template <std::size_t... ArgumentIndexes>
    void CallFunc(ArgumentIndexPack<ArgumentIndexes...>)
    {
        callback(std::get<ArgumentIndexes>(args)...);
    }
};

void Foo(int a, float b)
{
    std::cout << a << ' ' << b;
}

int main(int argc, char* argv[])
{
    try
    {

        Command<int, float> cmd1(&Foo, std::make_tuple(1, 2.0f));
        cmd1.Execute({"3", "4.0"});
    }
    catch (std::exception& e)
    {
        std::cerr << "Exception: " << e.what();
    }
    catch (...)
    {
        std::cerr << "Unknown exception.";
    }
}

The compile errors are:

/home/fatony/Stuff/C++/Test/Src/Main.cpp: In instantiation of ‘void Command<Args>::Execute(std::vector<std::basic_string<char> >) [with Args = {int, float}]’:
/home/fatony/Stuff/C++/Test/Src/Main.cpp:96:18:   required from here
/home/fatony/Stuff/C++/Test/Src/Main.cpp:34:84: error: dependent-name ‘Command<Args>::GenerateArgumentIndexPack<std::tuple_size<decltype (((Command<Args>*)this)->Command<Args>::args)>::value>::Pack’ is parsed as a non-type, but instantiation yields a type
   CallFunc(GenerateArgumentIndexPack<std::tuple_size<decltype(args)>::value>::Pack());
                                                                                ^
/home/fatony/Stuff/C++/Test/Src/Main.cpp:34:84: note: say ‘typename Command<Args>::GenerateArgumentIndexPack<std::tuple_size<decltype (((Command<Args>*)this)->Command<Args>::args)>::value>::Pack’ if a type is meant

Answer 1

There are two problems in your code. First: you should #include <sstream> .

Second: there is call of std::get<std::tuple_size<...>>(tuple) , that is incorrect, since there is no such index. You can fix it by using this

void Execute(std::vector<std::string> call)
{
    //auto size = call.size();
    Parse(std::integral_constant<std::size_t,
    std::tuple_size<decltype(args)>::value - 1>{}, args, call);
   //CallFunc(GenerateArgumentIndexPack<std::tuple_size<decltype(args)>::value>::Pack());
}

About your second error in CallFunc , this function should be

CallFunc(typename
GenerateArgumentIndexPack<std::tuple_size<decltype(args)>::value>::Pack());

as stated in compiler error.