Шаблонный оператор, перегружающий базовый класс

Question

У меня есть базовый класс со многими дочерними классами. Как мне реализовать оператор шаблона над загрузчиком в базовом классе, чтобы он работал для всех наследующих классов? Я пытался сделать один с оператором +, но он жаловался, что у меня было слишком много параметров. На самом деле я не уверен, что это правильный способ сделать это (я только начинаю использовать ООП), так что если вы можете придумать лучший способ, который также был бы великолепен.

Я делаю библиотеку, в которой каждое метрическое пространство является классом. Я хочу сделать базовый класс "Операции", который наследует каждое пространство.

Мой шаблон базового класса:

#ifndef __libSpace__Operations__
#define __libSpace__Operations__

template< typename T >
class Operations{
public:
    friend T operator+( const T& sp, const T& nsp ){
        return T(sp.dimension + nsp.dimension);
    };
};

#endif

ребенок:

#ifndef __libSpace__EuclidSP__
#define __libSpace__EuclidSP__

#include "Operations.h"

class EuclidSP: public Operations<EuclidSP>{
public:
    EuclidSP(int n = 0, ...);
    ~EuclidSP();

    double* vector();

private:
    int dimension;
    double *vec = new double(dimension);
};

#endif

главный:

#include <iostream>
#include "EuclidSP.h"

int main(int argc, const char * argv[])
{
EuclidSP ob1(3,4.0,5.0,6.0);
EuclidSP ob2(3,2.0,5.0,3.0);
EuclidSP obj3();

obj3 = ob2+ob1;

return 0;
}

Answer 1

Член operator +() есть только один параметр, правый операнд. Левый или первый всегда *this, В зависимости от вашей ситуации вам нужна только база +, виртуальный + или шаблон. Бесплатный operator +() возьмите два аргумента, "левый" и "правый".

В вашем коде:

template< typename T >
class Operations{
public:
    friend T operator+( const T& sp, const T& nsp ){
        return T(sp.dimension + nsp.dimension);
    };
};

Вы хотите члена или друга?

Если у друга проблема в том, что +() нужно определять вне класса, это только друг, а не член.

template< typename T >
    T operator+( const T& sp, const T& nsp );

template< typename T >
class Operations{
public:
    friend T operator+<T>( const T& sp, const T& nsp );

};

template< typename T >
    T operator+( const T& sp, const T& nsp )
    {
        return T(sp.dimension + nsp.dimension);
    }

НО!!!! Теперь у вас есть проблема REAL: +() использует приватный член производного класса, а не базовый класс, поэтому он должен быть другом производного класса. Я думаю, вам нужно переосмыслить;-) ваш дизайн. Если вам так удобно использовать измерение в Operations... может ли это быть защищенным членом Operations??? Все ваши операции имеют измерение?

Answer 2

Ваш базовый класс должен знать класс производных типов, получая его в качестве параметра шаблона и реализуя operator+ как friend:

template< typename T >
class base
{
    friend T operator+( const T& lhs, const T& rhs )
    {
       // your generic implementation here...
    }
};

потом производные классы наследуются от базового класса следующим образом:

class D1 : public base<D1> { ... };
class D2 : public base<D2> { ... };