Do you want to learn about Deleted Copy Constructor? Do you want to avoid Implicit Generation of the Copy Constructor ? This post explains how you can avoid Implicit Generation of the Copy Constructor by using a Deleted Copy Constructor.
The Constructor in C++ is a function, a method in the class, but it is a ‘special method’ that is automatically called when an object of a class is created. We don’t need to call this function. Whenever a new object of a class is created, the Constructor allows the class to initialize member variables or allocate storage. This is why the name Constructor is given to this special method. Here is a simple constructor class example below,
|
1 2 3 4 5 6 7 8 9 10 |
class myclass { public: myclass() { std::cout << "myclass is constructed!\n"; }; }; |
There are different constructor types in classes and the Copy Constructor is one of these. Copy Constructors not only used in classes but also used with struct and union data types Do you want to learn what is copy constructor or what kind of methods we have that we can declare and use copy constructors? In this post, we will try to explain how to use Copy Constructor with examples.
The Copy Constructor in classes (i.e class_name) is a non-template constructor whose first parameter is class_name&, const class_name&, volatile class_name&, or const volatile class_name& . It can be used with no other parameters or with the rest of the parameters all have default values.
The Copy Constructor is a constructor type for classes that class_name must name the current class, or it should be a qualified class name when it is declared at namespace scope or in a friend declaration.
Deleted Copy Constructor (Avoiding Implicit Generation of the Copy Constructor)
Deleted Copy Constructor is used if you are Avoiding implicit generation of the copy constructor.
Syntax,
|
1 2 3 |
class_name ( const class_name & ) = delete; |
In example, copy constructor can be defined with attributes as delete;
|
1 2 3 4 5 6 7 8 9 10 11 |
class myclass { public: myclass() // Default Constructor { }; myclass(const myclass& ) = delete; // Copy Constructor with attributes as delete }; |
This is a full example with a Deleted Copy Constructor, here we put reminder where compile error and avoids to generate a new class by using copy constructor,
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
#include <iostream> class myclass { public: int param; myclass() // Default Constructor { }; myclass(const myclass& ) = delete; // Copy Constructor with attributes as delete }; int main() { myclass class1; class1.param=100; // myclass class2(class1); // ERROR : 'myclass' has been explicitly marked deleted here // That means, copy constructor is not passible in implicit generation return 0; } |
If you don’t want implicit generation of the copy constructor then used Deleted Copy Constructor.
