Question: I have used the following code for assignment operator overloading:

```
SimpleCircle SimpleCircle::operator=(const SimpleCircle & rhs)
{
     if(this == &rhs)
        return *this;
     itsRadius = rhs.getRadius();
     return *this;
}

```

My Copy Constructor is this:

```
SimpleCircle::SimpleCircle(const SimpleCircle & rhs)
{
    itsRadius = rhs.getRadius();
}

```

In the above operator overloading code, copy constructor is called as there is a new object is being created; hence I used the below code:

```
SimpleCircle & SimpleCircle::operator=(const SimpleCircle & rhs)
{
    if(this == &rhs)
       return *this;
    itsRadius = rhs.getRadius();
    return *this;
}

```

Its working perfectly and the copy constructor problem is avoided, but is there any unknown issues (to me) regarding this ?

Answer: 
There are no problems with the second version of the assignment operator. In fact, that is the standard way for an assignment operator.

**Edit**: Note that I am referring to the return type of the assignment operator, not to the implementation itself. As has been pointed out in comments, the implementation itself is another issue. See [here](http://en.wikibooks.org/wiki/More_C++_Idioms/Copy-and-swap).
it's right way to use operator overloading
now you get your object by reference
avoiding value copying.