How can I overload an operator for an abstract class?

Question

I'm relatively new to C++, and my professor did not go into as much detail into operator overloading as I'd like when I took his class. I'm trying to implement a way to compare objects (using > or <) that all inherit an abstract class, but I'm having trouble with the syntax/logic.

I tried having it be a member of the parent class, but I couldn't figure out how to call a pure virtual function from inside the base class. Then I tried using templates but that's just giving me a headache (my professor didn't go too in-depth on those either).

I'm aware I completely failed in the operator function (and any help with the proper syntax would be appreciated).

#include <iostream>

enum cType { point, maxima, inflection };

class CONSTRAINT {
public:
    //coordinates
    int x, y;
    //gets what type of constraint the object is
    virtual cType getType() = 0; //pure virtual
    //I'm sure this syntax is horrendous and completely wrong.
    //I was just trying to emulate what I found online :(
    bool operator > (const CONSTRAINT &rhs) { 
            //If the constraints have the same type, compare by their x-value
        if (getType() == rhs.getType())
            return (x > rhs.x);
            //Otherwise, it should be point > maxima > inflection
        else
            return (getType() > rhs.getType());
    }
};
class POINT : public CONSTRAINT {
public:
    virtual cType getType() { return point; }
};
class MAXIMA : public CONSTRAINT {
public:
    virtual cType getType() { return maxima; }
};
//I have another inflection class that follows the pattern

int main() {
    POINT point1, point2;
    point1.x = 3;
    point2.x = 5;
    MAXIMA maxima;
    maxima.x = 4;
    std::cout << (point1 > point2);
    std::cout << (point2 > point1);
    std::cout << (maxima > point2);
    std::cout << (point1 > maxima );
    return 0;
}

I would expect: 0110 if the program would compile.

Instead I get the following errors:

"the object has type qualifiers that are not compatible with the member function "CONSTRAINT::getType""

"'cType CONSTRAINT::getType(void)': cannot convert 'this' pointer from 'const CONSTRAINT' to 'CONSTRAINT &'"

Thanks.

In general it's a Very Bad Idea™ to have a virtual `operator>` or any other virtual binary operator. There are exceptions but they are few and far between. It is a different kind of Very Bad Idea™ to refer to any kind of "type identifier" such as your `enum cType` to perform business logic. — n. m. could be an AI, Jul 11 '19 at 17:38

user4581301 · Accepted Answer · 2019-07-11T17:57:40.433

In

bool operator > (const CONSTRAINT &rhs)

rhs is const. It cannot be changed inside this method. But...

virtual cType getType() = 0; //pure virtual

Is not a const method. This means the method could change rhs, so the compiler refuses to allow it to be called.

Solution: Declare the method const

virtual cType getType() const = 0; //pure virtual

Now the compiler is promised that calling the function will not allow rhs to be changed. The compiler will also enforce this and refuse to compile the program if an implementation of getType tries to change the object on which it is invoked.

Side notes:

Once a method is declared to be virtual, all overrides will also be virtual.

The override keyword will catch errors if a method should override but doesn't due to a mismatch. Adding const to the base class method, but not the derived class method, is a good example of where this is helpful.

Since it looks like this code is taking advantage of runtime polymorphism you may want a virtual destructor in the base class to ensure the correct classes are destroyed should you one day wish to delete a derived class through a pointer to the base class.

Wrapping all that up:

#include <iostream>

enum cType { point, maxima, inflection };

class CONSTRAINT {
public:
    //coordinates
    int x, y;

    virtual ~CONSTRAINT() = default;
//  ^ added

    //gets what type of constraint the object is
    virtual cType getType() const = 0; //pure virtual
//                          ^ added
    //I'm sure this syntax is horrendous and completely wrong.
    //I was just trying to emulate what I found online :(
    bool operator > (const CONSTRAINT &rhs) {
            //If the constraints have the same type, compare by their x-value
        if (getType() == rhs.getType())
            return (x > rhs.x);
            //Otherwise, it should be point > maxima > inflection
        else
            return (getType() > rhs.getType());
    }
};
class POINT : public CONSTRAINT {
public:
    cType getType() const     override { return point; }
//                  ^ added   ^ added
};
class MAXIMA : public CONSTRAINT {
public:
    cType getType() const     override { return maxima; }
//                  ^ added   ^ added
};
//I have another inflection class that follows the pattern

int main() {
    POINT point1, point2;
    point1.x = 3;
    point2.x = 5;
    MAXIMA maxima;
    maxima.x = 4;
    std::cout << std::boolalpha // < added. prints true and false instead of 1 and 0
              << (point1 > point2) << '\n'
              << (point2 > point1) << '\n'
              << (maxima > point2) << '\n'
              << (point1 > maxima);
    // took advantage of chaining and added newlines to the output for clarity
    return 0;
}

Final side note: It is generally recommended that operator< be implemented as a Free Function. For more on that, and much other wisdom on Operator Overloading, see What are the basic rules and idioms for operator overloading?

How can I overload an operator for an abstract class?

1 Answers1