Eliminación de array de objetos en C++

Necesidad de eliminación del objeto :

• Para evitar pérdidas de memoria , como cuando un objeto se crea dinámicamente usando new , ocupa memoria en la sección Heap .
• Si los objetos no se eliminan explícitamente, el programa se bloqueará durante el tiempo de ejecución.

Programa 1: Cree un objeto de la clase que se crea dinámicamente usando el operador nuevo y eliminándolo explícitamente usando el operador de eliminación :

// C++ program to create an object
// dynamically and  delete explicitly
#include <iostream>
using namespace std;
  
// Class
class Student {
  
public:
    // Constructor
    Student()
    {
        cout << "Constructor is called!\n";
    }
  
    // Destructor
    ~Student()
    {
        cout << "Destructor is called!\n";
    }
  
    // Function to display the message
    void write()
    {
        cout << "Writing!\n";
    }
};
  
// Driver Code
int main()
{
    // Create an array of objects
    Student* student = new Student();
  
    // Function Call to write()
    // using instance
    student->write();
  
    // De-allocate the memory
    // explicitly
    delete student;
  
    return 0;
}

Constructor is called!
Writing!
Destructor is called!

Programa 2: Cree una array de objetos usando el operador new dinámicamente. Cada vez que se crea una array del objeto de una clase en tiempo de ejecución, es responsabilidad del programador eliminarlo y evitar una pérdida de memoria:

// C++ program to create an array of
// objects and deleting it explicitly
#include <iostream>
using namespace std;
  
// Class
class Student {
  
public:
    // Constructor
    Student()
    {
        cout << "Constructor is called!\n";
    }
  
    // Destructor
    ~Student()
    {
        cout << "Destructor is called!\n";
    }
  
    // Function to display message
    void write()
    {
        cout << "Writing!\n";
    }
};
  
// Driver Code
int main()
{
    // Create an array of the object
    // dynamically
    Student* student = new Student[3];
  
    // Function Call to write()
    student[0].write();
    student[1].write();
    student[2].write();
  
    // De-allocate the memory
    // explicitly
    delete[] student;
  
    return 0;
}

Constructor is called!
Constructor is called!
Constructor is called!
Writing!
Writing!
Writing!
Destructor is called!
Destructor is called!
Destructor is called!

Programa 3:

A continuación se muestra el programa donde se usa delete para eliminar una array de objetos :

// C++ program to delete array of
// objects
#include <iostream>
using namespace std;
  
// Class
class Student {
  
public:
    // Constructor
    Student()
    {
        cout << "Constructor is called!\n";
    }
  
    // Destructor
    ~Student()
    {
        cout << "Destructor is called!\n";
    }
  
    // Function to display message
    void write()
    {
        cout << "Writing!\n";
    }
};
  
// Driver Code
int main()
{
    // Create an object dynamically
    Student* student = new Student[3];
  
    // Function call to write()
    student[0].write();
    student[1].write();
    student[2].write();
  
    // De-allocate the memory
    // explicitly
    delete student;
  
    return 0;
}

Explicación: este programa fallará en tiempo de ejecución. En este programa, los constructores funcionan correctamente, pero el destructor se ejecuta solo para el primer objeto, y después de ese programa se bloquea en tiempo de ejecución debido a una pérdida de memoria. Es porque se crean 3 objetos en tiempo de ejecución, pero solo un objeto se elimina explícitamente y es por eso que los dos objetos restantes fallan en tiempo de ejecución.

Conclusión :
en C++ , el único objeto de la clase que se crea en tiempo de ejecución con un operador nuevo se elimina con el operador de eliminación , mientras que la array de objetos se elimina con el operador eliminar[] para que no se produzca una pérdida de memoria.