Question

I’m not sure why I get the following error when trying to overload the = operator

error: passing ‘const MyCircle’ as ‘this’ argument of ‘double MyCircle::getRadius()’ discards qualifiers|

Code:

#include <iostream>

#define PI 3.14

using namespace std;


class MyCircle
{
  public:
    MyCircle();
    MyCircle(int r);
    MyCircle(const MyCircle& c);
    void setRadius(double r);
    double getRadius();
    double getArea();
    static void increaseInstanceCount();
    static int getInstanceCount();
    MyCircle operator=(const MyCircle &);

  private:
    double radius;
    static int instanceCount;
};

int MyCircle::instanceCount = 0;

/**
1. A default constructor, that sets the radius to 0
**/
MyCircle::MyCircle()
{
    radius = 0.0;
    increaseInstanceCount();
}

/**
2. A one argument costructor that accepts an int and uses it to initialize the radius
**/
MyCircle::MyCircle(int r)
{
    radius = r;
    increaseInstanceCount();
}

/**
3. A copy constructor that accepts a Circle reference as an argument, and uses it to initialize radius
**/
MyCircle::MyCircle(const MyCircle& c)
{
    radius = c.radius;
    increaseInstanceCount();
}

void MyCircle::increaseInstanceCount()
{
    instanceCount++;
}

int MyCircle::getInstanceCount()
{
    return instanceCount;
}
void MyCircle::setRadius(double r)
{
    radius = r;
}

double MyCircle::getRadius()
{
    return radius;
}

double MyCircle::getArea()
{
    return (radius * radius) * PI;
}

//overload = operator
MyCircle MyCircle::operator=(const MyCircle &rhs)
{
    if(this == &rhs)
        return *this;

    radius = rhs.getRadius();
    return *this;

}

int main()
{
    MyCircle circle;
    circle.setRadius(5.4);
    MyCircle circle2;
    circle2.setRadius(3.0);
    MyCircle circle3;
    circle3.setRadius(343.3);

    cout << "Total instances: " << circle.getInstanceCount() << endl;
    return 0;
}

Answer 1

You need to add a const qualifier to the getRadius() method, like

double MyCircle::getRadius() const
{
    return radius;
}

this will qualify the method to be called with an const object. You might want to add this qualifier to any methods that don’t change member variables, avoiding this type of error.