Diferentes formas de instanciar un objeto en C++ con ejemplos

requisito previo: clases y objetos de C++

Diferentes formas de instanciar un objeto

En C++, hay diferentes formas de instanciar objetos y uno de los métodos es usar Constructores. Estos son miembros de clases especiales a los que llama el compilador cada vez que se crea una instancia de un objeto de esa clase. Hay tres formas diferentes de instanciar un objeto a través de constructores:

1. A través de constructores predeterminados.
2. A través de constructores parametrizados.
3. A través de los constructores de copias.

1. A través del constructor predeterminado: se puede crear una instancia de un objeto a través de un constructor predeterminado de forma estática o dinámica. 

Sintaxis:

Duración de almacenamiento automático/ Inicialización estática 
classname objectname; 
Duración de almacenamiento dinámico/ Inicialización dinámica 
classname *objectname = new classname(); 
Eliminar objeto dinámico 
delete objectname;

A continuación se muestra el programa C++ para demostrar la creación de instancias de objetos a través del constructor predeterminado:

// C++ program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Defining class example
class example {
    int x;
 
public:
    void set(int x)
    {
        this->x = x;
        cout << "The value of x is: "
             << x << "\n";
    }
};
 
// Driver code
int main()
{
    // Creating automatic storage object
    example obj1;
    obj1.set(5);
 
    // Creating dynamic storage object
    example* obj2 = new example();
    obj2->set(10);
 
    // Explicitly deleting the obj2
    delete obj2;
 
    return 0;
}

Explicación:
en el código anterior, hay dos tipos de formas diferentes de instanciar un objeto :

1. ejemplo obj1: esta línea está instanciando un objeto que tiene una duración de almacenamiento automático. Este objeto se eliminará automáticamente cuando esté fuera del alcance.
2. ejemplo *obj2 = nuevo ejemplo(): Esta es la forma de instanciar un objeto que tiene una duración de almacenamiento dinámico. Este objeto no se eliminará automáticamente. El usuario tendrá que usar una declaración de eliminación explícita para eliminar el objeto.

eliminar obj2;

2. A través del constructor parametrizado:  la creación de instancias de objetos se puede realizar a través del constructor parametrizado de forma estática y dinámica. Es posible pasar argumentos a constructores parametrizados. Normalmente, estos argumentos ayudan a inicializar un objeto cuando se crea. 

Sintaxis: 

Inicialización estática 
1. classname objectname(parámetro); 
2. nombre de clase nombre de objeto = nombre de clase (parámetro); 
Nombre de clase de inicialización dinámica 
* nombre de objeto = nuevo nombre de clase (parámetro); 
Eliminar objeto dinámico 
delete objectname;

A continuación se muestra el programa C++ para demostrar el constructor parametrizado:

// C++ program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Defining the class example
class example {
    int x;
 
public:
    // Parameterized constructor
    example(int y)
    {
        x = y;
        cout << "The value of x is: "
             << x << "\n";
    }
};
 
// Driver code
int main()
{
    // Creating object with automatic
    // storage duration using Method 1
    example obj1(10);
 
    // Creating object with automatic
    // storage duration using Method 2
    example obj2 = example(8);
 
    // Creating object with dynamic
    // storage duration using Method 3
    example* obj3 = new example(20);
 
    delete obj3;
    return 0;
}

Explicación:
en el código anterior, hay tres formas de instanciar un objeto :

1. ejemplo obj1(10): esta línea está instanciando un objeto utilizando el constructor parametrizado que tiene una duración de almacenamiento automático. Este objeto se eliminará automáticamente cuando esté fuera del alcance.
2. ejemplo obj2 = ejemplo (8): esta línea está instanciando un objeto utilizando el constructor parametrizado que tiene una duración de almacenamiento automático. Este objeto se eliminará automáticamente cuando esté fuera del alcance.
3. ejemplo *obj3 = nuevo ejemplo(20): Esta es la forma de instanciar un objeto utilizando el constructor parametrizado que tiene una duración de almacenamiento dinámico. Este objeto no se eliminará automáticamente. El usuario tendrá que usar una declaración de eliminación explícita para eliminar el objeto.

3. Constructor de copias: se puede usar un constructor de copias para instanciar un objeto de forma estática o dinámica. La inicialización estática o dinámica de un objeto mediante un constructor de copia tiene el siguiente prototipo de función general: 

Sintaxis: 

Copiar 
ClassName Constructor (const ClassName &old_obj); 
Cree una instancia de un objeto utilizando el constructor de copias .  
Inicialización estática 
1. classname obj1; 
nombre de clase obj2 = obj1; 
2. nombre de clase obj1; 
nombre de clase obj2(obj1); 
Inicialización dinámica 
1. classname *obj1 = new classname(); 
nombre de clase *obj2 = nuevo nombre de clase(*obj1); 

A continuación se muestra el programa C++ para demostrar el constructor de copias: 

// C++ program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Defining the class
class example {
    int x;
 
public:
    // Parameterized constructor
    example(int y)
    {
        x = y;
        cout << "The value of x is: "
             << x << "\n";
    }
 
    // Copy constructor
    example(example& obj)
    {
        x = obj.x;
        cout << "The value of x in "
             << "copy constructor: "
             << x << "\n";
    };
};
 
// Driver code
int main()
{
    // Instantiating copy constructor
    // using Method 1
    example obj1(4);
    example obj2 = obj1;
 
    // Instantiating copy constructor
    // using Method 2
    example obj3(obj1);
 
    // Instantiating copy constructor
    // using Method 3
    example* obj4 = new example(10);
    example* obj5 = new example(*obj4);
 
    delete obj5;
    delete obj4;
    return 0;
}

 Explicación:
en el código anterior, hay tres formas de instanciar un objeto usando un constructor de copia :

1. Método 1:
   • ejemplo obj1(4): Esta línea está instanciando un objeto que tiene una duración de almacenamiento automático.
   • ejemplo obj2 = obj1: esta línea invoca al constructor de copia y crea un nuevo objeto obj2 que es una copia del objeto obj1.
2. Método 2:
   • ejemplo obj3(obj1): Esta línea invoca al constructor de copias y crea un nuevo objeto obj3 que es una copia del objeto obj1.
3. Método 3:
   • ejemplo *obj4 = nuevo ejemplo(10): Esta es la forma de instanciar un objeto que tiene duración de almacenamiento dinámico. Este objeto no se eliminará automáticamente. El usuario tendrá que usar una declaración de eliminación explícita para eliminar el objeto.
   • ejemplo *obj5 = nuevo ejemplo(*obj4): Esta línea invoca un constructor de copias y crea un nuevo objeto obj5 que es una copia del objeto obj4. El usuario tendrá que usar una declaración de eliminación explícita para eliminar el objeto.