delete vs delete [] operatori in C ++

Qual è la differenza tra deletee delete[]operatori in C ++?

L' deleteoperatore disloca la memoria e chiama il distruttore per un singolo oggetto creato con new.

L' delete []operatore disloca la memoria e chiama i distruttori per una matrice di oggetti creati con new [].

L'utilizzo deletesu un puntatore restituito da new []o delete []su un puntatore restituito da newcomporta un comportamento indefinito.

L' delete[]operatore viene utilizzato per eliminare le matrici. L' deleteoperatore viene utilizzato per eliminare oggetti non array. Richiama operator delete[]e operator deletefunziona rispettivamente per eliminare la memoria occupata dall'array o dall'oggetto non array dopo (eventualmente) chiamare i distruttori per gli elementi dell'array o l'oggetto non array.

Quanto segue mostra le relazioni:

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;

Per newquesto crea un array (quindi, new type[]o newapplicato a un costrutto di tipo array), lo Standard cerca un operator new[]nella classe del tipo di elemento dell'array o nell'ambito globale e passa la quantità di memoria richiesta. Potrebbe richiedere più di N * sizeof(ElementType)quanto desideri (ad esempio per memorizzare il numero di elementi, quindi in seguito, quando si elimina, sa quante chiamate del distruttore devono essere eseguite). Se la classe dichiara operator new[]un'aggiunta alla quantità di memoria accetta un'altra size_t, quel secondo parametro riceverà il numero di elementi allocati - può usarlo per qualsiasi scopo (debug, ecc ...).

Per quello newche crea un oggetto non-array, cercherà un operator newnella classe dell'elemento o nell'ambito globale. Passa la quantità di memoria richiesta (esattamente sizeof(T)sempre).

Per il delete[], esamina il tipo di classe di elementi delle matrici e chiama i loro distruttori. La operator delete[]funzione utilizzata è quella nella classe del tipo di elemento, o se non ce n'è nessuna nell'ambito globale.

Infatti delete, se il puntatore passato è una classe base del tipo di oggetto reale, la classe base deve avere un distruttore virtuale (altrimenti il ​​comportamento non è definito). Se non è una classe base, viene chiamato il distruttore di quella classe e viene usato un operator deletein quella classe o il globale operator delete. Se è stata passata una classe di base, viene chiamato il distruttore del tipo di oggetto reale e operator deleteviene utilizzato il trovato in quella classe, o se non ce n'è nessuno, operator deleteviene chiamato un globale . Se operator deletenella classe ha un secondo parametro di tipo size_t, riceverà il numero di elementi da deallocare.

Questo è l'uso base del modello allocate / DE-allocate in c ++ malloc/ free, new/ delete, new[]/delete[]

Dobbiamo usarli di conseguenza. Ma vorrei aggiungere questa particolare comprensione per la differenza tra deleteedelete[]

1) deleteviene utilizzato per disallocare la memoria allocata per singolo oggetto

2) delete[]viene utilizzato per disallocare la memoria allocata per la matrice di oggetti

class ABC{}

ABC *ptr = new ABC[100]

quando diciamo new ABC[100], il compilatore può ottenere le informazioni su quanti oggetti deve essere allocato (qui è 100) e chiamerà il costruttore per ciascuno degli oggetti creati

ma di conseguenza, se usiamo semplicemente delete ptrquesto caso, il compilatore non saprà quanti oggetti ptrpunta e finirà per chiamare il distruttore e cancellare la memoria per 1 solo oggetto (lasciando l'invocazione dei distruttori e la deallocazione dei rimanenti 99 oggetti). Quindi ci sarà una perdita di memoria.

quindi dobbiamo usare delete [] ptrin questo caso.

Gli operatori deletee delete []vengono utilizzati rispettivamente per distruggere gli oggetti creati con newe new[], tornando alla memoria allocata lasciata disponibile al gestore della memoria del compilatore.

Gli oggetti creati con newdevono necessariamente essere distrutti deletee con cui gli array creati new[]devono essere eliminati delete[].

Quando ho posto questa domanda, la mia vera domanda era: "c'è una differenza tra i due? Il runtime non deve conservare le informazioni sulla dimensione dell'array, e quindi non sarà in grado di dire quale intendiamo?" Questa domanda non appare nelle "domande correlate", quindi solo per dare una mano a quelli come me, ecco la risposta: "perché abbiamo persino bisogno dell'operatore delete []?"

deleteviene utilizzato per un singolo puntatore e delete[]viene utilizzato per eliminare un array tramite un puntatore. Questo potrebbe aiutarti a capire meglio.

Beh .. forse penso che sia solo per esplicito. L'operatore deletee l'operatore delete[]si distinguono ma anche l' deleteoperatore può rilasciare l'array.

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

E già verificato che questo codice non abbia perdite di memoria.