c++ 使用指向基类的指针在派生类中重载运算符

Question

I'm writing a class in c++ for an embedded system that behaves like a variable of multiple types (int, float, string, etc). By means of subclasses that handle each type of value. I need to do operator overloading for several operators like (+ - * / =! = + = - = == > < && ||!) But perform the operations from a pointer to the base class . How should I write these functions? I'm testing something like this, but it does not do the sum.

class base
  { 
    public:
    virtual base& operator=(const base& other) {};
    virtual base& operator+(const base& other) {};
 ...
  }

class VarInt: public base
{
 public:
    int value;
    VarInt& operator=(const VarInt& other);
    VarInt& operator+(const VarInt& other);
}

class VarFloat : public base
{
 public:
    float value;
  ...
}

main(){
 ...
    base* varbase1 = new VarInt();
    base* varbase2 = new VarInt();
    *varbase1 = 1;
    *varbase2 = 2;
    *varbase1 += *varbase2;
}

Answer 1

Your problem lies in the assumption that when VarInt inherits from base , then:

virtual base& operator = (const base& other) {};

and

virtual VarInt& operator = (const VarInt& other) {};

are the the exact same thing. Unfortunately, they are not . What you do here, is hiding the previous method. When you override a virtual function you need to specify it the exact same way it was firstly declared, that is:

virtual base& operator = (const base& other) {};

The returned base& can be bounded to VarInt object, so we are safe here. The provided argument, being const base& can also be referenced to a VarInt object. Now you have to think about what you actually want to achieve here. Assuming that from your base class multiple classes with different functionalities can inherit, what will happen if you, for example, try to add VarFloat to VarInt ? What is the expected result? Compiler error? Throwing an exception?

If you really wish to enable operator = to work with all the permutations of your inherited classes, then using dynamic_cast<> and static_cast<> will do the trick, however - keep in mind that if you happen to need to use casts, you might wish to rethink your design. Their usage is not recommended .

For a working example with ...cast usage, see here:

class Base{
public:
    // mandatory for destructing the objects via pointer of a base class
    virtual ~Base() = default;

    virtual Base& operator = (const Base& other) {};
};

class VarInt : public Base{
public:
    virtual Base& operator = (const Base& other) override
    {
        const auto ptr = dynamic_cast<const VarInt*>(&other);
        if(ptr != nullptr){
            // do whatever you need to - the *other* object is of a type VarInt!
            // use *ptr* to use *other* as VarInt
            return *this;
        } else {
            // do whatever you need to, when *other* is NOT a VarInt!
            // throw an exception? Add nothing?
        }
    }
};

Please keep in mind that this is not recommended for everyday usage - casts are a sign of a design flaw and should not be preferred