25

目前我在尝试存储参数包时遇到问题，这是设计的示例代码：

template<typename Func, typename... Args>
void handleFunc(Func func, Args&&... args) {
    struct nest {
        Func nestFunc;
        Args... nestArgs; // I DONT KNOW WHAT TO DO HERE
        void setup(Func func, Args... args) {
            nestFunc = func;
            nestArgs = (args)...; // SO I CAN SET IT HERE
        }
        // Later I will forward this and run the function with its arguments
        unsigned process() {
            nestFunc(std::forward<Args>(nestArgs)...); // USE IT HERE
            return 0;
        }
    };
    nest* myNest;
    myNest->setup(func, (args)...);
}

这是问题所涉及的所有内容的示例，我需要将参数存储在我的嵌套结构中以供以后调用。另外，如果您有存储它的解决方案但设置它与我的不同，也请让我知道。谢谢。

4

2 回答 2

24

从 2018 年开始编辑：在 C++17 中，这个问题的答案是不同的。您仍然必须将参数存储在 a 中::std::tuple，但是当调用函数时，会处::std::apply理解包此元组并为您调用函数。如果您需要将索引技巧用于其他用途，::std::apply那么您应该调查::std::integer_sequence相关的辅助函数。::std::make_index_sequence

现在回到 2013 年的 C++11/14 答案。

您必须使用::std::tuple<Args...>它来存储它。但接下来的问题是如何在需要时打开它。为此，您需要使用一种称为“索引”的技术。

所以，这里有一个链接，指向一个我已经完成了你想要做的事情的地方。这里最相关的类是核心部分suspended_call。

https://bitbucket.org/omnifarious/sparkles/src/tip/sparkles/deferred.hpp?at=default

稍后，我将提取最相关的部分并将它们放在您的代码中。

这一行：

auto saved_args = ::std::make_tuple(::std::move(args)...);

将参数保存到元组中。我在::std::move那里使用过，我认为这是正确的做法。但有可能我错了，我应该使用::std::forward. 除了信号意图之外，我一直不清楚确切的区别。

可以在此处找到实际使用保存的参数进行调用的代码。现在该代码完全针对我正在做的事情。实现索引技巧的位包括创建一组整数，这些整数映射到索引以用作::std::get<I>模板的参数。一旦你有了这个整数包，你就可以使用它来扩展调用以::std::get获取所有元组元素作为单独的参数。

我将尝试以相对简单的方式编写代码：

#include <tuple>
#include <cstddef>
#include <string>
#include <utility>

template < ::std::size_t... Indices>
struct indices {};

template < ::std::size_t N, ::std::size_t... Is>
struct build_indices : build_indices<N-1, N-1, Is...>
{};

template < ::std::size_t... Is>
struct build_indices<0, Is...> : indices<Is...>
{};

template <typename FuncT, typename ArgTuple, ::std::size_t... Indices>
auto call(const FuncT &f, ArgTuple &&args, const indices<Indices...> &)
   -> decltype(f(::std::get<Indices>(::std::forward<ArgTuple>(args))...))
{
   return ::std::move(f(::std::get<Indices>(::std::forward<ArgTuple>(args))...));
}

template <typename FuncT, typename ArgTuple>
auto call(const FuncT &f, ArgTuple &&args)
     -> decltype(call(f, args,
                      build_indices< ::std::tuple_size<ArgTuple>::value>{}))
{
    const build_indices< ::std::tuple_size<ArgTuple>::value> indices;

    return ::std::move(call(f, ::std::move(args), indices));
}

int myfunc(::std::string name, const unsigned int foo)
{
   return 0;
}

int foo(::std::tuple< ::std::string, const unsigned int> saved_args)
{
   return call(myfunc, ::std::move(saved_args));
}

很多这段代码是从这个页面上的索引技巧中借来的。

此外，这是一个样本，您必须稍微适应您的具体情况。基本上，只是在call(nestFunc, saved_args)某个地方打电话。

于 2013-03-21T01:26:27.390 回答
16

我知道已经有一段时间了，但我有类似的需求并想出了这个解决方案，希望它可以帮助某人：

#include <functional>

template<typename Func, typename... Args>
struct nest {
    std::function<void()> callBack;

    void setup(Func func1, Args... args) {
        callBack = [func1, args...]()
        {
            (func1)(args...);
        };
    }

    unsigned process() {
        callBack();
        return 0;
    }
};

template<typename Func, typename... Args>
void handleFunc(Func func, Args&&... args) {
    nest<Func, Args...> myNest;
    myNest.setup(func, args...);
}
于 2016-12-17T17:20:17.770 回答