Do you want to know what is Deleted Implicitly Declared Copy Constructor ? Implicitly-Declared Copy Constructor helps you to do this, here is the full post;
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
The Copy Constructor in classes (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 Implicitly-Declared Copy Constructor
In C++, we can implicitly declare a copy constructor while it is deleted in previous class. The implicitly-declared or defaulted copy constructor for a class is defined as deleted if,
- class has non-static data members that cannot be copied
- class has direct or virtual base class that cannot be copied
- class has direct or virtual base class with a deleted or inaccessible destructor
- class is a union-like class and has a variant member with non-trivial copy constructor
- class has a data member of rvalue reference type;
- class has a user-defined copy constructor or copy assignment operator
The compiler declares a Copy Constructor as a non-explicit inline public member of its class If a copy constructor is not defined for a class type (struct, class, or union), We can Implicitly declare a copy constructor when defining a new class.
Remember that copy constructor has this syntax,
|
1 2 3 4 5 6 |
class_name (const class_name& ) // Copy Constructor { }; |
and this Copy Constructor will be declared implicitly when declaring a new class as below,
|
1 2 3 4 5 6 |
class new_class_name : access_type class_name { // Copy Constructor will be Declared Implicitly }; |
If we combine both with a Deleted copy Constructor, here is an Deleted Implicitly-Declared Copy Constructor example,
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
class myclass { public: myclass() // Default Constructor { }; myclass(const myclass& ) = delete; // Copy Constructor Deleted }; class my_otherclass : public myclass { my_otherclass(const myclass& a) : myclass() // Deleted Implicitly-Declared Copy Constructor { }; }; |
Here is the full Deleted Implicitly-Declared Copy Constructor example that causes errors as below,
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
#include <iostream> class myclass { public: int param; myclass() // Default Constructor { }; myclass(const myclass& ) = delete; // Copy Constructor Deleted }; class my_otherclass : public myclass // Implicitly-Declared Copy Constructor { public: }; int main() { myclass class1; class1.param=100; std::cout << class1.param << '\n' ; my_otherclass class2(class1); // Error : candidate constructor (the implicit default constructor) not viable: requires 0 arguments, but 1 was provided // Error : candidate constructor (the implicit copy constructor) not viable: no known conversion from 'myclass' to 'const my_otherclass' for 1st argument std::cout << class2.param << '\n' ; getchar(); return 0; } |
To avoid this error, we can declare a Copy Constructor in a new class (my_otherclass) as below,
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
#include <iostream> class myclass { public: int param; myclass() // Default Constructor { }; myclass(const myclass& ) = delete; // Copy Constructor Deleted }; class my_otherclass : public myclass { public: my_otherclass(const myclass& a) : myclass() // Deleted Implicitly-Declared Copy Constructor { param = a.param; }; }; int main() { myclass class1; class1.param=100; std::cout << class1.param << '\n' ; my_otherclass class2(class1); std::cout << class2.param << '\n' ; getchar(); return 0; } |
output will be like this.
|
1 2 3 4 |
100 100 |
As in this example, Deleted Implicit declared copy constructor copied values by the declared copy constructor.
