Stackallocatie
Hoe automatische opslag werkt
Stackallocatie is een gratis C++ Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject C++ Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus C++ Academy bevat in totaal 4 lessen.
Automatische opslag
Lokale variabelen leven in automatische opslag, meestal de stack genoemd. Ze worden gemaakt wanneer de uitvoering hun bereik binnengaat en vernietigd wanneer die het verlaat.
#include <iostream>
int main() {
int x = 42; // on the stack
double pi = 3.14; // on the stack
std::cout << x << " " << pi << "\n";
}De stack groeit en krimpt
Elke functieaanroep plaatst een stackframe met de lokale variabelen op de stack. Wanneer de functie terugkeert, wordt het frame verwijderd en verdwijnen de lokale variabelen: handmatig opruimen is niet nodig.
#include <iostream>
void greet() {
int local = 7; // pushed on call
std::cout << local << "\n";
} // popped on return
int main() { greet(); }LIFO-volgorde
De stack werkt volgens Last In, First Out: de meest recent gemaakte lokale variabele wordt als eerste vernietigd wanneer het bereik eindigt.
#include <iostream>
int main() {
int a = 1;
{
int b = 2; // created after a
std::cout << b << "\n";
} // b destroyed first
std::cout << a << "\n";
}Snel en goedkoop
Allocatie op de stack is extreem snel: alleen de stackpointer wordt verplaatst. Er hoeft niet naar vrije geheugenruimte te worden gezocht en er is geen administratie nodig zoals bij de heap.
Bereik bepaalt levensduur
Een object op de stack bestaat alleen binnen het blok waarin het is gedeclareerd. Geneste blokken hebben hun eigen bereik.
#include <iostream>
int main() {
for (int i = 0; i < 3; ++i) {
int square = i * i; // recreated each iteration
std::cout << square << "\n";
}
}Beperkte omvang
De stack heeft een vaste, beperkte omvang, vaak enkele megabytes. Grote arrays op de stack toewijzen kan een crash door een stack overflow veroorzaken.
// Risky: a large fixed array on the stack
int big[1000000]; // may overflow the stackEen stackadres teruggeven is een fout
Geef nooit een pointer of referentie naar een lokale variabele terug. Zodra de functie terugkeert, is die opslag verdwenen en wijst de pointer naar ongeldig geheugen.
int* bad() {
int local = 5;
return &local; // BUG: local dies here
}Grote objecten via referentie doorgeven
Grote objecten naar de stack kopiëren is verspilling. Geef ze door als const& om de kopie te vermijden en het stackgebruik klein te houden.
#include <string>
void print(const std::string& s) { // no copy
// use s
}Voor objecten op de stack is delete niet nodig
Omdat de compiler hun levensduur automatisch beheert, mag je nooit delete aanroepen voor een variabele op de stack.
#include <iostream>
int main() {
int n = 10;
// delete &n; // ERROR: not heap-allocated
std::cout << n << "\n";
}Arrays op de stack
Arrays met een vaste grootte en bekende lengte staan op de stack en worden automatisch vrijgegeven zodra het bereik eindigt.
#include <iostream>
int main() {
int values[3] = {10, 20, 30};
for (int v : values) std::cout << v << "\n";
}Wanneer je de stack verkiest
Geef de voorkeur aan de stack voor kleine objecten met een korte levensduur waarvan de grootte tijdens het compileren bekend is. De stack is sneller en ruimt zichzelf op — gebruik de heap alleen als dat echt nodig is.
Snelle controle
Test je begrip van stackallocatie.
Samenvatting
Je hebt geleerd dat stackallocatie automatische opslag gebruikt die aan het bereik is gekoppeld: variabelen worden bij binnenkomst aangemaakt en bij het verlaten ervan vernietigd, in LIFO-volgorde. Dit is snel, ruimt zichzelf op en heeft een beperkte grootte. Geef nooit adressen van lokale variabelen terug en voer nooit delete uit op objecten op de stack.
Leer C++ met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 51
- Lessen
- 203
Veelgestelde vragen
Is de les “Stackallocatie” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad C++ Academy, waaronder “Stackallocatie”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus C++ Academy bevat in totaal 4 lessen.
Wat leer ik in “Stackallocatie”?
Hoe automatische opslag werkt Je oefent met C++ Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met C++ Academy te beginnen?
Ervaring vooraf is niet nodig. C++ Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.
Hoe lang duurt de les “Stackallocatie”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over C++ Academy?
Ja. Elke les over C++ Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.