c ++：在类实例中封装可变参数的参数

Question

这里有一些带孔的代码：

template<typename... Args>
class A 
{

  typedef function_type = void(*)(Args...);

  public:
  void set_args(Args&& ... args)
  {
      // something magic manages to encapsulate
      // args in instance of A
  }
  void apply_args(function_type function)
  {
      // something magic manages to "retrieve"
      // the encapsulated args
      function(std::forward<Args>(args)...);
  }

};

以某种方式可能吗？

Answer 1

是的，有可能。为了存储参数，您需要std::tuple和进行调用std:: apply

Answer 2

您可以像下面一样使用tuple

#include <iostream>
#include <tuple>
#include <functional>

namespace Detail
{
    template <std::size_t... Ts>
    struct Index {};

    template <std::size_t N, std::size_t... Ts>
    struct Seq : Seq<N - 1, N - 1, Ts...> {};

    template <std::size_t... Ts>
    struct Seq<0, Ts...> : Index<Ts...> {};
}

template <typename... Ts>
class A
{
    private:
        std::function<void (Ts...)> f;
        std::tuple<Ts...> args;

        template <typename... Args, std::size_t... Is>
        void Invoke(std::tuple<Args...>& tup, Detail::Index<Is...>)
        {
            f(std::get<Is>(tup)...);
        }

        template <typename... Args>
        void Invoke(std::tuple<Args...>& tup)
        {
            Invoke(tup, Detail::Seq<sizeof...(Args)>{});
        }

    public:
        template <typename F>
        A(F&& func, Ts&&... args)
            : f(std::forward<F>(func)),
              args(std::make_tuple(std::forward<Ts>(args)...))
        {}

        void Invoke()
        {
            Invoke(args);
        }
};

template <typename F, typename... Args>
A<Args...> Create(F&& f, Args&&... args)
{
    return A<Args...>(std::forward<F>(f), std::forward<Args>(args)...);
}

int main()
{
    auto add = Create([] (int a, int b) { std::cout << a + b; }, 2, 3);

    add.Invoke();
}