Inicialización dinámica de objeto en C++

En este artículo, discutiremos la inicialización dinámica de objetos usando constructores dinámicos .

• La inicialización dinámica del objeto se refiere a la inicialización de los objetos en tiempo de ejecución, es decir, el valor inicial de un objeto se proporciona durante el tiempo de ejecución.
• Se puede lograr usando constructores y pasando parámetros a los constructores .
• Esto es realmente útil cuando hay varios constructores de la misma clase con diferentes entradas.

Constructor dinámico:

• El constructor utilizado para asignar la memoria en tiempo de ejecución se conoce como constructor dinámico .
• La memoria se asigna en tiempo de ejecución con un operador nuevo y, de manera similar, la memoria se desasigna en tiempo de ejecución con el operador de eliminación .

Asignación dinámica : 

Acercarse:

1. En el siguiente ejemplo, new se usa para inicializar dinámicamente la variable en el constructor predeterminado y la memoria se asigna en el montón .
2. Los objetos de la clase geek llaman a la función y muestra el valor de la variable asignada dinámicamente, es decir, ptr.

A continuación se muestra el programa para la inicialización dinámica del objeto utilizando el operador nuevo :

// C++ program for dynamic allocation
#include <iostream>
using namespace std;
 
class geeks {
    int* ptr;
 
public:
    // Default constructor
    geeks()
    {
        // Dynamically initializing ptr
        // using new
        ptr = new int;
        *ptr = 10;
    }
 
    // Function to display the value
    // of ptr
    void display()
    {
        cout << *ptr << endl;
    }
};
 
// Driver Code
int main()
{
    geeks obj1;
 
    // Function Call
    obj1.display();
 
    return 0;
}

10

Desasignación dinámica :
Enfoque:

1. En el siguiente código, se usa eliminar para liberar dinámicamente la memoria.
2. El contenido de obj1 se sobrescribe en el objeto obj2 usando el operador de asignación , luego obj1 se desasigna usando el operador de eliminación .

A continuación se muestra el código para la desasignación dinámica de la memoria utilizando el operador de eliminación .

// C++ program to dynamically
// deallocating the memory
#include <iostream>
using namespace std;
 
class geeks {
    int* ptr;
 
public:
    // Default constructor
    geeks()
    {
        ptr = new int;
        *ptr = 10;
    }
 
    // Function to display the value
    void display()
    {
        cout << "Value: " << *ptr
             << endl;
    }
};
 
// Driver Code
int main()
{
    // Dynamically allocating memory
    // using new operator
    geeks* obj1 = new geeks();
    geeks* obj2 = new geeks();
 
    // Assigning obj1 to obj2
    obj2 = obj1;
 
    // Function Call
    obj1->display();
    obj2->display();
 
    // Dynamically deleting the memory
    // allocated to obj1
    delete obj1;
 
    return 0;
}

Value: 10
Value: 10

A continuación, el programa C++ demuestra la inicialización dinámica de objetos y el cálculo del depósito bancario:

// C++ program to illustrate the dynamic
// initialization as memory is allocated
// to the object
#include <iostream>
using namespace std;
 
class bank {
    int principal;
    int years;
    float interest;
    float returnvalue;
 
public:
    // Default constructor
    bank() {}
 
    // Parameterized constructor to
    // calculate interest(float)
    bank(int p, int y, float i)
    {
        principal = p;
        years = y;
        interest = i/100;
        returnvalue = principal;
        cout << "\nDeposited amount (float):";
 
        // Finding the interest amount
        for (int i = 0; i < years; i++) {
            returnvalue = returnvalue
                          * (1 + interest);
        }
    }
 
    // Parameterized constructor to
    // calculate interest(integer)
    bank(int p, int y, int i)
    {
        principal = p;
        years = y;
        interest = float(i)/100;
        returnvalue = principal;
        cout << "\nDeposited amount"
             << " (integer):";
 
        // Find the interest amount
        for (int i = 0; i < years; i++) {
            returnvalue = returnvalue
                          * (1 + interest);
        }
    }
 
    // Display function
    void display(void)
    {
        cout << returnvalue
             << endl;
    }
};
 
// Driver Code
int main()
{
    // Variable initialization
    int p = 200;
    int y = 2;
    int I = 5;
    float i = 2.25;
 
    // Object is created with
    // float parameters
    bank b1(p, y, i);
 
    // Function Call with object
    // of class
    b1.display();
 
    // Object is created with
    // integer parameters
    bank b2(p, y, I);
 
    // Function Call with object
    // of class
    b2.display();
 
    return 0;
}

Producción:

Deposited amount (float):209.101

Deposited amount (integer):220.5