Copy semantics (part 1)

If the MyStruct type is implemented such that a deep copy is made upon initializing an MyStruct object with an object of the same type, what is the output of this program?

struct MyStruct {
  size_t number;
  char* letter;
  MyStruct() = default;
  MyStruct(const MyStruct& source) { /* implementation hidden */ }
};

int main() {
  MyStruct foo;
  foo.number = 5;
  foo.letter = new char('z');

  MyStruct bar = foo;
  *(bar.letter) = 'b';
  
  std::cout << foo.letter << std::endl;  // What will this print?
}
    

If the MyStruct type is implemented such that a shallow copy is made upon initializing an MyStruct object with an object of the same type, what is the output of this program?

struct MyStruct {
  size_t number;
  char* letter;
  MyStruct() = default;
  MyStruct(const MyStruct& source) { /* implementation hidden */ }
};

int main() {
  MyStruct foo;
  foo.number = 5;
  foo.letter = new char('z');

  MyStruct bar = foo;
  *(bar.letter) = 'b';
  
  std::cout << foo.letter << std::endl;  // What will this print?
}
    

The default copy mechanism for an object of a user-defined type using an instance of the same type is a memberwise copy. In the lesson, we state that the copy mechanism for a memberwise copy is a  .

A   means that the object is copied exactly as it is: data member values are copied exactly to the other object's corresponding data member.

When there is a pointer inside an object that points to dynamic data, a   of that object is may not be sufficient since:

• Only the values from pointers are copied into the other object’s corresponding pointers, but not the dynamic data that is pointed to.
• Consequently, the copy will be pointing to the original dynamic data.
• This results in the dynamic data being shared between the objects.

In a  , the objects pointed to in one object are first copied. Then the other object’s corresponding pointers are assigned the addresses of the copied objects.

After a   as been completed, each object's free store pointers point to the same values stored in different dynamically allocated objects; there is no dynamic data being shared between the objects.