- Shallow Copy<\/a><\/li>
- Deep Copy<\/a><\/li><\/ul><\/li>
- Difference between Copy Constructor and Assignment Operator<\/a><\/li><\/ol>\n\n\n\n
Let us begin by first understanding what a constructor is before we dive in what copy constructor in C++ is. <\/p>\n\n\n\n
Constructor<\/strong><\/h2>\n\n\n\n
A constructor is a special member function used to initialize objects of its class. It will be called automatically when the object is created. <\/p>\n\n\n\n
Let us see how a constructor is automatically <\/strong>executed at the time of object creation.<\/p>\n\n\n\n
Constructor Program in C++:<\/strong><\/p>\n\n\n\n
#include<iostream> \nusing namespace std; \nclass ABC { \n public:ABC(){\n cout<<\"Constructor is called automatically\";\n cout<<\"at the time of execution\"<<endl;\n }\n void display(){\n cout<<\"hello world\";\n } \n}; \n\nint main() { \n ABC ob1,ob2;\n ob1.display();\n ob2.display();\n return 0; \n} \n<\/code><\/pre>\n\n\n\nOutput: <\/strong><\/p>\n\n\n
![\"\"](\"https:\/\/www.mygreatlearning.com\/blog\/wp-content\/uploads\/2021\/06\/image-32-1024x221.png\")
<\/figure>\n\n\n\nIn the above program, we created two objects ob1 and ob2, for the same class ABC. As you can see, we have called the display() function to execute, but we didn\u2019t call for constructor ABC(). <\/p>\n\n\n\n
A constructor is called automatically when we created the object ob1 and ob2, but for display(), we need to call unless we call it won\u2019t execute explicitly. This is the advantage of using the constructor. It is easily accessible, and the user can easily understand the flow of the program.<\/p>\n\n\n\n
Let us see the program to find the sum of N natural numbers. <\/strong><\/p>\n\n\n\n
Program:<\/strong><\/p>\n\n\n\n
#include<iostream> \nusing namespace std; \nclass sum { \n private: int n,s; \n public: sum(){\n s=0;\n cout<<\"enter limit= \"; \n cin>>n;\n for(int i=1; i<=n; i++){\n s+=i;\n cout<<\"Sum of natural numbers= \"<<s;\n }\n } \n}; \n\nint main() { \n sum ob1;\n return 0; \n} <\/code><\/pre>\n\n\n\nOutput: <\/strong><\/p>\n\n\n
![\"\"](\"https:\/\/www.mygreatlearning.com\/blog\/wp-content\/uploads\/2021\/06\/image-31-1024x244.png\")
<\/figure>\n\n\n\n- In the above example, we created an object ob1 <\/strong>which calls the sum() function automatically. <\/li>
- We find the sum of the first five natural numbers, i.e., 1 to 5.<\/li>
- Sum() is the constructor which is automatically called at the time of object creation. It gives us the result as 15 <\/strong>[1+2+3+4+5=15]. <\/li><\/ul>\n\n\n\n
What is a Copy Constructor in C++?<\/strong><\/h2>\n\n\n\n
Copy constructors are the member functions of a class that initialize the data members of the class using another object of the same class. It copies the values of the data variables of one object of a class to the data members of another object of the same class. A copy constructor can be defined as follows:<\/p>\n\n\n\n
class class_name {\n Class_name(Class_name &old_object){ \/\/copy constructor\n Var_name = old_object.Var_name;\n \u2026.\n \u2026.\n }\n }\n<\/code><\/pre>\n\n\n\nA copy constructor in C++ is further categorized into two types:<\/p>\n\n\n\n
- Default Copy Constructor<\/li>
- User-defined Copy Constructor<\/li><\/ul>\n\n\n\n
Default Copy Constructors:<\/em><\/strong> When a copy constructor is not defined, the C++ compiler automatically supplies with its self-generated constructor that copies the values of the object to the new object.<\/p>\n\n\n\n
Example:<\/em><\/strong><\/p>\n\n\n\n
\n#include <iostream>\nusing namespace std;\n\nclass A {\n int x, y;\n \npublic:\n A(int i, int j)\n {\n x = i;\n y = j;\n }\n int getX() { return x; }\n int getY() { return y; }\n};\n \nint main()\n{\n A ob1(10, 46);\n A ob2 = ob1; \/\/ 1\n cout << \"x = \" << ob2.getX() << \" y = \" << ob2.getY();\n return 0;\n}\n<\/code><\/pre>\n\n\n\nOutput:<\/em><\/p>\n\n\n
![\"copy](\"https:\/\/www.mygreatlearning.com\/blog\/wp-content\/uploads\/2021\/08\/Screenshot-4.png\")
<\/figure>\n\n\n\nHere, in line 1, even without the copy constructor, the values of ob1\u2019s variable members copy fine to the member variables of ob2.<\/em><\/p>\n\n\n\n
User-defined Copy Constructors:<\/em><\/strong> <\/em>In case of a user-defined copy constructor, the values of the parameterised object of a class are copied to the member variables of the newly created class object. The initialization or copying of the values to the member variables is done as per the definition of the copy constructor.<\/p>\n\n\n\n
Example: <\/em><\/strong><\/p>\n\n\n\n
#include <iostream> \nusing namespace std; \nclass Example \n{ \n public: \n int a; \n Example(int x) \/\/ parameterized constructor \n { \n a=x; \n } \n Example(Example &ob) \/\/ copy constructor \n { \n a = ob.a; \n } \n}; \nint main() \n{ \n Example e1(36); \/\/ Calling the parameterized constructor \n Example e2(e1); \/\/ Calling the copy constructor \n cout<<e2.a; \n return 0; \n} \n<\/code><\/pre>\n\n\n\nOutput<\/strong><\/em><\/p>\n\n\n
![\"c++\"](\"https:\/\/www.mygreatlearning.com\/blog\/wp-content\/uploads\/2021\/08\/Screenshot-5.png\")
<\/figure>\n\n\n\nClassification of Constructors<\/strong><\/h2>\n\n\n\n
Constructors are classified as follows: <\/p>\n\n\n\n
- Parameterized Constructor <\/li>
- Constructor overloading<\/li>
- Copy Constructors<\/li>
- Default Constructor <\/li>
- Constructor with default arguments. <\/li><\/ul>\n\n\n\n
Let me give a brief introduction to the above topics. <\/p>\n\n\n\n
Parameterised constructor<\/strong>: <\/h4>\n\n\n\n
The constructor that takes arguments or parameters at the time of object creation is known as parameterized constructor. The syntax for calling a parameterised constructor is given below:<\/p>\n\n\n\n
Syntax: <\/p>\n\n\n\n
ClassName objectName (arg1, arg2 arg3,\u2026, argN);\n<\/code><\/pre>\n\n\n\nExample:<\/em><\/strong><\/p>\n\n\n\n
#include <iostream> \nusing namespace std;\n\nclass Transport \n{ \n public: \n int wheels; \n Transport(int n) \/\/ parameterized constructor \n { \n wheels=n; \n } \n}; \n\nint main() \n{ \n Transport car(4); \/\/ Calling the parameterized constructor for the 1st object \n Transport bike(2); \/\/ Calling the parameterized constructor for the 2nd object \n cout<<\"Car has \"<<car.wheels<<\" wheels\\n\"; \n cout<<\"Bike has \"<<bike.wheels<<\" wheels\\n\";\n return 0; \n } \n\n<\/code><\/pre>\n\n\n\nOutput:<\/em><\/p>\n\n\n
![\"\"](\"https:\/\/www.mygreatlearning.com\/blog\/wp-content\/uploads\/2021\/08\/Screenshot-6.png\")
<\/figure>\n\n\n\nConstructor overloading: <\/strong><\/h4>\n\n\n\n
- When a class contains more than one constructor, it is known as constructor overloading. The constructors are identical in names, so they are distinguished from each other on the basis of the number of arguments and type of arguments in their parameters. <\/li><\/ul>\n\n\n\n
Constructor overloading in C++ represents the polymorphism feature of OOP. The syntax for calling different constructors for different objects of the same class is shown below.<\/p>\n\n\n\n
Syntax:<\/em><\/strong><\/p>\n\n\n\n
ClassName object1 (arg1, arg2, arg3);\nClassName object2 (arg);\nClassName object3();\n<\/code><\/pre>\n\n\n\nThe syntax for the definition of multiple constructors corresponding to the above calling of constructors has been given below:<\/p>\n\n\n\n
Syntax:<\/em><\/strong><\/p>\n\n\n\n
class ClassName (datatype1 arg1, datatype2 arg2, datatype3 arg3){\n\t\/\/body of constructor1\n}\nClassName object2 (arg){\n\t\/\/body of constructor2\n}\nClassName object3(){\n\t\/\/body of constructor3\n}\n<\/code><\/pre>\n\n\n\nExample:<\/em><\/strong><\/p>\n\n\n\n
#include <iostream> \nusing namespace std;\n\nclass Transport \n{ \n public: \n int wheels; \n string name;\n string color;\n string type;\n \n \/\/Constructor Overloading\n Transport(int n) \/\/ Constructor1 \n { \n wheels=n; \n } \n Transport(string str1, string str2) \/\/Constructor2\n {\n name=str1;\n color=str2;\n }\n Transport(string str) \/\/Constructor3\n {\n type=str;\n }\n \n}; \n\nint main() \n{ \n Transport car(4); \/\/ Calling the 1st constructor \n Transport bike(\"Honda\", \"black\"); \/\/ Calling the 2nd constructor \n Transport cycle(\"roadways\"); \/\/Calling the 3rd constructor\n cout<<\"Car has \"<<car.wheels<<\" wheels\\n\"; \n cout<<\"Name of the bike is \"<<bike.name<<\" and its color is \"<<bike.color<<\"\\n\";\n cout<<\"Cycle is a \"<<cycle.type<<\" mode of transportation\";\n return 0; \n } \n<\/code><\/pre>\n\n\n\nOutput:<\/strong><\/em><\/p>\n\n\n
![\"copy](\"https:\/\/www.mygreatlearning.com\/blog\/wp-content\/uploads\/2021\/08\/Screenshot.png\")
<\/figure>\n\n\n\nCopy Constructors:<\/strong><\/h4>\n\n\n\n
A special type of constructor that can be used for directly creating a copy of an existing object of a class. To be precise, it initializes the member variables of the new object with the values of the member variables of the existing object that is being copied. The syntaxes for defining and calling the copy constructors have been given below:<\/p>\n\n\n\n
Syntax: <\/strong><\/p>\n\n\n\n
\/\/Definition\nClassName objectName (ClassName &existingObject)\n{\n Var1 = existingObject.Var1;\n Var2 = existingObject.Va2;\n}\n\n\/\/Calling\nClassName ob1;\nClassName ob2(&ob1);\n<\/code><\/pre>\n\n\n\nExample:<\/em><\/strong><\/p>\n\n\n\n
#include <iostream> \nusing namespace std;\n\nclass Transport \n{ \n public: \n int wheels; \n string name;\n string color;\n string type;\n \n Transport(int n) \n { \n wheels=n; \n } \n Transport(Transport &ob) \/\/Defining a copy constructor\n {\n wheels=ob.wheels;\n }\n \n}; \n\nint main() \n{ \n Transport car1(4); \/\/ Calling the 1st constructor \n Transport car2(car1); \/\/Method1 of calling a copy constructor\n Transport car3=car2; \/\/Method2 of calling a copy constructor\n cout<<\"Car2 has \"<<car2.wheels<<\" wheels\\n\";\n cout<<\"Car3 has \"<<car3.wheels<<\" wheels\";\n return 0; \n} \n\n<\/code><\/pre>\n\n\n\nOutput<\/em><\/strong>:<\/p>\n\n\n
![\"c++\"](\"https:\/\/www.mygreatlearning.com\/blog\/wp-content\/uploads\/2021\/08\/Screenshot-1.png\")
<\/figure>\n\n\n\nDefault Constructor<\/strong><\/h3>\n\n\n\n
It is possible that some constructors might not have any arguments at all. Such types of constructors are called default constructors. In the scenarios where no user-defined constructor exists for a class and one is needed, the compiler makes an implicit declaration of an inline default constructor that does not have any parameters. These constructors do not have any constructor initializer or body. <\/p>\n\n\n\n
Syntax:<\/em><\/strong><\/p>\n\n\n\n
class ClassName {\n \/\/member variables\n \/\/member functions\n };\n\nint main() \n {\n ClassName object; \/\/Calling of default constructor\n \u2026.\n \u2026.\n return 0;\n }\n<\/code><\/pre>\n\n\n\nExample:<\/em><\/strong><\/p>\n\n\n\n
#include <iostream> \nusing namespace std;\n\nclass Book \n{ \n public: \n int isbn; \n string title;\n string author;\n string type;\n \n}; \n\nint main() \n{ \n Book B1;\n \/\/Default Constructor has been created implicitly\n cout<<\"Success!\";\n return 0; \n } \n\n<\/code><\/pre>\n\n\n\nOutput<\/em><\/strong>:<\/p>\n\n\n
![\"c++\"](\"https:\/\/www.mygreatlearning.com\/blog\/wp-content\/uploads\/2021\/08\/Screenshot-2.png\")
<\/figure>\n\n\n\nNOTE: <\/em><\/strong>Every default constructor can be treated as zero argument constructor, but every zero argument constructor cannot be called a default constructor.<\/em><\/p>\n\n\n\n
Constructor with Default Arguments<\/strong><\/h3>\n\n\n\n
A constructor that holds default values for its parameters is known as a constructor with default arguments. The calling of a constructor with default arguments can be done with either one argument or no argument at all. The parameters of a constructor may or may not have default arguments. You can skip passing the values for the variable members with default values while creating the object. It becomes mandatory to pass the values for the variable members when calling a constructor of the class that has arguments without default values. Take a look at its syntax given below:<\/p>\n\n\n\n
Syntax:<\/em><\/strong><\/p>\n\n\n\n
\nclass ClassName(){\n type variable1;\n type variable2;\n \u2026.\n \u2026.\n\nClassName(type argument1=value1, type argument2=value2, \u2026.) \/\/Constructor definition\n {\n variable1=argument1;\n variable2=argument2;\n \u2026.\n \u2026.\n }\n \u2026.\n \/\/Other member functions\n \u2026.\n };\n<\/code><\/pre>\n\n\n\nExample:<\/em><\/strong><\/p>\n\n\n\n
#include <iostream> \nusing namespace std;\n\nclass Book \n{ \n public: \n int isbn; \n string title;\n string author;\n string type;\n \n \/\/ Constructor with default arguments\n Book(int n=1244, string name=\"Sally's Nightmare\", string writer=\"M.Jose\", string category=\"Fiction\") \n { \n isbn = n;\n title=name;\n author=writer;\n type=category;\n } \n \n}; \n\nint main() \n{ \n Book B1(15467, \"The Picture of Dorian Gray\", \"Oscar Wilde\", \"Fiction\");\n Book B2; \/\/1\n cout<<\"Details of first book:\\n\"<< B1.isbn << endl<< B1.title<< endl<< B1.author<< endl<< B1.type<< endl;\n cout<<\"\\nDetails of second book: \\n\"<< B2.isbn<< endl<< B2.title<< endl<< B2.author<< endl<< B2.type;\n return 0; \n } \n\n<\/code><\/pre>\n\n\n\nIn line 1, no parameter has been passed while creating the B2 object. Hence, the calling of default constructor leads to assigning the default values to the member variables of the object B2.<\/em><\/p>\n\n\n\n
Output<\/em><\/strong><\/p>\n\n\n
![\"copy](\"https:\/\/www.mygreatlearning.com\/blog\/wp-content\/uploads\/2021\/08\/Screenshot-3.png\")
<\/figure>\n\n\n\nUses of Copy Constructor<\/strong><\/h2>\n\n\n\n
- When we initialize an object by another object of the same class. <\/li>
- When we return an object as a function value. <\/li>
- When the object is passed to a function as a non-reference parameter. <\/li><\/ol>\n\n\n\n
Example of Copy Constructor in C++<\/strong><\/h2>\n\n\n\n
#include <iostream> \nusing namespace std; \nclass ABC \n{ \n public: int x; \n ABC (int a){ \/\/ this is parameterized constructor \n x=a;\n } \n ABC (ABC &i){ \/\/ this is copy constructor \n x = i.x; \n } \n}; \n \nint main () \n{ \n ABC a1(40); \/\/ Calling the parameterized constructor. \n ABC a2(a1); \/\/ Calling the copy constructor. \n cout<<a2.x; \n return 0; \n} <\/code><\/pre>\n\n\n\nOutput: <\/strong><\/h4>\n\n\n
![\"\"](\"https:\/\/www.mygreatlearning.com\/blog\/wp-content\/uploads\/2021\/06\/image-28.png\")
<\/figure>\n\n\n\nIn the above example, we are using both parameterised constructor and copy constructor. The variable 'i' is the object which stores the copy of variable 'x'. <\/p>\n\n\n\n
Constructor Copies<\/strong><\/h2>\n\n\n\n
There are two ways in which copy constructor copies, and they are: <\/p>\n\n\n\n
- Shallow copy. <\/li>
- Deep copy. <\/li><\/ol>\n\n\n\n
Let\u2019s go through these topics one by one. <\/p>\n\n\n\n
Shallow Copy <\/strong><\/h4>\n\n\n\n
- It is the process of creating a copy of an object by copying data of all the member variables as it is. <\/li>
- Only a default Constructor produces a shallow copy. <\/li>
- A Default Constructor is a constructor which has no arguments.<\/li><\/ul>\n\n\n\n
Let us understand deeply how it works through programming example <\/p>\n\n\n\n
#include <iostream> \nusing namespace std; \nclass Opp { \n int a; \n int b; \n int *z; \n public: Opp() { \n z=new int; \n } \n void input(int x, int y, int l) { \n a=x; \n b=y; \n *z=l; \n } \n void display() { \n cout<<\"value of a:\" <<a<<endl; \n cout<<\"value of b:\" <<b<<endl; \n cout<<\"value of z:\" <<*z<<endl; \n } \n}; \n \nint main() { \n Opp obj1; \n obj1.input(4,8,12); \n Opp obj2 = obj1; \n obj2.display(); \n return 0; \n} <\/code><\/pre>\n\n\n\nOutput:<\/strong><\/p>\n\n\n
![\"\"](\"https:\/\/www.mygreatlearning.com\/blog\/wp-content\/uploads\/2021\/06\/image-29.png\")
<\/figure>\n\n\n\nExplanation for above one is given in figure below: <\/p>\n\n\n\n
obj1 Shallow copy obj 2 <\/p>\n\n\n\n
A B C <\/strong><\/p>\n\n\n\n
4 <\/strong><\/p>\n\n\n\n
8 <\/strong><\/p>\n\n\n\n
2 <\/strong><\/p>\n\n\n\n
12<\/strong><\/p>\n\n\n\n
<\/strong>x y <\/strong><\/p>\n\n\n\n
z <\/strong><\/strong><\/p>\n\n\n\n
Fig: <\/strong>illustration of shallow copy <\/p>\n\n\n\n
- In the above figure, both 'obj1' and 'obj2' will be having the same input and both the object variables will be pointing to the same memory locations. <\/strong><\/li>
- The changes <\/strong>made to one object will affect <\/strong>another one. <\/li>
- This particular problem is solved by using the user-defined constructor, <\/strong>which uses deep copy. <\/strong><\/li><\/ul>\n\n\n\n
Deep Copy<\/strong><\/h4>\n\n\n\n
- It dynamically allocates memory for the copy first and then copies the actual value. <\/li>
- In a deep copy, both objects which have to copy and another which has to be copied will be having different memory locations. <\/li>
- So, the changes made to one will not affect another. <\/li>
- This is used by a user-defined copy constructor. <\/li><\/ul>\n\n\n\n
The syntax for the user-defined copy constructor is mentioned above refer to that. Let us see the example for the same below <\/p>\n\n\n\n
#include<iostream> \nusing namespace std; \nclass Number { \n private: int a; \n public: Number(){} \/\/default constructor Number (int n) { \n Number(int n){\n a=n; \n } \n Number(Number &x) { \n a=x.a; \n cout<<\"copy constructor is invoked\"; \n } \n void display() { \n cout<<\"value of a:\"<<a<<endl; \n } \n}; \n\nint main() { \n Number N1(100); \/\/ create an object and assign value to member variable \n Number N2(N1); \/\/ invoke user defined copy constructor \n N1.display (); \n N2.display (); \n return 0; \n} <\/code><\/pre>\n\n\n\nOutput: <\/strong><\/h4>\n\n\n
![\"\"](\"https:\/\/www.mygreatlearning.com\/blog\/wp-content\/uploads\/2021\/06\/image-30.png\")
<\/figure>\n\n\n\nN1 N2 <\/p>\n\n\n\n
n <\/strong>100 <\/sub><\/strong>x<\/strong>100<\/sup><\/strong><\/p>\n\n\n\n
\u27a2 In the above example, N1 and N2 are the two objects. \u2018N2\u2019 is the object which stores the value of objec\u2019N1\u2019. \u2018N1\u2019 takes 100 as input and will initialise to \u2018N2\u2019. \u27a2 Both N1 and N2 will have different locations. <\/strong><\/p>\n\n\n\n
\u27a2 Changes made to one will not affect the other. <\/p>\n\n\n\n
Difference between Copy Constructor and Assignment Operator<\/strong><\/h2>\n\n\n\n
Copy Constructor<\/strong><\/td> Assignment Operator<\/strong><\/td><\/tr> It is an overloaded constructor.<\/td> It is an operator.<\/td><\/tr> The new object is initialized with an object already existing.<\/td> Value of one object is assigned to another object both of which exists already.<\/td><\/tr> Here, both the objects use different or separate memory locations.<\/td> Here, different variables points to the same location but only one memory location is used.<\/td><\/tr> The compiler provides a copy constructor if there is no copy constructor defined in the class.<\/td> Bitwise copy will be made if the assignment operator is not overloaded.<\/td><\/tr> Copy Constructor is used when a new object is being created with the help of the already existing element.<\/td> Assignment operator is used when we need to assign an existing object to a new object<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n Let us now look at the differences between assignment and initialisation. <\/p>\n\n\n\n
Consider the following code segment: <\/p>\n\n\n\n
MYClass a; <\/strong><\/p>\n\n\n\n
MYClass b=a; <\/strong><\/p>\n\n\n\n
- The changes <\/strong>made to one object will affect <\/strong>another one. <\/li>
- In the above figure, both 'obj1' and 'obj2' will be having the same input and both the object variables will be pointing to the same memory locations. <\/strong><\/li>
- When a class contains more than one constructor, it is known as constructor overloading. The constructors are identical in names, so they are distinguished from each other on the basis of the number of arguments and type of arguments in their parameters. <\/li><\/ul>\n\n\n\n
- Deep Copy<\/a><\/li><\/ul><\/li>