-Woverloaded-virtual warning for const function

user_1872084 0
Viewed 115

I have this piece of code:

class ISerializable
{
        public:
            virtual bool operator==(const ISerializable* /*value*/) const { return false;};
            virtual bool operator!=(const ISerializable* /*value*/) const { return true;};
};

class Point2I : public ISerializable
{
        public:
            bool operator==(const Point2I& value)
            {
                return (x == value.x && y == value.y);
            }

            bool operator!=(const Point2I& value)
            {
                return !(*this == value);
            }
            public:
            int x;
            int y;
};

class Coordinate : public ISerializable
{
         public:
            virtual bool operator==(const Coordinate& value) const;
            virtual bool operator!=(const Coordinate& value) const;
};

It is causing me -Woverloaded-virtual warning on gcc compiler.

I understand this warning due to that function declaration in Point2I hides virtual functions from ISerializable. But I am not sure if just missing const in Point2I can cause this warning.

Can you please help me understand if it is const which is causing this warning or something else? Warning description from gcc didn't mention anything specifically.

Update:

I found another class Coordinate in my code base which was already overriding this and gcc not throwing warning for this. Only difference in Point2I and Coordinate is I didn't declare it virtual with const in Point2I. It appears just const is hiding base class declaration.

gcc-warning declaration operator-overloading class c++
2 Answers

if it is const which is causing this warning or something else?

I'd say that it's something else, namely that you are not actually overriding the base class methods, even if you add const.

The argument const ISerializable* is not the same as const Point2I&.

One solution could be to override the base class methods, using const ISerializable& as the argument, and cast in the overridden methods:

class ISerializable {
public:
    // add virtual destructor if you need to delete objects through
    // base class pointers later:
    virtual ~ISerializable() = default;
    virtual bool operator==(const ISerializable&) const { return false; }
    virtual bool operator!=(const ISerializable&) const { return true; }
};

class Point2I : public ISerializable {
public:
    bool operator==(const ISerializable& value) const override {        
        auto rhs = dynamic_cast<const Point2I*>(&value);
        // rhs will be nullptr if the cast above fails
        return rhs && (x == rhs->x && y == rhs->y);
    }

    bool operator!=(const ISerializable& value) const override {
        return !(*this == value);
    }

private:
    int x = 0;
    int y = 0;
};

Example usage:

#include <iostream>

class Foo : public ISerializable {   // another ISerializable 
public:
};

int main() {
    Point2I a, b;
    std::cout << (a == b) << '\n';  // true  - using Point2I::operator==

    Foo f;
    std::cout << (a == f) << '\n';  // false - using Point2I::operator==
    std::cout << (f == a) << '\n';  // false - using ISerializable::operator==

    // this makes the default implementation in ISerializable utterly confusing:
    std::cout << (f == f) << '\n';  // false - using ISerializable::operator==
}

Another possible solution could be using CRTP but this would not work if you want to compare different types derived from ISerializable<T>:

template<class T>
class ISerializable {
public:
    virtual ~ISerializable() = default;
    virtual bool operator==(const T&) const = 0;
    virtual bool operator!=(const T&) const = 0;
};

class Point2I : public ISerializable<Point2I> {
public:
    bool operator==(const Point2I& value) const override {
        return (x == value.x && y == value.y);
    }

    bool operator!=(const Point2I& value) const override {
        return !(*this == value);
    }

public:
    int x;
    int y;
};
user_75822470

There are two problems.

The first one is different types of parameters

In these functions the parameters have the pointer type const ISerializable*

virtual bool operator==(const ISerializable* /*value*/) const { return false;};
virtual bool operator!=(const ISerializable* /*value*/) const { return true;};

and in these functions the parameters have the referenced type const Point2I&

bool operator==(const Point2I& value)
{
    return (x == value.x && y == value.y);
}

bool operator!=(const Point2I& value)
{
    return !(*this == value);
}

The second one is that the first functions are constant member functions while the second functions are not constant member functions.

user_28772410
Related