Meny

Pekere og pekeroperasjoner i C ++

pointers pointer operations c

Prøv Instrumentet Vårt For Å Eliminere Problemer

En intensiv studie av pekere og deres bruk i C ++.

En peker er en av de kraftigste funksjonene i C ++ språk. En peker hjelper til med å manipulere variablene gjennom adressen.

hvordan du oppdaterer Windows 10 bios

I denne opplæringen vil vi utforske alt om pekere og dets bruk i C ++ i detalj.

=> Se opp den enkle C ++ treningsserien her.

Pekere i c ++

Hva du vil lære:

Hva er en peker?

En peker er en variabel som inneholder adressen til en minneplassering. Vi vet at alle variablene vi erklærer, har en spesifikk adresse i minnet. Vi erklærer en pekervariabel som peker til disse adressene i minnet.

Den generelle syntaksen for å erklære en pekervariabel er:

datatype * variable_name;

For eksempel, erklæringen int * ptr;

Dette betyr at ptr er en peker som peker på en variabel av typen int. Derfor inneholder en pekervariabel alltid en minneplassering eller adresse. La oss se hvordan pekervariabler fungerer nedenfor.

Tenk at vi har følgende erklæringer:

Int p, *ptr; //declare variable p and pointer variable ptr p = 4; //assign value 4 to variable p ptr = &p; //assign address of p to pointer variable ptr

Til minne vil disse erklæringene være representert som følger:

minnetildeling av pekere

Dette er den interne representasjonen av pekeren i minnet. Når vi tilordner adressevariabelen til pekervariabelen, peker den på variabelen som vist i representasjonen ovenfor.

Siden ptr har en adresse til variabelen p, vil * ptr gi verdien av variabelen p (variabel pekervariabelen ptr peker på).

Merk: Operatøren * som vi bruker med pekeren brukes til å betegne at det er en pekervariabel.

La oss se noen av pekerkonseptene som brukes i C ++.

Pointer Arithmetic

Vi vet at en pekervariabel alltid peker på adressen i minnet. Blant operasjonene vi kan utføre, har vi følgende aritmetiske operasjoner som utføres på pekere.

  • Intrement operator (++)
  • Redusere operatør (-)
  • Tillegg (+)
  • Subtraksjon (-)

La oss se bruken av disse operasjonene i et eksempelprogram.

#include #include using namespace std; int main() { int myarray(5) = {2, 4,6, 8,10}; int* myptr; myptr = myarray; cout<<'First element in the array :'<<*myptr<

Produksjon:

Første element i matrisen: 2
neste element i matrisen: 4
neste element i matrisen: 6
neste element i matrisen: 4
neste element i matrisen: 2

Vi har sett aritmetiske operasjoner utført på pekere. Merk at økningsoperatoren ++ inkrementerer pekeren og peker på neste element i matrisen. På samme måte reduserer deksjonsoperatoren pekervariabelen med 1 slik at den peker på forrige element i matrisen.

Vi bruker også + og - operatorer. Først har vi lagt 1 til pekervariabelen. Resultatet viser at den peker på neste element i matrisen. På samme måte gjør - operator pekervariabelen for å peke på forrige element i matrisen.

Bortsett fra disse aritmetiske operatorene, kan vi også bruke sammenligningsoperatorer som ==,.

Null And Void-pekere

Hvis en pekervariabel ikke tildeles en adresse til en variabel, er det en god praksis å tilordne en NULL-verdi til pekervariabelen. Pekervariabel med en NULL-verdi kalles NULL-pekeren.

En nullpeker er en konstant peker med verdien null definert i iostream-overskriften. Minne på adresse 0 er reservert av operativsystemet, og vi har ikke tilgang til dette stedet.

Ved å bruke nullpekeren kan vi unngå misbruk av ubrukte pekere og forhindre at pekervariabler får noen søppelverdier tildelt dem.

Void-pekere er de spesielle pekerne som peker på verdiene uten type. Tområdepekerne er mer fleksible da de kan peke på hvilken som helst type. Men de kan ikke direkte refereres til. For dereferanse, må tomromspekeren konverteres til en peker som peker på en verdi med den konkrete datatypen.

Vi har vist hvordan NULL-pekeren og ugyldig pekeren fungerer i følgende kode Eksempel.

#include #include using namespace std; int main() { int intvar = 10; char c = 'A'; void* vptr; int* myptr = NULL; cout<<'NULL pointer value :'<

Produksjon:

NULL-pekerverdi: 0
Tømmerpekeren vptr peker på: A
Tømmerpeker vptr peker på: 10

I det ovennevnte programmet erklærer vi først et heltallpeker som er tildelt en verdi NULL. Når vi skriver ut denne pekeren, ser vi at verdien er 0 som vi har diskutert tidligere.

Deretter erklærer vi en ugyldig peker. Først tilordner vi en adresse til tegnvariabelen til denne ugyldige pekeren. Deretter tildeler vi en tom peker til en tegnpeker og skriver den med char *. Deretter skriver vi ut charptr-verdi som peker på char A som var en tegnvariabel som vi erklærte tidligere og blir pekt av tomrumspekeren.

Deretter har vi tilordnet en heltallvariabel til tomrumspekeren, og deretter utfører vi de samme trinnene for å gjengjelde denne ugyldige pekeren ved å bruke en heltallspeker.

Arrays And Pointers

Arrays og pekere er sterkt assosiert med hverandre. Vi vet at navnet på matrisen peker mot det første elementet i matrisen, og dette er en konstant peker.

salgsutvikler intervju spørsmål og svar

Vi kan tilordne denne pekeren til en pekervariabel og deretter få tilgang til matrisen enten ved å dekrementere pekeren eller ved å bruke abonnementsoperatøren.

Vi vil se denne sammenhengen mellom pekervariabelen og matrisen i følgende kodeeksempel.

#include #include using namespace std; int main() { int myarray(5) = {1, 1, 2, 3, 5}; int* ptrvar; ptrvar = myarray; for(int i=0;i<5;i++) { cout<<*ptrvar<<' '; ptrvar++; } return 0; }

Produksjon:

1 1 2 3 5

I programmet ovenfor tilordner vi matrisenavnet til en pekervariabel. Når matrisenavnet peker på det første elementet i matrisen, kan vi skrive ut innholdet i hele matrisen ved å bruke en pekervariabel og øke den ved hjelp av ++ -operatøren. Dette vises i utgangen.

Array Of Pointers

Noen ganger trenger vi mer enn én pekervariabler i et program. I stedet for å erklære hver enkelt pekervariabel, kan vi erklære en rekke pekere.

La oss straks ta et eksempel for å demonstrere en rekke pekere.

#include #include using namespace std; int main() { int myarray(5) = {2,4,6,8,10}; int *ptr(5); //array of pointers for(int i=0;i<5;i++){ ptr(i) = &myarray(i); } for (int i = 0; i < 5; i++) { cout << 'Value of myarray(' << i << ') = '; cout << *ptr(i) << endl; } return 0; }

Produksjon:

Verdien av myarray (0) = 2
Verdien av myarray (1) = 4
Verdien av myarray (2) = 6
Verdien av myarray (3) = 8
Verdien av myarray (4) = 10

I erklæringen ovenfor,

int * ptr (5);

Vi kan tolke som; ptr er en matrise med 5 heltallspekere. Derfor vil hvert element i ptr peke på en variabel av typen heltall.

Vi bruker et heltall-array og tilordner adressen til hvert element i arrayet til hvert av ptr-elementene. Deretter viser vi innholdet i ptr-array ved å skrive ut '* ptr (i)'.

Pointer Of Pointers

Pekeren til pekere er ikke annet enn flere indireksjoner. Det er en slags kjede med pekere. Når vi definerer en peker med pekere, har den første pekeren en adresse til den andre pekeren, som igjen har adressen til variabelen som den peker på.

Til minne vil dette bli representert som:

Pointer of Pointers Memory Allocation

En pekepeker er erklært som følger:

int** intptr;

Vi tar direkte et kodeeksempel for bedre å forstå pekepekeren.

#include #include using namespace std; int main() { int *vptr; int ** intptr; int var = 10; vptr = &var; intptr = &vptr; cout<<'Variable var: '<

Produksjon:

Variabel var: 10
Peker til variabel: 10
Peker til peker til en variabel: 10

I det ovennevnte programmet erklærer vi en heltallvariabel, en heltallpeker og en peker til en peker til et heltall. Som vist i programmet tilordnes pekervariabelen verdien til en variabel. Pekeren til pekervariabelen tildeles adressen til pekervariabelen.

Til slutt skriver vi ut de tre variablene som viser samme verdi 10 lik en heltallvariabel.

Overføring av pekere til funksjoner

Å overføre pekere til funksjon er det samme som andre parameteroverføringsteknikker der vi overfører pekervariabler til funksjonen.

Vi går tilbake til bytte av to verdier og endrer den for å sende pekervariabler som parametere.

#include #include using namespace std; void swap(int* a, int* b) { int temp; temp = *a; *a = *b; *b = temp; } int main() { int a, b; cout<>a>>b; cout<<'a = '< Funksjonspekere

På samme måte, som vi har pekere til variabler, matriser, etc., kan vi også ha pekere til funksjoner. Men forskjellen er at funksjonspekeren peker på den kjørbare koden og ikke på data som variabler eller matriser.

Vi tar et eksempel for å demonstrere funksjonspekere.

#include #include using namespace std; void displayVal(int a) { printf('Value of a is %d ', a); } int main() { void (*func_ptr)(int) = &displayVal; (*func_ptr)(100); return 0; }

Produksjon:

Verdien av a er 100

hvordan laste ned full spilleliste fra youtube uten programvare

I det ovennevnte programmet har vi en funksjon ‘displayVal’ som bare skriver ut en heltall som er sendt til den. I hovedfunksjonen har vi definert en funksjonspeker ‘func_ptr’ som tar int som argument og returnerer en tomtype.

ugyldig (* func_ptr) (int)

Merk: Vi må legge ved funksjonspekeren inne i (). Hvis vi utelater det, blir det en funksjonsprototype.

Vi har tilordnet adressen til funksjonen 'displayVal' til denne funksjonspekeren. Deretter bruker vi denne funksjonspekeren ‘func_ptr’ vi passerer argumentverdien 100 som tilsvarer å kalle displayVal med argument 100.

Nå hvis vi har en annen funksjon med samme prototype, kan vi bruke den samme funksjonspekeren ved å tildele adressen til funksjonen til den. Dette er den viktigste bruken av funksjonspekere.

Konklusjon

Dette handler om pekepinnene, definisjonene og bruken i C ++.

I vår neste opplæring vil vi lære mer om referanser i C ++. Referanser har også spesiell bruk i C ++ og brukes ofte som alias for variabler.

=> Klikk her for den absolutte C ++ treningsserien.

Anbefalt lesing

^