c++ - 某些输入的展平/重构 C++ 模板源

Question

我有一些要重构的模板代码。具体来说，它是一种几何类型，由参数维度模板化(因此它可以表示曲线、曲面、体积、超体积等)以及点类型。

问题在于，以这种通用方式进行编辑变得非常笨拙，而且大多数时候我们只使用参数维度 1、2 和 3。部分特化是目前唯一发生变化的事情，共享代码相当稳定和完整。

除了编辑代码的困难之外，还存在一些性能问题，这些问题源于必须以泛化到任意维度网格的方式存储内部数据。在通用中可以减轻性能问题方式，但这只会继续增加很多不必要的复杂性。基本上问题在于模板过于笼统。

因此，我将用 3 个单独的模板替换通用模板代码，每个模板一个。我还想保留点类型的模板，所以我不想只使用普通类。

如果我使用宏和 #include 文件多次完成 C 方式的模板化，我可以通过预处理器运行输入并获得我想要的 3 个不同版本。

虽然我可以手动完成，但我更喜欢自动化解决方案，至少作为起点。

C++ 是否存在任何类似的方法或重构解决方案，以获取具有特定输入的模板的源代码？

---

更具体一点，我有这样的代码:

template< int Dimension, class PointType > class Nurbs { ... }
template< class PointType > class NurbsCurve : public Nurbs< 1, PointType > { ... }
template< class PointType > class NurbsSurface : public Nurbs< 2, PointType > { ... }
template< class PointType > class NurbsVolume : public Nurbs< 3, PointType > { ... }

但我想以这样的代码结束:

template< class PointType > class NurbsCurve { ... }
template< class PointType > class NurbsSurface { ... }
template< class PointType > class NurbsVolume { ... }

Answer 1

这并没有真正回答您的问题，但它是保留模板代码的另一种方法。

如果我没理解错的话，你的代码有太多的特化以至于变得笨拙。处理这个问题的一种方法是使用一些帮助模板类来处理所有细节，并从其他模板调用它的静态成员。帮助程序类将有一个实现通用(维度无关代码)的基类，然后会有专门化，它只覆盖特定维度需要覆盖的任何内容。

namespace details {
  template<int Dimension> struct helper_base  // generic code
  {
    static_assert(Dimension>1,"missing specialisation Dimension=0,1");
    static const int Last = Dimension-1;

    template<typename T>
    static T dot_product(const T*a, const T*b) noexcept
    { return helper<Last>::dot_product(a,b) + a[Last]*b[Last]; }
  };

  template<> struct helper_base<1>
  {
    template<typename T>
    static T dot_product(const T*a, const T*b) noexcept
    { return a[0]*b[0]; }
  };

  template<int Dimension> struct helper // special code for certain dimensions
    : helper_base<Dimension> {};
  template<> struct helper<3> : helper_base<3>
  {
    // any code that is particular to 3D.
    template<typename T>
    static void cross_product(T*p, const T*x, const T*y) noexcept
    {
      p[0] = x[1]*y[2] - x[2]*y[1];
      p[1] = x[2]*y[0] - x[0]*y[2];
      p[2] = x[0]*y[1] - x[1]*y[0];
    }
  };
}

template<typename T, int Dimension>
struct point
{
   using helper = details::helper<Dimension>;
   T X[Dimension];  // for instance
   T operator*(point const&x) const noexcept { return helper::dot_product(X,x.X); }
   // etc.
};

template<typename T>
point<T,3> operator^(point<T,3> const&x, point<T,3> const&y) noexcept
{
  point<T,3> result;
  details::helper<3>::cross_product(result.X,x.X,y.X);
  return result;
}