Question about Copy Constructor and Overloading Assignment Operator

Hi everbody,
I'm self-studying C++, so there are some points confusing me. Please help me make it clear:

Consider this Copy Constructor Declaration:
MyClass(const MyClass& myObj);

Why must a copy constructor have call-by-reference parameter ? what happens if that is call-by-value parameter ? If call-by-value, will the compiler assign the parameter to another copy of the argument, and their pointers (pArr) will be pointing to the same array in memory that will later be destroyed by the destructor, when the temporary myObj goes out of scope once Copy Constructor finishes its job ?

Code:

---


MyClass
{
  public:
  /* ....  */
  MyClass(const MyClass& myObj);
  ~MyClass();
  operator=(const Myclass& rsideObj);
  /* ...  */
  private:
  /* ... */
  char *pArr; /* used to create  dynamic array type of char (a C_string, I mean ... */
};

---

Why operator=(const MyClass& rsideObj) must be a member function, rather than friend function, just like other overloading operators?

Quote:

---

Why must a copy constructor have call-by-reference parameter ? what happens if that is call-by-value parameter ?

---

I am guessing that passing the copy constructor argument by value is not possible.

Quote:

---

Why operator=(const MyClass& rsideObj) must be a member function, rather than friend function, just like other overloading assignment ?

---

Actually, I think other overloaded assignment operators should also be member functions.

Quote:

---

Originally Posted by trongsi

Why operator=(const MyClass& rsideObj) must be a member function, rather than friend function, just like other overloading assignment ?

---

Making it a friend isn't sensible. Good OOP design is keeping your data as safe and as unchanged as possible: if you made operator= a friend function, you would have to pass in references to both sides of the operator, and make changes to both of those. Plus, the assignment operator needs access to the class' private members, and making it a member avoids the overhead of calling getter functions.

Thanks for your reponses, back to the first question, why does C++ require the copy constructor and overloading assignment operator having call-by-reference parameter. Is the reason I listed above the major problem that makes them not having call-by-value ?

If you tried to do this with call by value, it would be an unnecessary headache, and to be honest it doesn't make any sense either, since your assignment operator didn't create anything it's working with.

Quote:

---

Originally Posted by trongsi

back to the first question, why does C++ require the copy constructor and overloading assignment operator having call-by-reference parameter.

---

Well, if your "copy constructor" isn't by reference, then needs to make a copy using the copy constructor, which needs to make a copy using the copy constructor, which needs to make a copy using the copy constructor, which needs to make a copy...

Well, Thanks Dave_Sinkula.

Are following definition of Overloading Operator Assignment equivalent ?
Why must the second one's return type be MyClass&, not MyClass ? What does it mean with that return type ?

Code:

---

//The first one, assume that its declaratoin including in class interface

void MyClass::operator=(const MyClass& rsideObj)
{
  if (this==&rsideObj) //check if rightside is leftside object itself.
        return;
  else
  {
        delete [] pArr;
        pArr = new char[strlen(rsideObj.pArr) + 1];
        strcpy(a,rsideObj.pArr);
  }
}


//the altinative

MyClass& MyClass::operator=(const MyClass& rsideObj)
{
  if (this==&rsideObj) //check if rightside is leftside object itself.
        return *this;
  else
  {
        delete [] pArr;
        pArr = new char[strlen(rsideObj.pArr) + 1];
        strcpy(a,rsideObj.pArr);
        return *this;
  }
}

---

Thanks in advance for helping me, and please patient with me...

I don't think that there's any requirement, its just that references
are far more efficient. Also your assignment code is wrong:

Code:

---

void MyClass::Operator=(const MyClass& rsideObj)
{
  if (this!=&rsideObj) //check if rightside is leftside object itself.
        exit(1);
  else
  {
        delete [] pArr;
        pArr = new char[strlen(rsideObj.pArr) + 1];
        strcpy(a,rsideObj.pArr);
  }
}

---

should actually be this:

Code:

---

void MyClass::Operator=(const MyClass& rsideObj)
{
  if (this!=&rsideObj) //check if rightside is leftside object itself.
  {
        delete [] pArr;
        pArr = new char[strlen(rsideObj.pArr) + 1];
        strcpy(a,rsideObj.pArr);
  }
  return;
}

---

similarly, your alternative will be this:

Code:

---

MyClass& MyClass::Operator=(const MyClass& rsideObj)
{
  if (this!=&rsideObj) //check if rightside is leftside object itself.
  {
        delete [] pArr;
        pArr = new char[strlen(rsideObj.pArr) + 1];
        strcpy(a,rsideObj.pArr);
  }
  return *this;
}

---

See why?

[update]
operator is a keyword - not Operator.
[/update]

Quote:

---

Originally Posted by trongsi

Are following definition of Overloading Operator Assignment equivalent ?
Why must the second one's return type be MyClass&, not MyClass ? What does it mean with that return type ?

---

Returning a reference allows assignment chaining.

• http://www.parashift.com/c++-faq-lit...html#faq-27.10

Maybe wander around the C++ FAQ LITE (I have been):

• http://parashift.com/c++-faq-lite/ctors.html
• http://parashift.com/c++-faq-lite/as...operators.html
• http://parashift.com/c++-faq-lite/op...erloading.html

Quote:

---

Originally Posted by Richie T

I don't think that there's any requirement, its just that references
are far more efficient. Also your assignment code is wrong:

Code:

---

/*Correction for my previous wrong posting */
void MyClass::operator=(const MyClass& rsideObj)
{
  if (this==&rsideObj) //check if rightside is leftside object itself.
        return;
  else
  {
        delete [] pArr;
        pArr = new char[strlen(rsideObj.pArr) + 1];
        strcpy(a,rsideObj.pArr);
  }
}

---

should actually be this:

Code:

---

void MyClass::operator=(const MyClass& rsideObj)
{
  if (this==&rsideObj) //check if rightside is leftside object itself.
  {
        delete [] pArr;
        pArr = new char[strlen(rsideObj.pArr) + 1];
        strcpy(a,rsideObj.pArr);
  }
  return;
}

---

similarly, your alternative will be this:

Code:

---

MyClass& MyClass::Operator=(const MyClass& rsideObj)
{
  if (this!=&rsideObj) //check if rightside is leftside object itself.
  {
        delete [] pArr;
        pArr = new char[strlen(rsideObj.pArr) + 1];
        strcpy(a,rsideObj.pArr);
  }
  return *this;
}

---

See why?

[update]
operator is a keyword - not Operator.
[/update]

---

Yes yes, You're so right. I made some mistakes when I posted these code. However, I meant that those function work exactly alike, don't them ?
Thanks all for your helping.