c++ 入门中关于复制构造函数的问题

Question

Point global;

Point foo_bar(Point arg)
{
    Point local=arg,*heap=new Point(global);
    *heap=local;

    Point pa[4]={ local,*heap };
    return *heap;
}

the question is how many places are copy constructors used?

The supporting answer of this book says that * heap = local uses the copy constructor, but I don't think so. Isn't the copy assignment operator used here

Is there a problem with my understanding or is the answer wrong?

Answer 1

To test this out, lets write a test program.

#include <iostream>

struct CopyConstructCheck {
    CopyConstructCheck() {}
    CopyConstructCheck(const CopyConstructCheck& other) { std::cout << "Copy constructed!\n"; }
    CopyConstructCheck(CopyConstructCheck&& other) noexcept { std::cout << "Move constructed!\n"; }

    CopyConstructCheck& operator=(const CopyConstructCheck& other) { std::cout << "Copy assigned!\n"; return *this; }
};

CopyConstructCheck global;
CopyConstructCheck* heap = nullptr;

CopyConstructCheck foo(CopyConstructCheck arg)
{
    CopyConstructCheck local = arg; heap = new CopyConstructCheck(global);
    *heap = local;

    CopyConstructCheck pa[2] = { local, *heap };
    return *heap;
}

int main()
{
    CopyConstructCheck ret = foo(CopyConstructCheck());

    delete heap;
    return 0;
}

Now when you run the above program, this is the output.

Copy constructed!
Copy constructed!
Copy assigned!
Copy constructed!
Copy constructed!
Copy constructed!

Now lets dissect this.
The first copy construction happens here CopyConstructCheck local = arg; as your assigning the value from arg to the local variable upon instantiation.

The second is in heap = new CopyConstructCheck(global); as your explicitly calling the copy constructor.

Third and forth copy constructions happen in this line CopyConstructCheck pa[2] = { local, *heap }; as your initializing the array with existing data, thus calling the calling the copy constructor of each element.

Finally the last happens in CopyConstructCheck ret = foo_return; line as your constructing the ret variable with the value returned by the function. Note that I first assign the return to a reference variable so that we can handle delete the allocated memory block later.

Now after analyzing, we see that there has been an copy assignment happening right after the 2nd copy construction. If we trace back, its this line *heap = local; . And this proves that your hypothesis is true, it is indeed copy assignment. That's because your not constructing anything there, your assigning data to an existing variable.

Minor touches:
The sample code is the same as the OP's post but fixed a few errors like,

1. Initializing an array with the size of 4 by using 2 variables in the initializer list.
2. The heap allocated block was not deleted once everything is done.
3. Dereferencing a pointer and then trying to assign a newly allocated pointer to it.