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 [].
CPP
// 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.
CPP
// 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
CPP
#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
CPP
#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
CPP
#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 :
CPP
#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
CPP
#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.
CPP
#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
Publicación traducida automáticamente
Artículo escrito por Abhishek rajput y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA