Pointer to template function workaround

Since pointers to template functions are not possible in C++ I would like to know how to go about solving the following issue:

Given the template function:

Code:

---

namespace Math
{
    class Utils
    {
          template <typename T> static T LinearInterpolate(T value1, T value2, float lerpFactor)
          {
                return static_cast<T>(value1 + lerpFactor * (value2 - value1));
          }
    }
}

---

To use this function you obviously do:

Code:

---

float floatResult = Math.Utils.LinearInterpolate<float>(10.0f,20.0f,0.5f);
double doubleResult = Math.Utils.LinearInterpolate<double>(10.0,20.0,5.0f);
D3DXCOLOR colorResult = Math.Utils.LinearInterpolate<D3DXCOLOR>(D3DXCOLOR(0.0f, 0.0f, 0.0f, 0.0f), D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f), 0.5f);

---

However this will be littered throughout my code. If I want to change the type of linear interpolation (IE: cosine interpolation) using this approach I will have to go through the code and change all LinearInterpolate calls to some other template function. However it is nice to have a template function here b/c you can then LinearInterpolate between any type that has the correct operators overloaded which is quite handy.

It would be nice to simply use a function pointer to Math.Utils.LinearInterpolate which then would mean to alter the function being used I would simply alter what function the pointer pointed to...but b/c it is a template this is not an option.

Any ideas?

EDIT: Fixed typo in code that used coef instead of lerpFactor.

Maybe make this policy-based?

Code:

---

template<typename T> class Linear
{
public:
        T interpolate(T value1, T value2, float lerpFactor)
        {
                return (value1 + coef * (value2 - value1));
        }
};

template<typename T> class Cosine
{
public:
        T interpolate(T value1, T value2, float lerpFactor)
        {
                // consine interpolation implementation
        }
};


// Change default parameter to `Cosine<T>` if you want to change everywhere.
template <typename T, class C = Linear<T> >
static T Interpolate(T value1, T value2, float lerpFactor)
{
        return static_cast<T>C::interpolate(value1, value2, lerpFactor);
}

float floatResult = Interpolate<float>(10.0f, 20.0f, 0.5f);

---

Not completely sure if this is what your looking for, but I gave it a shot. :)

Quote:

---

Originally Posted by VirtualAce

To use this function you obviously do:

---

Heh, I think you have been dabbling in another programming language recently ;)

Quote:

---

Originally Posted by VirtualAce

However this will be littered throughout my code. If I want to change the type of linear interpolation (IE: cosine interpolation) using this approach I will have to go through the code and change all LinearInterpolate calls to some other template function. However it is nice to have a template function here b/c you can then LinearInterpolate between any type that has the correct operators overloaded which is quite handy.

---

Why not just define:

Code:

---

template <typename T>
T interpolate(T value1, T value2, float lerpFactor)
{
    return Math::Utils::LinearInterpolate<T>(value1, value2, lerpFactor);
}

---

Then use interpolate instead of the specific function template. So, if you need to change the interpolation function, just change this one function template.

Quote:

---

Originally Posted by msh

Maybe make this policy-based?

---

I was going down that path too, but the benefits provided are a little different from what I think VirtualAce is asking for.

Quote:

---

Originally Posted by laserlight

I was going down that path too, but the benefits provided are a little different from what I think VirtualAce is asking for.

---

I figured that he could want to use either.

Quote:

---

Then use interpolate instead of the specific function template. So, if you need to change the interpolation function, just change this one function template.

---

Very nice - one more level of abstraction is all I needed. The policy thing is pretty nifty as well but probably a bit too much for this simple task. Thank you both for your suggestions.

And yes...I have been dabbling in another language recently. I guess my use of the dot operator sort of makes that obvious. :)

"All problems in computer science can be solved by another level of abstraction... except for the problem of too many layers of abstraction." ;)

If you would want a pointer to the function, you might as well take a functor into the function.
A lambda that wraps the appropriate interpolation function or std::bind or boost::bind would be enough to create an appropriate functor object.

Is it critical that the polymorphism be static? If you tolerate dynamic, you can have your pointer..

Code:

---

template <typename T>
class InterpolateInterface
{
    virtual ~InterpolateInterface() {}
    virtual T Interpolate(T a, T b, T frac) = 0;
};

template <typename T>
class LinearInterpolate : public InterpolateInterface<T>
{
public:
    T Interpolate(T a, T b, T frac) { return b*frac + a*(T(1)-frac); }
};

InterpolateInterface<float> *pMyInterpolator = new LinearInterpolate<float>;

---

EDIT: Won't you need to change the code anyway if you switch from linear to (for example) cosine? The interpolation parameter is likely not the same so you need to change it anyway.

Another great suggestion. I went the interface route at first but then did not like the fact that I had to dynamically allocate the object. It seemed like a waste when the object was doing so little.

All are definitely valid approaches and I will look at each one. Thanks for the help.

Well, to tweak brewbuck's solution a little, you could a reference to the base class. Then there will be no need for any new'ing.