Thread: C++ Operator overloading

These are probably silly questions

Is is possible to force derived classed to overload certain operators, like we do with pure virtual functions?

Is this possible to dynamically bind objects to their respective overloaded operators?

I am getting errors with undefined references to my base class vtable when I hackly try to overload:

Code:

operator+

I am not sure whether this is possible.

Implement the operator with respect to the base class using a pure virtual member function which will derived classes will then override. You can make this pure virtual member function private so that you only expose the operator as part of the interface rather than having two things in the same interface to do the same thing.

This approach is sometimes used to overload operator<< for standard output streams in a base class, with a (pure) virtual print member function that derived classes override.

Originally Posted by laserlight

Implement the operator with respect to the base class using a pure virtual member function which will derived classes will then override. You can make this pure virtual member function private so that you only expose the operator as part of the interface rather than having two things in the same interface to do the same thing.

This approach is sometimes used to overload operator<< for standard output streams in a base class, with a (pure) virtual print member function that derived classes override.

Well, Thanks. It seems I was making a silly mistake somewhere.

Is this possible to dynamically bind objects to their respective overloaded operators?

This seems like a very silly question because dynamic binding is based on pointers while in operators work the other way round.

This seems like a very silly question because dynamic binding is based on pointers while in operators work the other way round.

O_o

I've looked at this for a few minutes, and I can't figure out what you are actually saying.

I solved my problem more hackly by tracking my types, so there is nothing to worry about.

I'm also not sure about what this comment is saying.

If you are "tacking your types" just to overload an operator, you are almost certainly doing something very unnecessary for very little reason.

Soma

Operators can accept their arguments by reference (if they change the argument) or by const reference (if they are not). Operators that are members of the class receive the "this" pointer, from which a reference to the corresponding argument can be obtained.

Since they receive references, they can exploit virtual function dispatch. Which means, according to your inaccurate description, "polymorphism works".