Meny

Pekare och pekfunktioner i C ++

pointers pointer operations c

Prova Vårt Instrument För Att Eliminera Problem

En intensiv studie av pekare och deras användning i C ++.

En pekare är en av de mest kraftfulla funktionerna i C ++ - språket. En pekare hjälper till att manipulera variablerna genom dess adress.

hur man gör en youtube-video till en wav-fil

I denna handledning kommer vi att utforska allt om pekare och dess användning i C ++ i detalj.

=> Se upp den enkla C ++ träningsserien här.

Pekare i c ++

Vad du kommer att lära dig:

Vad är en pekare?

En pekare är en variabel som innehåller adressen till en minnesplats. Vi vet att alla variabler som vi deklarerar har en specifik adress i minnet. Vi förklarar en pekervariabel som pekar på dessa adresser i minnet.

Den allmänna syntaksen för att deklarera en pekervariabel är:

datatype * variable_name;

Till exempel, förklaringen int * ptr;

Detta betyder att ptr är en pekare som pekar på en variabel av typen int. Därför innehåller en pekervariabel alltid en minnesplats eller adress. Låt oss se hur pekervariabler fungerar nedan.

Tänk på att vi har följande deklarationer:

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

Till minne kommer dessa deklarationer att representeras på följande sätt:

minnesallokering av pekare

Detta är den interna representationen av pekaren i minnet. När vi tilldelar adressvariabeln till pekervariabeln pekar den på variabeln som visas i representationen ovan.

Eftersom ptr har en adress av variabel p, kommer * ptr att ge värdet av variabel p (variabel som pekvariabeln ptr pekar på).

Notera: Operatorn * som vi använder med pekaren används för att beteckna att det är en pekervariabel.

Låt oss se några av pekarkoncepten som används i C ++.

Pekare Aritmetik

Vi vet att en pekvariabel alltid pekar på adressen i minnet. Bland de operationer som vi kan utföra har vi följande aritmetiska operationer som utförs på pekare.

  • Ökningsoperatör (++)
  • Minskningsoperatör (-)
  • Tillägg (+)
  • Subtraktion (-)

Låt oss se användningen av dessa operationer i ett exempelprogram.

#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<

Produktion:

Första elementet i matrisen: 2
nästa element i matrisen: 4
nästa element i matrisen: 6
nästa element i matrisen: 4
nästa element i matrisen: 2

Vi har sett aritmetiska operationer utförda på pekare. Observera att inkrementoperatören ++ ökar pekaren och pekar på nästa element i arrayen. På liknande sätt minskar dekreteringsoperatören pekvariabeln med 1 så att den pekar på föregående element i matrisen.

Vi använder också + och - operatorer. Först har vi lagt till 1 i pekervariabeln. Resultatet visar att det pekar på nästa element i matrisen. På samma sätt gör operatören pekervariabeln för att peka på föregående element i matrisen.

Förutom dessa aritmetiska operatorer kan vi också använda jämförelseoperatorer som ==,.

Noll och ogiltiga pekare

Om en pekvariabel inte tilldelas en variabeladress, är det bra att tilldela ett NULL-värde till pekervariabeln. Pekervariabel med ett NULL-värde kallas NULL-pekaren.

En nollpekare är en konstant pekare med värdet noll definierat i iostream-rubriken. Minnet vid adress 0 är reserverat av operativsystemet och vi kan inte komma åt den här platsen.

Med hjälp av nollpekaren kan vi undvika missbruk av oanvända pekare och förhindra att pekvariabler får några avfallsvärden tilldelade.

Annulleringspekare är de speciella pekarna som pekar på värdena utan typ. Hålrumspekarna är mer flexibla eftersom de kan peka på vilken typ som helst. Men de kan inte diredereras direkt. För dereferens måste tomrumspekaren konverteras till en pekare som pekar på ett värde med den konkreta datatypen.

Vi har visat hur NULL-pekaren & tomrumspekaren fungerar i följande kod Exempel.

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

Produktion:

NULL-pekervärde: 0
Tompekaren vptr pekar på: A
Tompekaren vptr pekar på: 10

I ovanstående program förklarar vi först en helpekare som tilldelas ett värde NULL. När vi skriver ut den här pekaren ser vi att värdet är 0 som vi har diskuterat tidigare.

Därefter förklarar vi en ogiltig pekare. Först tilldelar vi en adress till teckenvariabel till den här ogiltiga pekaren. Sedan tilldelar vi en ogiltig pekare till en teckenpekare och skriver den med char *. Därefter skriver vi ut charptr-värde som pekar på char A som var en teckenvariabel som vi förklarade tidigare och pekas av tomrumspekaren.

Därefter har vi tilldelat en heltalvariabel till tomrumspekaren och sedan utför vi samma steg för att referera till denna tomrumspekare med hjälp av en heltalspekare.

Arrays och pekare

Arrayer och pekare är starkt associerade med varandra. Vi vet att namnet på matrisen pekar på det första elementet i matrisen och detta är en konstant pekare.

Vi kan tilldela den här pekaren till en pekervariabel och sedan komma åt matrisen antingen genom att minska pekaren eller genom att använda prenumerationsoperatören.

Vi ser denna koppling mellan pekervariabeln och matrisen i följande kodexempel.

#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; }

Produktion:

hur många typer av filer finns det python

1 1 2 3 5

I ovanstående program tilldelar vi matrisnamnet till en pekervariabel. När arraynamnet pekar på det första elementet i arrayen kan vi skriva ut innehållet i hela arrayen med hjälp av en pekervariabel och öka den med ++ -operatören. Detta visas i utgången.

Array Of Pointers

Ibland behöver vi mer än en pekervariabler i ett program. Istället för att deklarera varje enskild pekervariabel kan vi deklarera en rad pekare.

Låt oss genast ta ett exempel för att visa en rad pekare.

#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; }

Produktion:

Värde på myarray (0) = 2
Värde på myarray (1) = 4
Värde på myarray (2) = 6
Värde på myarray (3) = 8
Värde på myarray (4) = 10

I förklaringen i ovanstående

int * ptr (5);

Vi kan tolka som; ptr är en matris med 5 heltalspekare. Därför kommer varje element i ptr att peka på en variabel av typen heltal.

Vi använder ett heltal array och tilldelar adressen till varje element i arrayen till vart och ett av ptr-elementen. Sedan visar vi innehållet i ptr-array genom att mata ut '* ptr (i)'.

Pekare Av Pekare

Pekaren för pekare är inget annat än flera riktningar. Det är en slags kedja av pekare. När vi definierar en pekare med pekare har den första pekaren en adress till den andra pekaren, som i sin tur har adressen till variabeln som den pekar på.

Till minne kommer detta att representeras som:

Pointer of Pointers Memory Allocation

En pekare med pekare förklaras enligt följande:

int** intptr;

Vi tar direkt ett kodexempel för att bättre förstå pekarens pekare.

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

Produktion:

Variabel var: 10
Pekare till variabel: 10
Pekare till pekare till en variabel: 10

I ovanstående program förklarar vi en heltalsvariabel, en heltalspekare och en pekare för en pekare till ett heltal. Som visas i programmet tilldelas pekervariabeln värdet på en variabel. Pekaren på pekvariabeln tilldelas pekvariabelns adress.

Till slut skriver vi ut de tre variablerna som visar samma värde 10 lika med en heltalsvariabel.

Vidarebefordra pekare till funktioner

Att skicka pekare till funktion är detsamma som andra parameteröverföringstekniker där vi skickar pekervariabler till funktionen.

Vi återgår till att byta två värden och ändra det för att skicka pekervariabler som parametrar.

#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 = '< Funktionspekare

På samma sätt, eftersom vi har pekare på variabler, matriser, etc., kan vi också ha pekare till funktioner. Men skillnaden är att funktionspekaren pekar på den körbara koden och inte på data som variabler eller matriser.

Vi tar ett exempel för att visa funktionspekare.

#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; }

Produktion:

Värdet på a är 100

android intervju frågor och svar för 3 års erfarenhet

I ovanstående program har vi en funktion 'displayVal' som bara skriver ut ett heltal som skickas till det. I huvudfunktionen har vi definierat en funktionspekare 'func_ptr' som tar ett int som ett argument och returnerar en ogiltig typ.

ogiltigt (* func_ptr) (int)

Notera: Vi måste bifoga funktionspekaren inuti (). Om vi ​​utelämnar det blir det en funktionsprototyp.

Vi har tilldelat funktionen för funktionen 'displayVal' till denna funktionspekare. Använd sedan denna funktionspekare 'func_ptr' vi skickar argumentvärdet 100 vilket motsvarar att anropa displayVal med argument 100.

Nu om vi har en annan funktion med samma prototyp kan vi använda samma funktionspekare genom att tilldela funktionen till funktionen till den. Detta är den största användningen av funktionspekare.

Slutsats

Det här handlar om pekare, dess definitioner och användningar i C ++.

I vår nästa handledning lär vi oss mer om referenser i C ++. Referenser har också speciell användning i C ++ och används ofta som alias för variabler.

=> Klicka här för den absoluta C ++ träningsserien.

Rekommenderad läsning

^