C++能否引用模板模板参数？线性代数类运算符重载问题

针对你基于NDimContainer实现Vector等线性代数类时，无法编写通用operator+来访问基类模板参数的问题，这里提供几种无额外运行时开销的可行方案：

方案1：直接针对派生类编写operator+（最直观） #

如果只需要支持Vector这类特定派生类，直接针对其模板参数编写operator+即可，无需复杂的模板模板参数：

#include <array>

// 基类：N维容器
template <typename T, size_t N, size_t... Dims>
struct NDimContainer {
    static constexpr size_t total_size = N * (... * Dims);
    std::array<T, total_size> data;

    // 通用元素访问
    T& operator[](size_t idx) { return data[idx]; }
    const T& operator[](size_t idx) const { return data[idx]; }
};

// 派生类：Vector
template <typename T, size_t N>
struct Vector : NDimContainer<T, N> {
    // 扩展方法示例：点积
    T dot(const Vector& other) const {
        T sum{};
        for (size_t i = 0; i < N; ++i) {
            sum += (*this)[i] * other[i];
        }
        return sum;
    }
};

// 针对Vector的operator+
template <typename T, size_t N>
Vector<T, N> operator+(const Vector<T, N>& lhs, const Vector<T, N>& rhs) {
    Vector<T, N> res;
    for (size_t i = 0; i < N; ++i) {
        res[i] = lhs[i] + rhs[i];
    }
    return res;
}

// 使用示例
int main() {
    Vector<int, 3> a{{1,2,3}}, b{{4,5,6}};
    auto c = a + b; // c.data = {5,7,9}
    return 0;
}

方案2：通用operator+支持所有NDimContainer派生类 #

如果需要支持Matrix等更多派生类，可以通过在基类中暴露模板参数，结合类型推导实现通用operator+：

步骤1：修改基类暴露模板参数 #

在NDimContainer中添加类型别名和编译期常量，让派生类能直接访问模板参数：

template <typename T, size_t N, size_t... Dims>
struct NDimContainer {
    using value_type = T;
    static constexpr size_t first_dim = N;
    static constexpr size_t total_size = N * (... * Dims);
    using dims_sequence = std::index_sequence<Dims...>; // 编译期类型，无运行时开销

    std::array<T, total_size> data;

    T& operator[](size_t idx) { return data[idx]; }
    const T& operator[](size_t idx) const { return data[idx]; }
};

步骤2：编写通用operator+ #

利用C++20的requires约束，确保只匹配NDimContainer的派生类：

#include <type_traits>

// 辅助 trait 判断是否为NDimContainer派生类
template <typename T>
struct is_ndim_container : std::false_type {};

template <template <typename, size_t, size_t...> class Container, typename T, size_t N, size_t... Dims>
struct is_ndim_container<Container<T, N, Dims...>> : std::true_type {};

// 通用operator+
template <typename Derived>
requires is_ndim_container<Derived>::value
auto operator+(const Derived& lhs, const Derived& rhs) -> Derived {
    Derived res;
    constexpr size_t size = Derived::total_size;
    for (size_t i = 0; i < size; ++i) {
        res[i] = lhs[i] + rhs[i];
    }
    return res;
}

步骤3：派生类无需额外修改 #

Vector、Matrix等派生类直接继承NDimContainer即可，通用operator+会自动匹配：

// Matrix示例
template <typename T, size_t Rows, size_t Cols>
struct Matrix : NDimContainer<T, Rows, Cols> {
    // 扩展方法示例：转置
    Matrix transpose() const {
        Matrix res;
        const auto& self = static_cast<const NDimContainer<T, Rows, Cols>&>(*this);
        for (size_t i = 0; i < Rows; ++i) {
            for (size_t j = 0; j < Cols; ++j) {
                res[j * Rows + i] = self[i * Cols + j];
            }
        }
        return res;
    }
};

// 使用示例
int main() {
    Vector<int, 3> a{{1,2,3}}, b{{4,5,6}};
    auto c = a + b;

    Matrix<int, 2, 2> m1{{1,2,3,4}}, m2{{5,6,7,8}};
    auto m3 = m1 + m2; // m3.data = {6,8,10,12}
    return 0;
}

方案3：CRTP模式在基类中定义operator+ #

如果希望operator+直接成为基类的一部分，可使用奇异递归模板模式（CRTP），让基类知道派生类类型：

template <typename Derived, typename T, size_t N, size_t... Dims>
struct NDimContainer {
    static constexpr size_t total_size = N * (... * Dims);
    std::array<T, total_size> data;

    // 基类中定义operator+，直接返回派生类对象
    Derived operator+(const Derived& rhs) const {
        Derived res;
        const Derived& lhs = static_cast<const Derived&>(*this);
        for (size_t i = 0; i < total_size; ++i) {
            res.data[i] = lhs.data[i] + rhs.data[i];
        }
        return res;
    }

    T& operator[](size_t idx) { return data[idx]; }
    const T& operator[](size_t idx) const { return data[idx]; }
};

// 派生类继承时传入自身类型
template <typename T, size_t N>
struct Vector : NDimContainer<Vector<T,N>, T, N> {
    T dot(const Vector& other) const {
        T sum{};
        for (size_t i = 0; i < N; ++i) {
            sum += (*this)[i] * other[i];
        }
        return sum;
    }
};

// 使用示例
int main() {
    Vector<int,3> a{{1,2,3}}, b{{4,5,6}};
    auto c = a + b; // 直接调用基类的operator+
    return 0;
}

方案对比 #

• 方案1：实现最简单，适合只需要支持少数派生类的场景。
• 方案2：通用性最强，支持所有NDimContainer派生类，无需修改基类的继承结构。
• 方案3：operator+内置在基类中，派生类无需额外实现运算符，但基类和派生类耦合度较高。

内容的提问来源于stack exchange，提问作者Daniel Kříž