Add conversion constructor to specializaton of template

Question

Background

I am implementing a special-purpose container for numbers.

template <typename T>
class VectorBase
{
    // Some constructors...

    friend VectorBase<T> operator+(const VectorBase& a, const VectorBase& b)
    {
        VectorBase<T> res;
        // Addition...
        return res;
    }

    // Additional non-trivial logic...
}

It is then used for various types especially for double and float:

typedef VectorBase<float>    VectorFloat;
typedef VectorBase<double>   VectorDouble;

Now I would like to use a construct like this

VectorFloat  inFloat;
VectorDouble inDouble;

VectorDouble outDouble = inFloat + inDouble;

Where I want to guarantee that the addition operation is executed on double objects and not on float ones to avoid precision problems. Exactly as it is done in pure C expressions.

One way of achieving this is to first convert the VectorFloat object into VectorDouble and then perform the addition operation in the "double world". This can be done by hand (assigning the float variable into temporary double one) or automatically by the compiler into a temporary variable. To my knowledge, to do this, I need to have a parametric constructor or an assignment operator on the VectorDouble which takes an argument of type VectorFloat and does the actual conversion.

Question

Is it possible to add a new parametric constructor to a specialization of a template without the need of replicating the whole template code for a specific template parameter?

VectorBase<double>::VectorBase<double>(const VectorBase<float> &b) { ... }

I know I can make a derived class which will contain the needed parametric constructor, but that will not work for me, since I need to derive another class from the VectorBase later on while still keeping it a template:

template<typename T>
class VerySpecialDerivedVector: public VectorBase<T> { ... };

Answer 1

It can be done with SFINAE, something like:

template <typename T2,
    typename = typename std::enable_if<std::is_same<double, T>::value
                                       && std::is_same<float, T2>::value>::type>
VectorBase(const VectorBase<T2> &) { /* .. */ }

Live example.

but I think it would be better to have:

template <typename T1, typenale T2>
friend VectorBase<typename std::common_type<T1, T2>::type>
operator+(const VectorBase<T1>& a, const VectorBase<T2>& b)
{
    using T = typename std::common_type<T1, T2>::type;
    VectorBase<T> res;
    // Addition...
    return res;
}