Confusion overloading '=' operator

[hjast]

I'm trying to implement a = operater to set one circle or rectangle to another and this is giving me all kind of bugs.

#include <iostream.h>
 
 
class Shape
{
  private:
     int x_Center, y_Center;
 
  public:
    Shape()
    {
    cout <<"In defualt constructer";
    }
    Shape(Shape& sh)
    {
    x_Center=sh.x_Center;
    y_Center=sh.y_Center;
    }
     // Constructors
     Shape(int cx, int cy)
    {
        x_Center=cx;
        y_Center=cy;
    }
 
     // Member functions
     int getCenter_X();
     int getCenter_Y();
     virtual void draw()=0;
};
 
class Rectangle : public Shape
{
private:
    int length,width;
 
 public:
 
  // Default constructor
  Rectangle (Rectangle& r) : Shape(r)
    {
    length=r.length;
    width=r.width;
    }
 
  // Constructor
  Rectangle (int cx, int cy,int l,int w) : Shape(cx, cy)
    {
    length=l;
    width=w;
      cout << "In Rectangle constructor" << endl;
    }
 
 
 
    // Destructor
    ~Rectangle ()
      {
    cout << "In Rectangle destructor" << endl;
      }
 
    void draw()
    {
    cout <<"In drawing of Rectangle"<<endl;
    }
 
    Rectangle & operator=(const Rectangle &obj)
    {
            return Rectangle(obj.getCenter_X(),obj.getCenter_Y(),obj.length,obj.width);
    }
    // Methodds
    void printAllValues();
};
 
class Circle : public Shape
{
private:
int diameter;
 
 public:
 
  // Default Constructor
  Circle ()
    {
      cout << "In the default constructor of Circle" << endl;
    }
 
    Circle (Circle& r) : Shape(r)
    {
    diameter=r.diameter;
    }
  // Constructor
  Circle (int cx, int cy, int dia) : Shape (cx, cy)
    {
      cout << "In Circle Constructer" << endl;
      diameter=dia;
    }
 
    // Destructor
    ~Circle ()
      {
    cout << "In Circle destructor" << end}
      }
      void draw()
    {
    cout <<"In drawing of Circle"<<endl;
    }
    Circle & operator=(const Circle &obj)
    {
        return Circle(getCenter_X(),getCenter_Y(),diameter);
    }
    // Methods
    void printAllValues();
};

Could someone please help point me in the right diretion please.

[weaknessforcats]

Let's look at the situation:

You have a Shape.

Therefor you need a Shape assignment operator.

You have Circle deriving from Shape.

Therefore you need a Circle assignment operator.

In each case the assignment operator must change the this object since iot is that object that in to the left of the operator (and thereby, the hidden firstargument of the assignment operator function).

For Shape:
1) assign the values of the argument to the this object.
2) do not assign the this obect ot itself.

Shape Shape::operator=(const Shape& rhs)
{
   if (this == rhs) return *this;    //nothing to do if self-assignment
   this->x_Center = rhs.x_Center;
   this->y_Center = rhs.y_Center;
   return *this;
}
 

For Circle:
1) assign the base class object first
2 assign the values of the argument to the this object.
3) do not assign the this obect ot itself.

Circle Circle::operator=(const Circle& rhs)
{
   if (this == rhs) return *this;    //nothing to do if self-assignment
   Shape::operator=(*this);       //assign the base class object
   this->diameter= rhs.diameter;
   return *this;
}
 

That said, it does not look like your Circle IS-A kind of Shape since it does not use x_Center or y_Center at all. I question whether your class inheritance model is correct.

[hjast]

Thanks a lot, but shouldn't I create a new object in the heap and then copy all attribtes and then give the pointer to that? Does the code you just exampled make a copy operater?

I am a little confused on why you return itself. Please clarify.

Reuben

[gpraghuram]

Thanks a lot, but shouldn't I create a new object in the heap and then copy all attribtes and then give the pointer to that? Does the code you just exampled make a copy operater?

I am a little confused on why you return itself. Please clarify.

Reuben

You need not create a new object and retun it.
Becos the function is called by a object and the values you change for this affects the object calling it.

Raghuram

[weaknessforcats]

Thanks a lot, but shouldn't I create a new object in the heap and then copy all attribtes and then give the pointer to that? Does the code you just exampled make a copy operater?

I am a little confused on why you return itself. Please clarify.

Reuben

The fact that your assignment operator returns a Circle means that a copy is returned. That means you should have a copy constructor to make that copy.

If you create your own copy on the heap and try to return it, you still need a copy constructor to make the copy top be returned. Plus now you have to delete the copy you made before returning.

It's not my code that requires a copy. It's the fact that the function returns a Circle.

By returning *this, I am calling Circle::Circle( const Circle& rhs), which os your copy copnstructor.

If you don't have one, the compiler trots out its default copy constructor which makes memberwise copies of each of your data members. If all of your data members a built-in types, like int, then this default will work fine.