Question

So I’ve always been taught that good coding practice is to use accessor methods versus directly accessing member variables, however while writing overloaded operators, I cannot compile if using these accessor methods within the operator class definition. So assume the following class:

    class Point
    {
    public:
        Point() {};
        virtual ~Point() {};

        // Accessor Methods
        inline void SetX(ushort nX) { m_nX = nX; }
        inline void SetY(ushort nY) { m_nY = nY; }
        inline ushort GetX() { return m_nX; }
        inline ushort GetY() { return m_nY; }

        // Overloaded Operators
        Point operator+(const Point& pnt);

    private:
        ushort m_nX, m_nY;
    };

In the operator definition, the following seems perfectly legal, but it goes against what I’ve been taught:

    Point Point::operator+(const Point& pnt)
    {
        Point myPoint;
        myPoint.SetX(GetX() + pnt.m_nX);
        myPoint.SetY(GetY() + pnt.m_nY);
        return myPoint;
    }

However, the following compiles with the error:

Point.cpp:7:36: error: passing ‘const Point {aka const Point}’ as ‘this’ argument of ‘ushort Point::GetX()’ discards qualifiers [-fpermissive]

Point.cpp:8:36: error: passing ‘const Point {aka const Point}’ as ‘this’ argument of ‘ushort Point::GetY()’ discards qualifiers [-fpermissive]

    Point Point::operator+(const Point& pnt)
    {
        Point myPoint;
        myPoint.SetX(GetX() + pnt.GetX());    // Here I am trying to use accessor methods vs. member variables
        myPoint.SetY(GetY() + pnt.GetY());
        return myPoint;
    }

The latter code will compile if the ‘const’ keyword is removed from the parameter list, which I don’t fully understand, just because I’m passing in a const variable, why does that eliminate my ability to use the accessor methods?

Answer 1

Your getter functions are not marked as const, so cannot be called on a constant object:

inline ushort GetX() const { return m_nX; }
                     ^^^^^

Without the const keyword, the compiler must assume that the function might modify the object, and thus cannot be called on a constant object. It’s also good to note that in some cases, you may want both a const and a non-const version, with different return types, such as:

const_iterator vector<T>::begin() const; //const version
iterator vector<T>::begin(); //mutable version

Using getters and setters is (in my opinion) more correct than accessing the right hand sides’s members directly.