1

我想写一个这样的函数：

template<class IterableType>
void CheckAndProcessIterables(IterableType& a, IterableType& b, IterableType& c) {
  IteratorRangeType range{}; // empty range
  if (Check(a)) {
    range = boost::range::join(range, a);
  }
  if (Check(b)) {
    range = boost::range::join(range, b);
  }
  if (Check(c)) {
    range = boost::range::join(range, c);
  }
  Process(range);
}

可能吗？我应该使用哪种类型而不是IteratorRangeType？据我了解，boost::range::join返回类型取决于它的参数。是否有一些包装类可以分配任何类型的范围，只要其基础值类型相同？

4

1 回答 1

1

您可以使用类型擦除迭代器范围，Boost 以any_range.

当心这些的性能成本，这很快就会变得非常明显。我会重新考虑这种方法，除非您非常确定这不是在任何热门路径上，并且可读性比性能更受关注。

活在 CoCompiler Explorer

#include <boost/range/join.hpp>
#include <boost/range/any_range.hpp>

// for demo only:
#include <boost/range/algorithm/for_each.hpp>
#include <boost/lambda/lambda.hpp>
#include <fmt/ranges.h>

template<class Range>
bool Check(Range const& r) {
    bool odd_len = boost::size(r) % 2;
    fmt::print("Check {}, odd_len? {}\n", r, odd_len);
    return odd_len;
}

template<class Range>
void Process(Range const& r) {
    fmt::print("Processing {}\n", r);
    using namespace boost::lambda;
    for_each(r, _1 *= _1);
}

template<class IterableType>
void CheckAndProcessIterables(IterableType& a, IterableType& b, IterableType& c) {
    using V = typename boost::range_value<IterableType>::type;
    using ErasedRange= boost::any_range<V, boost::forward_traversal_tag>;

    ErasedRange range{}; // empty range
    if (Check(a)) {
        range = boost::range::join(range, a);
    }
    if (Check(b)) {
        range = boost::range::join(range, b);
    }
    if (Check(c)) {
        range = boost::range::join(range, c);
    }
    Process(range);
}

int main() {
    std::vector a{1, 2, 3}, b{4, 5}, c{6, 7, 8};
    CheckAndProcessIterables(a, b, c);

    fmt::print("After process: a:{} b:{} c:{}\n", a, b, c);
}

印刷

Check {1, 2, 3}, odd_len? true
Check {4, 5}, odd_len? false
Check {6, 7, 8}, odd_len? true
Processing {1, 2, 3, 6, 7, 8}
After process: a:{1, 4, 9} b:{4, 5} c:{36, 49, 64}
于 2021-05-01T13:19:57.590 回答