Hoe de Heap werkt in C ++ - dummies

De heap is een amorf blokgeheugen dat door uw C ++ -programma kan worden geopend als dat nodig is. Lees meer over waarom het bestaat en hoe het te gebruiken.

Net zoals het mogelijk is om een ​​aanwijzer naar een functie door te geven, kan een functie een aanwijzer retourneren. Een functie die het adres van een double retourneert, wordt als volgt gedeclareerd:

double * fn (void);

U moet echter zeer voorzichtig zijn bij het retourneren van een aanwijzer. Om de gevaren te begrijpen, moet u iets weten over variabel bereik.

Beperkt bereik in C ++

Scope is het bereik waarover een variabele wordt gedefinieerd. Beschouw het volgende codefragment:

// de volgende variabele is toegankelijk voor // alle functies en gedefinieerd zolang het // -programma wordt uitgevoerd (globaal bereik) int intGlobal; // de volgende variabele intChild is // alleen voor de functie toegankelijk en wordt alleen // gedefinieerd zolang C ++ kind () of een // -functie uitvoert die child () aanroepen (functiebereik) ongeldig kind (ongeldig) {int intChild;} // de volgende variabele intParent heeft de functie // scope void parent (void) {int intParent = 0; kind(); int intLater = 0; intParent = intLater;} int main (int nArgs, char * pArgs []) {parent ();}

Dit programmafragment begint met de declaratie van een variabele intGlobal. Deze variabele bestaat vanaf het moment dat het programma begint met het uitvoeren totdat het wordt beëindigd. U zegt dat intGlobal "programmabereik heeft. "Je zegt ook dat de variabele" in scope gaat "nog voordat de functie main () wordt aangeroepen.

De functie main () roept meteen parent () aan. Het eerste dat de processor in bovenliggend () ziet, is de intentieverklaring. Op dat moment wordt intParent in scope geplaatst, dat wil zeggen, intParent is gedefinieerd en beschikbaar voor de rest van de functieraam ().

De tweede instructie in bovenliggend () is de aanroep van child (). Nogmaals, de functie child () declareert een lokale variabele, dit keer intChild. Het bereik van de variabele intChild is beperkt tot de functie child (). Technisch is intParent niet gedefinieerd binnen de scope van child () omdat child () geen toegang heeft tot intParent; de variabele intParent blijft echter bestaan ​​terwijl child () wordt uitgevoerd.

Wanneer child () wordt afgesloten, valt de variabele intChild buiten het bereik. IntChild is niet alleen niet meer toegankelijk, het bestaat niet meer. (Het geheugen dat door intChild wordt ingenomen, wordt teruggestuurd naar de algemene pool om voor andere dingen te worden gebruikt.)

Terwijl bovenliggend () doorgaat met uitvoeren, gaat de variabele intLater in scope op de declaratie. Op het moment dat parent () terugkeert naar main (), gaan zowel intParent als IntLater buiten het bereik.

Omdat intGlobal in dit voorbeeld globaal wordt verklaard, is het beschikbaar voor alle drie de functies en blijft het beschikbaar voor de levensduur van het programma.

Het probleem met de scope onderzoeken in C ++

Het volgende codesegment compileert zonder fouten maar werkt niet (haat je dat niet?):

double * child (void) {double dLocalVariable; return & dLocalVariable;} void parent (void) {double * pdLocal; pdLocal = child (); * pdLocal = 1. 0;}

Het probleem met deze functie is dat dLocalVariable alleen wordt gedefinieerd binnen het bereik van de functie child (). Dus, tegen de tijd dat het geheugenadres van dLocalVariable wordt geretourneerd door child (), verwijst het naar een variabele die niet langer bestaat. Het geheugen dat dLocalVariable voorheen in beslag nam, wordt waarschijnlijk voor iets anders gebruikt.

Deze fout komt zeer vaak voor omdat deze op verschillende manieren omhoog kan kruipen. Helaas zorgt deze fout er niet voor dat het programma onmiddellijk stopt. In feite werkt het programma mogelijk meestal goed - dat wil zeggen, het programma blijft werken zolang het geheugen dat voorheen door dLocalVariable werd gebruikt, niet onmiddellijk wordt hergebruikt. Dergelijke intermitterende problemen zijn de moeilijkste om op te lossen.

Een oplossing bieden met behulp van de heap in C ++

Het probleem met de scope is ontstaan ​​omdat C ++ het lokaal gedefinieerde geheugen heeft teruggehaald voordat de programmeur gereed was. Wat nodig is, is een blok geheugen dat door de programmeur wordt beheerd. Ze kan het geheugen toewijzen en terugzetten wanneer ze dat wil - niet omdat C ++ vindt dat het een goed idee is. Zo'n blok geheugen wordt de heap genoemd.

Heap-geheugen wordt toegewezen met behulp van het nieuwe sleutelwoord gevolgd door het type object dat moet worden toegewezen. Het nieuwe commando breekt een stuk geheugen uit de heap die groot genoeg is om het gespecificeerde type object te bevatten en retourneert zijn adres. Het volgende wijst bijvoorbeeld een dubbele variabele toe uit de heap:

double * child (void) {double * pdLocalVariable = new double; return pdLocalVariable;}

Deze functie werkt nu correct. Hoewel de variabele pdLocalVariable buiten het bereik valt wanneer de functie child () terugkeert, heeft het geheugen waarnaar pdLocalVariable verwijst dat niet. Een door nieuw geretourneerde geheugenlocatie valt niet buiten het bereik totdat deze expliciet wordt teruggestuurd naar de heap met behulp van de sleutelwoord delete, die specifiek voor dat doel is ontworpen:

void parent (void) {// child () retourneert het adres van een blok // van heapgeheugen dubbel * pdMyDouble = child (); // sla hier een waarde op * pdMyDouble = 1. 1; // … // keer nu het geheugen terug naar de heap delete pdMyDouble; pdMyDouble = 0; // …}

Hier wordt de aanwijzer geretourneerd door child () gebruikt om een ​​dubbele waarde op te slaan. Nadat de functie is voltooid met de geheugenlocatie, wordt deze teruggezet naar de heap. De functie parent () stelt de aanwijzer in op 0 nadat het heap-geheugen is geretourneerd - dit is geen vereiste, maar het is een heel goed idee.

Als de programmeur ten onrechte probeert iets op te slaan in * pdMyDouble na de verwijdering, zal het programma onmiddellijk crashen met een zinvolle foutmelding.

Je kunt ook nieuw gebruiken om arrays uit de heap toe te wijzen, maar je moet een array teruggeven met het delete [] -woord:

int * nArray = new int [10]; nArray [0] = 0; verwijder [] nArray;

Technisch gezien maakt nieuwe int [10] gebruik van de nieuwe [] -operator, maar deze werkt hetzelfde als nieuw.