这是我要实现的界面:

 Statement  select("SELECT * FROM People WHERE ID > ? AND ID < ?");
 select.execute(1462, 1477, [](int ID, std::string const& person, double item1, float item2){
     std::cout << "Got Row:" 
               << ID     << ", " 
               << person << ", " 
               << item1  << ", " 
               << item2  << "\n";
 });

“？”在哪里？选择字符串中的在运行时与变量参数列表 1462、1477 匹配。

这是类定义:

class Statement
{
    public:
        Statement(std::string const&);

        template<class Action, class ...Args>
        void execute(Args... param, Action action);
};

不幸的是，这会产生一个错误:

test.cpp:133:12: error: no matching member function for call to 'execute'
select.execute(1462, 1477, [](int ID, std::string const& person, double item1, float item2){
~~~~~^~~~~~~

test.cpp:86:14: note: candidate template ignored: couldn't infer template argument 'Action'
void execute(Args... param, Action action)
~~~^~~~~~~

1 error generated.

但如果我稍微更改函数定义(如下)，它可以正常编译。

class Statement
{
    public:
        Statement(std::string const&);

        template<class Action, class ...Args>
        void execute(Action action, Args... param);
                  // ^^^^^^^ Move action to the front.
};
// Also changed the call by moving the lambda to the first argument.

我知道可变参数列表的语法糖，但我想把可变参数列表放在第一位。有什么技巧可以帮助编译器正确推导 var arg 列表吗？

最佳答案

有点难看，但你可以使用元组:

#include <iostream>
#include <string>
#include <tuple>

template<int... Is>
struct integer_sequence {};
template<int N, int... Is>
struct make_integer_sequence : make_integer_sequence<N-1, N-1, Is...> {};
template<int... Is>
struct make_integer_sequence<0, Is...> : integer_sequence<Is...> {};

class Statement
{
    private:
        std::string foo;

    public:
        Statement(std::string const& p)
            : foo(p)
        {}

        template<class ...Args>
        void execute(Args... param)
        {
            execute_impl(make_integer_sequence<sizeof...(Args)-1>{}, param...);
        }

        template<int... Is, class... Args>
        void execute_impl(integer_sequence<Is...>, Args... param)
        {
            std::get<sizeof...(Args)-1>(std::tie(param...))
                (std::get<Is>(std::tie(param...))..., foo);
        }
};

使用示例:

int main()
{
    Statement s("world");
    s.execute("hello", ", ",
              [](std::string const& p1, std::string const& p2,
                 std::string const& p3)
              { std::cout << p1 << p2 << p3; });
    std::cout << "\nEND\n";
}

这是另一种解决方案，不那么难看但更冗长:

#include <iostream>
#include <string>
#include <tuple>

template<class Tuple, class...>
struct pop_back;

template<class T, class... Ts, class... Us>
struct pop_back<std::tuple<T, Ts...>, Us...>
    : pop_back<std::tuple<Ts...>, Us..., T>
{};

template<class T, class... Us>
struct pop_back<std::tuple<T>, Us...>
{
    using type = std::tuple<Us...>;
};

class Statement
{
    private:
        std::string foo;

    public:
        Statement(std::string const& p)
            : foo(p)
        {}

        template<class ...Args>
        void execute(Args... param)
        {
            helper<typename pop_back<std::tuple<Args...>>::type>
                ::execute(param..., foo);
        }

        template<class T>
        struct helper;

        template<class... Args>
        struct helper< std::tuple<Args...> >
        {
            template<class Action>
            static void execute(Args... param, Action action, std::string foo)
            {
                action(param..., foo);
            }
        };
};

这是一个简短的 is_callable 特性，它允许使用 static_assert 来获得更好的错误消息:

template<class F, class... Args>
struct is_callable
{
    template<class F1>
    static auto test(int)
        -> decltype( std::declval<F1>() (std::declval<Args>()...),
                     std::true_type{} );

    template<class F1>
    static std::false_type test(...);

    constexpr static auto value = decltype(test<F>(0))::value;
};

例如:

template<int... Is, class... Args>
void execute_impl(integer_sequence<Is...>, Args... param)
{
    auto& action = std::get<sizeof...(Args)-1>(std::tie(param...));
    auto param_tuple = std::tie(param...);

    static_assert(is_callable<decltype(action),
                              typename std::tuple_element<Is,
                                              decltype(param_tuple)>::type...,
                              decltype(foo)>::value,
                  "The action is not callable with those argument types.");

    action(std::get<Is>(param_tuple)..., foo);
}

关于C++11 变量参数对齐，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/22636151/