Hur höjningen fungerar i C ++ - dummies

Hopen är ett amorft minneblock som ditt C ++-program kan komma åt efter behov. Lär dig om varför den existerar och hur man använder den.

Precis som det är möjligt att skicka en pekare till en funktion, är det möjligt för en funktion att returnera en pekare. En funktion som returnerar adressen till en dubbel deklareras enligt följande:

dubbel * fn (tomrum);

Men du måste vara mycket försiktig när du återvänder en pekare. För att förstå farorna måste du veta något om variabel räckvidd.

Begränsat omfång i C ++

Omfattning är det intervall över vilket en variabel definieras. Tänk på följande kodbit:

// Följande variabel är tillgänglig för // alla funktioner och definieras så länge // programmet körs (globalt räckvidd) int intGlobal; // följande variabla intChild är tillgängligt // bara till funktionen och definieras endast // så länge som C ++ exekverar barn () eller en // funktion vilket barn () samtal (funktionsomfattning) tomrum (tomrum) {int intChild;} // följande variabla intParent har funktion // scope void parent (void) {int intParent = 0; barn(); int intLater = 0; intParent = intLater;} int main (int nArgs, char * pArgs []) {parent ();}

Detta programfragment börjar med deklarationen av en variabel intGlobal. Denna variabel existerar från det att programmet börjar exekvera tills det avslutas. Du säger att intGlobal "har programmets omfattning. "Du säger också att variabeln" går in i räckvidd "även innan huvudfunktionen () kallas.

Funktionshuvudet () aktiverar omedelbart föräldra (). Det första som processorn ser i parent () är intParent-deklarationen. På den punkten går intParent i räckvidd - det vill säga intParent definieras och är tillgängligt för återstoden av funktionsföräldern ().

Det andra uttalandet i parent () är samtalet till barnet (). Återigen deklarerar funktionsbarnet () en lokal variabel, den här gången intChild. Räckvidden för variabeln intChild är begränsad till funktionsbarnet (). Tekniskt definieras intParent inte inom ramen för barnet () eftersom barnet () inte har tillgång till intParent; Den rörliga intParent fortsätter emellertid att existera medan barnet () exekveras.

När barnet () utgår, kommer variabeln intChild att gå utanför räckvidden. Inte bara är intChild inte längre tillgängligt, det finns inte längre. (Minnet upptaget av intChild returneras till den allmänna poolen som ska användas för andra saker.)

Som förälder () fortsätter exekveringen, varierar intLater-räckvidden i deklarationen. När den förälder () återgår till huvud (), går både intParent och intLater utanför räckvidd.

Eftersom intGlobal förklaras globalt i det här exemplet är det tillgängligt för alla tre funktionerna och förblir tillgängligt för programmets livslängd.

Granskning av räckviddsproblemet i C ++

Följande kodsegment kompilerar utan fel men fungerar inte (hatar du inte det?):

dubbel * barn (tomrum) {double dLocalVariable; returnera & dLocalVariable;} void parent (void) {double * pdLocal; pdLocal = barn (); * pdLocal = 1. 0;}

Problemet med den här funktionen är att dLocalVariable definieras endast inom funktionsbarnets räckvidd (). Således hänvisas då till minnesadressen för dLocalVariable från barnet (), till en variabel som inte längre existerar. Minnet som dLocalVariable tidigare ockuperade används förmodligen för något annat.

Detta fel är mycket vanligt eftersom det kan krypa upp på ett antal sätt. Tyvärr orsakar detta fel inte att programmet stannar omedelbart. Faktum är att programmet kan fungera bra mest av tiden - det vill säga programmet fortsätter att fungera så länge som minnet som tidigare användes av dLocalVariable inte återanvänds omedelbart. Sådana intermittenta problem är de svåraste att lösa.

Tillhandahåller en lösning med höjden i C ++

Problemet med räckviddet berodde på att C ++ tog tillbaka det lokalt definierade minnet innan programmeraren var klar. Det som behövs är ett block av minne som styrs av programmeraren. Hon kan allokera minnet och lägga tillbaka det när hon vill - inte för att C ++ tycker att det är en bra idé. Ett sådant minnesblock kallas höjden.

Heapminne tilldelas med det nya sökordet följt av den typ av objekt som ska tilldelas. Det nya kommandot bryter en bit av minne från högen tillräckligt stor för att hålla den angivna typen av objekt och returnerar adressen. Till exempel fördelar följande en dubbelvariabel från högen:

dubbel * barn (tomrum) {double * pdLocalVariable = new double; returnera pdLocalVariable;}

Funktionen fungerar nu korrekt. Även om variabeln pdLocalVariable går utom räckvidd när funktionsbarnet () returnerar, det minne som pdLocalVariable hänvisar till inte. En minnesplats returnerad av ny går inte utom räckhåll för att den uttryckligen återförs till högen med hjälp av sökordet raderas, som är speciellt utformat för det ändamålet:

tomföräldrar (tomrum) {// child () returnerar adressen av ett block // av heapminne dubbel * pdMyDouble = barn (); // lagra ett värde där * pdMyDouble = 1. 1; // // // återför nu minnet till högen radera pdMyDouble; pdMyDouble = 0; // …}

Här pekaren returnerad av barnet () används för att lagra ett dubbelvärde. När funktionen är färdig med minnesplatsen returneras den till högen. Funktionsföräldern () sätter pekaren till 0 efter att hålminne har returnerats - det här är inte ett krav, men det är en mycket bra idé.

Om programmeraren felaktigt försöker lagra något i * pdMyDouble efter raderingen, kommer programmet att krascha omedelbart med ett meningsfullt felmeddelande.

Du kan använda nytt för att allokera arrays från högen, men du måste returnera en array med raderingsraden:

int * nArray = new int [10]; nArray [0] = 0; ta bort [] nArray;

Tekniskt nytt int [10] åberopar den nya [] operatören men det fungerar detsamma som nytt.