Question

我的同事给我做了一个“小测验”，他让他的学生解决了一次。似乎我虚弱的头脑无法理解现代C ++功能的所有美感。

主题：

实现join函数，接受任意函子并返回另一个函子，该函子的行为与它们中的任何一个一样。例如：

{
    auto result = std::visit(custom::join(
        [](std::string const& s) { return "it's a string"; },
        [](std::pair<int, int> const& p) { return "it's a pair"; }
    ), var);

    assert(result == "it's a string");

    var = std::make_pair(10, 20);

    auto lvalue_lambda = [](std::string const& s) { return "it's a string"; };
    result = std::visit(custom::join(
        lvalue_lambda,
        [](std::pair<int, int> const& p) { return "it's a pair"; }
    ), var);

    assert(result == "it's a pair");
}

好吧，经过一番思考，我明白了，std::variant的意思是“列出的一个”，因为它是一个“类型安全的联合”，所以我需要一个元组。尝试过类似的事情：

namespace custom
{
    template<typename ...Functors>
    class ResultFunctor
    {
    public:
        ResultFunctor(Functors&&... funcs)
            : m_funcs(std::make_tuple(std::move(funcs)...))
        {}

        template<typename ...Params>
        auto operator()(Params... params) // that's where I got stuck
        {
//            return std::get<void(Params...)>(m_funcs)(params...); // No, the return type spoils this idea
            return std::get<0>(m_funcs)(params...);  // Now I need to choose the correct functor
        }

    private:
        std::tuple<Functors...> m_funcs;
    };

    template<typename ...Functors>
    ResultFunctor<Functors...> join(Functors&&... funcs)
    {
        return ResultFunctor(std::move(funcs)...);
    }
}

如果仅用于返回类型为void的函子，则可以轻松获得所需的元组元素。但是似乎无法确定它，不能从给定参数推导返回类型（显然）。

另一个想法是使用SFINAE技巧来选择正确的operator()()版本，但是这种方式或另一种方式我必须“遍历”所有元组项（这很讨厌，但仍然可以通过Google搜索），然后根据给定的参数包检查该项目是否合适。

好吧，那是我停下来思考一下的地方。如果有人（谁能更好地处理各种杂文）有任何想法，我将不胜感激。

Answer 1

这是一个非常简单的解决方案，它不涉及SFINAE或模板元编程（仅是常规模板）。

第一步是编写一个表示关节过载集的函子。这很容易通过继承来实现，并且因为用作输入的所有函子必须具有不同的类型，所以我们不必做任何花哨的事情。

// This represents overload set
template<class F1, class F2>
struct Joint : public F1, public F2 {
    using F1::operator(); 
    using F2::operator(); 
};

为方便用户，我们可以添加一个推导指南：

template<class F1, class F2>
Joint(F1, F2) -> Joint<F1, F2>;

由于Joint是C ++ 17及更高版本中的聚合类型，因此我们不必提供构造函数，因为我们可以使用聚合初始化：

// This code magically works
auto result = std::visit(Joint{
    [](std::string const& s) { return "it's a string"; },
    [](std::pair<int, int> const& p) { return "it's a pair"; }
}, var);

编写custom::join函数同样简单：

template<class F1, class F2>
auto join(F1&& f1, F2&& f2) {
    return Joint { std::forward<F1>(f1), std::forward<F2>(f2) }; 
}

现在有了基本情况，我们可以很容易地将其概括化：

template<class F, class F2, class... Fs>
auto join(F&& f, F2&& f2, Fs&&... fs) {
    return Joint{
        std::forward<F>(f),
        join(std::forward<F2>(f2), std::forward<Fs>(fs)...)
    };
}

解决潜在的批评

为什么不为Joint定义构造函数？聚合初始化是最有效的初始化形式，因为当您不定义构造函数时，编译器能够就地分配值而不必复制或移动它们。
为什么要使用多重继承？如果我们依赖SFINAE，这将增加编译时间，增加代码复杂度，并且在某些情况下无法正常工作。使用SFINAE，您必须检查过载集的每个成员，看是否合适。在某些情况下，由于隐式转换，选择了更糟糕的重载，因为它是一个匹配项。通过使用继承，我们可以将语言的内置模式匹配用于函数调用。
为什么要添加演绎指南？它们使代码更整洁，在这种情况下，它们按预期工作：参数按值存储

Answer 2

namespace custom {
  template<class...Fs>
  struct overloaded : Fs... {
      using Fs::operator()...;
  };
  template<class...Fs>
  overloaded(Fs...)->overloaded<Fs...>;

  template<class F>
  F&& as_obj( F&& f ){ return std::forward<F>(f); }
  template<class R, class...Args>
  auto as_obj( R(*f)(Args...) {
    struct helper {
      R(*f)(Args...);
      R operator()(Args...args) const { return f(std::forward<Args>(args)...); }
    };
    return helper{f};
  }

  template<class...Fs>
  auto join( Fs&&...fs ){
    return overloaded{as_obj(std::forward<Fs>(fs))...};
  }
}

我添加了对非重载函数指针的额外支持。

С++可变参数模板：实现可变参数

2 个答案:

解决潜在的批评