Flatten / Refactor C++ template source for certain inputs - c++

Question

I've got some template code that I'm trying to refactor. Specifically, it's a geometric type, templated by parametric dimension (so it can represent a curve, surface, volume, hypervolume, and so forth), as well as point type.
The problem is that it is getting really unwieldy to edit in such a generic way, and most of the time we only ever use parametric dimensions 1, 2, and 3. The partial specializations are the only things that are changing these days, the shared code is quite stable and complete.
Aside from the difficulty in editing the code, there are also some performance problems that stem from having to store the internal data in a way that generalizes to a grid of arbitrary dimension.. it is possible to mitigate the perf problems in generic ways, but that would just continue to add a lot of unnecessary complexity. Basically the problem is that the templates are too generalized.
So, I'm going to replace the generic template code with 3 separate templates, one for each dimension. I also want to keep the templating of the point type, so I don't want to just use plain classes.
If I had done templating the C way with macros and #including files multiple times, I could run the input through the preprocessor and get the 3 different versions that I want.
While I could do it by hand, I'd prefer an automated solution, at least as a starting point.
Are there any similar methods or refactoring solutions that exist for C++, to get the source for a template with a specific input?
To be a bit more concrete, I have code like this:
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 > { ... }
But I want to end up with code like this:
template< class PointType > class NurbsCurve { ... }
template< class PointType > class NurbsSurface { ... }
template< class PointType > class NurbsVolume { ... }

Answer 1

This is not really answering your question, but it's an alternative way to keep the templated code.
If I understand correctly, your code has so many specialisations that it becomes unwieldy. One way to deal with this is to use some helper template class dealing with all the details and call its static members from the other templates. The helper class would have a base implementing generic (dimension-independent code) and then there will be specialisations which only override whatever needs to be overridden for the specific dimension.
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;
}

Answer 2

Not sure it answer your question:
You may remove inheritance, and use a member, so instead of:
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> { ... };
Use something like:
template<class PointType> class NurbsCurve { ... private: Nurbs<1, PointType> data; };
template<class PointType> class NurbsSurface { ... private: Nurbs<2, PointType> data; };
template<class PointType> class NurbsVolume { ... private: Nurbs<3, PointType> data; };
Note:
- You may have to copy prototype of Nurbs in each class.
- Later if needed, you may replace Nurbs by a specific implementation.