Shallow Copy vs Deep Copy and Memory Double Free Bug

Intermediate14 min read•Updated: 2026-10-22

💥 Shallow Copy vs Deep Copy & The Dreaded Double-Free Bug

Introduction

When a class manages dynamic heap memory via raw pointers, relying on the compiler's default copying mechanism leads to catastrophe. Understanding the difference between a shallow copy and a deep copy is a defining milestone in mastering C++.

☠️ The Disaster of Shallow Copying

By default, the C++ compiler synthesizes a bitwise copy (shallow copy). It simply copies the pointer address rather than the underlying memory buffer!

1[ Object A ] ──► m_data pointer ──┐
2                                  ▼
3[ Object B (Shallow Copy) ] ──► [ Heap Buffer: 100 bytes ]

The Double-Free Crash:

1
Object A is created; allocates 100 bytes on the heap.
2
Object B is created via default copy: Object B = A;. Now both A.m_data and B.m_data point to the same heap memory address.
3
Scope ends: B's destructor executes and calls delete[] m_data;. Memory is returned to the OS.
4
Next: A's destructor executes and calls delete[] m_data; on the exact same memory address that was already deleted!
5
💥 CRASH: free(): double free detected in tcache 2.

🛡️ Implementing a Deep Copy

A deep copy allocates a brand-new independent heap buffer for the clone, and copies the actual data bytes across:

1#include <iostream>
2#include <cstring>
3 
4class DynamicString {
5private:
6    char* m_buffer = nullptr;
7    std::size_t m_length = 0;
8 
9public:
10    // Constructor
11    DynamicString(const char* str) {
12        if (str) {
13            m_length = std::strlen(str);
14            m_buffer = new char[m_length + 1];
15            std::strcpy(m_buffer, str);
16        }
17    }
18 
19    // ✅ Deep Copy Constructor
20    DynamicString(const DynamicString& other) {
21        m_length = other.m_length;
22        if (other.m_buffer) {
23            m_buffer = new char[m_length + 1]; // Separate allocation!
24            std::strcpy(m_buffer, other.m_buffer);
25        } else {
26            m_buffer = nullptr;
27        }
28        std::cout << "[LOG]: Deep Copy performed.\n";
29    }
30 
31    // Destructor
32    ~DynamicString() {
33        delete[] m_buffer;
34    }
35 
36    void print() const {
37        if (m_buffer) std::cout << m_buffer << "\n";
38    }
39};
40 
41int main() {
42    DynamicString s1("MSK Institute Shikohabad");
43    DynamicString s2 = s1; // Deep copy constructor cleanly executed!
44 
45    s1.print();
46    s2.print();
47    // Exits cleanly without any double-free crashes!
48    return 0;
49}

Next Lesson

Copy Constructor and Copy Assignment Operator (Rule of Three)

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

Related Lessons

Previous Lesson	Next Lesson
The this Pointer and Const Member Functions	Copy Constructor and Copy Assignment Operator (Rule of Three)

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

☠️ The Disaster of Shallow Copying

By default, the C++ compiler synthesizes a bitwise copy (shallow copy). It simply copies the pointer address rather than the underlying memory buffer!

1[ Object A ] ──► m_data pointer ──┐
2                                  ▼
3[ Object B (Shallow Copy) ] ──► [ Heap Buffer: 100 bytes ]

The Double-Free Crash:

Object A is created; allocates 100 bytes on the heap.

Object B is created via default copy: Object B = A;. Now both A.m_data and B.m_data point to the same heap memory address.

Scope ends: B's destructor executes and calls delete[] m_data;. Memory is returned to the OS.

Next: A's destructor executes and calls delete[] m_data; on the exact same memory address that was already deleted!

💥 CRASH: free(): double free detected in tcache 2.

🛡️ Implementing a Deep Copy

A deep copy allocates a brand-new independent heap buffer for the clone, and copies the actual data bytes across:

1#include <iostream>
2#include <cstring>
3 
4class DynamicString {
5private:
6    char* m_buffer = nullptr;
7    std::size_t m_length = 0;
8 
9public:
10    // Constructor
11    DynamicString(const char* str) {
12        if (str) {
13            m_length = std::strlen(str);
14            m_buffer = new char[m_length + 1];
15            std::strcpy(m_buffer, str);
16        }
17    }
18 
19    // ✅ Deep Copy Constructor
20    DynamicString(const DynamicString& other) {
21        m_length = other.m_length;
22        if (other.m_buffer) {
23            m_buffer = new char[m_length + 1]; // Separate allocation!
24            std::strcpy(m_buffer, other.m_buffer);
25        } else {
26            m_buffer = nullptr;
27        }
28        std::cout << "[LOG]: Deep Copy performed.\n";
29    }
30 
31    // Destructor
32    ~DynamicString() {
33        delete[] m_buffer;
34    }
35 
36    void print() const {
37        if (m_buffer) std::cout << m_buffer << "\n";
38    }
39};
40 
41int main() {
42    DynamicString s1("MSK Institute Shikohabad");
43    DynamicString s2 = s1; // Deep copy constructor cleanly executed!
44 
45    s1.print();
46    s2.print();
47    // Exits cleanly without any double-free crashes!
48    return 0;
49}

Previous Lesson

Next Lesson

The this Pointer and Const Member Functions

Copy Constructor and Copy Assignment Operator (Rule of Three)