是否应使用模板特化？多坐标系向量类设计技术问询

我之前的问题因主观性被关闭，现在补充实际场景后重新提问——这是个设计问题而非编程实现问题。

我实现了一个数学向量类，包含若干成员变量与函数。现在需要基于不同坐标系（笛卡尔、极坐标、球坐标等）扩展该类：

• 不同坐标系的向量数据成员不同：比如笛卡尔向量用T _vector[Size]，极坐标用T radius和T angle
• 部分函数因计算公式不同需重实现，但存在大量公共函数（比如向量加法的逻辑本质是坐标转换后计算，但对外接口一致）

继承方案不可行，因为不同坐标系不需要相同成员变量；单独特化函数也受限于成员变量差异的问题。想请教：

• 是否应该用类模板特化方案？是否要重复实现所有公共功能？
• 有没有其他更优的可行方案？

现有代码示例 #

笛卡尔坐标系向量模板

template<typename T, std::size_t Size>
class Vector {
private:
    T _vector[Size]{};
public:
    // 各类公共/专属函数
};

极坐标系向量（预期实现）

template<typename T>
class Vector {
private:
    T radius; 
    T angle; 
public:
    // 部分函数与笛卡尔版不同，部分相同
};

方案1：类模板特化 + 标签分发（推荐） #

可以用模板特化区分不同坐标系，同时通过标签分发把公共功能的实现统一提取，避免重复编码。

实现思路 #

1. 定义空标签类标记不同坐标系（如CartesianTag、PolarTag）
2. 主模板默认对应笛卡尔坐标系，为其他坐标系编写模板特化版本
3. 公共功能（如模长、坐标转换）通过自由函数实现，利用标签分发调用对应坐标系的具体逻辑

代码示例 #

// 坐标系标签类
struct CartesianTag {};
struct PolarTag {};
struct SphericalTag {};

// 主模板：默认笛卡尔坐标系
template<typename T, std::size_t Size, typename CoordTag = CartesianTag>
class Vector {
private:
    T _vector[Size]{};
public:
    // 笛卡尔专属接口
    T& operator[](std::size_t idx) { return _vector[idx]; }
    const T& operator[](std::size_t idx) const { return _vector[idx]; }

    // 公共接口声明
    T magnitude() const;
};

// 极坐标系特化版本（仅支持2维）
template<typename T>
class Vector<T, 2, PolarTag> {
private:
    T radius;
    T angle;
public:
    // 极坐标专属接口
    T get_radius() const { return radius; }
    void set_radius(T r) { radius = r; }
    T get_angle() const { return angle; }
    void set_angle(T a) { angle = a; }

    // 公共接口声明
    T magnitude() const;
};

// 公共功能的统一实现：标签分发
template<typename T, std::size_t Size, typename CoordTag>
T Vector<T, Size, CoordTag>::magnitude() const {
    return detail::compute_magnitude(*this, CoordTag{});
}

// 细节命名空间：封装不同坐标系的具体计算逻辑
namespace detail {
    // 笛卡尔坐标系模长计算
    template<typename T, std::size_t Size>
    T compute_magnitude(const Vector<T, Size, CartesianTag>& vec, CartesianTag) {
        T sum = 0;
        for (std::size_t i = 0; i < Size; ++i) {
            sum += vec[i] * vec[i];
        }
        return std::sqrt(sum);
    }

    // 极坐标系模长计算（直接返回半径）
    template<typename T>
    T compute_magnitude(const Vector<T, 2, PolarTag>& vec, PolarTag) {
        return vec.get_radius();
    }
}

方案优势 #

• 不同坐标系的成员变量完全独立，符合需求
• 公共功能仅实现一次，编译时绑定无运行时开销
• 对外接口统一，用户无需关心底层坐标系实现

方案2：策略模式（动态切换场景） #

把坐标系的具体实现（数据存储、计算逻辑）封装成策略类，Vector类作为门面委托策略类完成功能，适合需要动态切换坐标系的场景。

代码示例 #

// 抽象策略基类
template<typename T>
class CoordStrategy {
public:
    virtual ~CoordStrategy() = default;
    virtual T magnitude() const = 0;
    virtual std::unique_ptr<CoordStrategy<T>> add(const CoordStrategy<T>& other) const = 0;
};

// 笛卡尔策略实现
template<typename T, std::size_t Size>
class CartesianStrategy : public CoordStrategy<T> {
private:
    T _vector[Size]{};
public:
    T magnitude() const override {
        T sum = 0;
        for (std::size_t i = 0; i < Size; ++i) {
            sum += _vector[i] * _vector[i];
        }
        return std::sqrt(sum);
    }

    std::unique_ptr<CoordStrategy<T>> add(const CoordStrategy<T>& other) const override {
        auto cart_other = dynamic_cast<const CartesianStrategy<T, Size>*>(&other);
        if (!cart_other) return nullptr;
        
        auto result = std::make_unique<CartesianStrategy<T, Size>>();
        for (std::size_t i = 0; i < Size; ++i) {
            result->_vector[i] = _vector[i] + cart_other->_vector[i];
        }
        return result;
    }
};

// 极坐标策略实现
template<typename T>
class PolarStrategy : public CoordStrategy<T> {
private:
    T radius;
    T angle;
public:
    T magnitude() const override { return radius; }

    std::unique_ptr<CoordStrategy<T>> add(const CoordStrategy<T>& other) const override {
        // 先转换为笛卡尔坐标相加，再转回极坐标
        // 实现坐标转换逻辑
        return nullptr;
    }
};

// Vector门面类
template<typename T>
class Vector {
private:
    std::unique_ptr<CoordStrategy<T>> _strategy;
public:
    Vector(std::unique_ptr<CoordStrategy<T>> strategy) : _strategy(std::move(strategy)) {}

    T magnitude() const { return _strategy->magnitude(); }
    Vector<T> add(const Vector<T>& other) const {
        return Vector<T>(_strategy->add(*other._strategy));
    }
};

方案优势 #

• 完全解耦Vector类与坐标系实现，新增坐标系仅需添加策略类
• 支持动态切换坐标系（如极坐标转笛卡尔）
• 对外接口统一，用户无需关心底层实现

方案3：CRTP（奇异递归模板模式）+ 标签分发 #

用CRTP把公共功能注入到各个特化的Vector类中，兼顾性能与代码复用，适合追求极致性能的场景。

代码示例 #

// CRTP基类：注入公共功能
template<typename Derived>
class VectorBase {
public:
    T magnitude() const {
        return detail::compute_magnitude(static_cast<const Derived&>(*this));
    }
};

// 细节命名空间：封装具体计算逻辑
namespace detail {
    template<typename T, std::size_t Size>
    T compute_magnitude(const Vector<T, Size, CartesianTag>& vec) {
        T sum = 0;
        for (std::size_t i = 0; i < Size; ++i) {
            sum += vec[i] * vec[i];
        }
        return std::sqrt(sum);
    }

    template<typename T>
    T compute_magnitude(const Vector<T, 2, PolarTag>& vec) {
        return vec.get_radius();
    }
}

// 笛卡尔Vector类：继承CRTP基类
template<typename T, std::size_t Size>
class Vector<T, Size, CartesianTag> : public VectorBase<Vector<T, Size, CartesianTag>> {
private:
    T _vector[Size]{};
public:
    T& operator[](std::size_t idx) { return _vector[idx]; }
    const T& operator[](std::size_t idx) const { return _vector[idx]; }
};

// 极坐标Vector类：继承CRTP基类
template<typename T>
class Vector<T, 2, PolarTag> : public VectorBase<Vector<T, 2, PolarTag>> {
private:
    T radius;
    T angle;
public:
    T get_radius() const { return radius; }
    void set_radius(T r) { radius = r; }
};

方案优势 #

• 公共功能仅实现一次，编译时绑定无运行时开销
• 不同坐标系的成员变量完全独立
• 代码复用性强，新增坐标系仅需实现专属接口

• 类模板特化是可行方案，但无需重复实现公共功能，通过标签分发、CRTP或自由函数即可提取公共逻辑
• 若需动态切换坐标系，优先选择策略模式
• 若追求极致性能，CRTP+标签分发是最优解

内容的提问来源于stack exchange，提问作者Guess