Objectlevensduur
Wanneer objecten worden gemaakt en vernietigd
Objectlevensduur is een gratis C++ Academy-les op CoddyKit. Dit is les 3 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.
Wanneer objecten ontstaan
De levensduur van een object begint nadat de opslag ervoor is toegewezen en de constructor is voltooid. Vanaf dat moment kun je het volledig gebruiken.
#include <iostream>
struct Widget {
Widget() { std::cout << "born\n"; }
};
int main() {
Widget w; // constructor runs here
}Wanneer objecten worden vernietigd
De levensduur eindigt wanneer de destructor wordt uitgevoerd. Bij een object op de stack gebeurt dat bij de afsluitende accolade van het bereik.
#include <iostream>
struct Widget {
~Widget() { std::cout << "dies\n"; }
};
int main() {
Widget w;
std::cout << "alive\n";
} // ~Widget runs hereVolgorde van constructie en vernietiging
Objecten worden vernietigd in de omgekeerde volgorde van hun constructie. Het laatst gebouwde object wordt als eerste afgebroken.
#include <iostream>
struct Tag {
int id;
Tag(int i) : id(i) { std::cout << "make " << id << "\n"; }
~Tag() { std::cout << "drop " << id << "\n"; }
};
int main() {
Tag a(1);
Tag b(2); // dropped before a
}Automatische levensduur (stack)
Automatische objecten blijven bestaan zolang hun omsluitende blok duurt. Dit is het meest gebruikelijke en veiligste model voor levensduur.
Dynamische levensduur (heap)
Objecten op de heap die met new zijn aangemaakt, blijven bestaan totdat delete wordt aangeroepen — hun levensduur wordt door jou beheerd, niet door het bereik.
#include <iostream>
struct Widget {
~Widget() { std::cout << "dies\n"; }
};
int main() {
Widget* w = new Widget();
std::cout << "still alive\n";
delete w; // destructor runs here
}Statische levensduur
Objecten met static-opslag blijven gedurende het hele programma bestaan. Een statische variabele binnen een functie wordt bij het eerste gebruik één keer geconstrueerd.
#include <iostream>
int next() {
static int counter = 0; // built once
return ++counter;
}
int main() {
std::cout << next() << next() << next() << "\n";
}Tijdelijke objecten
Een tijdelijk object dat in een expressie wordt aangemaakt, wordt meestal vernietigd aan het einde van de volledige expressie (de puntkomma).
#include <iostream>
#include <string>
int main() {
std::cout << (std::string("a") + "b") << "\n";
} // temporary string dies after this lineLeden worden vóór de body geconstrueerd
De leden van een klasse worden geconstrueerd voordat de constructorbody van het omsluitende object wordt uitgevoerd, en vernietigd nadat de destructorbody ervan is uitgevoerd.
#include <iostream>
#include <string>
struct Engine { Engine() { std::cout << "engine\n"; } };
struct Car {
Engine e;
Car() { std::cout << "car\n"; }
};
int main() { Car c; }Levensduur verlengen met een const-referentie
Door een tijdelijk object aan een const& te binden, verleng je de levensduur ervan tot die van de referentie — een handige C++-regel.
#include <iostream>
#include <string>
int main() {
const std::string& s = std::string("hi");
std::cout << s << "\n"; // s still valid
}Gebruik na het einde van de levensduur
Een object aanraken nadat zijn levensduur is geëindigd, leidt tot ongedefinieerd gedrag — de klassieke fout met een bungelende referentie of gebruik na vrijgave.
Levensduur vormt de basis van RAII
Omdat destructors deterministisch aan het einde van de levensduur worden uitgevoerd, koppelt C++ het opruimen van resources aan de levensduur — de basis van RAII, dat in de volgende cursus wordt behandeld.
Snelle controle
Test je begrip van de levensduur van objecten.
Samenvatting
Je hebt geleerd hoe de levensduur van een object na de constructie begint en met de vernietiging eindigt. Automatische objecten volgen het bereik, dynamische objecten volgen new/delete en statische objecten blijven het hele programma bestaan. Vernietiging gebeurt in omgekeerde volgorde — de basis voor RAII.
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 “Objectlevensduur” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad C++ Academy, waaronder “Objectlevensduur”, 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 “Objectlevensduur”?
Wanneer objecten worden gemaakt en vernietigd 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 3 van 4.
Hoe lang duurt de les “Objectlevensduur”?
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.