¿Cuándo crea el compilador constructores predeterminados y de copia en C++?

Un constructor es un tipo especial de función miembro de una clase que inicializa objetos de una clase. En C++, Constructor se llama automáticamente cuando se crea un objeto (instancia de una clase). Hay 3 tipos de constructores en C++

• Constructor predeterminado
• Copiar constructor
• Constructor parametrizado

En C++, el compilador crea un constructor predeterminado si no definimos nuestro propio constructor. En C++, el constructor predeterminado creado por el compilador tiene un cuerpo vacío, es decir, no asigna valores predeterminados a los miembros de datos. Sin embargo, en Java, los constructores predeterminados asignan valores predeterminados.

Sintaxis:

    Class_name()

Es posible pasar argumentos a los constructores en forma de un constructor parametrizado . Normalmente, estos argumentos ayudan a inicializar un objeto cuando se crea. Para crear un constructor parametrizado, agréguele parámetros como lo haría con cualquier otra función. Cuando defina el cuerpo del constructor, use los parámetros para inicializar el objeto 

Sintaxis:

    Class_name(Parameters)

El compilador también crea un constructor de copia si no escribimos nuestro propio constructor de copia. A diferencia del constructor predeterminado, el cuerpo del constructor de copia creado por el compilador no está vacío, copia todos los miembros de datos del objeto pasado al objeto que se está creando.

Sintaxis:

    Class_name(const Class_name& object)

¿Qué sucede cuando escribimos solo un constructor de copia? ¿El compilador crea un constructor predeterminado?
 
El compilador no crea un constructor predeterminado si escribimos cualquier constructor, incluso si es un constructor de copia. Por ejemplo, el siguiente programa no compila. 

// C++ Program to demonstrate what
// happens when we write
// only a copy constructor
#include <iostream>
using namespace std;
  
class Point {
    int x, y;
  
public:
    Point(const Point& p) // Copy Constructor
    {
        x = p.x;
        y = p.y;
    }
};
  
int main()
{
    Point p1;
    // Compiler Error
    Point p2 = p1;
    return 0;
}

Producción:

Compiler Error: no matching function for call to 'Point::Point()

¿Qué sucede cuando escribimos un constructor normal y no escribimos un constructor de copia?

El compilador crea un constructor de copia si no escribimos el nuestro. El compilador lo crea incluso si hemos escrito otros constructores en una clase. Por ejemplo, el siguiente programa funciona bien. 

// CPP Program to demonstrate what happens when we write a
// normal constructor and don't write a copy constructor
#include <iostream>
using namespace std;
  
class Point {
    int x, y;
  
public:
    Point(int i, int j)
    {
        x = 10;
        y = 20;
    }
    int getX() { return x; }
    int getY() { return y; }
};
  
int main()
{
    Point p1(10, 20);
    Point p2 = p1; // This compiles fine
    cout << "x = " << p2.getX() << " y = " << p2.getY();
    return 0;
}

x = 10 y = 20

Por lo tanto, necesitamos escribir un constructor de copia solo cuando tenemos punteros o asignación de recursos en tiempo de ejecución como identificador de archivo, una conexión de red, etc.

Debe leer:

• ¿Cuándo deberíamos escribir nuestro propio constructor de copias?
• ¿El compilador de C++ crea un constructor predeterminado cuando escribimos el nuestro?