Operadores new y deletenew and delete operators

C++ admite la asignación y desasignación dinámica de objetos mediante new los delete operadores y.C++ supports dynamic allocation and deallocation of objects using the new and delete operators. Estos operadores asignan memoria para los objetos de un conjunto denominado almacén libre.These operators allocate memory for objects from a pool called the free store. El new operador llama a la función especial operator new y el delete operador llama a la función especial operator delete .The new operator calls the special function operator new, and the delete operator calls the special function operator delete.

La new función de la biblioteca estándar de c++ admite el comportamiento especificado en el estándar de c++, que consiste en iniciar una std::bad_alloc excepción si se produce un error en la asignación de memoria.The new function in the C++ Standard Library supports the behavior specified in the C++ standard, which is to throw a std::bad_alloc exception if the memory allocation fails. Si todavía desea la versión de no lanzamiento de new , vincule el programa con nothrownew.obj .If you still want the non-throwing version of new, link your program with nothrownew.obj. Sin embargo, cuando se vincula con nothrownew.obj , el valor predeterminado operator new de la biblioteca estándar de C++ ya no funciona.However, when you link with nothrownew.obj, the default operator new in the C++ Standard Library no longer functions.

Para obtener una lista de los archivos de biblioteca de la biblioteca en tiempo de ejecución de C y la biblioteca estándar de C++, vea características de la biblioteca CRT.For a list of the library files in the C Runtime Library and the C++ Standard Library, see CRT Library Features.

new Operador The new operator

El compilador traduce una instrucción como esta a una llamada a la función operator new :The compiler translates a statement such as this one into a call to the function operator new:

char *pch = new char[BUFFER_SIZE];

Si la solicitud es para cero bytes de almacenamiento, operator new devuelve un puntero a un objeto distinto.If the request is for zero bytes of storage, operator new returns a pointer to a distinct object. Es decir, las llamadas repetidas para operator new devolver distintos punteros.That is, repeated calls to operator new return different pointers. Si no hay memoria suficiente para la solicitud de asignación, se operator new produce una std::bad_alloc excepción.If there's insufficient memory for the allocation request, operator new throws a std::bad_alloc exception. O bien, devuelve nullptr si se ha vinculado en soporte de no generación operator new .Or, it returns nullptr if you've linked in non-throwing operator new support.

Puede escribir una rutina que intente liberar memoria y reintentar la asignación.You can write a routine that attempts to free memory and retry the allocation. Para obtener más información, vea _set_new_handler.For more information, see _set_new_handler. Para más información sobre el esquema de recuperación, consulte la sección control de la memoria insuficiente .For details on the recovery scheme, see the Handling insufficient memory section.

Los dos ámbitos de las operator new funciones se describen en la tabla siguiente.The two scopes for operator new functions are described in the following table.

Ámbito de operator new las funcionesScope for operator new functions

OperadorOperator ÁmbitoScope
::operator new GlobalGlobal
nombre de clase***::operator new*class-name ::operator new ClaseClass

El primer argumento operator new de debe ser de tipo size_t , definido en <stddef.h> , y el tipo de valor devuelto siempre es void* .The first argument to operator new must be of type size_t, defined in <stddef.h>, and the return type is always void*.

operator new Se llama a la función global cuando new se usa el operador para asignar objetos de tipos integrados, objetos de tipo de clase que no contienen funciones definidas por el usuario operator new y matrices de cualquier tipo.The global operator new function is called when the new operator is used to allocate objects of built-in types, objects of class type that don't contain user-defined operator new functions, and arrays of any type. Cuando el new operador se usa para asignar objetos de un tipo de clase donde operator new se define, operator new se llama a la clase.When the new operator is used to allocate objects of a class type where an operator new is defined, that class's operator new is called.

Una operator new función definida para una clase es una función miembro estática (que no puede ser virtual) que oculta la operator new función global para los objetos de ese tipo de clase.An operator new function defined for a class is a static member function (which can't be virtual) that hides the global operator new function for objects of that class type. Considere el caso en el que new se usa para asignar y establecer la memoria en un valor determinado:Consider the case where new is used to allocate and set memory to a given value:

#include <malloc.h>
#include <memory.h>

class Blanks
{
public:
    Blanks(){}
    void *operator new( size_t stAllocateBlock, char chInit );
};
void *Blanks::operator new( size_t stAllocateBlock, char chInit )
{
    void *pvTemp = malloc( stAllocateBlock );
    if( pvTemp != 0 )
        memset( pvTemp, chInit, stAllocateBlock );
    return pvTemp;
}
// For discrete objects of type Blanks, the global operator new function
// is hidden. Therefore, the following code allocates an object of type
// Blanks and initializes it to 0xa5
int main()
{
   Blanks *a5 = new(0xa5) Blanks;
   return a5 != 0;
}

El argumento proporcionado entre paréntesis en new se pasa a Blanks::operator new como chInit argumento.The argument supplied in parentheses to new is passed to Blanks::operator new as the chInit argument. Sin embargo, la operator new función global está oculta, lo que hace que el código como el siguiente genere un error:However, the global operator new function is hidden, causing code such as the following to generate an error:

Blanks *SomeBlanks = new Blanks;

El compilador admite la matriz new de miembros y los delete operadores en una declaración de clase.The compiler supports member array new and delete operators in a class declaration. Por ejemplo:For example:

class MyClass
{
public:
   void * operator new[] (size_t)
   {
      return 0;
   }
   void   operator delete[] (void*)
   {
   }
};

int main()
{
   MyClass *pMyClass = new MyClass[5];
   delete [] pMyClass;
}

Controlar la memoria insuficienteHandling insufficient memory

Las pruebas de asignación de memoria con errores se pueden realizar como se muestra aquí:Testing for failed memory allocation can be done as shown here:

#include <iostream>
using namespace std;
#define BIG_NUMBER 100000000
int main() {
   int *pI = new int[BIG_NUMBER];
   if( pI == 0x0 ) {
      cout << "Insufficient memory" << endl;
      return -1;
   }
}

Hay otra manera de controlar las solicitudes de asignación de memoria con error.There's another way to handle failed memory allocation requests. Escriba una rutina de recuperación personalizada para controlar este tipo de error y, a continuación, registre la función mediante una llamada a la _set_new_handler función en tiempo de ejecución.Write a custom recovery routine to handle such a failure, then register your function by calling the _set_new_handler run-time function.

delete Operador The delete operator

La memoria que se asigna dinámicamente mediante el new operador se puede liberar mediante el delete operador.Memory that is dynamically allocated using the new operator can be freed using the delete operator. El operador Delete llama a la operator delete función, que libera la memoria de nuevo en el Grupo disponible.The delete operator calls the operator delete function, which frees memory back to the available pool. El uso del delete operador también hace que se llame al destructor de clase (si existe).Using the delete operator also causes the class destructor (if one exists) to be called.

Hay funciones globales y de ámbito de clase operator delete .There are global and class-scoped operator delete functions. Solo operator delete se puede definir una función para una clase determinada; si se define, oculta la función global operator delete .Only one operator delete function can be defined for a given class; if defined, it hides the global operator delete function. operator delete Siempre se llama a la función global para matrices de cualquier tipo.The global operator delete function is always called for arrays of any type.

Función global operator delete .The global operator delete function. Existen dos formas para las operator delete funciones globales y de miembro de clase operator delete :Two forms exist for the global operator delete and class-member operator delete functions:

void operator delete( void * );
void operator delete( void *, size_t );

Solo una de las dos formas anteriores puede estar presente para una clase determinada.Only one of the preceding two forms can be present for a given class. La primera forma toma un solo argumento de tipo void * , que contiene un puntero al objeto que se va a desasignar.The first form takes a single argument of type void *, which contains a pointer to the object to deallocate. La segunda forma, la desasignación de tamaño, toma dos argumentos: el primero es un puntero al bloque de memoria que se va a desasignar y el segundo es el número de bytes que se van a desasignar.The second form, sized deallocation, takes two arguments: the first is a pointer to the memory block to deallocate, and the second is the number of bytes to deallocate. El tipo de valor devuelto de ambos formularios es void ( operator delete no se puede devolver un valor).The return type of both forms is void (operator delete can't return a value).

La intención del segundo formulario es acelerar la búsqueda de la categoría de tamaño correcto del objeto que se va a eliminar.The intent of the second form is to speed up searching for the correct size category of the object to delete. Esta información no suele almacenarse cerca de la propia asignación y es probable que no esté almacenada en caché.This information often isn't stored near the allocation itself, and is likely uncached. La segunda forma resulta útil cuando operator delete se usa una función de una clase base para eliminar un objeto de una clase derivada.The second form is useful when an operator delete function from a base class is used to delete an object of a derived class.

La operator delete función es estática, por lo que no puede ser virtual.The operator delete function is static, so it can't be virtual. La operator delete función obedece el control de acceso, como se describe en Access Control de miembro.The operator delete function obeys access control, as described in Member-Access Control.

En el ejemplo siguiente se muestran las funciones y definidas por el usuario operator new operator delete diseñadas para registrar asignaciones y desasignaciones de memoria:The following example shows user-defined operator new and operator delete functions designed to log allocations and deallocations of memory:

#include <iostream>
using namespace std;

int fLogMemory = 0;      // Perform logging (0=no; nonzero=yes)?
int cBlocksAllocated = 0;  // Count of blocks allocated.

// User-defined operator new.
void *operator new( size_t stAllocateBlock ) {
   static int fInOpNew = 0;   // Guard flag.

   if ( fLogMemory && !fInOpNew ) {
      fInOpNew = 1;
      clog << "Memory block " << ++cBlocksAllocated
          << " allocated for " << stAllocateBlock
          << " bytes\n";
      fInOpNew = 0;
   }
   return malloc( stAllocateBlock );
}

// User-defined operator delete.
void operator delete( void *pvMem ) {
   static int fInOpDelete = 0;   // Guard flag.
   if ( fLogMemory && !fInOpDelete ) {
      fInOpDelete = 1;
      clog << "Memory block " << cBlocksAllocated--
          << " deallocated\n";
      fInOpDelete = 0;
   }

   free( pvMem );
}

int main( int argc, char *argv[] ) {
   fLogMemory = 1;   // Turn logging on
   if( argc > 1 )
      for( int i = 0; i < atoi( argv[1] ); ++i ) {
         char *pMem = new char[10];
         delete[] pMem;
      }
   fLogMemory = 0;  // Turn logging off.
   return cBlocksAllocated;
}

El código anterior se puede usar para detectar "fugas de memoria", es decir, la memoria que se asigna en el almacén libre pero que nunca se libera.The preceding code can be used to detect "memory leakage", that is, memory that's allocated on the free store but never freed. Para detectar pérdidas, new delete se han redefinido los operadores global y para contar la asignación y desasignación de memoria.To detect leaks, the global new and delete operators are redefined to count allocation and deallocation of memory.

El compilador admite la matriz new de miembros y los delete operadores en una declaración de clase.The compiler supports member array new and delete operators in a class declaration. Por ejemplo:For example:

// spec1_the_operator_delete_function2.cpp
// compile with: /c
class X  {
public:
   void * operator new[] (size_t) {
      return 0;
   }
   void operator delete[] (void*) {}
};

void f() {
   X *pX = new X[5];
   delete [] pX;
}