Wat is het verschil tussen delete
en delete[]
Operators in C++?
Antwoord 1, Autoriteit 100%
De delete
Operator-deallocates geheugen en roept de destructor op voor een enkel object gemaakt met new
.
De delete []
operator-deallocates geheugen en noemt destructors voor een reeks objecten gemaakt met new []
.
Gebruik delete
op een aanwijzer geretourneerd door new []
of delete []
op een aanwijzer die wordt geretourneerd door new
resulteert in ongedefinieerd gedrag.
Antwoord 2, Autoriteit 51%
De delete[]
operator wordt gebruikt om arrays te verwijderen. De delete
Operator wordt gebruikt om niet-array-objecten te verwijderen. Het roept operator delete[]
en operator delete
Functie respectievelijk om het geheugen te verwijderen dat het array of non-array-object bezet is na (uiteindelijk) de destructors belt voor de elementen van de array of het niet-array-object.
Hieronder ziet u de betrekkingen:
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;
Voor de new
die een array creëert (dus ofwel het new type[]
of new
toegepast op een arraytype constructie), de Standard zoekt naar een operator new[]
in de elementtypeklasse van de array of in de globale scope, en geeft de gevraagde hoeveelheid geheugen door. Het kan meer dan N * sizeof(ElementType)
vragen als het dat wil (bijvoorbeeld om het aantal elementen op te slaan, zodat het later bij het verwijderen weet hoeveel destructor-aanroepen er gedaan moeten worden). Als de klasse een operator new[]
verklaart die naast de hoeveelheid geheugen een andere size_t
accepteert, zal die tweede parameter het aantal toegewezen elementen ontvangen – hij kan dit gebruiken voor elk doel dat het wil (debuggen, enz…).
Voor de new
die een niet-array-object maakt, zoekt het naar een operator new
in de klasse van het element of in het globale bereik. Het geeft de gevraagde hoeveelheid geheugen door (precies sizeof(T)
altijd).
Voor de delete[]
kijkt het naar het type elementklasse van de arrays en roept het hun destructors aan. De operator delete[]
functie die wordt gebruikt is die in de klasse van het elementtype, of als er geen is dan in het globale bereik.
Voor de delete
, als de doorgegeven aanwijzer een basisklasse is van het eigenlijke objecttype, moet de basisklasse een virtuele destructor hebben (anders is het gedrag niet gedefinieerd). Als het geen basisklasse is, wordt de destructor van die klasse aangeroepen en wordt een operator delete
in die klasse of de globale operator delete
gebruikt. Als een basisklasse is doorgegeven, wordt de destructor van het eigenlijke objecttype aangeroepen en wordt de operator delete
in die klasse gebruikt, of als er geen is, een globale operator delete
wordt genoemd. Als de operator delete
in de klasse een tweede parameter van het type size_t
heeft, zal deze het aantal elementen ontvangen om de toewijzing ongedaan te maken.
Antwoord 3, autoriteit 12%
Dit is het basisgebruik van allocate/DE-allocate patroon in c++
malloc
/free
, new
/delete
, new[]
/delete[]
We moeten ze dienovereenkomstig gebruiken. Maar ik zou dit specifieke begrip willen toevoegen voor het verschil tussen delete
en delete[]
1) delete
wordt gebruikt om de toewijzing van geheugen voor één object
ongedaan te maken
2) delete[]
wordt gebruikt om de toewijzing van geheugen voor array van objecten
ongedaan te maken
class ABC{}
ABC *ptr = new ABC[100]
wanneer we new ABC[100]
zeggen, kan de compiler de informatie krijgen over het aantal objecten dat moet worden toegewezen (hier is het 100) en zal de constructor aanroepen voor elk van de gemaakte objecten
maar dienovereenkomstig, als we in dit geval gewoon delete ptr
gebruiken, weet de compiler niet naar hoeveel objecten ptr
verwijst en zal uiteindelijk destructor aanroepen en verwijderen geheugen voor slechts 1 object (waardoor de aanroep van destructors en deallocatie van de resterende 99 objecten achterblijven). Er zal dus een geheugenlek zijn.
dus we moeten in dit geval delete [] ptr
gebruiken.
Antwoord 4, autoriteit 3%
De operatoren delete
en delete []
worden respectievelijk gebruikt om de objecten te vernietigen die zijn gemaakt met new
en new[]
, terugkerend naar het toegewezen geheugen dat beschikbaar is voor de geheugenbeheerder van de compiler.
Objecten die zijn gemaakt met new
moeten noodzakelijkerwijs worden vernietigd met delete
en dat de arrays die zijn gemaakt met new[]
moeten worden verwijderd met delete[]
.
Antwoord 5, autoriteit 2%
Toen ik deze vraag stelde, was mijn echte vraag: “Is er een verschil tussen de twee? Moet de runtime geen informatie over de arraygrootte bewaren, en kan hij dus niet zeggen welke we bedoelen ?” Deze vraag komt niet voor in “gerelateerde vragen”, dus om mensen zoals ik te helpen, hier is het antwoord daarop: “waarom hebben we zelfs de delete[]-operator nodig?”
Antwoord 6
delete
wordt gebruikt voor één enkele aanwijzer en delete[]
wordt gebruikt voor het verwijderen van een array via een aanwijzer.
Ditkan je misschien helpen om het beter te begrijpen.