类模板非类型实参转类成员的限制及增量代码修改方案咨询

接手了一套规模庞大的代码库，其中存在类模板template <int dim> class point，功能类似vector。由于该类被大量其他类、方法级联引用，导致依赖类也必须使用相同的整数常量表达式作为类模板非类型实参。

现在需要为class D添加两个方法：

1. void D::coords(const point<dim>&)
2. void D::verif(const source<dim>&)
   其中source是拥有庞大继承体系的基类（可为抽象类），其某个方法中使用了point。这种情况下，似乎必须将D及其所有派生类改为模板类，意味着要修改数百个源文件/头文件的多处内容。

若point类将dim作为类成员而非模板参数，添加上述方法会简单得多——只需修改D.h和D.cc即可。目前查看的代码部分显示，这种变更不会影响原有功能。

在着手大规模修改前，希望了解：

1. 哪些使用整数常量表达式作为类模板非类型实参的场景无法用类成员替代？请提供示例。
2. 是否存在无需大规模修改，仅通过修改D.h和D.cc即可实现上述方法添加的方案？

1. 无法用类成员替代模板非类型实参的场景 #

以下几种场景下，模板非类型实参的作用无法被类成员替代：

编译期常量约束与优化 #

模板非类型实参是编译期常量，编译器可基于它做深度优化，比如静态数组分配、分支消除等。换成类成员（运行期确定）后，这些优化会失效：

// 模板版本：编译期确定数组大小，栈上分配无运行期开销
template<int dim>
class point {
    double data[dim];
};

// 类成员版本：必须动态分配内存，存在额外开销
class point {
    int dim;
    double* data;
};

此外，编译期可通过dim做分支消除：

template<int dim>
void point<dim>::normalize() {
    if constexpr (dim == 2) {
        double len = sqrt(data[0]*data[0] + data[1]*data[1]);
        data[0] /= len; data[1] /= len;
    } else if constexpr (dim ==3) {
        double len = sqrt(data[0]*data[0] + data[1]*data[1] + data[2]*data[2]);
        data[0] /= len; data[1] /= len; data[2] /= len;
    }
}

若dim是类成员，if constexpr无法使用，只能保留运行期分支，无法消除冗余代码。

模板特化 #

基于非类型实参的模板特化是类成员无法实现的：

// 通用版本
template<int dim>
class point { ... };

// 针对dim=2的特化版本，实现二维点专属功能
template<>
class point<2> {
    double x, y;
    void rotate(double angle); // 仅二维点需要的旋转方法
};

如果dim是类成员，无法针对特定维度做特化，只能在类内部用运行期判断实现，代码冗余且不优雅。

作为其他模板的实参 #

模板非类型实参可直接传递给其他模板，类成员则不行：

template<int dim>
struct VectorTraits {
    using type = point<dim>;
    static constexpr int size = dim;
};

// 直接传递dim实例化模板
using Vec3Traits = VectorTraits<3>;

若dim是类成员，无法在编译期获取并传递给其他模板，因为类成员的值只有运行期才能确定。

数组类型的模板参数 #

当模板需要接受数组类型作为参数时，非类型实参可指定数组大小，类成员无法替代：

template<typename T, int N>
class ArrayWrapper {
    T arr[N];
};

// 用point<3>作为元素类型，编译期确定数组大小
ArrayWrapper<point<3>, 10> arr;

这里的3是point的模板参数，编译期确定后可直接用于ArrayWrapper的数组大小。如果point的dim是类成员，ArrayWrapper无法在编译期知晓元素的维度约束。

2. 无需大规模修改的折中方案 #

可以通过以下几种方式避免将D及其派生类改为模板类：

方法一：添加模板成员函数 #

在D中添加模板成员函数，而非将整个D改为模板类：

// D.h
class D {
public:
    template<int dim>
    void coords(const point<dim>& p);
    
    template<int dim>
    void verif(const source<dim>& s);
};

// D.cc
template<int dim>
void D::coords(const point<dim>& p) {
    // 实现代码，可利用dim做编译期处理
}

template<int dim>
void D::verif(const source<dim>& s) {
    // 实现代码
}

// 显式实例化常用的dim值（比如2、3），避免链接错误
template void D::coords<2>(const point<2>&);
template void D::coords<3>(const point<3>&);
template void D::verif<2>(const source<2>&);
template void D::verif<3>(const source<3>&);

这样只需修改D.h和D.cc，无需改动D的派生类。调用时编译器会根据传入的point<dim>自动推导dim：

point<3> p;
D d;
d.coords(p); // 自动推导dim=3

方法二：类型擦除封装source #

如果source的接口允许，可对source<dim>做类型擦除，封装成非模板基类：

// 新增非模板基类
class SourceBase {
public:
    virtual ~SourceBase() = default;
    // 声明source类中需要用到的纯虚函数
    virtual void core_method() = 0;
};

// 修改原source模板类，继承自SourceBase
template<int dim>
class source : public SourceBase {
    // 原有实现...
};

// D.h中使用SourceBase替代source<dim>
class D {
public:
    template<int dim>
    void coords(const point<dim>& p);
    
    void verif(const SourceBase& s);
};

// D.cc中verif的实现
void D::verif(const SourceBase& s) {
    s.core_method();
    // 若需访问dim相关功能，可尝试dynamic_cast（注意类型安全）
    if (auto s2 = dynamic_cast<const source<2>*>(&s)) {
        // 处理dim=2的情况
    } else if (auto s3 = dynamic_cast<const source<3>*>(&s)) {
        // 处理dim=3的情况
    }
}

这种方式适合verif方法仅需调用source通用接口的场景；若必须依赖dim的编译期值，该方式有局限性。

方法三：别名模板简化派生类适配 #

如果D的派生类众多且无需新增依赖dim的方法，可使用别名模板减少改动：

// D.h保持非模板类，添加模板方法
class D {
    template<int dim> void coords(const point<dim>&);
    template<int dim> void verif(const source<dim>&);
};

// 用别名模板替代修改每个派生类
template<int dim>
using DDerived = DerivedD; // DerivedD是D的派生类

// 调用时使用DDerived<3>，原有使用DerivedD的代码无需修改

但该方式仅适用于派生类无需新增dim相关方法的场景，否则仍需修改派生类。

内容的提问来源于stack exchange，提问作者sancho.s ReinstateMonicaCellio