Stap 4: Gebruik van Pointers
PASSEREN ARGUMENTEN VOOR EEN FUNCTIEEr zijn twee manieren om het doorgeven van argumenten aan een functie: door waarde of aan de hand.
PASSEREN ARGUMENTEN DOOR WAARDE
Normaal gesproken zijn argumenten doorgegeven aan functies door waarde, wat betekent dat het de waarde van de variabele die wordt doorgegeven aan de functie en niet de variabele zelf.
De gevolgen hiervan duidelijk geworden in het volgende codefragment:
VOID fn (int nArg1, int nArg2)
{
Wijzig de waarden van de argumenten
nArg1 = 10;
nArg2 = 20;
}
int main (int nNumberofArgs, char * pszArgs [])
{
initiaize twee variabelen en hun waarden weergeven
int nValue1 = 1;
int nValue2 = 2;
nu proberen en deze wel wijzigen met het aanroepen van een functie
FN (nValue1, nValue2);
Wat is de waarde van nValue1 en nValue2 nu?
Cout cout
systeem ("pauze")
keren 0;
}
Dit programma verklaart twee variabelen, nValue1 en nValue2, ze aan een bekende waarde initialiseert en hun waarden wordt de doorgegeven aan een functie fn (). Deze functie wijzigt de waarde van de argumenten en gewoon als resultaat gegeven.
Vraag: Wat is de waarde van nValue1 en nValue2 in main () na controle geeft als van (fn resultaat)?
Antwoord: De waarde van nValue1 en nValue2 blijven onveranderd op 1 en 2, respectievelijk.
Om te begrijpen waarom, zorgvuldig bestuderen hoe C++ omgaat met geheugen in de oproep tot (fn). C++ worden lokale variabelen (zoals nValue1 en nValue2) opgeslagen in een speciaal gebied van geheugen, bekend als de stack. Bij binnenkomst in een functie, C++ cijfers uit hoe veel geheugen stapel de functie zullen vereisen en behoudt dan dat bedrag. Zeggen, omwille van het argument, dat in dit voorbeeld wordt het geheugen van de stapel gesneden uit voor main () op locatie 0x1000 start en strekt zich uit tot 0x101F. In dit geval nValue1 mogelijk op locatie 0x1000 en nValue2 misschien wel op locatie 0x1004.
(OPMERKING: ALS U CODE::BLOCKS GEBRUIKT, EEN INT IS 4 BYTES LANG.)
Als onderdeel van het bellen naar (fn), slaat C++ eerst de waarden van elk argument in de stack, beginnend bij de meest rechtse argument en zijn weg naar de links werken.
Het laatste wat C++ worden opgeslagen als onderdeel van de bellen het retouradres is zodat de functie waar om terug te keren weet nadat dit voltooid is.
Om redenen die meer moeten doen met de interne werking van de CPU, de stack "groeit naar beneden", wat betekent dat het geheugengebruik door fn () zal hebben adressen kleiner dan 0x1000.
Vergeet niet dat dit gewoon een mogelijke lay-out van het geheugen is. Ik niet weet (of zorg) dat deze in feite de werkelijke adressen door C++ in deze of een andere functie-aanroep gebruikt beschikbaar zijn.
De functie fn (int, int) bevat twee verklaringen:
nArg1 = 10;
nArg2 = 20;
Het belangrijkste punt om te zeggen dit is om aan te tonen van het feit dat het veranderen de waarden van nArg1 en nArg2 geen invloed op de oorspronkelijke variabelen terug op nValue1 en nValue2 heeft.
PASSEREN ARGUMENTEN DOOR VERWIJZING
Dus wat als ik wilde de wijzigingen permanent door fn ()? Ik kan dit doen door niet de waarde van de variabelen, maar hun adres doorgeven. Dit blijkt uit het volgende stukje code:
VOID fn (int * pnArg1, int * pnArg2)
{
Wijzig de waarde van de argumenten
* pnArg1 = 10;
* pnArg2 = 20;
}
int main (int nNumberofArgs, char * pszArgs [])
{
initialiseren van de twee variabelen en hun waarden weergeven
int nValue1 = 1;
int nValue2 = 2;
FN (nValue1, & nValue2);
systeem ("pauze")
keren 0;
}
Let ten eerste dat de argumenten bij de (fn) zijn nu verklaard niet gehele getallen maar pointers naar gehele getallen. De aanroep van fn (int *, int *) geeft niet de waarde van de variabelen nValue1 en nValue2 maar theie adressen.
Met behulp van de pointers, de wijzigingen in de twee variabelen permanent geworden. Zonder gebruik te maken van de pointers, zijn de wijzigingen alleen aangebracht in de waarden gekopieerd naar (fn).
