Lär dig att förstå C++ pekare (4 / 6 steg)

Steg 4: Använda pekare

Det finns två sätt att passera argument till en funktion: antingen genom värde eller referens.

PASSERAR ARGUMENT AV VÄRDE

Normalt, skickas argument till funktioner av värdet, vilket innebär att det är värdet för den variabel som skickas till funktionen och inte variabeln själv.

Konsekvenserna av detta blir tydligt i den följande kodsnutt:

void fn (int nArg1, int nArg2)
{
ändra värden för argumenten
nArg1 = 10;
nArg2 = 20;
}

int main (int nNumberofArgs, char * pszArgs [])
{
initiaize två variabler och deras värden
int nValue1 = 1;
int nValue2 = 2;

nu försöker och ändra dem genom att anropa en funktion

FN (nValue1, nValue2);

Vad är värdet av nValue1 och nValue2 nu?
Cout cout
system ("paus")
Return 0;

}

Detta program deklareras två variabler, nValue1 och nValue2, initierar dem till några kända värde och passerar sedan deras värden till en funktion (fn). Den här funktionen ändras värdet av sina argument och helt enkelt returnerar.

Fråga: Vad är värdet av nValue1 och nValue2 i (huvudsakliga) efter kontrollen återgår från fn ()?

Svar: Värdet av nValue1 och nValue2 vara oförändrade på 1 och 2, respektive.

För att förstå varför, granska noga hur C++ hanterar minne i anropet till fn (). C++ lagrar lokala variabler (som nValue1 och nValue2) i ett speciellt område minne kallas stacken. Vid träder i funktion, C++ figurerar ut hur mycket stackminnet funktionen kommer att kräva och reserveras sedan detta belopp. Säga, för argument skull, att i det här exemplet stackminnet för (huvudsakliga) börjar på platsen 0x1000 och sträcker sig till 0x101F. I det här fallet nValue1 kan vara på plats 0x1000 och nValue2 kan vara på plats 0x1004.

(OBS: OM DU ANVÄNDER CODE::BLOCKS, EN INT TAR UPP 4 BYTE.)

Som en del av uppringningen till fn (), lagrar C++ först värdena för varje argument på stacken på argumentet längst till höger och arbetar sig till vänster.

Sista C++ lagrar som del av uppringningen avsändaradressen så att funktionen vet var man tillbaka efter den är klar.

Av skäl som har att göra mer med det inre arbetet i Processorn, stacken "växer nedåt", vilket innebär att minnet används av fn () har adresser mindre än 0x1000.

Kom ihåg att detta är bara en möjlig layout minne. Jag vet inte (eller hand) att någon av dessa i själva verket är de faktiska adresser som används av C++ i denna eller någon annan funktionsanropet.

Funktionen fn (heltal, heltal) innehåller två uttalanden:

nArg1 = 10;
nArg2 = 20;

Den viktigaste punkten i detta är att visa att ändra värdena på nArg1 och nArg2 har ingen effekt på de ursprungliga variablerna tillbaka på nValue1 och nValue2.

PASSERAR ARGUMENT MED HÄNVISNING

Så vad händer om jag ville de ändringar som gjorts av fn () ska vara permanent? Jag kunde göra detta genom att skicka inte värdet på variablerna men deras adress. Detta framgår av den följande kodsnutt:

void fn (int * pnArg1, int * pnArg2)
{
ändra värdet för argumenten
* pnArg1 = 10;
* pnArg2 = 20;
}

int main (int nNumberofArgs, char * pszArgs [])
{
initiera två variabler och deras värden
int nValue1 = 1;
int nValue2 = 2;

FN (& nValue1 & nValue2);

system ("paus")
Return 0;
}

Märke först att argumenten till fn () är nu inte förklarats vara heltal men pekare till heltal. Anropet till fn (int *, int *) passerar inte värdet på variablerna nValue1 och nValue2 men theie adresser.

Genom att använda pekare, blir ändringarna i de två variablerna permanent. Utan att använda pekare, görs ändringarna endast värden kopieras till fn ().