C ++何时执行深层复制和浅层复制？

Question

I wonder when C++ does deep copying, and when it does shallow copying.

For example:

int find()
{
    int n=5;
    return n;
}

In order to delete n after moving out of the function, it must create a temporary variable n, and return it back to the caller. As a result, that's shallow copy, is that right?

Answer 1

As a result, that's shallow copy, is that right?

A shallow copy keeps referring to whatever the original object ^† referred to. A deep copy refers to a copy of the referred resource ^†† (this new copy of the resource must be created by the copy constructor). That distinction is meaningful only if the copied object ^† is referential ie it refers to some resource.

int type does not refer to any object, so as far as the type system is concerned, it is not referential. However outside of the type system, one can give it referential meaning. It is quite typical for example, for an integer to represent identity of a resource such as an entity stored in a database. You need to consider whether that is the case for your integer. In object oriented design, such identifiers are typically wrapped into a class ^††† (which can be specified to support deep copies).

The copy of a non-class type is always shallow. Only copy constructor ^†††† can perform a deep copy. If 5 identifies some resource, then a copy of 5 also refers to that same resource.

Examples of referential types for which deep and shallow copy are relevant: References, pointers, classes which have referential members. Examples of usch classes: smart pointers, wrappers of referential identifiers ^††† . Of these, pointers and references are copied shallowly, since they aren't classes. Copy of a class instance may be shallow or deep, depending on the implementation of the copy constructor.

Then there is move construction. Move construction is a shallow copy, which modifies the original object in a way that enforces any class invariants that would be violated by a trivial shallow copy. For example, the move constructor of a unique pointer would shallowly copy the internal pointer, and set the original pointer to null, so that the uniqueness of pointer ownership is maintained.

---

^† I say object for simplicity, but this applies to copies of a reference types - which are not objects - too.

^†† A resource might be another object in memory, or for example a file descriptor, or a thread of execution.

^††† Example: std::thread which wraps a lower level identifier provided by the OS.

^†††† Any function can perform a deep copy, but a copy constructor is the only function that is invoked by copy initialisation.

Answer 2

int is not a referential type and so there is no question of shallow or deep copy. Its just a copy.

We can understand Deep and shallow copy as follows :

Deep Copy

A deep copy copies all fields, and makes copies of dynamically allocated memory pointed to by the fields. A deep copy occurs when an object is copied along with the objects to which it refers.

Shallow Copy

Shallow copy is a bit-wise copy of an object. A new object is created that has an exact copy of the values in the original object. If any of the fields of the object are references to other objects, just the reference addresses are copied ie, only the memory address is copied, not the actual objects.

Answer 3

The terms "shallow copy" and "deep copy" are generally understood to relate to types that themselves indirectly encapsulate some objects.

So, for example, a class with a pointer (that we assume points to something):

struct Foo
{
   Bar* ptr;
};

When you copy a Foo , is the Bar it points to copied as well ( deep )? Or does the new Foo merely share the original pointer to the original Bar ( shallow )?

This will depend upon how the copy is performed — usually your Foo will have a copy constructor, and it is the code in this copy constructor that makes the distinction.

For example, all standard C++ containers (eg vector ) are internally made up of a bunch of pointers to some allocated buffers, but they have copy constructors that ensure the whole buffer is copied when the vector is copied, so that each vector has its own , independent buffer. This is a deep copy.

But the example I gave above, without any copy constructor or other lovely code, will simply perform a shallow copy when assigned, because I didn't tell it to do anything except to copy over the value of ptr .

As for your case: an int is just a value and so we can make no such comparison. You just have a value copy, plain and simple. The internal details of how many (if any) temporaries are required to implement that functionality are irrelevant (and unimportant); it's meaningless to talk about shallow vs deep copies in this case because there is literally no encapsulated, indirectly-held object owned or not-owned that can be deemed shallow or deep or anything copied. And we can generally say this about any non-class type.

Answer 4

Your description of the behaviour of your code is consistent with the source code that you present but the compiler might not do that.

C++ compilers are allowed to implement an as-if rule: ie your source specifies your intentions not the form of the final executable.

In other words, the compiler could replace your entire function call with 5 .

In short, a deep copy creates duplicates every byte in your source object that's pertinent to that object. Any lesser copy than that is a shallow copy. Unless you overload = in some way, = takes a shallow copy.