eliminar palabra clave en C++

Eliminar es un operador que se utiliza para destruir objetos de array y no array (puntero) que se crean mediante una nueva expresión.
 

• Eliminar se puede utilizar mediante el operador Eliminar o el operador Eliminar [ ]
• El operador nuevo se usa para la asignación de memoria dinámica que coloca las variables en la memoria del montón.
• Lo que significa que el operador Eliminar desasigna memoria del montón.
• El puntero al objeto no se destruye, el valor o el bloque de memoria señalado por el puntero se destruye.
• El operador de eliminación tiene un tipo de retorno nulo y no devuelve un valor.

Aquí, a continuación, hay ejemplos en los que podemos aplicar el operador de eliminación:
1. Eliminación de objetos de array : eliminamos una array usando corchetes [].

// Program to illustrate deletion of array
#include <bits/stdc++.h>
using namespace std;
 
int main()
{
    // Allocate Heap memory
    int* array = new int[10];
     
    // Deallocate Heap memory
    delete[] array;
 
    return 0;
}

2. Eliminación del puntero NULL : Eliminar un NULL no provoca ningún cambio ni error.

// C++ program to deleting
// NULLL pointer
#include <bits/stdc++.h>
using namespace std;
 
int main()
{
    // ptr is NULL pointer
    int* ptr = NULL;
 
    // deleting ptr
    delete ptr;
 
    return 0;
}

3. Eliminar puntero con o sin valor

#include <bits/stdc++.h>
using namespace std;
 
int main()
{
    // Creating int pointer
    int* ptr1 = new int;
     
    // Initializing pointer with value 20
    int* ptr2 = new int(20);
 
    cout << "Value of ptr1 = " << *ptr1 << "\n";
    cout << "Value of ptr2 = " << *ptr2 << "\n";
 
    delete ptr1; // Destroying ptr1
    delete ptr2; // Destroying ptr2
 
    return 0;
}

Producción: 

Value of ptr1 = 0
Value of ptr2 = 20

4. Eliminación de un puntero vacío

#include <bits/stdc++.h>
using namespace std;
int main()
{
    void* ptr; // Creating void pointer
 
    delete ptr; // Destroying void pointer
 
    cout << "ptr deleted successfully";
    return 0;
}

Salida :  

ptr deleted successfully

5. borrar la memoria asignada dinámicamente por malloc 

#include <bits/stdc++.h>
using namespace std;
 
int main()
{
    // Dynamic memory allocated by using malloc
    int* ptr2 = (int*)malloc(sizeof(int));
 
    delete ptr2;
 
    cout << "ptr2 deleted successfully";
 
    return 0;
}

Salida :  

ptr2 deleted successfully

Aunque el programa anterior funciona bien en GCC. No se recomienda usar delete con malloc().
6. Eliminación de variables de tipos de datos definidos por el usuario :

#include <bits/stdc++.h>
using namespace std;
 
struct P {
    static void operator delete(void* ptr, std::size_t sz)
    {
        cout << "custom delete for size " << sz <<endl;
        delete (ptr); // ::operator delete(ptr) can also be used
    }
    static void operator delete[](void* ptr, std::size_t sz)
    {
        cout << "custom delete for size " << sz <<endl;
        delete (ptr); // ::operator delete(ptr) can also be used
    }
};
 
int main()
{
    P* var1 = new P;
    delete var1;
 
    P* var2 = new P[10];
    delete[] var2;
}

Salida :  

custom delete for size 1
custom delete for size 18

Excepciones :
1. Intentar eliminar un objeto que no sea un puntero

#include <bits/stdc++.h>
using namespace std;
 
int main()
{
    int x;
 
    // Delete operator always
    // requires pointer as input
    delete x;
 
    return 0;
}

Salida :  

error: type ‘int’ argument given to ‘delete’, expected pointer

2. Intentar eliminar el puntero a una variable asignada de la pila local. 

#include <bits/stdc++.h>
using namespace std;
 
int main()
{
    int x;
    int* ptr1 = &x;
 
    // x is present on stack frame as
    // local variable, only dynamically
    // allocated variables can be destroyed
    // using delete operator
    delete ptr1;
 
    return 0;
}

Salida : 

Runtime error