User-Defined Types and Their Members

When you create a new object from an existing one in C++, you often do not have to write any special instructions telling the language how to do it. Objects can be copied by default. This holds for objects of types you define yourself, and it also holds for builtin types such as int and double. The real question is what, precisely, that default copy does. This article answers that question by following the copy one piece at a time.

Before reading on, consider a small case. Suppose you have an object with two pieces of data, and you create a second object from it. Ask yourself: after the copy, do the two objects hold the same data, and does changing one of them change the other? Keep your answers in mind, because the rest of the article tests them.

The compartment picture is what makes the default copy easy to follow. The object is the whole container, and its members are the individual compartments. When an object is copied, the copy operation works through the compartments in turn, taking the value in each one and placing it into the matching compartment of the new object. Nothing about this requires the object to be large or unusual. An object with only two members is copied by handling each of those two members.

The default meaning of copy is called memberwise copy. The name reflects its organization: the copy is organized around members, and it is applied to each of them. Each member of the source object is copied into the corresponding member of the target object. The target object ends up with its own members, each filled from the matching member of the source.

The diagram below shows the relationship in words. Each member of the source object is matched with a member of the target object, and each target member is filled from its partner. The result is two separate objects that hold equal member values.

Now look at a complete program. It uses a small user-defined type named Point with two members. Read the code first and predict what each printed line will show before you look at the output.

Two operations in C++ use this default. The first is initialization, where a new object is created and given the values of an existing object at the moment it comes into existence. The second is assignment, where an object that already exists is overwritten with the values of another object. The source is explicit that both of these operations perform a memberwise copy.

The two operations differ in timing and in what already exists. Initialization creates the target at the moment of copying. Assignment works on a target that is already there, so whatever member values it held are replaced. In both cases the transferred values are the same kind of thing: each member of the source is copied into the matching member of the target.

The before and after states of the target c in the example show the effect of assignment member by member. Before the assignment, c holds 5 in both members. After c = a, each member has been overwritten with the value from the matching member of a.

After the copy, the source and target hold equal member values. The source does not describe any link between the two objects after the copy, so this article does not claim one. In the example, changing b.x left a.x unchanged. What you can rely on is that the target received equal member values at the moment of the copy and that each object has its own members afterward.

A natural question is whether the default copy behaves differently for types you write yourself and for types the language provides. The source says it does not. Objects can be copied by default for user-defined types, and this is also true for builtin types. The default meaning of copy is the same memberwise copy in both cases.