Operador new (C++)new Operator (C++)

Aloca memória para um objeto ou uma matriz de objetos do nome do tipo do repositório livre e retorna um ponteiro adequadamente tipado, diferente de zero para o objeto.Allocates memory for an object or array of objects of type-name from the free store and returns a suitably typed, nonzero pointer to the object.

Observação

Extensões de componentes do Microsoft C++ fornece suporte para o novo palavra-chave para adicionar entradas de slot a vtable.Microsoft C++ Component Extensions provides support for the new keyword to add vtable slot entries. Para obter mais informações, consulte novo (novo slot em vtable)For more information, see new (new slot in vtable)

SintaxeSyntax

[::] new [placement] new-type-name [new-initializer]
[::] new [placement] ( type-name ) [new-initializer]

ComentáriosRemarks

Caso contrário, novos retorna zero ou lança uma exceção, consulte o novo e excluir operadores para obter mais informações.If unsuccessful, new returns zero or throws an exception; see The new and delete Operators for more information. Você pode alterar esse comportamento padrão escrevendo uma rotina de manipulação de exceção personalizada e chamando o set_new_handler a função de biblioteca de tempo de execução com o nome de função como seu argumento.You can change this default behavior by writing a custom exception-handling routine and calling the _set_new_handler run-time library function with your function name as its argument.

Para obter informações sobre como criar um objeto no heap gerenciado, consulte gcnew.For information on how to create an object on the managed heap, see gcnew.

Quando novo é usado para alocar memória para um objeto de classe do C++, o construtor do objeto é chamado depois que a memória é alocada.When new is used to allocate memory for a C++ class object, the object's constructor is called after the memory is allocated.

Use o exclua operador para desalocar a memória alocada com o novo operador.Use the delete operator to deallocate the memory allocated with the new operator.

O exemplo a seguir aloca e depois libera uma matriz bidimensional de caracteres de tamanho dim por 10.The following example allocates and then frees a two-dimensional array of characters of size dim by 10. Ao alocar uma matriz multidimensional, todas as dimensões, exceto a primeira, devem ser expressões de constantes que são avaliadas como valores positivos; a dimensão mais à esquerda da matriz pode ser qualquer expressão que seja avaliada como um valor positivo.When allocating a multidimensional array, all dimensions except the first must be constant expressions that evaluate to positive values; the leftmost array dimension can be any expression that evaluates to a positive value. Ao alocar uma matriz usando o novos operador, a primeira dimensão pode ser zero — o novos operador retorna um ponteiro exclusivo.When allocating an array using the new operator, the first dimension can be zero — the new operator returns a unique pointer.

char (*pchar)[10] = new char[dim][10];
delete [] pchar;

O nome do tipo não pode conter const, volátil, declarações de classe nem declarações de enumeração.The type-name cannot contain const, volatile, class declarations, or enumeration declarations. Dessa forma, a expressão a seguir é inválida:Therefore, the following expression is illegal:

volatile char *vch = new volatile char[20];

O novo operador não aloca tipos de referência porque eles não são objetos.The new operator does not allocate reference types because they are not objects.

O novo operador não pode ser usado para alocar uma função, mas ele pode ser usado para alocar ponteiros para funções.The new operator cannot be used to allocate a function, but it can be used to allocate pointers to functions. O exemplo a seguir aloca e depois libera uma matriz de sete ponteiros para funções que retornam inteiros.The following example allocates and then frees an array of seven pointers to functions that return integers.

int (**p) () = new (int (*[7]) ());
delete *p;

Se você usar o operador novos sem qualquer argumento extra e compilar com o /GX, /EHa, ou /EHs opção, o compilador realizará Gerar código para chamar o operador excluir se o construtor gerará uma exceção.If you use the operator new without any extra arguments, and compile with the /GX, /EHa, or /EHs option, the compiler will generate code to call operator delete if the constructor throws an exception.

A lista a seguir descreve os elementos de gramática do novo:The following list describes the grammar elements of new:

placementplacement
Fornece uma maneira de passar argumentos adicionais se você sobrecarregar novo.Provides a way of passing additional arguments if you overload new.

type-nametype-name
Especifica o tipo a ser alocado; pode ser um tipo definido pelo usuário ou interno.Specifies type to be allocated; it can be either a built-in or user-defined type. Se a especificação de tipo for complicada, poderá ficar entre parênteses para forçar a ordem de associação.If the type specification is complicated, it can be surrounded by parentheses to force the order of binding.

initializerinitializer
Fornece um valor para o objeto inicializado.Provides a value for the initialized object. Não é possível especificar inicializadores para matrizes.Initializers cannot be specified for arrays. O novo operador criará matrizes de objetos somente se a classe tem um construtor padrão.The new operator will create arrays of objects only if the class has a default constructor.

ExemploExample

O exemplo de código a seguir aloca uma matriz de caracteres e um objeto da classe CName e depois os libera.The following code example allocates a character array and an object of class CName and then frees them.

// expre_new_Operator.cpp
// compile with: /EHsc
#include <string.h>

class CName {
public:
   enum {
      sizeOfBuffer = 256
   };

   char m_szFirst[sizeOfBuffer];
   char m_szLast[sizeOfBuffer];

public:
   void SetName(char* pszFirst, char* pszLast) {
     strcpy_s(m_szFirst, sizeOfBuffer, pszFirst);
     strcpy_s(m_szLast, sizeOfBuffer, pszLast);
   }

};

int main() {
   // Allocate memory for the array
   char* pCharArray = new char[CName::sizeOfBuffer];
   strcpy_s(pCharArray, CName::sizeOfBuffer, "Array of characters");

   // Deallocate memory for the array
   delete [] pCharArray;
   pCharArray = NULL;

   // Allocate memory for the object
   CName* pName = new CName;
   pName->SetName("Firstname", "Lastname");

   // Deallocate memory for the object
   delete pName;
   pName = NULL;
}

ExemploExample

Se você usar o formato do novos operador, o formulário com argumentos além do tamanho da alocação, o compilador não oferece suporte a um formulário de posicionamento da excluir operador se o construtor lança uma exceção.If you use the placement new form of the new operator, the form with arguments in addition to the size of the allocation, the compiler does not support a placement form of the delete operator if the constructor throws an exception. Por exemplo:For example:

// expre_new_Operator2.cpp
// C2660 expected
class A {
public:
   A(int) { throw "Fail!"; }
};
void F(void) {
   try {
      // heap memory pointed to by pa1 will be deallocated
      // by calling ::operator delete(void*).
      A* pa1 = new A(10);
   } catch (...) {
   }
   try {
      // This will call ::operator new(size_t, char*, int).
      // When A::A(int) does a throw, we should call
      // ::operator delete(void*, char*, int) to deallocate
      // the memory pointed to by pa2.  Since
      // ::operator delete(void*, char*, int) has not been implemented,
      // memory will be leaked when the deallocation cannot occur.

      A* pa2 = new(__FILE__, __LINE__) A(20);
   } catch (...) {
   }
}

int main() {
   A a;
}

Inicializando o objeto alocado com newInitializing object allocated with new

Um recurso opcional inicializador campo está incluído na gramática para o novos operador.An optional initializer field is included in the grammar for the new operator. Isso permite que os novos objetos sejam inicializados com construtores definidos pelo usuário.This allows new objects to be initialized with user-defined constructors. Para obter mais informações sobre como a inicialização é feita, consulte inicializadores.For more information about how initialization is done, see Initializers. O exemplo a seguir ilustra como usar uma expressão de inicialização com o novo operador:The following example illustrates how to use an initialization expression with the new operator:

// expre_Initializing_Objects_Allocated_with_new.cpp
class Acct
{
public:
    // Define default constructor and a constructor that accepts
    //  an initial balance.
    Acct() { balance = 0.0; }
    Acct( double init_balance ) { balance = init_balance; }
private:
    double balance;
};

int main()
{
    Acct *CheckingAcct = new Acct;
    Acct *SavingsAcct = new Acct ( 34.98 );
    double *HowMuch = new double ( 43.0 );
    // ...
}

Neste exemplo, o objeto CheckingAcct é alocado usando o nova operador, mas nenhuma inicialização padrão é especificado.In this example, the object CheckingAcct is allocated using the new operator, but no default initialization is specified. Portanto, o construtor padrão da classe, Acct(), é chamado.Therefore, the default constructor for the class, Acct(), is called. O objeto SavingsAcct é então alocado da mesma maneira, mas ele é inicializado explicitamente como 34,98.Then the object SavingsAcct is allocated the same way, except that it is explicitly initialized to 34.98. Como 34,98 é do tipo duplas, o construtor que usa um argumento desse tipo é chamado para manipular a inicialização.Because 34.98 is of type double, the constructor that takes an argument of that type is called to handle the initialization. Por fim, o tipo sem classe HowMuch é inicializado como 43,0.Finally, the nonclass type HowMuch is initialized to 43.0.

Se um objeto for de um tipo de classe e essa classe tiver construtores (como no exemplo anterior), o objeto pode ser inicializado com o novo operador somente se uma das seguintes condições for atendida:If an object is of a class type and that class has constructors (as in the preceding example), the object can be initialized by the new operator only if one of these conditions is met:

  • Os argumentos fornecidos no inicializador concordam com os de um construtor.The arguments provided in the initializer agree with those of a constructor.

  • A classe tem um construtor padrão (um construtor um que pode ser chamado sem argumentos).The class has a default constructor (a constructor that can be called with no arguments).

Nenhuma inicialização explícita por elemento pode ser feita ao alocar matrizes usando o novo operador; somente o construtor padrão, se estiver presente, é chamado.No explicit per-element initialization can be done when allocating arrays using the new operator; only the default constructor, if present, is called. Ver argumentos padrão para obter mais informações.See Default Arguments for more information.

Se a alocação de memória falhar (operador new retorna um valor de 0), nenhuma inicialização será executada.If the memory allocation fails (operator new returns a value of 0), no initialization is performed. Isso protege contra tentativas de inicialização de dados que não existem.This protects against attempts to initialize data that does not exist.

Assim como acontece com as chamadas de função, a ordem em que as expressões inicializadas são avaliadas não está definida.As with function calls, the order in which initialized expressions are evaluated is not defined. Além disso, você não deve confiar que essas expressões serão totalmente avaliadas antes que a alocação da memória seja executada.Furthermore, you should not rely on these expressions being completely evaluated before the memory allocation is performed. Se a alocação de memória falhar e o novo operador retorna zero, algumas expressões no inicializador não podem ser avaliados completamente.If the memory allocation fails and the new operator returns zero, some expressions in the initializer may not be completely evaluated.

Tempo de vida de objetos alocados com novoLifetime of objects allocated with new

Objetos alocados com o novo operador não são destruídos quando o escopo no qual eles são definidos é fechado.Objects allocated with the new operator are not destroyed when the scope in which they are defined is exited. Porque o novo operador retorna um ponteiro para os objetos que ele atribui, o programa deve definir um ponteiro com escopo apropriado para acessar esses objetos.Because the new operator returns a pointer to the objects it allocates, the program must define a pointer with suitable scope to access those objects. Por exemplo:For example:

// expre_Lifetime_of_Objects_Allocated_with_new.cpp
// C2541 expected
int main()
{
    // Use new operator to allocate an array of 20 characters.
    char *AnArray = new char[20];

    for( int i = 0; i < 20; ++i )
    {
        // On the first iteration of the loop, allocate
        //  another array of 20 characters.
        if( i == 0 )
        {
            char *AnotherArray = new char[20];
        }
    }

    delete [] AnotherArray; // Error: pointer out of scope.
    delete [] AnArray;      // OK: pointer still in scope.
}

Uma vez que o ponteiro AnotherArray sai do escopo no exemplo, o objeto não pode mais ser excluído.Once the pointer AnotherArray goes out of scope in the example, the object can no longer be deleted.

Como new funcionaHow new works

O alocação-expression — a expressão que contém o novos operador — faz três coisas:The allocation-expression — the expression containing the new operator — does three things:

  • Localiza e reserva o armazenamento para que o objeto ou objetos sejam alocados.Locates and reserves storage for the object or objects to be allocated. Quando essa fase for concluída, a quantidade correta de armazenamento é alocada, mas ela ainda não é um objeto.When this stage is complete, the correct amount of storage is allocated, but it is not yet an object.

  • Inicializa o(s) objeto(s).Initializes the object(s). Após a conclusão da inicialização, informações suficientes estão presentes para que o armazenamento alocado seja um objeto.Once initialization is complete, enough information is present for the allocated storage to be an object.

  • Retorna um ponteiro para o objeto (s) de um tipo de ponteiro derivado novo nome de tipo ou nome do tipo.Returns a pointer to the object(s) of a pointer type derived from new-type-name or type-name. O programa usa esse ponteiro para acessar o objeto recentemente alocado.The program uses this pointer to access the newly allocated object.

O novos operador invoca a função operador new.The new operator invokes the function operator new. Para matrizes de qualquer tipo e para objetos que não são do classe, struct, ou união tipos, uma função global, :: operador new, é chamado para alocar o armazenamento.For arrays of any type, and for objects that are not of class, struct, or union types, a global function, ::operator new, is called to allocate storage. Objetos de tipo de classe podem definir seus próprios operador new função de membro estático em uma base por classe.Class-type objects can define their own operator new static member function on a per-class basis.

Quando o compilador encontra a novos operador para alocar um objeto do tipo tipo, ele emite uma chamada para type :: operador new (sizeof ( type )) ou, se não definido pelo usuário operador new estiver definido, :: operador new (sizeof ( type )).When the compiler encounters the new operator to allocate an object of type type, it issues a call to type::operator new( sizeof( type ) ) or, if no user-defined operator new is defined, ::operator new( sizeof( type ) ). Portanto, o novo operador pode alocar a quantidade correta de memória para o objeto.Therefore, the new operator can allocate the correct amount of memory for the object.

Observação

O argumento operador new é do tipo size_t.The argument to operator new is of type size_t. Esse tipo é definido em <Direct. h >, <malloc >, <h >, <Search. h >, <stddef. h >, <stdio. h >, <stdlib. h >, <String. h >, e <time. h >.This type is defined in <direct.h>, <malloc.h>, <memory.h>, <search.h>, <stddef.h>, <stdio.h>, <stdlib.h>, <string.h>, and <time.h>.

Uma opção na gramática permite a especificação de posicionamento (consulte a gramática do operador new).An option in the grammar allows specification of placement (see the Grammar for new Operator). O posicionamento parâmetro pode ser usado apenas para implementações definidas pelo usuário operador new; ele permite que informações adicionais a serem passados para operador new.The placement parameter can be used only for user-defined implementations of operator new; it allows extra information to be passed to operator new. Uma expressão com um posicionamento campo, como T *TObject = new ( 0x0040 ) T; é convertido para T *TObject = T::operator new( sizeof( T ), 0x0040 ); se a classe T tiver o operador de membro novo, caso contrário, a T *TObject = ::operator new( sizeof( T ), 0x0040 );.An expression with a placement field such as T *TObject = new ( 0x0040 ) T; is translated to T *TObject = T::operator new( sizeof( T ), 0x0040 ); if class T has member operator new, otherwise to T *TObject = ::operator new( sizeof( T ), 0x0040 );.

A intenção original do posicionamento campo era permitir que os objetos dependentes de hardware a ser alocado em endereços especificados pelo usuário.The original intention of the placement field was to allow hardware-dependent objects to be allocated at user-specified addresses.

Observação

Embora o exemplo anterior mostra apenas um argumento na posicionamento campo, não há nenhuma restrição de quantos argumentos extras podem ser passados para operador new dessa maneira.Although the preceding example shows only one argument in the placement field, there is no restriction on how many extra arguments can be passed to operator new this way.

Mesmo quando operador new foi definido para um tipo de classe, o operador global pode ser usado com o formulário deste exemplo:Even when operator new has been defined for a class type, the global operator can be used by using the form of this example:

T *TObject =::new TObject;

O operador de resolução de escopo (::) força o uso do global nova operador.The scope-resolution operator (::) forces use of the global new operator.

Consulte tambémSee also

Expressões com operadores unáriosExpressions with Unary Operators
Palavras-chaveKeywords
novo e excluir operadoresnew and delete operators