使用折叠表达式

Question

当所有类型的参数包都相同时，我可以想象折叠表达式扩展的直接有效实现（简化的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的引用。参数类型。但是在这种情况下，元组本身很可能会导致扩展的复杂性以参数数的对数增长。

可以让编译器在内在地处理折叠表达式，以确保扩展的复杂性为O(N)，但在[expr.prim.fold]部分的c ++标准草案中，我可以＆＃39;看到这方面的保证。

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