Question

我正在尝试用C ++做一些可怕的事情。

我有一个函数f(void*, ...)需要接受指向int，double的指针，无论如何。我有很多这样的结构：

void whatever() {
  somelogicHere();

  int a;
  double b;
  char c;

  f(&a, &b, &c);

  some(a);
  actions(b);
  onabc(c);
}

我想将那些有害的动作和变量定义包装到某个模板中，并将其称为：

myTemplate([](int a, double b, char c) {      
      some(a);
      actions(b);
      onabc(c);
});

必须做的小例子：

template<int S, typename ...A> 
void magicTemplate(const char(&fmt)[S], std::function<void(A...)> callback)
{
    char format[2 + S];
    format[0] = 'O';
    format[1 + S] = '\0';
    int s = S;
    memcpy(format + 1, fmt, S);

    // next lines is just a random stuff that does not work
    std::tuple<A...> local_arguments;

    extractArgs(format, &local_arguments...); //pointers to arguments must be passed
    callback(local_arguments...);  // arguments must be passed

}

...并调用我的模板：

magicTemplate("iii", [](int a, double b, char c)
{
    std::cout < a << std::endl;
    std::cout < b << std::endl;
    std::cout < c << std::endl;
});

第一件事 - 我的模板与这个论点不匹配，第二件事 - 我不知道magicTemplate的身体内部必须有什么。

Answer 1

我从parameter-detection code获得了一些好的里程：）

让我们先完成这项工作 - 我们希望从传递给magicTemplate的任何类型中获取参数类型列表：

namespace glk {
    namespace tmp {
        template <class T>
        struct type_is {
            using type = T;
        };

        template <class...>
        using void_t = void;

        // Pack of arbitrary types
        template <class...>
        struct pack { };

        namespace detail_parameters {
            template <class F, class = void_t<>>
            struct parameters { };

            template <class F>
            struct parameters<F, void_t<decltype(&F::operator ())>>
            : parameters<decltype(&F::operator ())> { };

            template <class R, class... Params>
            struct parameters<R(Params...)> : type_is<pack<Params...>>{ };

            template <class R, class... Params>
            struct parameters<R(*)(Params...)> : type_is<pack<Params...>>{ };

            template <class T, class R, class... Params>
            struct parameters<R(T::*)(Params...)> : type_is<pack<Params...>>{ };

            template <class T, class R, class... Params>
            struct parameters<R(T::*)(Params...) const> : type_is<pack<Params...>>{ };
        }

        // Retrieve the parameter list from a functionoid
        template <class F>
        using parameters = typename detail_parameters::parameters<
            std::remove_reference_t<F>
        >::type;
    }
}

现在glk::tmp::parameters<F>为我们提供了glk::tmp::pack<T...>，其中每个T对应一个参数。现在，让我们假设我们拥有它，并实现magicTemplate的实际主体：

template <std::size_t FmtSize, class AndThen, class... Args, std::size_t... ArgsIdx>
void magicTemplate(
    char const (&fmt)[FmtSize], AndThen &&andThen,
    glk::tmp::pack<Args...>,
    std::index_sequence<ArgsIdx...>
) {
    std::array<char, FmtSize + 1> fmtStr;
    fmtStr[0] = 'O';
    std::copy(fmt, fmt + FmtSize, fmtStr.data() + 1);

    std::tuple<Args...> args;
    std::scanf(fmtStr.data(), &std::get<ArgsIdx>(args)...);

    std::forward<AndThen>(andThen)(std::get<ArgsIdx>(args)...);
}

（我已将extractArgs替换为std::scanf用于测试目的，因为它们似乎非常相似）

现在只需要一些管道来实际生成所需的std::index_sequence：

template <std::size_t FmtSize, class AndThen, class... Args>
void magicTemplate(
    char const (&fmt)[FmtSize], AndThen &&andThen,
    glk::tmp::pack<Args...>
) {
    return magicTemplate(
        fmt, std::forward<AndThen>(andThen),
        glk::tmp::pack<Args...>{},
        std::index_sequence_for<Args...>{}
    );
}

template <std::size_t FmtSize, class AndThen>
void magicTemplate(char const (&fmt)[FmtSize], AndThen &&andThen) {
    return magicTemplate(
        fmt, std::forward<AndThen>(andThen),
        glk::tmp::parameters<AndThen>{}
    );
}

Etvoilà！我们可以用你想要的确切语法来调用这个东西。当然，一切看起来像错误检查的东西都留给了读者一个练习：）

Live demo on Coliru

Answer 2

您可以使用std::apply（c ++ 17，但可在c ++ 11中实现）

template<int N, typename ... Ts>
void magicTemplate(const char(&fmt)[N], std::function<void(Ts...)> callback)
{
    char format[2 + N];
    format[0] = 'O';
    format[N + 1] = '\0';
    memcpy(format + 1, fmt, N);

    std::tuple<Ts...> local_arguments;
    std::apply([&](auto& ...args){ extractArgs(format, &args...); }, local_arguments);
    std::apply(callback, local_arguments);
}

然后，要将lambda转换为std::function，您可能会有：

template <typename C> struct helper : helper<decltype(&C::operator())> {};

template <typename Ret, typename C, typename ...Ts>
struct helper<Ret (C::*)(Ts...) const> {
    using type = Ret(Ts...);
};

template <typename Ret, typename C, typename ...Ts>
struct helper<Ret (C::*)(Ts...)> {
    using type = Ret(Ts...);
};

template <typename F>
std::function<typename helper<std::decay_t<F>>::type> as_std_function(F&& f) { return f; }

最后：

template<int N, typename F>
void magicTemplateFinal(const char(&fmt)[N], F&& f)
{
    magicTemplate(fmt, as_std_function(f));
}

存储可变参数模板参数并将它们传递给lambda

2 个答案: