Sobrecarga del operador Nuevo y Eliminar en c ++

Los operadores new y delete también se pueden sobrecargar como otros operadores en C++. Los operadores New y Delete se pueden sobrecargar globalmente o se pueden sobrecargar para clases específicas. 

• Si estos operadores están sobrecargados usando la función miembro para una clase, significa que estos operadores están sobrecargados solo para esa clase específica .
• Si la sobrecarga se realiza fuera de una clase (es decir, no es una función miembro de una clase), se llamará a ‘nuevo’ y ‘eliminar’ sobrecargados cada vez que haga uso de estos operadores (dentro de las clases o fuera de las clases). Esta es una sobrecarga global .

Sintaxis para sobrecargar el operador new: 

void* operator new(size_t size);

El nuevo operador sobrecargado recibe un tamaño de tipo size_t, que especifica el número de bytes de memoria que se asignarán. El tipo de retorno del nuevo sobrecargado debe ser nulo*. La función sobrecargada devuelve un puntero al comienzo del bloque de memoria asignado.
Sintaxis para sobrecargar el operador de eliminación:  

void operator delete(void*);

La función recibe un parámetro de tipo void* que debe eliminarse. La función no debería devolver nada. 
NOTA: Tanto las funciones sobrecargadas de operador nuevo como de eliminación son miembros estáticos de forma predeterminada. Por lo tanto, no tienen acceso a este puntero .
Sobrecarga del operador new y delete para una clase específica:

// CPP program to demonstrate
// Overloading new and delete operator
// for a specific class
#include<iostream>
#include<stdlib.h>
 
using namespace std;
class student
{
    string name;
    int age;
public:
    student()
    {
        cout<< "Constructor is called\n" ;
    }
    student(string name, int age)
    {
        this->name = name;
        this->age = age;
    }
    void display()
    {
        cout<< "Name:" << name << endl;
        cout<< "Age:" << age << endl;
    }
    void * operator new(size_t size)
    {
        cout<< "Overloading new operator with size: " << size << endl;
        void * p = ::operator new(size);
        //void * p = malloc(size); will also work fine
     
        return p;
    }
 
    void operator delete(void * p)
    {
        cout<< "Overloading delete operator " << endl;
        free(p);
    }
};
 
int main()
{
    student * p = new student("Yash", 24);
 
    p->display();
    delete p;
}

Overloading new operator with size: 40
Name:Yash
Age:24
Overloading delete operator 

NOTA: En la nueva función sobrecargada anterior, hemos asignado memoria dinámica a través de un nuevo operador, pero debería ser un nuevo operador global; de lo contrario, irá en recursión 
nula *p = nuevo estudiante(); // esto irá en recursión ya que new se sobrecargará una y otra vez 
void *p = ::nuevo estudiante(); // esto es correcto

Sobrecarga global del operador new y delete 

// CPP program to demonstrate
// Global overloading of
// new and delete operator
#include<iostream>
#include<stdlib.h>
 
using namespace std;
void * operator new(size_t size)
{
    cout << "New operator overloading " << endl;
    void * p = malloc(size);
    return p;
}
 
void operator delete(void * p)
{
    cout << "Delete operator overloading " << endl;
    free(p);
}
 
int main()
{
    int n = 5, i;
    int * p = new int[3];
 
    for (i = 0; i<n; i++)
    p[i]= i;
 
    cout << "Array: ";
    for(i = 0; i<n; i++)
        cout << p[i] << " ";
         
    cout << endl;
 
    delete [] p;
}

New operator overloading 
Array: 0 1 2 3 4 
Delete operator overloading 

NOTA: En el código anterior, en la nueva función sobrecargada no podemos asignar memoria usando ::new int[5] ya que irá en recursividad. Necesitamos asignar memoria usando malloc solamente.
 

¿Por qué sobrecargar new y delete? 

1. La nueva función de operador sobrecargada puede aceptar argumentos; por lo tanto, una clase puede tener múltiples funciones de operador nuevas sobrecargadas . Esto le da al programador más flexibilidad para personalizar la asignación de memoria para los objetos. Por ejemplo: 

void *operator new(size_t size, char c)
{
   void *ptr;
   ptr = malloc(size);
   if (ptr!=NULL)
      *ptr = c;
return ptr;
}
main()
{
   char *ch = new('#') char;
}

2. NOTA: El código no solo asignará memoria para un solo carácter, sino que también inicializará la memoria asignada con el carácter # . 

3. Los operadores new o delete sobrecargados también proporcionan recolección de elementos no utilizados para el objeto de la clase.

4. La rutina de manejo de excepciones se puede agregar en la nueva función de operador sobrecargada.

5. A veces desea que los operadores new y delete hagan algo personalizado que las versiones proporcionadas por el compilador no ofrecen . Por ejemplo, puede escribir una eliminación de operador personalizada que sobrescriba la memoria desasignada con ceros para aumentar la seguridad de los datos de la aplicación.

6. Podemos usar la función realloc() en la nueva función para reasignar la memoria dinámicamente.

7. El nuevo operador sobrecargado también permite a los programadores obtener un rendimiento adicional de sus programas. Por ejemplo, en una clase, para acelerar la asignación de nuevos Nodes, se mantiene una lista de Nodes eliminados para que su memoria pueda reutilizarse cuando se asignan nuevos Nodes. En este caso, el operador de eliminación sobrecargado agregará Nodes a la lista de Nodes eliminados y el nuevo operador sobrecargado asignará memoria de esta lista en lugar de del montón para acelerar la asignación de memoria. La memoria del montón se puede usar cuando la lista de Nodes eliminados está vacía.

Este artículo es una contribución de Yash Singla . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.