Question

I’ve got kind of an issue here with c++ – I’ve got two classes:
class vec and class vecD : public vec

class vec overloads pretty much any operator – some of them (as +=) return an object of the class itself for obvious reasons. Now my questions is: is it possible to reuse the overloaded functions of vec for vecD but return a vecD object instead? I mean for sure it’s possible to define all functions virtual and redefine them all over again…but, you know there must be some smoother way?

EDIT: Sorry, sure some code: Is it possible to use inheritance like that? Starting from a templated class? Can I reuse them operators from the parents class?

template<typename TYPE>
class vec{
public:

    TYPE *val;
    int dimension;
public:

    vec();
    ~vec();


    TYPE operator[](int right);
    virtual vec<TYPE>& operator=( TYPE right );
    virtual vec<TYPE>& operator=( vec<TYPE> right );
    virtual vec<TYPE> operator+( TYPE right );
    virtual vec<TYPE> operator-( TYPE right );
    [etc]
};

class vecD : public vec<long>{
public:
    long *X;
    long *Y;
    long *Z;
    long *Xmax;
    long *Ymax;
    long *Zmax;

public:
    vecD();
    ~vecD();

    long getAddress();
    long setAddress( long _X, long _Y, long _Z );


    TYPE operator[](int right);
    virtual vecD<long>& operator=( long right );
    virtual vecD<long>& operator=( vecD<long> right );
    virtual vecD<long>& operator=( vec<long> right );

    virtual vecD<long> operator+=( vecD<long> right );
    [etc]
};

Answer 1

Judging by the comments, this might also interest you:

//this is used as a common base, so that you don't have to write the gory 
//details twice.  Only once.
template<typename TYPE>
class vec_base{
protected:
    TYPE *val;
    int dimension;
    vec(); /*protected so only vec can use vec_base, nobody else*/
    ~vec();
    /* I don't see any reason for these to be virtual */
    TYPE operator[](int right);
    vec<TYPE>& operator=( TYPE right );
    vec<TYPE>& operator=( vec<TYPE> right );
    vec<TYPE> operator+( TYPE right );
    vec<TYPE> operator-( TYPE right );
    [etc]
};

//most types just use this.
//it's just a simple wrapper around vec_base<TYPE>
template<typename TYPE>
class vec : public vec_base<TYPE> {
    //no data
    vec(const vec_base<TYPE>& b) :vec_base<TYPE>(b) {}
    vec(vec_base<TYPE>&& b) :vec_base<TYPE>(b) {}
public: 
    vec() {}
    vec(const vec& b) :vec_base<TYPE>(b) {}
    vec(vec&& b) :vec_base<TYPE>(b) {}
    ~vec() {}
    vec<TYPE>& operator=(const vec<TYPE>& b) 
    {vec_base<TYPE>::operator=(b); return *this;}
    vec<TYPE>& operator+=(const vec<TYPE>& b) 
    {vec_base<TYPE>::operator+=(b); return *this;}
    vec<TYPE> operator+(const vec<TYPE>& b) 
    {return vec<TYPE>(vec_base<TYPE>::operator+(b));}
    vec<TYPE>& operator-=(const vec<TYPE>& b) 
    {vec_base<TYPE>::operator-=(b); return *this;}
    vec<TYPE> operator-(const vec<TYPE>& b) 
    {return vec<TYPE>(vec_base<TYPE>::operator-(b));}
    /*other overloads that return vec_base<TYPE>*/
    /*all they do is call the base, super easy.*/
};

//when someone wants <long>, they get this instead
//which is vec_base, but so much more
//(not that I know what that is)
class vec : public vec_base<long>{
public:
    long *X;
    long *Y;
    long *Z;
    long *Xmax;
    long *Ymax;
    long *Zmax;
public:
    vecD() : vec_base<long>(), X(nullptr), Y(nullptr), Z(nullptr), /*etc*/ {}
    ~vecD() {delete[] X; delete[] Y; delete[] Z;}

    /* vec<long> can have unique functions */
    long getAddress();
    long setAddress( long _X, long _Y, long _Z );

    /* some are simple wrappers, some you have to play with X/Y/Z*/
    TYPE operator[](int right)
    {return vec_base<long>::operator[](right);}
    vec<long>& operator=( long right ) 
    {
         vec_base<long>::operator=(right);
         return *this;
    }
    vec<long>& operator=( vec<long> right )
    {
         vec_base<long>::operator=(right);
         X = right.X;
         Y = right.Y;
         Z = right.Z;
         return *this;
    }
    vec<long> operator+=( vecD<long> right );
    [etc]
    /*other overloads all must be overridden*/
    /*if they touch X,Y,Z,etc.*/
};

int main() {
    vec<int> a; //this is what you already had as vec<TYPE>
    vec<long> b; //this is what you already had as vec<TYPE>
    b.getAddress();  //this is allowed on b, but not a
}