operadores delete vs delete [] em C ++

Qual é a diferença entre deletee delete[]operadores em C ++?

O deleteoperador desaloca a memória e chama o destruidor para um único objeto criado com new.

O delete []operador desaloca a memória e chama destruidores para uma matriz de objetos criados new [].

O uso deletede um ponteiro retornado por new []ou delete []em um ponteiro retornado newresulta em comportamento indefinido.

O delete[]operador é usado para excluir matrizes. O deleteoperador é usado para excluir objetos que não são da matriz. Ele chama operator delete[]e operator deletefunciona, respectivamente, para excluir a memória que o objeto da matriz ou não matriz ocupou após (eventualmente) chamar os destruidores dos elementos da matriz ou do objeto que não é da matriz.

O seguinte mostra as relações:

typedef int array_type[1];

// create and destroy a int[1]
array_type *a = new array_type;
delete [] a;

// create and destroy an int
int *b = new int;
delete b;

// create and destroy an int[1]
int *c = new int[1];
delete[] c;

// create and destroy an int[1][2]
int (*d)[2] = new int[1][2];
delete [] d;

Para o newque cria uma matriz (portanto, new type[]ou newaplicada a uma construção de tipo de matriz), o Padrão procura um operator new[]na classe de tipo de elemento da matriz ou no escopo global e passa a quantidade de memória solicitada. Ele pode solicitar mais do N * sizeof(ElementType)que deseja (por exemplo, armazenar o número de elementos, portanto, mais tarde, ao excluir, sabe quantas chamadas de destruidor devem ser feitas). Se a classe declarar operator new[]que um adicional à quantidade de memória aceita outro size_t, esse segundo parâmetro receberá o número de elementos alocados - poderá usá-lo para qualquer finalidade que desejar (depuração, etc ...).

Para o newque cria um objeto que não é de matriz, ele procurará um operator newna classe do elemento ou no escopo global. Passa a quantidade de memória solicitada (exatamente sizeof(T)sempre).

Para o delete[], ele examina o tipo de classe de elemento dos arrays e chama seus destruidores. A operator delete[]função usada é a da classe do tipo de elemento ou, se não houver, no escopo global.

Para o delete, se o ponteiro passado é uma classe base do tipo de objeto real, a classe base deve ter um destruidor virtual (caso contrário, o comportamento é indefinido). Se não for uma classe base, o destruidor dessa classe será chamado e um operator deletenessa classe ou no global operator deleteserá usado. Se uma classe base foi aprovada, o destruidor do tipo de objeto real é chamado e o operator deleteencontrado nessa classe é usado, ou, se não houver, um global operator deleteé chamado. Se o operator deletena classe tiver um segundo parâmetro do tipo size_t, ele receberá o número de elementos a serem desalocados.

Esse é o uso básico do padrão alocar / DE-alocar em c ++ malloc/ free,new / delete, new[]/delete[]

Precisamos usá-los correspondentemente. Mas eu gostaria de acrescentar esse entendimento específico para a diferença entre deleteedelete[]

1) delete é usado para desalocar a memória alocada para um único objeto

2) delete[]é usado para desalocar a memória alocada para a matriz de objetos

class ABC{}

ABC *ptr = new ABC[100]

quando dizemos new ABC[100] , o compilador pode obter as informações sobre quantos objetos precisam ser alocados (aqui é 100) e chamará o construtor para cada um dos objetos criados

mas correspondentemente se simplesmente usarmos delete ptr nesse caso, o compilador não saberá quantos objetos ptrestão apontando e acabará chamando o destruidor e excluindo a memória para apenas 1 objeto (deixando a invocação de destruidores e desalocação dos 99 objetos restantes). Portanto, haverá um vazamento de memória.

então precisamos usar delete [] ptrneste caso.

Os operadores deletee delete []são usados ​​respectivamente para destruir os objetos criados com newenew[] , retornando à memória alocada deixada disponível para o gerenciador de memória do compilador.

Os objetos criados com newdevem necessariamente ser destruídos com deletee as matrizes criadas com new[]devem ser excluídas com delete[].

Quando eu fiz essa pergunta, minha verdadeira pergunta era: "existe uma diferença entre os dois? O tempo de execução não precisa manter informações sobre o tamanho da matriz e, portanto, não será capaz de dizer qual deles queremos dizer?" Esta pergunta não aparece em "perguntas relacionadas"; portanto, apenas para ajudar pessoas como eu, aqui está a resposta: "por que precisamos do operador delete []?"

deleteé usado para um único ponteiro e delete[]é usado para excluir uma matriz por meio de um ponteiro. Isso pode ajudá-lo a entender melhor.

Bem ... talvez eu pense que é apenas por explícito. O operador deletee o operador delete[]se distinguem, mas o deleteoperador também pode liberar a matriz.

test* a = new test[100];
delete a;

E já verifiquei esse código não tem vazamento de memória.