通过示例了解复制构造函数和赋值运算符

Question

I've been reading the book "An Introduction to Design Patterns in C++ with Qt 4" recently and I am confused by the following example (codes are from the book, with a small modification by myself):

"fraction.h"

class Fraction
{
public:
    Fraction(int n, int d): m_Numer(n), m_Denom(d) {
        ++ctors;
    }

    Fraction(const Fraction& other)
        : m_Numer(other.m_Numer), m_Denom(other.m_Denom) {
        ++copies;
    }

    Fraction& operator = (const Fraction& other) {
        m_Numer = other.m_Numer;
        m_Denom = other.m_Denom;
        ++assigns;
        return *this;
    }

    Fraction multiply(Fraction f2) {
        return Fraction (m_Numer*f2.m_Numer, m_Denom*f2.m_Denom);
    }

    static void report();

private:
    int m_Numer, m_Denom;
    static int assigns;
    static int copies;
    static int ctors;
};

"main.cpp"

#include <iostream>
#include "fraction.h"
using namespace std;

int Fraction::assigns = 0;
int Fraction::copies = 0;
int Fraction::ctors = 0;

void Fraction::report()
{
    cout<<"[assigns: "<<assigns<<", copies: "<<copies<<", ctors: "<<ctors<<"]\n\n";
}

int main()
{
    Fraction twothirds(2, 3); // It calls a constructor
    Fraction threequarters(3, 4); // It calls a constructor
    Fraction acopy(twothirds); // It calls a copy constructor
    Fraction f4 = threequarters;  
    // [Question A]: The book says it's using a copy constructor 
    //               but I don't see how. Isn't it an assignment?

    cout<<"after declarations\n";
    Fraction::report();  //output: [assogns: 0, copies: 2, ctors: 2]

    f4 = twothirds;  // It's an assignment using the assignment operator
    cout<<"before multiply\n";
    Fraction::report();  //output: [assogns: 1, copies: 2, ctors: 2]

    f4 = twothirds.multiply(threequarters);
    cout<<"after multiply\n";
    Fraction::report();  //output: [assogns: 2, copies: 3, ctors: 3]
    // [Question B]: How does the frunction "multiply" creates three Fraction objects?

    return 0;
}

As the comments I left in main.cpp , I got 2 questions.

[Question A]: Why Fraction f4 = threequarters using copy constructor rather than assignment?

[Question B]: How does the frunction "multiply" creates three Fraction objects?

Especially for Question B, I can't figure out where are those three objects from.

Please help me understanding the concepts. Thanks in advance.

Answer 1

Question A: Why Fraction f4 = threequarters using copy constructor rather than assignment?

Answer A: That is the definition of the C++ language. If you had used

Fraction f4;
f4 = threequarters; 

then the second line would use the assignment operator.

Question B: How does the frunction "multiply" creates three Fraction objects?

Answer B:

When you call multiply , the argument f2 is created by using copy construction.

The line

return Fraction (m_Numer*f2.m_Numer, m_Denom*f2.m_Denom);

construct on object using the regular constructor.

The line

f4 = twothirds.multiply(threequarters);

assigns the object constructed in multiply to f4 .

Answer 2

Question A: Because in line Fraction f4 = threequarters, f4 doesn't exist yet so copy constructor is called to create a copy of "threequarters". operator= is only called when object already exists (ie. f4 = twothirds)

Question B: Fraction multiply(Fraction f2), when twothirds.multiply(threequarters) is executed, function call parameters are "pass by value" (ie. a copy is passed into the function). So in this instance a copy of "threequarters" is made and passed into "multiply". Then inside that function you explicitly created a Fraction by calling a constructor. Finally you returned this as Fraction which means a copy of it returned. So entire function call made 1 copy constructor call to pass it in, 1 constructor call to create the Fraction and 1 copy constructor call to return the Fraction, total 3.