Абстрактный класс арифметического оператора перегрузки

Question

Я изучаю C++, и я пытаюсь сделать некоторый полиморфизм и перегрузку оператора, и у меня возникают некоторые проблемы.

Что я здесь делаю это абстрактный базовый класс, называемый номер и образовавшаяся класс называется Минт, мне нужно перегрузить оператор +, - для того, чтобы работать с MyInt номерами, MyDouble номерами ... и т.д.

После прочитав много сообщений, я застрял в этой ошибке error: invalid operands of types 'Number*' and 'Number*' to binary 'operator+' cout << n + m << endl; Как я могу сделать эту работу?

Я знаю, что это работает, используя шаблоны, но я не могу использовать его здесь, потому что точка этого упражнения является создание что-то вроде MyStack<Number*> держать различных типов

#include <cstdlib> 
#include <iostream> 
#include <string> 
#include <sstream> 
using namespace std; 

class Number { 
public: 
    virtual Number* operator+(Number* n) = 0; 
    virtual string toString() = 0; 
    friend ostream& operator<<(ostream& os, Number* n){ 
     return os << n->toString(); 
    } 
}; 

class MyInt: public Number{ 
public: 
    int value; 
    MyInt(int e){ 
     value = e; 
    } 
    virtual ~MyInt(){} 
    int getNum(){ return value;} 

    Number* operator+(Number* n){ 
     MyInt* a = (MyInt*) n;   
     return new MyInt(value + a->value); 
    } 

    string toString(){ 
     ostringstream oss; 
     oss << value; 
     return oss.str(); 
    } 
}; 

int main(int argc, char** argv) { 
    Number* n = new MyInt(5); 
    Number* m = new MyInt(3); 

    cout << "N: " << n << endl; 
    cout << "M: " << m << endl; 


    cout << n + m << endl; 

    return 0; 
} 

Answer 1

данных Вы сделали это очень неправильно. Непосредственным источником ошибки является то, что и ваши n, и m являются указателями, но член operator+ хотел бы, чтобы объект вызывался.

Вы могли бы, в теории, выполнить двойную диспетчеризацию (в противном случае синтаксис будет просто некрасиво):

// define operator+ as a free function 
Number* operator+(Number* lhs, Number* rhs) { 
    return lhs->operator+(rhs); 
} 

Однако, в то время как плюс будет вызываться для lhs будет называться практически, rhs останется абстрактным тип. Вы не сможете понять, что это такое, если вы не делаете dynamic_cast для этого - и это просто уродливо. В общем, ваш пример просто не подходит для динамического полиморфизма.