Can I override operators in C++?

Question

I knew that we can overload operators for a class. But my question is whether I can override operators?

Let us consider that I have a base class and derived class, is it possible to override an operator defined ( overloaded ) in the base class in the derived class (as with function overriding)?

Answer 1

You can achieve the desired effect by providing a "cover" virtual function in the base class, and call it from the operator's implementation in the base class:

struct Base {
    Base operator+(const Base& other) {
        return add(other);
    }
protected:
    virtual Base add(const Base& other) {
        cout << "Adding in Base's code." << endl;
        return Base();
    }
};

struct Derived : public Base {
protected:
    virtual Base add(const Base& other) {
        cout << "Adding in Derived's code." << endl;
        return Derived();
    }
};

int main() {
    Base b1;
    Base b2;
    Derived d1;
    Derived d2;
    Base res;
    res = b1+b2; // Prints "Adding in Base's code."
    res = b1+d2; // Prints "Adding in Base's code."
    res = d1+b2; // Prints "Adding in Derived's code."
    res = d1+d2; // Prints "Adding in Derived's code."
    return 0;
}

Demo.

Answer 2

An overloaded operator is just a function, so it can be virtual, and overridden.

But it's seldom a good idea.

Consider an overridden copy assignment operator, that in some derived class checks whether the value to be assigned is compatible with the object assigned to. Effectively it has replaced static type checking with dynamic type checking, which involves a lot of laborous testing and only a statistical chance of correctness.

---

Example of ungoodness:

#include <assert.h>
#include <iostream>
#include <string>
using namespace std;

struct Person
{
    string name;

    virtual
    auto operator=( Person const& other )
        -> Person&
    { name = other.name; return *this; }

    Person( string const& _name ): name( _name ) {}
};

struct Employee: Person
{
    int     id;

    auto operator=( Person const& other )
        -> Person&
        override
    {
        auto& other_as_employee = dynamic_cast<Employee const&>( other );

        Person::operator=( other );
        id =  other_as_employee.id;
        return *this;
    }

    auto operator=( Employee const& other )
        -> Employee&
    {
        return static_cast<Employee&>(
            operator=( static_cast<Person const&>( other ) )
            );
    }

    Employee( string const& _name, int const _id )
        : Person( _name )
        , id( _id )
    {}
};

void foo( Person& someone )
{
    someone = Person( "Maria" );        // Fails, probably unexpectedly.
}

auto main() -> int
{
    Person&& someone = Employee( "John", 12345 );
    foo( someone );
}

Answer 3

I want to add one more thing: After my personal frustration about the default behavior of certain operators on built-in types, I wondered if it was possible to override that operators in a simple and readable way. The answer was my Polyop project, which achieves exactly that.

So, can you override the default behavior of C++ operators? Yes, just wrap them in a way that the operator call seems to be the same, but the thing its actually calling a completely different operator with the properties and behavior you defined.

//Redefine the behavior of the int vs int equality operator
auto operator==(void(int,int) , pop::default_context )
{
    return [](int lhs , int rhs )
    {
        return lhs * 2 == rhs;
    };
}

using pop::triggers::_;

int main()
{
    bool equal = _(4) == 2; //Returns true, since its the behavior we defined above
}

All with no performance hits at all.