Hallo, en welkom terug. In deze lezing wil ik het hebben over dynamische geheugentoewijzing.
Dit heeft direct met pointers te maken, dit kun je alleen
op pointers gebruiken. Dus laten we beginnen.
Dus telkens wanneer u een variabele definieert
in c, wijst de compiler automatisch de juiste hoeveelheid opslagruimte voor u toe op basis van het gegevenstype.
We hebben dit overal gezien. Wanneer we gehele getallen, floats, doubles maken, hoeven we geen geheugen toe te wijzen.
De compiler doet het voor je. Het wijst eigenlijk wat geheugen toe.
Hetzelfde geldt trouwens voor pointers. Wanneer u een aanwijzer maakt, wordt
er geheugen voor u toegewezen, zodat het een aanwijzertype, een adres, opslaat.
Dat betekent niet dat er geheugen voor dat adres wordt toegewezen.
Tot nu toe, wanneer we gegevens toewijzen aan een -- naar
een aanwijzer, hebben we altijd een bestaande variabele toegewezen.
Dus als we gegevens aan
een aanwijzer wilden toewijzen, hebben we het ampersand-adres van de operator gebruikt
op een variabele voor die variabele waaraan al geheugen was toegewezen.
Maar wat als u een aanwijzer wilt maken en u wilt er niet het adres van de
operator aan toewijzen, u wilt dynamisch geheugen toewijzen. Daar gaat deze hele lezing over.
Het is dus vaak wenselijk om dynamisch opslag toe te wijzen
terwijl een programma draait. Wijs geheugen toe wanneer u het nodig heeft.
Als je een programma hebt dat is ontworpen om een set gegevens uit een bestand in
te lezen in een array in het geheugen, heb je drie keuzes.
U kunt de array definiëren om het maximale aantal mogelijke elementen te bevatten die compileren,
het is een vaste grootte.
Als u de array definieert die 50 elementen heeft,
zal deze slechts 50 elementen bevatten. De compiler bepaalt dat het 50 is,
het zal zoveel geheugen toewijzen wanneer het wordt uitgevoerd.
U kunt een array met variabele lengte gebruiken om de grootte van de array-runtime te bepalen.
We hebben het even gehad over deze arrays met
variabele lengte, ze worden pas in C11 ondersteund. Ze verwijderen eigenlijk C11, ze voegen C99 toe.
Hier kun je variabelen invoeren.
Maar dit zijn nog steeds een soort vaste grootte,
want dat betekent alleen variabele gekoppelde arrays, het betekent alleen dat je variabelen kunt doorgeven voor maten.
Maar ze zijn nog steeds statisch.
Of de beste keuze is dat u de array dynamisch kunt toewijzen wanneer u deze nodig hebt.
En er zijn verschillende c-functies die je hiervoor kunt aanroepen.
Het zal dus erg handig zijn om geheugen dynamisch toe te wijzen.
Dus met de eerste benadering die we tot nu toe hebben gedaan, of het nu
een array is of een gegevenstype, het is een vaste grootte.
U moet uw array definiëren om het maximale aantal elementen te bevatten
dat in een array past.
Dus je zou zoiets als dit doen, int dataArray [1000].
Dit betekent echter dat het gegevensbestand niet meer dan duizend elementen kan bevatten.
Als dat zo is, gaat je programma kapot.
U hoeft dus alleen maar te hopen dat het bestand waarin u leest niet veel gegevens bevat.
Uw programma werkt niet met grote sets bestanden of grote bestanden.
En als je toch met grote bestanden wilt werken, moet je terug en moet je de array groter maken.
Je moet de grootte veranderen, maar
dan moet je het opnieuw compileren op al die dingen, het is gecompileerde tijd.
Welke waarde je ook kiest, je hebt altijd de kans om in
de toekomst weer tegen hetzelfde probleem aan te lopen omdat het een vaste maat is.
Deze grootte wordt bepaald wanneer u de code compileert, het
past zich niet aan wanneer u het programma uitvoert.
Het verandert niet dynamisch.
Met behulp van dynamische geheugentoewijzingsfuncties kunt u opslagruimte krijgen wanneer u die nodig hebt.
Met deze benadering kunt u geheugen toewijzen terwijl het programma wordt uitgevoerd.
Bedenk dus de voordelen hiervan. Allereerst creëer je niet
een hoop geheugen die je misschien niet
gebruikt, je gaat alleen zoveel creëren als je nodig hebt.
En als u meer nodig heeft, kunt u meer toewijzen.
U hoeft niet terug te gaan en opnieuw te compileren en de grootte te wijzigen.
Dus dynamische geheugentoewijzing is de juiste keuze.
Het hangt af van het concept van een aanwijzer
en het geeft een sterke stimulans om aanwijzers in uw code te gebruiken.
Dus we hebben het gehad over de voordelen van
pointers en je hebt misschien bij jezelf gedacht, oké, het is een cool concept, maar
waarom moeten we ze gebruiken,
dit is een van de belangrijkste redenen, zodat je geheugen dynamisch kunt toewijzen.
En nogmaals, wat is dit - C gaat allemaal over efficiënte taal
en niet veel geheugen gebruiken.
Dus c draait op embedded systemen, real-time programmering en dit is
een van de redenen waarom, omdat je kunt beperken hoeveel geheugen je
gebruikt op basis van de behoefte.
Door dynamische geheugentoewijzing kan geheugen voor het opslaan van gegevens dynamisch worden toegewezen wanneer
het programma wordt uitgevoerd.
Dynamisch geheugen toewijzen is alleen mogelijk omdat je
pointers tot je beschikking hebt.
Omdat je een adres hebt en
je kunt wijzigen naar hoeveel de aanwijzer wijst, kun je het geheugen aanpassen.
De meeste productieprogramma's zullen dynamische geheugentoewijzing gebruiken.
Als je code in c schrijft, ga je dit gebruiken.
Zelfs als je een beginner bent, ga
je dynamische geheugentoewijzing gebruiken. De meeste bruikbare programma's zullen dit concept gebruiken.
Door gegevens dynamisch toe te wijzen, kunt u tijdens runtime pointers maken die net
groot genoeg zijn om de hoeveelheid gegevens te bevatten die u voor de taak
nodig hebt, zodat u geen geheugen verspilt. Vitaal.
We moeten ook praten over de heap versus de stack.
Er zijn twee manieren waarop u geheugen in een programma kunt opslaan,
twee verschillende datastructuren, u kunt gegevens op de stapel opslaan of u kunt gegevens op
de heap opslaan.
Dynamische geheugentoewijzing reserveert alles op de heap.
We gaan niet in detail in op hoe deze zijn georganiseerd, maar in wezen.
Wanneer u gegevens op de heap opslaat, is er
meer verandering mogelijk.
Je kunt willekeurig de grootte van gegevensobjecten wijzigen en het blijft veel
langer hangen als je geheugen in een hoop toewijst, het
blijft rond je hele programma hangen.
Wanneer u een stapel gebruikt, is deze beperkter.
De stapel wordt voor alles gebruikt, van functieargumenten en lokale variabelen.
Daar wordt alles opgeslagen.
En daarom hebben we het gehad over de call-stack.
Er werd gekeken naar methoden
en functies. Ik gebruik zo nu en dan methoden, maar methoden is echt een
objectgeoriënteerde term, dus functies.
Alles met betrekking tot functies wordt op de stapel gemaakt.
Dus wat dat betekent, is dat wanneer je een
functie uitvoert, deze op de stapel wordt geplaatst. De lokale variabelen worden op de stapel geplaatst.
Wanneer u de functie verlaat, wordt alles verwijderd.
Geheugen op de stapel blijft dus niet lang hangen.
Dat is een van de redenen waarom je geheugen dynamisch toewijst dat
het op de heap
staat, omdat je bepaalt wanneer je het gebruikt en wanneer je het niet gebruikt, je het toewijst en het verwijdert.
Dingen op de stapel heb je niet in de hand. Het wordt
automatisch verwijderd, automatisch toegewezen.
Dus lokale variabelen, variabelen binnen functies zoals de hoofdfunctie, die
worden op de stapel gemaakt, enzovoort.
Het geheugen op de heap is anders, het wordt bestuurd door jou, de programmeur.
Wanneer je geheugen toewijst op de heap, is het aan jou om bij te houden wanneer je het geheugen dat
je hebt toegewezen niet langer nodig hebt, dus je moet het geheugen verwijderen.
U moet de ruimte vrijmaken
wanneer deze niet meer door u wordt gebruikt. En dit is belangrijk
omdat geheugen een zeer, zeer schaarse hulpbron is.
Tegenwoordig hebben we veel geheugen waarmee je een computer kunt draaien, 12 optredens, 16
optredens, wat het ook is. Maar voor programma's die
zijn ingebed die op apparaten worden uitgevoerd, heb je
niet per se zoveel geheugen. En dus wilt u bepalen hoeveel geheugen u
gebruikt en u wilt het geheugen ook vrijgeven als u klaar bent met het gebruik,
zodat andere toepassingen het kunnen gebruiken.
Nogmaals, belangrijker in systemen van het ingebedde type op laag niveau.
Maar dit is een vrijheid die veel talen niet hebben. Deze mogelijkheid om het
geheugen van uw manager door de programmeur te beheren, kan
het programma veel efficiënter en veel sneller maken.
Dus in de volgende lezing gaan we het hebben over hoe je
dit daadwerkelijk kunt doen, welke functies je kunt gebruiken. Het is duidelijk dat er verschillende functies zijn die u
kunt aanroepen om geheugen toe te wijzen aan vrij geheugen. Dank u.