专注于默认模板参数包

Question

假设我为STL元组(元组,对)以及STL序列(向量,列表,双端队列)编写了通用映射函数.现在我想编写一个全局map函数,在给定输入类型的情况下调用相应的特殊函数.

我有类似的东西

template <typename... Ts>
struct mappable {
    static constexpr bool is_instance = false;
};

template <typename... Tuples, typename = require<all<is_stl_tuple, Tuples...>::value>>
struct mappable<Tuples...> {
  template <typename Func>
  auto map(Func&& f, Tuples&&... ts) {
     return tuple::map(std::forward<Func>(f), ts...);
  }

  static constexpr bool is_instance = true;
};

template <typename... Sequences, typename = require<all<is_stl_sequence, Sequences...>::value>>
struct mappable<Sequences...> {
    template <typename Func>
    auto map(Func&& f, Sequences&&... seqs) {
        return sequence::map(std::forward<Func>(f), seqs...);
    }

    static constexpr bool is_instance = true;
};

template <typename Func, typename... Ts>
auto map(Func&& f, Ts&&... ts) {
    static_assert(mappable<Ts...>::is_instance, "Tried calling map on unsupported types. Mappable arguments must be supplied.");
    return mappable<Ts...>::map(std::forward<Func>(f), std::forward<Ts>(ts)...);
}

虽然希望不言自明的类型检查功能定义:

// true iff Unary<Ts>::value... == true for at least one Ts
template <template <typename> class Unary, typename... Ts>
struct any;

// true iff Unary<Ts>::value... == true for all Ts
template <template <typename> class Unary, typename... Ts>
struct all;

template <bool B>
using require = typename std::enable_if<B>::type;

显然,这不会(也不会)起作用,因为我专门对默认参数进行mappable.有没有办法做到这一点,如果没有(我必须重新设计),你将如何重新设计这些功能？例如,sequence :: map应该采用stl序列的任意组合,所以我对重组的所有想法都只是将问题转移到其他地方......

在此先感谢任何帮助......

编辑:在我开始执行上述操作之前,这里要求的是用法示例(实际上是我的测试代码):

auto t0 = std::make_tuple(2.f, -5, 1);
auto t1 = std::make_tuple(1, 2);
auto b0 = tuple::map([] (auto v) { return v > decltype(v)(0); }, t0);
auto r0 = tuple::map([] (auto v0, auto v1) { return v0 + v1; }, t0, t1);
// b0 is tuple<bool, bool, bool>(true, false, true)
// b1 is tuple<float, int>(3.f, -3)

和序列:

std::vector<float> s0 = {1.f, 2.f, 3.f, 0.f};
std::list<int>   s1 = {3, 0, -2};
auto r = sq::map([] (auto v0, auto v1) { return v0 + v1; }, s0, s1);
// type of r is compound type of first argument (vector here), result is
// vector<float>(4.f, 2.f, 1.f)

这些地图函数的实现是完全不同的 - 我上面的方法的目的是能够删除命名空间,只使用地图让它做正确的事情.

Answer 1

为什么不只是两个函数重载？

template <typename Func, typename... Tuples,
    require<all<is_stl_tuple, Tuples...>>...>
auto map(Func&& f, Tuples&&... ts) {
    return tuple::map(std::forward<Func>(f), std::forward<Tuples>(ts)...);
}

template <typename Func, typename... Sequences,
    require<all<is_stl_sequence, Sequences...>>...>
auto map(Func&& f, Sequences&&... seqs) {
    return sequence::map(std::forward<Func>(f), std::forward<Sequences>(seqs)...);
}

它使用了一个调整来require实现两个重载:

template <bool condition>
struct require_impl {};

template <>
struct require_impl<true> {
    enum class type {};    
};

template <typename Condition>
using require = typename require_impl<Condition::value>::type;