Hvordan heap fungerer i C ++ - dummies

Højen er en amorf blok af hukommelse, som dit C ++-program kan få adgang til efter behov. Lær om hvorfor det eksisterer og hvordan man bruger det.

Ligesom det er muligt at sende en peger til en funktion, er det muligt for en funktion at returnere en peger. En funktion, der returnerer adressen til en dobbelt, erklæres som følger:

dobbelt * fn (tomrum);

Du skal dog være meget forsigtig, når du vender tilbage. For at forstå farerne skal du vide noget om variabelt omfang.

Begrænset omfang i C ++

Anvendelsesområde er det område, over hvilket en variabel er defineret. Overvej følgende kodestykke:

// Følgende variabel er tilgængelig for // alle funktioner og defineret så længe // programmet kører (globalt omfang) int intGlobal; // den følgende variable intChild er tilgængelig // kun til funktionen og er kun defineret // så længe C ++ udfører barnet () eller en // -funktion hvilket barn () opkald (funktionsomfang) tomrum (tomrum) {int intChild;} // følgende variabel intParent har funktion // omfang tom forælder (tom) {int intParent = 0; barn(); int intLater = 0; intParent = intLater;} int main (int nArgs, char * pArgs []) {parent ();}

Dette programfragment begynder med erklæringen af ​​en variabel intGlobal. Denne variabel eksisterer fra det tidspunkt, hvor programmet begynder at køre, indtil det afsluttes. Du siger, at intGlobal "har programmets omfang. "Du siger også, at variablen" går i omfang ", selv før funktionen hoved () kaldes.

Funktionshovedet () aktiverer straks forældre (). Den første ting, som processoren ser i forælder () er erklæringen om intParent. På det tidspunkt går intParent ind i omfang - det vil sige intParent er defineret og tilgængeligt for resten af ​​funktionen forælder ().

Den anden erklæring i forælder () er opkaldet til barnet (). Endnu engang erklærer funktionsbarnet () en lokal variabel, denne gang intChild. Omfanget af variablen intChild er begrænset til funktionsbarnet (). Teknisk set er intParent ikke defineret inden for børns anvendelsesområde (), fordi barnet () ikke har adgang til intParent; Den variable intParent eksisterer dog fortsat, mens barnet () udføres.

Når barnet () udgår, går variablen intChild uden for anvendelsesområdet. Ikke kun er intChild ikke længere tilgængelig, det eksisterer ikke længere. (Hukommelsen optaget af intChild returneres til den generelle pool, der skal bruges til andre ting.)

Som forælder () fortsætter udførelsen, går den variable intLater ind i anvendelsesområdet ved erklæringen. På det tidspunkt, hvor forælder () vender tilbage til main (), går både intParent og intLater uden for anvendelsesområdet.

Da intGlobal er erklæret globalt i dette eksempel, er den tilgængelig for alle tre funktioner og forbliver tilgængelig for programmets levetid.

Undersøg omfangsproblemet i C ++

Følgende kodesegment kompilerer uden fejl, men virker ikke (har du ikke bare hader det?):

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

Problemet med denne funktion er, at dLocalVariable kun er defineret inden for funktionsbarnets anvendelsesområde (). På den tid refereres hukommelsesadressen til dLocalVariable fra barnet () til en variabel, der ikke længere eksisterer. Den hukommelse, som dLocalVariable tidligere optog, bruges sandsynligvis til noget andet.

Denne fejl er meget almindelig, fordi den kan krybe op på en række måder. Desværre forårsager denne fejl ikke, at programmet øjeblikkeligt stopper. Faktisk kan programmet fungere fint det meste af tiden - det vil sige, at programmet fortsætter med at virke, så længe den hukommelse, der tidligere var optaget af dLocalVariable, ikke genbruges umiddelbart. Sådanne intermitterende problemer er de vanskeligste at løse.

Giver en løsning ved hjælp af bunken i C ++

Omfangsproblemet opstod, fordi C ++ tog tilbage den lokalt definerede hukommelse, før programmeringen var klar. Hvad der er brug for er en blok af hukommelse, der styres af programmøren. Hun kan allokere hukommelsen og sætte den tilbage, når hun vil - ikke fordi C ++ synes det er en god idé. En sådan blok af hukommelse hedder bunken.

Heap hukommelse er tildelt ved hjælp af det nye søgeord efterfulgt af den type objekt at allokere. Den nye kommando brækker en del hukommelse ud af bunken, der er stor nok til at holde den specificerede type objekt og returnerer adressen. For eksempel tildeler følgende en dobbeltvariabel fra bunken:

dobbelt * barn (tomrum) {double * pdLocalVariable = new double; returner pdLocalVariable;}

Denne funktion virker nu korrekt. Selv om variablen pdLocalVariable går uden for rækkevidden, når funktionsbarnet () vender tilbage, vil den hukommelse, som pdLocalVariable henviser til, ikke. En hukommelsesplacering, der returneres af ny, går ikke ud af omfanget, før den eksplicit returneres til bunken ved hjælp af søgeordets sletning, som er specielt designet til dette formål:

tom forælder (tom) {// child () returnerer adressen af en blok // af bunkehukommelse dobbelt * pdMyDouble = barn (); // gem en værdi der * pdMyDouble = 1. 1; // … // returner nu hukommelsen til bunken slet pdMyDouble; pdMyDouble = 0; // …}

Her bliver pointeren returneret af barnet () brugt til at gemme en dobbeltværdi. Når funktionen er færdig med hukommelsesstedet, returneres den til bunken. Funktionsforældre () sætter pegeren til 0, efter at hulehukommelsen er returneret - det er ikke et krav, men det er en meget god ide.

Hvis programmereren fejlagtigt forsøger at gemme noget i * pdMyDouble efter sletningen, vil programmet straks slå sammen med en meningsfuld fejlmeddelelse.

Du kan bruge ny til at tildele arrayer fra bunken også, men du skal returnere en matrix ved at slette [] nøgleordet:

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

Teknisk ny int [10] påberåber den nye [] operatør, men det virker som det samme som nyt.