Copy Constructor and Copy Assignment Operator (Rule of Three)

Intermediate14 min read•Updated: 2026-10-22

📜 Copy Constructor, Copy Assignment Operator & The Rule of Three

Introduction

The Rule of Three is a foundational guideline in C++: If a class needs to explicitly define a custom Destructor, it almost certainly needs to implement a custom Copy Constructor and a custom Copy Assignment Operator.

🏛️ The Three Pillars

1
Destructor: Deallocates owned dynamic resources.
2
Copy Constructor: Initializes a new object as an identical deep clone of an existing object (MyClass b = a;).
3
Copy Assignment Operator (operator=): Overwrites an already existing object's state with another object's state (b = a;).

💻 Canonical Rule of Three Implementation

1#include <iostream>
2#include <algorithm>
3 
4class IntBuffer {
5private:
6    int* m_data = nullptr;
7    std::size_t m_size = 0;
8 
9public:
10    // 1. Parameterized Constructor
11    explicit IntBuffer(std::size_t size)
12        : m_data(new int[size]{}), m_size(size) {}
13 
14    // 2. Destructor
15    ~IntBuffer() {
16        delete[] m_data;
17    }
18 
19    // 3. Copy Constructor (Deep Copy)
20    IntBuffer(const IntBuffer& other)
21        : m_data(new int[other.m_size]), m_size(other.m_size) {
22        std::copy(other.m_data, other.m_data + m_size, m_data);
23    }
24 
25    // 4. Copy Assignment Operator (Handles Self-Assignment Guard)
26    IntBuffer& operator=(const IntBuffer& other) {
27        // Self-assignment check (e.g. buf = buf;)
28        if (this == &other) {
29            return *this;
30        }
31 
32        // Release existing buffer
33        delete[] m_data;
34 
35        // Allocate and copy new buffer
36        m_size = other.m_size;
37        m_data = new int[m_size];
38        std::copy(other.m_data, other.m_data + m_size, m_data);
39 
40        return *this;
41    }
42 
43    void set(std::size_t index, int value) {
44        if (index < m_size) m_data[index] = value;
45    }
46 
47    int get(std::size_t index) const {
48        return (index < m_size) ? m_data[index] : 0;
49    }
50};
51 
52int main() {
53    IntBuffer a(3);
54    a.set(0, 100);
55    a.set(1, 200);
56 
57    IntBuffer b = a; // Copy constructor
58    IntBuffer c(1);
59    c = a;           // Copy assignment operator
60 
61    std::cout << "b[1]: " << b.get(1) << ", c[0]: " << c.get(0) << "\n";
62    return 0;
63}

💡 Modern C++ Note (The Rule of Zero)

Whenever possible, prefer the Rule of Zero: Use standard library containers like std::vector and std::string as member variables. Because they already implement copy and move semantics, your class does not need to write any manual destructors or copy operators!

Next Lesson

Overloading Arithmetic Operators (+, -, *, /)

Continue learning with hands-on practice, examples, and exercises in the upcoming topic.

Related Lessons

Previous Lesson	Next Lesson
Shallow Copy vs Deep Copy and Memory Double Free Bug	Overloading Arithmetic Operators (+, -, *, /)

Practice Quiz

Test your understanding of this lesson with 1 questions. Each question has one correct answer.

Previous Next

PreviousPrevNext

MSK Institute • Shikohabad

Loading Page Content...

Preparing courses, live labs, and learning resources.सामग्री लोड हो रही है, कृपया प्रतीक्षा करें...

Connecting serverPlease wait...

💻 Practical Labs🚀 Free Demo📜 Verified Certificates

💻 Canonical Rule of Three Implementation

1#include <iostream>
2#include <algorithm>
3 
4class IntBuffer {
5private:
6    int* m_data = nullptr;
7    std::size_t m_size = 0;
8 
9public:
10    // 1. Parameterized Constructor
11    explicit IntBuffer(std::size_t size)
12        : m_data(new int[size]{}), m_size(size) {}
13 
14    // 2. Destructor
15    ~IntBuffer() {
16        delete[] m_data;
17    }
18 
19    // 3. Copy Constructor (Deep Copy)
20    IntBuffer(const IntBuffer& other)
21        : m_data(new int[other.m_size]), m_size(other.m_size) {
22        std::copy(other.m_data, other.m_data + m_size, m_data);
23    }
24 
25    // 4. Copy Assignment Operator (Handles Self-Assignment Guard)
26    IntBuffer& operator=(const IntBuffer& other) {
27        // Self-assignment check (e.g. buf = buf;)
28        if (this == &other) {
29            return *this;
30        }
31 
32        // Release existing buffer
33        delete[] m_data;
34 
35        // Allocate and copy new buffer
36        m_size = other.m_size;
37        m_data = new int[m_size];
38        std::copy(other.m_data, other.m_data + m_size, m_data);
39 
40        return *this;
41    }
42 
43    void set(std::size_t index, int value) {
44        if (index < m_size) m_data[index] = value;
45    }
46 
47    int get(std::size_t index) const {
48        return (index < m_size) ? m_data[index] : 0;
49    }
50};
51 
52int main() {
53    IntBuffer a(3);
54    a.set(0, 100);
55    a.set(1, 200);
56 
57    IntBuffer b = a; // Copy constructor
58    IntBuffer c(1);
59    c = a;           // Copy assignment operator
60 
61    std::cout << "b[1]: " << b.get(1) << ", c[0]: " << c.get(0) << "\n";
62    return 0;
63}

Previous Lesson

Next Lesson

Shallow Copy vs Deep Copy and Memory Double Free Bug

Overloading Arithmetic Operators (+, -, *, /)