virtual functions with compile time constants - c++

Question

I will put my question first and add some longer explanation below. I have the following class design which is not working as C++ does not support virtual template methods. I would be happy to learn about alternatives and workarounds to implement this behaviour.
class LocalParametersBase
{
public:
template<unsigned int target>
virtual double get() const = 0; //<--- not allowed by C++
};
template<unsigned int... params>
class LocalParameters : public LocalParametersBase
{
public:
template<unsigned int target>
double get() const; //<--- this function should be called
};
Using a simple function argument instead of the template parameter is at the moment no alternative for the following reasons:
The implementation of this method in the derived class relies on some template meta-programming (using the variadic class template arguments). As far as I know it is not possible to use function arguments (even if they are of constant integral type) as template arguments.
The method will be only called with compile-time constants. Performance is crucial in my application and therefore I want to benefit from the calculation at compile time.
The common base class is needed (I have left out the rest of the interface for brevity).
Any suggestions are highly appreciated.
Update: Motivation
As there were many questions about the motivation for this kind of layout, I'll try to explain it with a simple example. Imagine you want to measure a trajectory in a three-dimensional space, In my specific example these are tracks of charged particles (of fixed mass) in a magnetic field. You measure these tracks by sensitive detectors which are approximated as 2D surfaces. At each intersection of a track with a sensitive detector, the trajectory is uniquely identified by 5 parameters:
two local coordinates describing the intersection point of the track with the surface in the local coordinate system of the detector surface (that's why the class names are chosen this way),
two angles specifying the direction of the trajectory,
one parameter containing the information about the momentum and the electric charge of the particle.
A trajectory is therefore completely identified by a set of five parameters (and the associated surface). However, individual measurements only consist of the first two parameters (the intersection point in the local 2D coordinate system of the surface). These coordinate systems can be of different types (kartesian, cylindrical, spherical etc). So each measurement potentially constraints different parameters out of the full set of 5 parameters (or maybe even non-linear combinations of those). Nevertheless, a fitting algorithm (think of a simple chi2 minimizer for instance) should not depend of the specific type of a measurement. It only needs to calculate residuals. That looks like
class LocalParametersBase
{
public:
virtual double getResidual(const AtsVector& fullParameterSet) const = 0;
};
This works fine as each derived class knows how to map the full 5-d parameter set on its local coordinate system and then it can calculate the residuals. I hope this explains a bit why I need a common base class. There are other framework related reasons (such like the existing I/O infrastructure) which you could think of as external constraints.
You may be wondering that the above example does not require to have the templated get method I am asking about. Only the base class is supposed to be exposed to the user. Therefore it would be very confusing if you have a list of LocalParameterBase objects and you can fit a trajectory using them. You even can get the values of the measured local parameters. But you can't access the information which values where actually measured (which renders the previous information useless).
I hope this could shed some light on my problem. I appreciate all the comments received so far.
For my current project I am writing a class whose main purpose is to act as a wrapper around a sparse vector of fixed size. Instead of storing the whole vector (which is the representation of some system state) my class has a vector of reduced size as member variable (= corresponding to a sub-domain of the total parameter space). I hope the illustration below gives you an idea of what I am trying to describe:
VectorType(5) allParameters = {0.5, 2.1, -3.7, 4, 15/9}; //< full parameter space
VectorType(2) subSpace = {2.1, 4}; //< sub domain only storing parameters with index 1 and 3
In order to be able to make the connection to the original vector, I need to "store" the indexes which are copied to my "shortened" vector. This is achieved using non-type variadic template parameters. I also need to be able to query the value of the parameter with a certain index. This should yield a compile time error in case this parameter is not stored in the "shortened" vector. My simplified code for this looks like:
template<unsigned int... index>
class LocalParameters
{
public:
template<unsigned int target>
double get() const;
private:
AtsVectorX m_vValues;
};
LocalParameters<0,1,4> loc;
//< ... do some initialisation ...
loc.get<1>(); //< query value of parameter at index 1
loc.get<2>(); //<-- this should yield a compile time error as the parameter at index 2 is not stored in this local vector class
I managed to implement this behaviour using some simple template programming. But other parts of my code need to treat these "shortened" vectors uniformly through one interface. I still want to be able to access through the interface LocalParametersBase the information whether a parameter with a specific index is stored (if not I want to get a compile time error), and if yes, I would like to access the value of this parameter. In code this should look similar to
LocalParametersBase* pLoc = new LocalParameters<0,1,3>();
pLoc->get<1>();

Answer 1

A suggestion
Without more information about what you are doing, I am only making educated guesses about what is driving you towards this approach.
A common performance problem with code that depends on a virtual interface is that the framework provides generic functionality that dispatches to the virtual methods at very high frequency. This seems to be the issue that you are facing. You have code that is performing computation on sparse vectors, and you want to provide to it a generic interface representing each sparse vector you happen to create.
void compute (LocalParametersBase *lp) {
// code that makes lots of calls to lp->get<4>()
}
However, an alternative approach is to make the computation generic by using a template parameter to represent the derived object type being manipulated.
template <typename SPARSE>
void perform_compute (SPARSE *lp) {
// code that makes lots of calls to lp->get<4>()
}
Each get<> call in the template version of compute is against the derived object. This allows the computation to occur as fast as if you had written code to directly manipulate a LocalParameters<0,1,4>, rather than performing a dynamic dispatch per get<> call.
If you must allow the framework control when the computation is performed, and so the computation is performed on the base class, the base class version can dispatch to a virtual method.
class ComputeBase {
public:
virtual void perform_compute () = 0;
};
void compute (LocalParametersBase *lp) {
auto c = dynamic_cast<ComputeBase *>(lp);
c->perform_compute();
}
By using CRTP, you can create a helper class that takes the derived type as a template parameter, and it implements this virtual method by passing in the derived. Thus, the computation only costs one dynamic dispatch, and the rest of the computation is performed on the actual sparse vector itself.
template <typename Derived>
class CrtpCompute : public ComputeBase {
void perform_compute () {
auto d = static_cast<Derived *>(this);
perform_compute(d);
}
};
Now your sparse vector derives from this helper class.
template <unsigned int... params>
class LocalParameters
: public LocalParametersBase,
public CrtpCompute<LocalParameters<params...>> {
public:
template <unsigned int target> double get() const;
};
Making your interface work the way you have specified it
After the results are computed, you want to place the resulting sparse vector into a container for later retrieval. However, that should no longer be a performance sensitive operation, so you can use the method described below to achieve that.
Base template method &rightarrow; Base template class virtual method &rightarrow; Derived template method
If you are wish to use polymorphism, then delegate the template method call in the base class to a virtual function. Since it is a template method, the virtual function has to come from a template class. You can use a dynamic cast to get to the corresponding template class instance.
template <unsigned int target>
class Target {
public:
virtual double get() const = 0;
};
class LocalParametersBase {
public:
virtual ~LocalParametersBase () = default;
template <unsigned int target> double get() const {
auto d = dynamic_cast<const Target<target> *>(this); // XXX nullptr
return d->get();
}
};
To automate the implementation of the virtual methods for each Target, you can again use CRTP, passing in the derived type to the helper. The helper casts to the derived type to invoke the corresponding template method.
template <typename, unsigned int...> class CrtpTarget;
template <typename Derived, unsigned int target>
class CrtpTarget<Derived, target> : public Target<target> {
double get() const {
auto d = static_cast<const Derived *>(this);
return d->template get<target>();
}
};
template <typename Derived, unsigned int target, unsigned int... params>
class CrtpTarget<Derived, target, params...>
: public CrtpTarget<Derived, target>,
public CrtpTarget<Derived, params...> {
};
And now, you inherit appropriately from your derived class.
template <unsigned int... params>
class LocalParameters
: public LocalParametersBase,
public CrtpCompute<LocalParameters<params...>>,
public CrtpTarget<LocalParameters<params...>, params...> {
public:
template <unsigned int target> double get() const;
};