Search⌘ K
AI Features
Home
Courses
Master Modern C++

Copy and Move Semantics

Explore how to implement copy and move semantics in C++ to safely manage resource ownership and object duplication. Understand shallow versus deep copying, and learn how move operations optimize performance by transferring resources instead of duplicating them. Gain practical insight into constructors, assignment operators, and the rule of zero for safer and more efficient code.

We'll cover the following...

In the previous lesson, we implemented an IntBuffer class that manages a raw memory pointer. While the class functions correctly in isolation, a problem arises when we attempt to copy an object. For example, consider the following code:

IntBuffer a(10);
IntBuffer b = a;

In this case, the program is likely to crash. The reason is that, by default, C++ does not understand how to copy ownership of a resource. As a result, both objects end up pointing to the same memory, and both believe they own it. When the objects are destroyed, they each attempt to free the same memory, leading to undefined behavior.

To prevent this, we must explicitly define how an object should be duplicated and how ownership of a resource should be transferred. This is achieved through copy semantics, which describe how an object creates an independent copy of itself, and move semantics, which allow ownership to be transferred safely and efficiently.

The problem with shallow copying

When we do not explicitly define how an object should be copied, the compiler provides a default behavior known as a shallow copy. A shallow copy duplicates the object’s member variables exactly as they are. For simple value types, such as int or double, this behavior is safe and appropriate. However, for pointer members, a shallow copy duplicates only the memory address, not the data stored at that address.

Consider an IntBuffer object a that points to the memory address 0x100. If we create IntBuffer b = a using a shallow copy, b also points to 0x100. This situation leads to two serious problems:

  1. Double-free error: When object a goes out of scope, its destructor deletes the memory at 0x100. Later, when object b goes out of scope, its destructor attempts to delete the same memory again. Deleting the same memory twice results in undefined behavior and commonly causes a program to crash.

  2. Data corruption: Because both objects reference the same memory, a change made through a is immediately visible through b. This unintended coupling violates the expectation that independent objects ...