C++中能否基于模板整数生成代码优化向量运算符？

结论：可以实现，但你提出的递归宏方案不可行 #

你想要在编译期把向量加法的循环展开为逐元素代码的思路是对的，但递归宏无法实现这个需求，不过C++原生提供了多种更安全、更优雅的编译期代码生成方案，完全不需要依赖预处理器宏。

为什么递归宏不可行 #

预处理器的处理时机早于模板实例化：当预处理器解析vec_sum(D, values, v1, v2)时，模板参数D还只是一个符号，不是具体的数值，预处理器无法判断D > 0这种条件，会直接把代码原封不动地保留下来，最终导致编译错误。

推荐的C++原生实现方案 #

方案1：C++20 利用std::integer_sequence（最简洁直观） #

通过生成编译期索引序列，直接展开所有元素的加法操作，代码可读性极高：

#include <utility>

template<typename T, unsigned int D>
class Vector {
private:
    T values[D];
public:
    // 提供初始化列表构造函数，方便展开赋值
    constexpr Vector(std::initializer_list<T> init) {
        std::copy(init.begin(), init.end(), values);
    }

    // 提供[]访问运算符
    constexpr const T& operator[](unsigned int idx) const {
        return values[idx];
    }
};

template<typename T, unsigned int D, std::size_t... Is>
constexpr Vector<T, D> vec_sum_impl(const Vector<T, D>& v1, const Vector<T, D>& v2, std::index_sequence<Is...>) {
    return Vector<T, D>{v1[Is] + v2[Is]...};
}

template<typename T, unsigned int D>
constexpr Vector<T, D> operator+(const Vector<T, D>& v1, const Vector<T, D>& v2) {
    return vec_sum_impl<T, D>(v1, v2, std::make_index_sequence<D>{});
}

方案2：C++17 constexpr if递归函数 #

利用C++17引入的constexpr if在编译时判断递归终止条件，自动展开代码：

template<typename T, unsigned int D>
class Vector {
private:
    T values[D];
public:
    constexpr Vector(T arr[D]) {
        for (unsigned int i = 0; i < D; ++i) {
            values[i] = arr[i];
        }
    }

    constexpr const T& operator[](unsigned int idx) const {
        return values[idx];
    }
};

template<typename T, unsigned int D, unsigned int I = 0>
constexpr void vec_sum(T* result, const Vector<T, D>& v1, const Vector<T, D>& v2) {
    if constexpr (I < D) {
        result[I] = v1[I] + v2[I];
        vec_sum<T, D, I + 1>(result, v1, v2);
    }
}

template<typename T, unsigned int D>
constexpr Vector<T, D> operator+(const Vector<T, D>& v1, const Vector<T, D>& v2) {
    T values[D];
    vec_sum<T, D>(values, v1, v2);
    return Vector<T, D>(values);
}

方案3：C++11 模板元编程递归 #

如果需要兼容C++11及更早版本，可以用模板特化实现递归终止：

template<typename T, unsigned int D>
class Vector {
private:
    T values[D];
public:
    constexpr Vector(T arr[D]) {
        for (unsigned int i = 0; i < D; ++i) {
            values[i] = arr[i];
        }
    }

    constexpr const T& operator[](unsigned int idx) const {
        return values[idx];
    }
};

// 递归模板辅助结构
template<typename T, unsigned int D, unsigned int I = 0>
struct VectorSumHelper {
    static constexpr void apply(T* result, const Vector<T, D>& v1, const Vector<T, D>& v2) {
        result[I] = v1[I] + v2[I];
        VectorSumHelper<T, D, I + 1>::apply(result, v1, v2);
    }
};

// 递归终止特化
template<typename T, unsigned int D>
struct VectorSumHelper<T, D, D> {
    static constexpr void apply(T*, const Vector<T, D>&, const Vector<T, D>&) {}
};

template<typename T, unsigned int D>
constexpr Vector<T, D> operator+(const Vector<T, D>& v1, const Vector<T, D>& v2) {
    T values[D];
    VectorSumHelper<T, D>::apply(values, v1, v2);
    return Vector<T, D>(values);
}

额外提示：编译器自动优化 #

其实你不需要急于手动展开代码——现代编译器（GCC、Clang、MSVC）在开启-O2及以上优化级别时，会自动将固定维度的循环展开为逐元素操作，和你手动写的代码效果完全一致。建议先测试原始循环版本的性能，如果已经满足需求，就没必要手动实现展开。

内容的提问来源于stack exchange，提问作者LucioleMaléfique