拥抱negative thinking的力量，从零而不是一开始归纳：

auto sum(auto &&val, auto &&...vals) {
    if constexpr (sizeof...(vals) == 0)
        return val;
    else
        return val + sum(std::forward<decltype(vals)>(vals)...);  
}

上面的定义有一个副作用，sum(x)现在将编译并返回x。（实际上，您甚至可以通过让该函数返回零来使该函数使用 no 参数工作，但问题随之而来：为了避免出现这种情况，我没有定义这个例子。）如果你坚持sum只能从arity 2开始定义，你可以使用下面的方法：

auto sum(auto &&val0, auto &&val1, auto &&...vals) {
    if constexpr (sizeof...(vals) == 0)
        return val0 + val1;
    else
        return val0 + sum(std::forward<decltype(val1)>(val1),
            std::forward<decltype(vals)>(vals)...);
}

然而，只要有意义，你就应该允许使用“vacuous”格：它使代码更简单、更通用。注意例如在后一个定义中加法运算符出现了两次：这实际上是在两种情况之间复制折叠逻辑（在这种情况下，它只是一个加法，所以相对简单，但对于更复杂的运算，它可能会更麻烦），而处理退化情况通常是微不足道的，不会复制任何东西。
（我省略了概念注解，因为它们似乎与主要问题并不特别相关。）

template<class... Additive> decltype(auto) sum(Additive &&...val) {
    return (std::forward<Additive>(val) + ...);
}

？
题外话：由于不确定Op的真实的需求，我偶然地快速设计了一个我一直在思考的东西。

#include <iostream>
#include <functional>
#include <type_traits>

template<class... Fs> struct Overloads;

template<class F, class... Fs> struct Overloads<F, Fs...>: Overloads<Fs...> {
        using Fallback = Overloads<Fs...>;

        constexpr Overloads(F &&f, Fs &&...fs): Fallback(std::forward<Fs>(fs)...), f(std::forward<F>(f)) {}

        template<class... Args> constexpr decltype(auto) operator()(Args &&...args) const {
                if constexpr(std::is_invocable_v<F, Args...>) return std::invoke(f, std::forward<Args>(args)...);
                else return Fallback::operator()(std::forward<Args>(args)...);
        }
private:
        F f;
};

template<class... Fs> Overloads(Fs &&...fs) -> Overloads<Fs...>;

template<class F> struct Overloads<F> {
        constexpr Overloads(F &&f): f(std::forward<F>(f)) {}

        template<class... Args> constexpr decltype(auto) operator()(Args &&...args) const {
                return std::invoke(f, std::forward<Args>(args)...);
        }
private:
        F f;
};

template<> struct Overloads<> {
        template<class... Args> constexpr void operator()(Args &&...) const noexcept {}
};

constexpr int f(int x, int y) noexcept { return x + y; }

void g(int x) { std::cout << x << '\n'; }

template<class... Vals> decltype(auto) omg(Vals &&...vals) {
        static constexpr auto fg = Overloads(f, g);
        return fg(std::forward<Vals>(vals)...);
}

int main() {
        omg(omg(40, 2));
}

〉_〈

您可以将一个项目解包到一个变量中并使用该变量：

if constexpr (sizeof...(vals) == 1) {
    auto&& only_value(std::forward<decltype(vals)>(vals)...);
    return val + only_value;
}