Как переопределить перегруженную функцию в производном классе?

#include <iostream>
class Number {
public:
    virtual Number* operator+(Number*)=0;
};
class Int :public Number {
    int x;
public:
    Int(int X=0) : x(X) {}
 
    Number* operator+( Number& N) {x+=N. //????  return this; }
};

class Number {
public:
    virtual Number& operator+(Number&)=0;
};
class Int :public Number {
    int x;
public:
    Int(int X=0) : x(X) {}
    Number& operator+( Number& N) 
    {
        x+=static_cast<Int&>(N).x;
        return *this; 
    }
};

#include <iostream>
#include <stdexcept>
 
#ifndef OUT_TO_STREAM
    #define OUT_TO_STREAM(type_)  \
        template<class T>friend   \
        ::std::basic_ostream<T>&  \
        operator<<(::std::basic_ostream<T>& os, const type_& obj )
#endif
 
 
 
struct Number {
    
    virtual ~Number(){}
    
    virtual std::string AboutMe()const = 0;
 
    virtual const Number& operator+=(const Number&)=0;
    
    OUT_TO_STREAM(Number)
    {
        return os<< obj.AboutMe();
    }
};
 
 
struct Int : Number {
    
    int x;
 
    Int(const int X=0) : x(X) {}
    const Number& operator+=(const Number& N) 
    {
        const auto* valid = dynamic_cast<const Int*>(&N);
        
        if(!valid)
            throw std::logic_error("invalid cast of type");
        
        x += valid->x;
        return *this;
    }
    
    virtual std::string AboutMe()const 
    {
        return std::to_string(x);
    }
};
 
struct Float : Number {
    float x;
 
    Float(const float X=0) : x(X) {}
    const Number& operator+=(const Number& N) 
    {
        const auto* valid = dynamic_cast<const Float*>(&N);
        
        if(!valid)
            throw std::logic_error("invalid cast of type");
        
        x += valid->x;
        return *this;
    }
    
    virtual std::string AboutMe()const 
    {
        return std::to_string(x);
    }
};
 
 
void plus(Number& l, const Number& r)
{
    l += r;
}
 
void simulate_error()
{
    try{
        
        Int i(10);
        Float f(10);
        plus(i,f);
        
    }
    catch(const std::exception& e)
    {
        std::cout<<"detected error: "<< e.what();
    }
}
 
int main()
{
    std::cout << "Hello, world!\n";
    
    Int val1(10);
    Int val2(10);
    
    std::cout << "before: val1 = " << val1<< '\n';
    
    plus(val1,val2);
    
    std::cout << "after : val1 = " << val1<< '\n';
    
    simulate_error();
    
}