pointersAan de slag met pointers


Opmerkingen

Deze sectie geeft een overzicht van wat pointers zijn en waarom een ontwikkelaar het misschien wil gebruiken.

Het moet ook alle grote onderwerpen binnen aanwijzers vermelden en een link naar de gerelateerde onderwerpen bevatten. Omdat de documentatie voor verwijzingen nieuw is, moet u mogelijk eerste versies van die gerelateerde onderwerpen maken.

Aan de slag met Pointers

Aanwijzers zijn variabelen die het adres van een andere variabele opslaan. Als taalkenmerk zijn ze beschikbaar in verschillende programmeertalen zoals, maar niet beperkt tot:

  • Gaan
  • C / C ++
  • Ada
  • Pascal
  • C # (beschikbaar onder bepaalde beperkingen)
  • COBOL
  • FORTRAN

Volg deze stappen om aan de slag te gaan met C / C ++ -aanwijzers

  1. Installeer de compiler zoals Minimalistic GNU voor Windows, http://www.mingw.org/wiki/Getting_Started

  2. Ga bijvoorbeeld naar de installatiemap van g ++ binary via de opdrachtregel:

    C:\MinGW\bin>
     

3.Maak een tekstbestand en schrijf dit C ++ -programma

#include <iostream>

int main () {

   int  pointed=0;
   int* ptr = & pointed;

   std::cout<<"Address of pointed variable is: "<<ptr<<std::endl;

   return 0;
}
 
  1. Opslaan als pointer.cpp 5. Voer de opdracht uit vanaf de opdrachtprompt

g ++ -o pointer.exe -c pointer.cpp

  1. In de werkmap krijgt u een uitvoerbaar bestand als pointer.exe, dit exe bij het uitvoeren geeft wat output zoals

Adres van de puntvariabele is: 0x7e892dac0a0c

Als u de bovenstaande uitvoer ontvangt, hebt u uw eerste pointerprogramma geschreven

Wat is een aanwijzer?

Het is eigenlijk een adres van een variabele in het geheugen. Hiermee kunnen we indirect toegang krijgen tot een variabele. Dus met behulp van aanwijzers kunnen we het hebben over het adres van een variabele (en over de waarde ervan door de aanwijzer van een verwijzing te ontdoen). Ze zijn handig wanneer we het adres van een geheugenlocatie willen behandelen in plaats van de waarde ervan.

Overweeg de volgende eenvoudige ruilfunctie in C:

void Swap(int firstVal, int secondVal)
{
 int tempVal = firstVal;
 firstVal = secondVal;
 secondVal = tempVal;
}
 

nu hoofdzakelijk als we de volgende code hebben:

.
.
int a = 9,b = 100;
swap(a,b);
//print a and b
.
.
 

De waarden van a en b zouden ongewijzigd blijven zoals duidelijk zou zijn door hun waarden in de hoofdfunctie af te drukken. Om de swapfunctie correct te implementeren, geven we in plaats van de waarden van variabelen a en b , het adres van variabelen a en b door als:

swap(&a,&b);
 

De operator & retourneert het adres van de variabele. Het wordt als volgt gebruikt:

int *address_of_a = &a;
 

het int *address_of_a , geeft aan dat de variabele address_of_a naar (slaat het adres op van) een geheel getal variabele.

Nu zou onze juiste ruilfunctie zijn:

void Swap(int *firstaddress, int *secondaddress)
{
 int tempVal = *firstaddress;
 *firsaddress = *secondaddress;
 *secondaddress = tempVal;
}
 

Nu zouden de verwisselde waarden worden weerspiegeld in de hoofdfunctie:

int a = 9,b = 100;
swap(&a,&b);
//print
 

U kunt de aanwijzer altijd afleiden met * , als u niet over de oorspronkelijke variabele beschikt. Stel dat u in een functie niet de oorspronkelijke variabele hebt, maar het adres in een pointervariabele int *x . We hebben eenvoudig toegang tot de waarde van het geheugenadres als value = *x ;

Als we geen aanwijzingen hadden, zouden we nooit pass by reference in C kunnen emuleren, omdat C pass by value is . Maar onthoud dat we alleen kunnen emuleren , want zelfs wanneer we pointers gebruiken, zijn het int *firstaddress, int *secondaddress alleen lokale int *firstaddress, int *secondaddress gemaakt, die het adres hebben van variabelen a en b .