Rule of Five

Rule of Five

---

Prerequisites

---

1. What is Rule of Five

The Rule of Five states:

If a class manages resources and defines one of these:

• destructor
• copy constructor
• copy assignment operator

Then it should also define:

• move constructor
• move assignment operator

If your class manages resources, you should explicitly define all five special member functions.

2. Why Do We Need It?

C++ classes often manage:

• dynamic memory (new/delete)
• file handles
• sockets
• mutexes

Use when:

• managing raw resources
• using new/delete
• handling ownership manually

❌ Default Behavior Problem

class A
{
    int* data;

public:
    A(int v)
    {
        data = new int(v);
    }

    ~A()
    {
        delete data;
    }
};

Issue

A a1(10);
A a2 = a1;  // shallow copy

• Both objects point to the same memory
• double delete → crash

3. The Five Functions

3-1. Destructor

~A()
{
    delete data;
}

releases resource

3-2. Copy Constructor

A(const A& other)
{
    data = new int(*other.data);
}

deep copy

3-3. Copy Assignment Operator

A& operator=(const A& other)
{
    if (this != &other)
    {
        delete data;
        data = new int(*other.data);
    }
    return *this;
}

3-4. Move Constructor

A(A&& other) noexcept
{
    data = other.data;
    other.data = nullptr;
}

transfers ownership (no copy)

3-5. Move Assignment Operator

A& operator=(A&& other) noexcept
{
    if (this != &other)
    {
        delete data;

        data = other.data;
        other.data = nullptr;
    }
    return *this;
}

4. Performance Perspective

❌ Copy

alloc → copy → slow

✔️ Move

pointer transfer → fast

Move avoids:

• allocation
• deep copy
• expensive operations

4-1. Stable Design

❌ Missing self-assignment check

if (this != &other)

❌ Not using noexcept

A(A&& other) noexcept;

required for STL optimizations

5. Full Example

class A
{
    int* data;

public:
    A(int v) : data(new int(v)) {}

    ~A()
    {
        delete data;
    }

    A(const A& other)
    {
        data = new int(*other.data);
    }

    A& operator=(const A& other)
    {
        if (this != &other)
        {
            delete data;
            data = new int(*other.data);
        }
        return *this;
    }

    A(A&& other) noexcept
    {
        data = other.data;
        other.data = nullptr;
    }

    A& operator=(A&& other) noexcept
    {
        if (this != &other)
        {
            delete data;

            data = other.data;
            other.data = nullptr;
        }
        return *this;
    }
};

6. Rule of Zero / One / Three / Five

Rule	Meaning	Focus	When to Use	Key Functions
Rule of Zero	Do not define any special member functions	No manual resource management	Use STL containers / smart pointers	None
Rule of One	One class manages one resource (RAII principle)	Single responsibility for a resource	Designing simple resource wrappers	Typically destructor (and possibly others)
Rule of Three	If one is defined, define all three	Safe copying of resources	When managing raw resources (C++98 style)	Destructor, Copy Constructor, Copy Assignment
Rule of Five	Rule of Three + move semantics	Efficient resource transfer	When performance matters (C++11+)	+ Move Constructor, Move Assignment