Code360 powered by Coding Ninjas X Naukri.com. Code360 powered by Coding Ninjas X Naukri.com
Last Updated: Apr 5, 2024
Difficulty: Easy

Copy Constructor C++

Leveraging ChatGPT - GenAI as a Microsoft Data Expert
Speaker
Prerita Agarwal
Data Specialist @
23 Jul, 2024 @ 01:30 PM

Introduction

Copy constructor is the fundamental but important concept of C++. Copy constructors help ensure that objects in C++ are copied correctly & efficiently, maintaining the integrity of your code. 

Copy Constructor C++

In this article will talk about copy constructors, from their basic characteristics to the more advanced subtopics like copy elision & the differences between copy constructors & assignment operators. We will try our best to clear all your doubts regarding Copy constructor with the help of relevant examples also.

Characteristics of Copy Constructor

A copy constructor in C++ is like a special rulebook that tells your program how to make a copy of an object. Think of it as instructions for creating a duplicate, but not just any duplicate – one that preserves the unique details of the original object.

Creates an Object Copy

The main job of a copy constructor is to create a new object as a copy of an existing object. This is super useful when you want to pass objects around in your code without messing up the original data.

Takes a Reference

To make a copy, the copy constructor needs to know which object it's duplicating. It does this by taking a reference to the original object. This way, it can access all the original's details without directly changing anything.

Can be Automatic or Custom

Sometimes, C++ will automatically give you a copy constructor that does a basic job of copying objects. But if your object has special needs, like if it holds resources outside of itself (think of a bookshelf holding books), you might need to write your own to ensure everything copies over correctly.

Used in Specific Situations

Copy constructors aren't called all the time. They spring into action mainly in three situations: when you're making a new object from an existing one, passing an object by value to a function, or returning an object from a function by value.

Ensures Efficient Copying

With the right setup, a copy constructor can make copying objects efficient, preventing unnecessary work and ensuring your program runs smoothly.

For example :  

  • C++

C++

#include <iostream>
using namespace std;

class Box {
public:
int length;
// Basic constructor
Box(int l) : length(l) {}
// Copy constructor
Box(const Box &b) : length(b.length) {
cout << "Copy constructor called" << endl;
}
};

int main() {
Box Box1(10); // Declare Box1
Box Box2 = Box1; // Declare Box2, a copy of Box1

// Output the length of Box2
cout << "Length of Box2 : " << Box2.length << endl;

return 0;
}

Output

Copy constructor called
Length of Box2 : 10


In this code, Box is a simple class with one property, length. The copy constructor Box(const Box &b) is defined to create a new Box object as a copy of an existing one. When we run this program, Box2 is created as a copy of Box1, and the copy constructor prints a message to let us know it was called.

Get the tech career you deserve, faster!
Connect with our expert counsellors to understand how to hack your way to success
User rating 4.7/5
1:1 doubt support
95% placement record
Akash Pal
Senior Software Engineer
326% Hike After Job Bootcamp
Himanshu Gusain
Programmer Analyst
32 LPA After Job Bootcamp
After Job
Bootcamp

Types of Copy Constructors

Default Copy Constructor

The default copy constructor is the one C++ gives you for free, without you having to write any extra code. It does a straightforward job: it copies each field from the original object to the new object. This works well for simple classes or structs without complex, dynamically allocated memory or other resources.

Example :

  • C++

C++

class SimpleClass {
public:
int value;
SimpleClass(int val) : value(val) {} // A simple constructor
};

int main() {
SimpleClass original(100); // Create an original object
SimpleClass copy = original; // C++ uses the default copy constructor

// If we print 'copy.value', it will be the same as 'original.value'
return 0;
}


In this example, when we create copy, C++ automatically uses the default copy constructor to make sure copy.value is the same as original.value.

User-Defined Copy Constructor

Sometimes, the default copy constructor isn't enough, especially when your class deals with dynamic memory or needs to perform specific actions when copied. In these cases, you write a user-defined copy constructor.

Example:

#include<iostream>
#include<stdlib.h>
#include<string.h>
class ComplexClass {
public:
   char *data;
   ComplexClass(const char *str) {
       data = new char[strlen(str) + 1];
       strcpy(data, str);
   }
   // User-defined copy constructor
   ComplexClass(const ComplexClass &cc) {
       data = new char[strlen(cc.data) + 1];
       strcpy(data, cc.data);
   }
   ~ComplexClass() {
       delete[] data; // Don't forget to free the allocated memory
   }
};
int main() {
   ComplexClass original("Hello");
   ComplexClass copy = original; // Now using our user-defined copy constructor
   // 'copy.data' will be a separate copy of 'original.data'
   return 0;
}


In this more complex example, ComplexClass has a pointer to dynamically allocated memory. The user-defined copy constructor makes sure to allocate new memory for the copy, & then copy the content. This way, both original & copy have their own separate copies of the data, avoiding potential issues when one of them is modified or deleted.

When is the Copy Constructor Called?

The copy constructor isn't called all the time but in specific situations. Here are the main scenarios where C++ decides it's time to use the copy constructor:

Creating a New Object from an Existing Object

When you declare one object & initialize it with another, C++ uses the copy constructor to make the new object a copy of the existing one.

MyClass obj1;        // Default constructor is called
MyClass obj2 = obj1; // Copy constructor is called

Passing an Object by Value to a Function

If a function takes an argument by value & you pass an object to it, C++ uses the copy constructor to create a copy of the object for the function to use.

void function(MyClass obj) { // Copy constructor is called when 'obj' is created
    // Function body
}

Returning an Object from a Function by Value

When a function returns an object by value, the copy constructor is used to create the return value from the object inside the function.

MyClass function() {
    MyClass obj;
    return obj; // Copy constructor is called to create the return value
}

Initializing an Object with Curly Braces

Even when you use curly braces to initialize an object, if you're essentially copying another object, the copy constructor is called.

MyClass obj1;
MyClass obj2{obj1}; // Copy constructor is called


In all these cases, the copy constructor's job is to ensure that the new object is an exact, independent copy of the original. This process is automatic, but it's important to know when it happens so you can write your copy constructor with these moments in mind, especially if your class manages resources like dynamic memory.

Copy Elision

Copy elision is a performance optimization technique used by C++ compilers to reduce the unnecessary copying of objects. This might sound a bit technical, but it's actually a straightforward concept that helps make your programs faster and more efficient.

When C++ code is written, there are times when objects might be copied more than is truly necessary. Imagine you have a function that returns an object, and you use that function to initialize a new object. Normally, you might expect a copy to be made when the function returns its result, and another copy to be made when the new object is initialized with that result. However, copy elision allows the compiler to skip these extra steps, effectively "eliding" (or removing) the unnecessary copies.

Example of how copy elision works:

class MyClass {
public:
    MyClass() { /* Constructor code here */ }
    MyClass(const MyClass&) { /* Copy constructor code here */ }
};
MyClass createObject() {
    MyClass obj;
    return obj; // This return might involve copying
}
int main() {
    MyClass myObj = createObject(); // Normally, copying would happen here
    return 0;
}


In this code, without copy elision, myObj in main() would be created by copying the object returned by createObject(). However, with copy elision, the compiler is allowed to construct myObj directly in the place where the return object would be, eliminating the need for a copy.

Copy elision is particularly common in two scenarios:

  • Return Value Optimization (RVO): When an object is returned by value from a function, the compiler can create the object directly in the location where it is expected, avoiding a copy.
     
  • Named Return Value Optimization (NRVO): Similar to RVO, but applies when the object being returned has a name within the function.
     

Copy elision not only makes programs faster by reducing the number of copies but also helps to avoid potential issues related to object copying, such as unnecessary resource allocation and deallocation.

Note -: It's important to note that copy elision is an optimization, which means the compiler can choose to apply it, but it's not guaranteed in all cases. However, modern C++ standards (C++17 and onwards) have made certain forms of copy elision mandatory, making it a more reliable optimization.

When is a User-Defined Copy Constructor Needed?

Sometimes, the default copy constructor that C++ provides isn't enough for your needs. This is where a user-defined copy constructor comes into play. You might need to write your own copy constructor in a few specific situations, mainly when your class deals with resources like dynamic memory, file handles, or complex states that need careful duplication.

Now. we will see where a user-defined copy constructor is necessary:

Managing Dynamic Memory

If your class allocates memory dynamically, like using new to allocate memory for a pointer, the default copy constructor won't suffice. It performs a shallow copy, which means both the original and the copied object would point to the same memory location. This can lead to issues like double frees or memory leaks. A user-defined copy constructor ensures a deep copy, duplicating the memory and other resources properly.

class MyClass {
public:
    int* data;
    MyClass(int size) { data = new int[size]; } // Allocates memory
    MyClass(const MyClass& that) { 
        data = new int[/*size*/]; // Allocate new memory for the copy
        std::copy(that.data, that.data + /*size*/, data); // Duplicate the content
    }
    ~MyClass() { delete[] data; } // Frees allocated memory
};

Handling External Resources

If your class manages resources outside of its own memory, like file handles or network connections, you'll likely need a user-defined copy constructor. You must define how to correctly duplicate these resources, or sometimes, decide not to duplicate them but rather to share or uniquely handle each instance.

Implementing Cloning

In some designs, especially those involving polymorphism, you might need to clone objects polymorphically. The default copy constructor doesn't support polymorphic cloning, but a user-defined one can be designed to do so, often in conjunction with a virtual clone method.

Custom Copy Logic

There may be instances where the copying of an object involves more than just duplicating its fields. Maybe there's some initialization or state update that needs to happen when an object is copied. In such cases, a user-defined copy constructor allows you to embed this custom logic.

Here's a simple example to show when you might need a user-defined copy constructor:

class ResourceHolder {
public:
    Resource* resource;
    // Constructor that allocates a new resource
    ResourceHolder() { resource = new Resource(); }
    // User-defined copy constructor
    ResourceHolder(const ResourceHolder& rhs) {
        // Allocate a new resource and copy the data from the original
        resource = new Resource(*rhs.resource);
    }

    // Destructor to free the allocated resource
    ~ResourceHolder() { delete resource; }
};


In this example, ResourceHolder manages a resource that needs to be carefully duplicated when the object is copied. The user-defined copy constructor ensures that a new resource is created for the copy, preventing potential issues like shared state or resource conflicts.

Copy Constructor vs Assignment Operator

AspectCopy ConstructorAssignment Operator
PurposeUsed to initialize a new object as a copy of an existing object.Used to copy values from one existing object to another existing object.
SyntaxMyClass(const MyClass& other);MyClass& operator=(const MyClass& other);
When CalledWhen a new object is created and initialized with another object of the same class.When an existing object is assigned the value of another object of the same class after both have already been initialized.
ParameterTakes a reference to the object being copied.Takes a reference to the object being copied.
Return TypeTypically none (constructor).Typically returns a reference to *this to allow chaining assignments.
Use Cases- Creating a new object from another object. <br> - Passing an object by value to a function. <br> - Returning an object from a function by value.- Reassigning values to an existing object. <br> - Changing the state of an object after it has been created.
OverloadingCannot be overloaded.Can be overloaded.
Default BehaviorIf not defined by the user, the compiler provides a default copy constructor that does a shallow copy.If not defined by the user, the compiler provides a default assignment operator that does a shallow copy.
Side EffectsA poorly designed copy constructor can lead to issues like double deletion, memory leaks, etc.Improper handling in the assignment operator can lead to issues like self-assignment pitfalls, resource leaks, etc.

Example – Class Where a Copy Constructor is Required

Imagine we have a class called Notebook, which represents a notebook with pages. Each page can have text written on it. In our Notebook class, we'll use dynamic memory allocation to represent the pages. This is a classic scenario where a default copy constructor won't cut it, and we need a user-defined copy constructor to ensure each Notebook copy has its own separate pages.

Lets see how to implement this :

  • C++

C++

#include <iostream>
#include <cstring>

class Notebook {
public:
char* text;
int pageCount;

// Constructor
Notebook(int pages) : pageCount(pages) {
text = new char[pageCount * 100]; // Let's assume each page can hold 100 characters
strcpy(text, "This is a new notebook."); // Initial text
}

// User-defined copy constructor
Notebook(const Notebook& n) {
pageCount = n.pageCount;
text = new char[pageCount * 100];
strcpy(text, n.text); // Copy the text to the new notebook
}

// Destructor
~Notebook() {
delete[] text; // Clean up the allocated memory
}

// A method to add text to a page (for simplicity, we'll just append text)
void addText(const char* newText) {
strcat(text, newText);
}

// Display notebook content
void display() {
std::cout << text << std::endl;
}
};

int main() {
Notebook myNotebook(30); // Create a Notebook with 30 pages
myNotebook.addText(" More notes."); // Add some text

Notebook copiedNotebook = myNotebook; // Use the copy constructor

// Let's add different text to the copied notebook
copiedNotebook.addText(" This text is only in the copied notebook.");

// Display both notebooks
std::cout << "Original Notebook: ";
myNotebook.display();

std::cout << "Copied Notebook: ";
copiedNotebook.display();

return 0;
}

Output

Original Notebook: This is a new notebook. More notes.
Copied Notebook: This is a new notebook. More notes. This text is only in the copied notebook.


In this example, Notebook has a dynamic array text to store the notebook's content. The user-defined copy constructor ensures that when a Notebook is copied, the new Notebook has its own copy of the text, not just a pointer to the same text as the original. This prevents potential issues like changes in one notebook affecting the other or errors when the notebooks are destroyed.

Can We Make the Copy Constructor Private?

In C++, you have the option to make the copy constructor private. Doing this is a way to control how objects of a class are copied. When a copy constructor is private, it means you can't use it in the usual way, like when you try to copy an object outside of the class methods.

Here's what happens when you make a copy constructor private:

Restricts Object Copying

By making the copy constructor private, you're essentially saying, "You can't create a direct copy of this object." This is useful in scenarios where copying an object doesn't make sense or could lead to problems, like with singleton patterns where only one instance of a class should exist.

Controlled Copying Inside the Class

Even though the copy constructor is private, you can still use it within the class methods or friend functions. This allows for controlled copying of objects in a way that's safe and aligns with the class design.

Compiler Error

If you try to copy an object of a class with a private copy constructor outside of its allowed scope, the compiler will throw an error. This is a good way to enforce certain design constraints in your code.

Example of private copy constructor

class UniqueObject {
private:
    // Private copy constructor
    UniqueObject(const UniqueObject& obj) { /* Copy logic here */ }
public:
    UniqueObject() { /* Constructor logic here */ }
    static UniqueObject createObject() {
        UniqueObject obj;
        // Copying is allowed here because it's within the class scope
        UniqueObject copy = obj;
        return copy; // This works because it's returning by value, but copy elision may apply
    }
};
int main() {
    UniqueObject obj1 = UniqueObject::createObject();

    // The following line would cause a compiler error because the copy constructor is private
    // UniqueObject obj2 = obj1;

    return 0;
}


In this example, UniqueObject has a private copy constructor. You can still create objects using the createObject method, which uses the private copy constructor internally. However, trying to copy UniqueObject instances outside of this method, like in main, would lead to a compiler error.

Note -: Making the copy constructor private is a design choice that can help prevent misuse of the class and ensure objects are copied only in a controlled manner that the class designer intended.

Why Argument to a Copy Constructor Must Be Passed as a Reference?

In C++, when you define a copy constructor, the argument is always passed as a reference, specifically a const reference. This is a rule, not just a recommendation. Let’s see why it is so -: 

Preventing Infinite Recursion

If the argument to the copy constructor were passed by value, to call the copy constructor, C++ would need to make a copy of the argument. But making a copy requires calling the copy constructor, which needs a copy, and so on. This would lead to an infinite recursion. Passing the argument by reference avoids this, as no copy is made just to call the constructor.

Efficiency

Even if it were possible to pass by value without causing recursion, doing so would involve making a copy of the object, which can be inefficient, especially for large objects. Passing by reference avoids unnecessary copying, making the process more efficient.

Const Correctness

The argument is passed as a const reference because the copy constructor should not modify the object it's copying from. This ensures the original object remains unchanged after the copy, which is usually the desired behavior.

Let’s see an example, highlighting the use of a const reference:

class MyClass {
public:
    // Other members...
    // Copy constructor taking a const reference as an argument
    MyClass(const MyClass& other) {
        // Copy the content of 'other' to 'this'
    }
};


In this example, the MyClass(const MyClass& other) copy constructor takes a const reference to an object of the same class. This approach allows the constructor to access the members of other to duplicate them in the new object without triggering recursion, unnecessary copying, or modifying the original object.

Why Argument to a Copy Constructor Should Be Const?

When defining a copy constructor in C++, the argument is typically made const in addition to being a reference. This is a crucial part of the function signature for a copy constructor, and here's why:

Protecting the Original Object

Making the argument const ensures that the copy constructor does not accidentally modify the object being copied. This is important because the purpose of a copy constructor is to create a new object that is an exact replica of the existing object, without altering the original.

Enabling Copying of Const Objects

If the argument to the copy constructor is not const, then you wouldn't be able to pass const objects to it. There are many scenarios where you might want to copy an object that is const, so the copy constructor needs to accept const arguments to handle these cases.

Adhering to Principle of Least Privilege

The principle of least privilege suggests that code should only have the permissions it needs to perform its task, and no more. Since the copy constructor's job is to copy data, not to modify the original, it should not have the ability to modify the argument, hence the argument is const.

For example -: 

class MyClass {
public:
    int data;
    // Constructor
    MyClass(int d) : data(d) {}
    // Copy constructor with const reference argument
    MyClass(const MyClass& other) : data(other.data) {
        // The constructor copies 'data' from 'other' to 'this' object
        // 'other' is const, so it cannot be modified
    }
};


In this example, the copy constructor MyClass(const MyClass& other) takes a const reference to another instance of MyClass. This allows the constructor to read other.data without the risk of modifying other.

Note -: Using const in this way is a best practice that helps prevent bugs, makes your intentions clear to others reading your code, and ensures your objects can be copied safely and correctly.

Frequently Asked Questions

Can a copy constructor create a deep copy of an object?

Yes, a copy constructor can create a deep copy of an object. This is essential for classes that manage dynamic resources or complex states. A deep copy means that all resources are duplicated, ensuring the new object is entirely independent of the original.

Is it mandatory to define a copy constructor in every class?

No, it's not mandatory to define a copy constructor in every class. C++ provides a default copy constructor that performs a shallow copy. However, for classes managing dynamic resources or needing special copying behavior, a user-defined copy constructor is recommended.

How does copy elision affect the copy constructor?

Copy elision is an optimization that can eliminate unnecessary calls to the copy constructor, even if it's defined. This can improve performance by reducing overhead. With C++17 and later, certain cases of copy elision are mandatory, further optimizing code.

Conclusion

In this article, we learned everything about copy constructors in C++, a fundamental concept for understanding object copying and resource management. We started by defining what a copy constructor is and its role in creating object copies. We explored the distinctions between default and user-defined copy constructors, highlighting scenarios where each is applicable. Apart from this we also discussed why copy constructor is needed and how it could be called with all relevant examples.

You can refer to our guided paths on the Coding Ninjas. You can check our course to learn more about DSADBMSCompetitive ProgrammingPythonJavaJavaScript, etc. Also, check out some of the Guided Paths on topics such as Data Structure andAlgorithmsCompetitive ProgrammingOperating SystemsComputer Networks, DBMSSystem Design, etc., as well as some Contests, Test Series, and Interview Experiences curated by top Industry Experts.

Topics covered
1.
Introduction
2.
Characteristics of Copy Constructor
2.1.
Creates an Object Copy
2.2.
Takes a Reference
2.3.
Can be Automatic or Custom
2.4.
Used in Specific Situations
2.5.
Ensures Efficient Copying
2.6.
C++
3.
Types of Copy Constructors
3.1.
Default Copy Constructor
3.2.
C++
3.3.
User-Defined Copy Constructor
4.
When is the Copy Constructor Called?
4.1.
Creating a New Object from an Existing Object
4.2.
Passing an Object by Value to a Function
4.3.
Returning an Object from a Function by Value
4.4.
Initializing an Object with Curly Braces
5.
Copy Elision
6.
When is a User-Defined Copy Constructor Needed?
6.1.
Managing Dynamic Memory
6.2.
Handling External Resources
6.3.
Implementing Cloning
6.4.
Custom Copy Logic
7.
Copy Constructor vs Assignment Operator
8.
Example – Class Where a Copy Constructor is Required
8.1.
C++
9.
Can We Make the Copy Constructor Private?
9.1.
Restricts Object Copying
9.2.
Controlled Copying Inside the Class
9.3.
Compiler Error
9.4.
Example of private copy constructor
10.
Why Argument to a Copy Constructor Must Be Passed as a Reference?
10.1.
Preventing Infinite Recursion
10.2.
Efficiency
10.3.
Const Correctness
11.
Why Argument to a Copy Constructor Should Be Const?
11.1.
Protecting the Original Object
11.2.
Enabling Copying of Const Objects
11.3.
Adhering to Principle of Least Privilege
12.
Frequently Asked Questions
12.1.
Can a copy constructor create a deep copy of an object?
12.2.
Is it mandatory to define a copy constructor in every class?
12.3.
How does copy elision affect the copy constructor?
13.
Conclusion