C ++默认副本构造函数

Question

I have the following code:

#include <iostream>
    #include <string>
    using namespace std;
    class Uno {
    public: Uno() { cout << "X"; }
    };



    int main()
    {
            Uno u;
            Uno k=u;

            return 0;
    }

So from what I understand, the code Uno k=u; would create a copy of u. It seems like the constructor is called twice. I'm expecting "XX", but the program only outputs "X". Can you please explain what is going on?

thank you

Answer 1

What is going on is that this:

Uno k = u;

Is a (copy-) initialization , which copy-constructs the Uno object k from the Uno object u . Copy-construction means that the copy constructor (implicitly generated by the compiler, in this case) is invoked, not the default constructor.

This is why the message you output does not get printed during the initialization of k : your constructor does not get called; instead, another (implicitly generated) constructor is invoked.

Also notice, that the above declaration is not equivalent to this in general:

Uno k;
k = u;

In this last snippet, the expression k = u is an assignment , not an initialization. Although both constructs use the = sign, you should not let that confuse you.

Answer 2

k is being created using the default copy constructor which doesn't output an X .

Try adding this:

Uno(const Uno&) { cout << "Y"; }

And you should see XY output instead.

Answer 3

In this case, I believe that the constructor is not called, because you are not creating a new object; rather, you are copying an old object to a different location.

However, as you are not using pointers, they should be independent; changes to one will not affect the other.

The code does not run the constructor a second time, because it is not building something new. Imagine that you had made some change to a field of u after it was created. Calling the constructor again would not make a copy of u, so C++ does not do that. It's sort of like copying a photograph - doing so does not make your camera go off twice, because that could produce a different picture; instead, you run it through the copier, which is something different.

EDIT: as I've been informed, it does run a constructor, just not the one that you've written. Suppose that the camera in my metaphor had a built-in copier, which of course would not set off the flash.

Answer 4

It is because your class doesn't have a copy constructor. If no copy constructor created, then C++ calls the default one. Which is obviously doesn't have the cout<<"X" line.

Uno u;     // your constructor called, --> X to output
Uno k = u; // default copy constructor called

However the copy constructor does not make sense if you don't have member variables.

So let's say this is what you want:

#include <iostream>
#include <string>

using namespace std;

class Uno
{
  public:

    string text;

    // constructor
    Uno()
    {
        text = "X";
        cout << text;
    }

    // copy constructor
    Uno(const Uno &o)
    {
        text = o.text;
        cout << text;
    }
};

int main()
{
        Uno u;        // call constructor -> X
        u.text = "Y"; // change text in constructed object
        Uno k=u;      // create new object via calling copy constructor --> Y
                      // so u.text copied to k.text

        return 0;
}

I recommend learncpp.com articles, they are very useful and keep things simple.

More info about copy constructor and assignment operator: http://www.learncpp.com/cpp-tutorial/911-the-copy-constructor-and-overloading-the-assignment-operator/

Answer 5

Putting on my pedant hat for a moment ... Unless you explicitly tell the compiler otherwise, you always have, by default, the copy constructor:

Uno(const Uno & other);

and the assignment operator:

Uno & operator=(const Uno & other);

whether you ask for them or not. If you don't define any other constructors, you also get the default constructor:

Uno();

Since you've defined the no-argument constructor, yours will be used instead of that last default.

When you define the variable:

Uno u;

your constructor is used to initialize the object instance. When you do the assignment:

Uno k=u;

the assignment operator is used.

And how, you might ask, do I prevent copying or assigning an object? Declare them to be private, and do not implement them:

class Uno
{
private:
    Uno(const Uno &);
    Uno & operator=(const Uno &);
        ...
};