赋值操作和对象传递期间的构造方法调用

Question

I am confused over the differences between passing objects by reference and by value to functions of a particular class. If I pass objects by value, I know that the default copy constructor makes a member-by-member copy of the the object for use in the given function. However, if I am passing objects as a const reference for a class that requires deep copy, is the copy constructor still called? Say that I had a function

     void debug(const MyClass& object1); 

Would passing object1 call the copy constructor? Or is the object passed into the function directly without having a copy made? One more question - If I have a class called Fraction-

     Fraction A(1,2); // 1 is this numerator, 2 the denominator

     A = Fraction(2,3);

Does the aforementioned line call the default constructor to make a temporary object Fraction(2,3) and then the assignment operator?

Thanks.

Answer 1

In the following we will consider [x] to mean that x is optional.

I am confused over the differences between passing objects by reference and by value to functions of a particular class.

When you pass an object by value, the program must create the local object of the function therefore it calls the copy constructor of the class to create this object. When you pass by reference (and seemingly by pointer) the variable object1 inside the function is just an alias of the object you passed to the function; therefore if you edit the one inside the function, the edits will be applied to the outside object as well.

Does the aforementioned line call the default constructor to make a temporary object Fraction(2,3) and then the assignment operator?

It's the assignment operator. Considering A to be an already declared variable of type X it will be called X Fraction::operator=([const] Fraction[&]) or any compatible type.

Notice: when declaring Fraction x = Fraction(2, 3) it won't be used the operator= as you may expect, the corresponding constructor will be called instead (in this case Fraction::Fraction([const] Fraction[&]) ).

Answer 2

Would passing object1 call the copy constructor?

No, it will not call the copy constructor since passed by reference No copy is made in this case

A = Fraction(2,3);

Yes, it will call the constructor with two parameters (or default constructor if both parameters have default values), then call the copy assignment operator.

You can see the output from code below:

 #include <iostream>
 using namespace std;
 class Fraction
 {
  public:
  int denom;
  int nominator;
  Fraction(int d , int n ):denom(d), nominator(n)
  {
    cout << "call non-copy constructor" <<endl;
  }

  Fraction(const Fraction&  rhs)
  {
    cout << "call copy constructor" <<endl;
    denom = rhs.denom;
    nominator = rhs.nominator;
  }

  const Fraction& operator=(const Fraction&  rhs)
  {
   cout << "call copy assignment operator" << endl;
   if (this == &rhs)
   {
      return *this;
   }

   denom = rhs.denom;
   nominator = rhs.nominator;
   return *this;
   }
};

void debug(const Fraction& obj)
{
  cout << "this is debug: pass by reference " <<endl;
}

void debugPassByValue(Fraction obj)
{
  cout << "this is debug: pass by value" <<endl;
}

int main()
{
  Fraction A(1,2);
  cout << "--------------" <<endl;
  debug(A);
  cout << "--------------" <<endl;
  A = Fraction(2,3);
  cout << "--------------" <<endl;
  debugPassByValue(A);
  cout << "--------------" <<endl;
  cin.get();
  return 0;

}

You will see the following output:

call non-copy constructor  //Fraction A(1,2);
--------------
this is debug: pass by reference  //debug(A);
--------------
call non-copy constructor    //A = Fraction(2,3);---> construct temporary object
call copy assignment operator  //A = Fraction(2,3);
--------------
call copy constructor   //debugPassByValue(A);
this is debug: pass by value
--------------

Now you will have a clearer view of what are called.

Answer 3

Indeed in the case of debug no copy is made.

In the second case, I'm not quite sure I understand your question. This line:

A = Fraction(2,3);

Should use Fraction 's assignment operator. A already exists, so it uses the assignment operator on instance A to assign it Fraction(2,3) which is a temporary object.