C ++ Дочерние классы - повторное использование перегруженных операторов?

Question

У меня есть какая-то проблема здесь с c ++ - у меня есть два класса: class vec и class vecD : public vec

класс vec перегружает практически любой оператор - некоторые из них (как + =) вернуть объект самого класса по понятным причинам.Теперь мои вопросы: возможно ли повторно использовать перегруженные функции vec для vecD, но вместо этого вернуть объект vecD?Я имею в виду наверняка, что можно определить все функции виртуально и переопределить их заново ... но, вы знаете, должен быть какой-то более плавный способ?

РЕДАКТИРОВАТЬ: Извините, конечно код: Возможно ли использовать наследование, как это?Начиная с шаблонного класса?Могу ли я использовать их операторы из класса родителей?

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

Судя по комментариям, это также может вас заинтересовать:

//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
}

Answer 2

Так же, как это:

class vecD : public vec<long> {
     /*whatever makes it unique here, incl constructors/destructors*/
     int data;

     vecD& operator+=(const vecD& b) {
         vec<long>::operator+=(b); //here's the magic line
         data += b.data;
         return *this;
     }
     vecD& operator+=(const vec<long>& b) { //overload for base type [optional]
         vec<long>::operator+=(b); //here's the magic line
         return *this;
     }
     /*[etc]*/
};