Copy-and-Swap Idiom in C++: What It Is, Why It Matters, and When to Use It

By the end of this page, you will understand what the copy-and-swap idiom is in C++, why it is used to implement assignment safely, and how it helps with exception safety and self-assignment. You will also see how C++11 move semantics changed the way this idiom is used in modern C++ code.

The copy-and-swap idiom is a common C++ technique for implementing the assignment operator safely and cleanly.

At a high level, it works like this:

1. Make a copy of the right-hand side object.
2. Swap the current object's data with the copy.
3. Let the temporary copy go out of scope and clean up the old data.

A typical form looks like this:

class Buffer {
public:
    Buffer& operator=(Buffer other) {
        swap(*this, other);
        return *this;
    }

    friend void swap(Buffer& a, Buffer& b) noexcept {
        using std::swap;
        swap(a.size, b.size);
        swap(a.data, b.data);
    }

private:
    std::size_t size{};
    int* data{};
};

The parameter other is passed by value, which means it is copied (or moved) before the function body runs. Once the copy succeeds, the function swaps the current object with that local copy.

What problem does it solve?

The idiom mainly solves three issues:

1. Exception safety

If copying the right-hand side fails, the current object is not modified.

Think of your object like a person carrying a backpack.

• The current object is wearing an old backpack.
• The right-hand side object represents a new backpack setup.
• Instead of emptying the old backpack item by item and risking mistakes, you first prepare a complete new backpack.
• Then you swap backpacks.
• The temporary person walks away with the old backpack, and when they leave, the old backpack is destroyed safely.

This model explains why the idiom is safe:

• if preparing the new backpack fails, you keep the old one unchanged
• if it succeeds, the swap is quick and simple
• cleanup happens automatically when the temporary object is destroyed

So copy-and-swap is really: build the replacement first, then trade places.

Core syntax

A classic copy-and-swap assignment operator looks like this:

class MyClass {
public:
    MyClass(const MyClass& other);  // copy constructor
    ~MyClass();

    MyClass& operator=(MyClass other) {
        swap(*this, other);
        return *this;
    }

    friend void swap(MyClass& a, MyClass& b) noexcept {
        using std::swap;
        swap(a.value, b.value);
    }

private:
    int* value{};
};

Beginner-friendly example

Here is a small class that owns a dynamic array:

#include <algorithm>
#include <cstddef>
#include <iostream>

class IntArray {
public:
    IntArray(std::size_t size = )
        : (size), (size ?  [size] : ) {}

    ( IntArray& other)
        : (other.size_), (other.size_ ?  [other.size_] : ) {
        std::(other.data_, other.data_ + size_, data_);
    }

    ~() {
        [] data_;
    }

    IntArray& =(IntArray other) {
        (*, other);
         *;
    }

    {
         std::swap;
        (a.size_, b.size_);
        (a.data_, b.data_);
    }

    {
        data_[index] = value;
    }

    {
         data_[index];
    }

    {
         size_;
    }

:
    std:: size_{};
    * data_{};
};

Consider this code:

IntArray a(2);
a.set(0, 10);
a.set(1, 20);

IntArray b(2);
b.set(0, 1);
b.set(1, 2);

a = b;

Let us trace a = b;.

Before assignment

• a owns memory containing: [10, 20]
• b owns memory containing: [1, 2]

Step 1: Call assignment operator

The compiler calls:

a.operator=(b)

Because the parameter is passed by value, b is copied into a local object named other.

Copy-and-swap is most useful in classes that own resources directly.

Common examples

Dynamic memory wrappers

A custom container, matrix, buffer, or string-like class may own raw heap memory.

File or handle wrappers

If a class owns a low-level handle and supports copying by duplicating the handle, safe assignment logic is needed.

Legacy C++ codebases

Older projects often have custom resource-owning classes written before modern standard library usage became common.

Educational implementations

When learning the Rule of Three or Rule of Five, copy-and-swap is a clean way to understand safe assignment.

Example scenarios

• a Matrix class reallocates memory when assigned a matrix of different size
• a TextBuffer class stores a manually managed character array
• a Image class owns pixel data and must avoid leaks during assignment
• a custom String class must support self-assignment and exception safety

When it is less necessary

If you use standard types like these:

• std::vector
• std::string
• std::unique_ptr

In real projects, developers usually prefer the simplest safe design.

Modern pattern: Rule of Zero first

If your class is composed of well-behaved members, write this:

class UserProfile {
public:
    std::string name;
    std::vector<int> scores;
};

No custom destructor, copy constructor, or assignment operator is needed.

This is usually better than implementing copy-and-swap manually.

When custom assignment still appears

Developers still use custom assignment operators when:

• wrapping a C library resource
• maintaining older code with raw pointers
• implementing low-level containers
• needing a strong exception guarantee for replacement-style assignment

Common patterns around copy-and-swap

1. Custom swap

A class defines a swap function that swaps all resource-owning members.

friend void swap(Buffer& a, Buffer& b) noexcept {
    using std::swap;
    swap(a.size_, b.size_);
    swap(a.data_, b.data_);
}

2. By-value assignment

1. Forgetting to implement a proper swap

If swap does not exchange every important member, the object may become inconsistent.

Broken example:

friend void swap(IntArray& a, IntArray& b) noexcept {
    using std::swap;
    swap(a.data_, b.data_);
    // forgot to swap size_
}

Why it is wrong:

• the pointer and size no longer match
• later access may read invalid memory

2. Writing unsafe manual assignment first

Beginners often write assignment like this:

IntArray& operator=(const IntArray& other) {
    delete[] data_;
    size_ = other.size_;
    data_ = new int[size_];
    std::copy(other.data_, other.data_ + size_, data_);
    return *this;
}

Problems:

• if new throws, the object is already damaged
• self-assignment can cause trouble because you delete your own data before copying

3. Ignoring self-assignment

Copy-and-swap vs manual copy assignment

Pre-C++11 vs C++11 and later

Copy-and-swap quick reference

Purpose

• Implement copy assignment safely
• Handle self-assignment naturally
• Provide strong exception safety

Core pattern

class T {
public:
    T(const T& other);

    T& operator=(T other) {
        swap(*this, other);
        return *this;
    }

    friend void swap(T& a, T& b) noexcept {
        using std::swap;
        swap(a.member1, b.member1);
        swap(a.member2, b.member2);
    }
};

How it works

• other is copied or moved into the parameter
• swap current object with other
• other destroys the old state when it goes out of scope

Benefits

• strong exception safety
• self-assignment safety
• simpler assignment code

Requirements

What is the copy-and-swap idiom in C++?

It is a way to implement assignment by first copying the source object, then swapping its contents with the current object. The old data is cleaned up automatically when the temporary copy is destroyed.

Why is copy-and-swap considered safe?

Because the current object is not modified until copying succeeds. If copying throws an exception, the object stays unchanged.

Does copy-and-swap handle self-assignment?

Yes, in most normal implementations it does. Since the right-hand side is copied first, obj = obj; does not corrupt the object.

Is copy-and-swap still useful in C++11 and later?

Yes, but it is less universally needed. Move semantics and standard RAII types often make custom assignment operators unnecessary.

Is operator=(T other) better than operator=(const T& other)?

Not always. The by-value form is elegant and safe, but a separate move assignment operator can sometimes be more efficient.

Should I always use copy-and-swap for resource-owning classes?

No. First consider whether the class should own raw resources directly at all. If you can use std::vector, std::string, or smart pointers, that is usually better.

What is the relationship between copy-and-swap and the Rule of Three?

If your class manually manages a resource, you often need a destructor, copy constructor, and copy assignment operator. Copy-and-swap is one way to implement the assignment part safely.

What is the relationship between copy-and-swap and the Rule of Five?

Rule of Three

Classes that manage resources often need a destructor, copy constructor, and copy assignment operator.

Rule of Five

In modern C++, move constructor and move assignment operator are added to the resource-management story.

Rule of Zero

The best design is often to avoid manual resource management entirely by using standard RAII types.

Move semantics

C++11 introduced moves, which affect how assignment operators and by-value parameters behave.

Copy constructor

Copy-and-swap depends on making a safe copy before swapping.

Move constructor

With a by-value parameter, rvalues may move into the parameter instead of copying.

Exception safety

The idiom is closely tied to the strong exception guarantee.

RAII

Resource Acquisition Is Initialization is the broader idea behind safe cleanup and ownership in C++.

swap

A correct and efficient swap function is central to the idiom.

Self-assignment

One major benefit of copy-and-swap is avoiding bugs in obj = obj;.