C ++模板专业化冗余减少

我想编写自己的Vector类模板，还想添加一些专门知识，例如3D矢量类型，可以通过x / y / z访问组件。

到目前为止，模板和专业化工具都可以正常工作，但是问题是，专业化模板需要从基础模板进行大量复制/粘贴才能正常工作。我想减少这一点。

这是现在的样子：

template<class T, unsigned int dim>
class Vector;

template<class T, unsigned int dim>
Vector<T, dim> add(Vector<T, dim> const& lhs, Vector<T, dim> const& rhs)
{
    Vector<T, dim> tmp;
    for (unsigned int i = 0; i < dim; ++i)
    {
        tmp[i] = lhs[i] + rhs[i];
    }

    return tmp;
}

template<class T, unsigned int dim, class S>
Vector<T, dim> add(Vector<T, dim> const& lhs, S const& rhs)
{
    Vector<T, dim> tmp;
    for (unsigned int i = 0; i < dim; ++i)
    {
        tmp[i] = lhs[i] + rhs;
    }

    return tmp;
}

template<class T, unsigned int dim>
Vector<T, dim> operator+(Vector<T, dim> const& lhs, Vector<T, dim> const& rhs)
{
    return vectors::add(lhs, rhs);
}

template<class T, unsigned int dim, class S>
Vector<T, dim> operator+(Vector<T, dim> const& lhs, S const& rhs)
{
    return vectors::add(lhs, rhs);
}

template<class T, unsigned int dim>
class Vector
{
//...
protected:
    T values[dim] __attribute((aligned(16)));
public:
    template<class R, unsigned int fdim>
    friend Vector<R, fdim> operator+(Vector<R, fdim> const& lhs, Vector<R, fdim> const& rhs);
    template<class R, unsigned int fdim, class S>
    friend Vector<R, fdim> operator+(Vector<R, fdim> const& lhs, S const& rhs);
    template<class R, unsigned int fdim, class S>
    friend Vector<R, fdim> operator+(S const& lhs, Vector<R, fdim> const& rhs);
//...
//constructors, etc.
};

template<class T>
class Vector<T, 3>
{
//...
protected:
    T values[3] __attribute((aligned(16)));
public:
    T& x = values[0];
    T& y = values[1];
    T& z = values[2];

    //lots of copy-pasta :(
    template<class R, unsigned int fdim>
    friend Vector<R, fdim> operator+(Vector<R, fdim> const& lhs, Vector<R, fdim> const& rhs);
    template<class R, unsigned int fdim, class S>
    friend Vector<R, fdim> operator+(Vector<R, fdim> const& lhs, S const& rhs);
    template<class R, unsigned int fdim, class S>
    friend Vector<R, fdim> operator+(S const& lhs, Vector<R, fdim> const& rhs);
//...
//constructors, etc.
};

现在，我认为简单的解决方案将是简单地将其定义Vector3D为Vector模板的子类，如下所示：

template<class T>
class Vector3D: public Vector<T, 3>
{
//...
public:
    T& x = values[0];
    T& y = values[1];
    T& z = values[2];

    //no copy-pasta :)
//...
//constructors, etc.
};

由于模棱两可，这根本不起作用：

ambiguous overload for ‘operator+’ (operand types are ‘const vec3f {aka const math::vectors::Vector3D<float>}’ and ‘math::vectors::vec3f {aka math::vectors::Vector3D<float>}’)
../main.cpp:84:16: note: candidates are:
In file included from ../main.cpp:10:0:
../include/vector.hpp:720:16: note: math::vectors::Vector<T, dim> math::vectors::operator+(const math::vectors::Vector<T, dim>&, const math::vectors::Vector<T, dim>&) [with T = float; unsigned int dim = 3u]
 Vector<T, dim> operator+(Vector<T, dim> const& lhs, Vector<T, dim> const& rhs)
                ^
../include/vector.hpp:726:16: note: math::vectors::Vector<T, dim> math::vectors::operator+(const math::vectors::Vector<T, dim>&, const S&) [with T = float; unsigned int dim = 3u; S = math::vectors::Vector3D<float>]
 Vector<T, dim> operator+(Vector<T, dim> const& lhs, S const& rhs)
                ^
../include/vector.hpp:732:16: note: math::vectors::Vector<T, dim> math::vectors::operator+(const S&, const math::vectors::Vector<T, dim>&) [with T = float; unsigned int dim = 3u; S = math::vectors::Vector3D<float>]
 Vector<T, dim> operator+(S const& lhs, Vector<T, dim> const& rhs)

看起来模板替换失败了，因为S也可以用新的Vector3D类替换，而它只能处理标量。

因此，我尝试通过为标量编写一个小型包装器类来摆脱该问题，如下所示：

template<class T>
class ScalarType
{
public:
    T value;
    ScalarType() :
            value(0)
    {

    }

    ScalarType(T const& _v) :
            value(_v)
    {

    }

    ScalarType(ScalarType<T> const& rhs) :
            value(rhs.value)
    {

    }

    operator T&()
    {
        return value;
    }

    operator T() const
    {
        return value;
    }
};

和替换的所有实例S const& (l|r)hs用ScalarType<S> const& (l|r)hs。

这使得两侧都有Vectors的运算符可以再次工作，但是应该处理Vector-Scalar运算符的运算符仍然失败。

这次是由于这样一个事实，标量值必须显式为type ScalarType，因为对其的隐式转换不适用于模板替换。

那么，有什么办法可以使它完全起作用，还是我必须坚持复制粘贴代码？