2

当所有类型的参数包都相同时，我可以想象一个直接有效的折叠表达式扩展实现（简化的 c++11 示例）：

#include <type_traits>
#include <array>

template <bool...>
struct bool_pack { };

template <bool... Bs>
using and_ = std::is_same<bool_pack<true, Bs...>, bool_pack<Bs..., true>>;

template <std::size_t I, std::size_t N, class T>
constexpr typename std::enable_if<(I == N - 1),T>::type fold_impl_impl(std::array<T, N> const &arr) {
    return arr[I];
}

template <std::size_t I, std::size_t N, class T>
constexpr typename std::enable_if<(I < N - 1),T>::type fold_impl_impl(std::array<T, N> const &arr) {
    return arr[I] + fold_impl_impl<I+1, N>(arr);
}

template <class T, std::size_t N>
constexpr T fold_impl(std::array<T, N> arr) {
    return fold_impl_impl<0, N>(arr);
}

template <class T, class... Ts>
constexpr typename std::enable_if<and_<std::is_same<T, Ts>::value...>::value, T>::type fold(T first, Ts... rest) {
    return fold_impl<T, sizeof...(Ts) + 1>({{first, rest...}});
}

int main() {
    static_assert(fold(1, 2, 3, 4) == 10, "!");
}

当然，当我们考虑更一般的情况时，即当我们不能真正假设类型相同时，我们可以将引用替换为参数类型std::array的引用。std::tuple然而，在这种情况下，元组本身很可能会导致扩展的复杂性随着参数数量的对数增长。

它可以使编译器在本质上处理折叠表达式，以确保扩展的复杂性是，但是在[expr.prim.fold]O(N)部分的 C++ 标准草案中，我看不到对此的保证。

我们可以假设使用折叠表达式扩展参数包很便宜吗？

4

0 回答 0