Copy Constructor

Introduction

A Copy Constructor is a special type of constructor in object-oriented programming—most notably in C++—used to create a new object as a copy of an existing object. It’s crucial for ensuring that the new object owns its own copy of the data, especially when that data is stored in dynamic memory or involves pointers.

Copy constructors are essential for:

• Creating deep copies of objects
• Ensuring correct memory management
• Defining how objects behave when passed by value
• Controlling resource duplication

What Is a Copy Constructor?

In C++, a copy constructor is a constructor that takes a reference to another object of the same class as its parameter:

ClassName(const ClassName& other);

This constructor is called automatically when:

• An object is initialized from another object
• An object is passed by value
• An object is returned by value
• An object is explicitly copied via assignment

Syntax Example

class Person {
public:
    std::string name;

    // Regular constructor
    Person(std::string name) : name(name) {}

    // Copy constructor
    Person(const Person& other) {
        name = other.name;
        std::cout << "Copy constructor called\n";
    }
};

Usage:

Person p1("Alice");
Person p2 = p1;  // Copy constructor is called

Default Copy Constructor

If you don’t define one yourself, the compiler generates a default copy constructor, which performs a shallow copy—copying all member variables bit-by-bit.

This works fine for simple data types but is dangerous for objects that manage dynamic memory.

Example of Shallow Copy Issue

class Buffer {
public:
    int* data;

    Buffer(int size) {
        data = new int[size];
    }

    ~Buffer() {
        delete[] data;
    }
};

If you copy a Buffer object without defining a copy constructor, both objects will point to the same memory, causing:

• Double deletion
• Memory corruption
• Undefined behavior

Deep Copy with Custom Copy Constructor

class Buffer {
public:
    int* data;
    int size;

    Buffer(int size) : size(size) {
        data = new int[size];
    }

    // Deep copy
    Buffer(const Buffer& other) : size(other.size) {
        data = new int[size];
        for (int i = 0; i < size; ++i) {
            data[i] = other.data[i];
        }
    }

    ~Buffer() {
        delete[] data;
    }
};

Now, copying Buffer creates a separate memory block, eliminating shared ownership issues.

Copy Constructor vs Assignment Operator

Tip

If you define a copy constructor, you often must also define the copy assignment operator and destructor—a rule known as the Rule of Three in C++.

Rule of Three / Five / Zero

C++11 and the =default and =delete Keywords

To instruct the compiler:

class MyClass {
public:
    MyClass(const MyClass&) = default;  // Use compiler-defined copy constructor
    MyClass& operator=(const MyClass&) = delete; // Prevent copying
};

Copy Constructor in Other Languages

Java

Java does not have copy constructors in the same sense. Copying is typically done via:

• Copy constructors (custom-written methods)
• Cloneable interface and clone() method
• Copy factory methods

public class Person {
    String name;

    public Person(Person other) {
        this.name = other.name;
    }
}

Python

Python supports object copying through:

• copy.copy() → Shallow copy
• copy.deepcopy() → Deep copy

import copy

p1 = {"name": "Alice"}
p2 = copy.deepcopy(p1)

JavaScript

Use spread syntax or structured cloning:

const p1 = { name: "Alice" };
const p2 = { ...p1 };  // Shallow copy

Deep Copy vs Shallow Copy

A copy constructor should usually implement deep copy to avoid shared ownership bugs.

Copy Elision and Return Value Optimization (RVO)

Modern C++ compilers often skip the copy constructor altogether when:

• Returning objects from functions
• Initializing from temporaries

This is called copy elision or RVO (Return Value Optimization).

Buffer createBuffer() {
    Buffer b(100);
    return b;  // May avoid copy altogether
}

Example: Copy Constructor with Smart Pointers

In modern C++, smart pointers simplify deep copy logic.

#include 

class Data {
public:
    std::shared_ptr arr;

    Data(int size) {
        arr = std::make_shared(size);
    }

    // No need for custom copy constructor
};

Pitfalls

Best Practices

• ✅ Always define a custom copy constructor for classes managing dynamic memory or resources
• ✅ Follow the Rule of Three (or Five)
• ✅ Use smart pointers to simplify memory management
• ✅ Avoid unnecessary copies—prefer references or move semantics
• ✅ Use =delete to explicitly disable copying if needed

Summary

Related Keywords

• Assignment Operator
• Copy Elision
• Deep Copy
• Destructor
• Dynamic Memory Allocation
• Move Constructor
• Object Lifecycle
• Resource Management
• Rule of Three
• Shallow Copy