C++Builder Learn About Implicitly-Defined Copy Constructor

[FireWind]

Learn About Implicitly-Defined Copy Constructor
By Yilmaz Yoru June 30, 2021

Do you want to define a copy constructor in a implicit way ? Implicitly-Defined 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,

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.

Implicitly-Defined Copy Constructor​

The implicitly-defined copy constructor is defined by the compiler if Implicitly Declared Copy Constructor is not deleted. In union types this implicitly-defined copy constructor copies the object representation by using std::memmove statement. In other non-union class types (like classes and structs), their constructor performs full member-wise copy of the object’s bases and non-static members, in their initialization order, using direct initialization. Remember that copy constructor has this syntax,

class_name (const class_name& ) // Copy Constructor
{
 
};

and this Copy Constructor will be defined implicitly when declaring a new class as below,

class new_class_name : access_type class_name
{
   new_class_name() : clas_name() { } // Copy Constructor Defined Implicitly
}

The generation of the implicitly-defined copy constructor is deprecated if T has a user-defined destructor or user-defined copy assignment operator.

#include <iostream>
 
class  myclass
{
  public:
 int param;
 myclass()   // Default Constructor
 {
 };
 
 myclass(const myclass& ) // Copy Constructor
 {
 
 };
};
 
class my_otherclass : public myclass
{
 public:
 my_otherclass() : myclass() { }   // Implicitly-Defined Copy Constructor
 /*my_otherclass(const my_otherclass&)
 {
 };*/
};
 
int main()
{
 myclass class1;
 class1.param=100;
 
 std::cout << class1.param << '\n' ;
 
 // Using Implicitly-Defined Copy Constructor
 my_otherclass class2;
 my_otherclass class3(class2);
 
 std::cout << class3.param << '\n' ;
 
 getchar();
 return 0;
}