Pekere er symbolske representasjoner av adresser. De gjør det mulig for programmer å simulere samtale-for-referanse samt å lage og manipulere dynamiske datastrukturer. Iterering over elementer i arrays eller andre datastrukturer er en av hovedbruken av pekere.

Adressen til variabelen du jobber med er tilordnet pekervariabelen som peker til samme datatype (som en int eller streng).

arrayliste metoder

Syntaks:

datatype *var_name; int *ptr; // ptr can point to an address which holds int data>

Hvordan bruke en peker?

• Definer en pekervariabel
• Tilordne adressen til en variabel til en peker ved å bruke den unære operatoren (&) som returnerer adressen til den variabelen.
• Tilgang til verdien som er lagret i adressen ved å bruke unær operator (*) som returnerer verdien til variabelen som ligger på adressen spesifisert av operanden.

Grunnen til at vi forbinder datatype med en peker er at den vet hvor mange byte dataene er lagret i . Når vi øker en peker, øker vi pekeren med størrelsen på datatypen den peker til.

// C++ program to illustrate Pointers #include  using namespace std; void geeks() {  int var = 20;  // declare pointer variable  int* ptr;  // note that data type of ptr and var must be same  ptr = &var;  // assign the address of a variable to a pointer  cout << 'Value at ptr = ' << ptr << '
';  cout << 'Value at var = ' << var << '
';  cout << 'Value at *ptr = ' << *ptr << '
'; } // Driver program int main()  {   geeks();   return 0; }>

Value at ptr = 0x7ffe454c08cc Value at var = 20 Value at *ptr = 20>

Referanser og tips

Det er 3 måter å sende C++-argumenter til en funksjon:

• Ring-etter-verdi
• Ring-ved-referanse med et pekerargument
• Ring-for-referanse med et referanseargument

// C++ program to illustrate call-by-methods #include  using namespace std; // Pass-by-Value int square1(int n) {  // Address of n in square1() is not the same as n1 in  // main()  cout << 'address of n1 in square1(): ' << &n << '
';  // clone modified inside the function  n *= n;  return n; } // Pass-by-Reference with Pointer Arguments void square2(int* n) {  // Address of n in square2() is the same as n2 in main()  cout << 'address of n2 in square2(): ' << n << '
';  // Explicit de-referencing to get the value pointed-to  *n *= *n; } // Pass-by-Reference with Reference Arguments void square3(int& n) {  // Address of n in square3() is the same as n3 in main()  cout << 'address of n3 in square3(): ' << &n << '
';  // Implicit de-referencing (without '*')  n *= n; } void geeks() {  // Call-by-Value  int n1 = 8;  cout << 'address of n1 in main(): ' << &n1 << '
';  cout << 'Square of n1: ' << square1(n1) << '
';  cout << 'No change in n1: ' << n1 << '
';  // Call-by-Reference with Pointer Arguments  int n2 = 8;  cout << 'address of n2 in main(): ' << &n2 << '
';  square2(&n2);  cout << 'Square of n2: ' << n2 << '
';  cout << 'Change reflected in n2: ' << n2 << '
';  // Call-by-Reference with Reference Arguments  int n3 = 8;  cout << 'address of n3 in main(): ' << &n3 << '
';  square3(n3);  cout << 'Square of n3: ' << n3 << '
';  cout << 'Change reflected in n3: ' << n3 << '
'; } // Driver program int main() { geeks(); }>

address of n1 in main(): 0x7fffa7e2de64 address of n1 in square1(): 0x7fffa7e2de4c Square of n1: 64 No change in n1: 8 address of n2 in main(): 0x7fffa7e2de68 address of n2 in square2(): 0x7fffa7e2de68 Square of n2: 64 Change reflected in n2: 64 address of n3 in main(): 0x7fffa7e2de6c address of n3 in square3(): 0x7fffa7e2de6c Square of n3: 64 Change reflected in n3: 64>

I C++ sendes som standard argumenter av verdi og endringene som er gjort i den kalte funksjonen vil ikke reflektere i den beståtte variabelen. Endringene gjøres til en klone laget av den kalte funksjonen. Hvis du ønsker å modifisere den originale kopien direkte (spesielt ved å passere et stort objekt eller en rekke) og/eller unngå overhead ved kloning, bruker vi pass-by-referanse. Pass-by-Reference med referanseargumenter krever ingen klønete syntaks for referanse og dereferering.

• Funksjonspekere i C
• Peker til en funksjon

Arraynavn som pekere

An array navn inneholder adressen til det første elementet i matrisen som fungerer som en konstant peker. Det betyr at adressen som er lagret i arraynavnet ikke kan endres. For eksempel, hvis vi har en matrise som heter val da val og &val[0] kan brukes om hverandre.

// C++ program to illustrate Array Name as Pointers #include  using namespace std; void geeks() {  // Declare an array  int val[3] = { 5, 10, 20 };  // declare pointer variable  int* ptr;  // Assign the address of val[0] to ptr  // We can use ptr=&val[0];(both are same)  ptr = val;  cout << 'Elements of the array are: ';  cout << ptr[0] << ' ' << ptr[1] << ' ' << ptr[2]; } // Driver program int main() { geeks(); }>

Elements of the array are: 5 10 20>

Hvis peker ptr sendes til en funksjon som et argument, kan array val nås på lignende måte. Pointer vs Array

Pekeruttrykk og Pekeraritmetikk

Et begrenset sett med aritmetikk operasjoner kan utføres på pekere som er:

css midtknapp

• økte ( ++ )
• redusert ( — )
• et heltall kan legges til en peker ( + eller += )
• et heltall kan trekkes fra en peker ( – eller -= )
• forskjell mellom to pekere (p1-p2)

( Merk: Pekeraritmetikk er meningsløs med mindre den utføres på en matrise.)

// C++ program to illustrate Pointer Arithmetic #include  using namespace std; void geeks() {  // Declare an array  int v[3] = { 10, 100, 200 };  // declare pointer variable  int* ptr;  // Assign the address of v[0] to ptr  ptr = v;  for (int i = 0; i < 3; i++) {  cout << 'Value at ptr = ' << ptr << '
';  cout << 'Value at *ptr = ' << *ptr << '
';  // Increment pointer ptr by 1  ptr++;  } } // Driver program int main() { geeks(); }>

Value at ptr = 0x7ffe5a2d8060 Value at *ptr = 10 Value at ptr = 0x7ffe5a2d8064 Value at *ptr = 100 Value at ptr = 0x7ffe5a2d8068 Value at *ptr = 200>

Avansert pekernotasjon

Vurder pekernotasjon for de todimensjonale numeriske matrisene. vurdere følgende erklæring

int nums[2][3] = { { 16, 18, 20 }, { 25, 26, 27 } };>

Generelt er nums[ i ][ j ] ekvivalent med *(*(nums+i)+j)

Pekere og strengbokstaver

Strengliteraler er matriser som inneholder nullterminerte tegnsekvenser. Strengliteraler er matriser av typen karakter pluss avsluttende null-tegn, der hvert av elementene er av typen const char (ettersom tegnene i strengen ikke kan endres).

>

Dette erklærer en matrise med den bokstavelige representasjonen for geek, og deretter blir en peker til det første elementet tilordnet ptr. Hvis vi forestiller oss at geek er lagret på minnestedene som starter på adresse 1800, kan vi representere den forrige erklæringen som:

rihanna alder

Ettersom pekere og matriser oppfører seg på samme måte i uttrykk, kan ptr brukes for å få tilgang til tegnene i en streng bokstavelig. For eksempel:

char ptr = 0; char x = *(ptr+3); char y = ptr[3];>

Her inneholder både x og y k lagret ved 1803 (1800+3).

Pekere til pekere

I C++ kan vi lage en peker til en peker som igjen kan peke til data eller en annen peker. Syntaksen krever ganske enkelt den unære operatoren (*) for hvert indirektionsnivå mens pekeren erklæres.

char a; char *b; char ** c; a = ’g’; b = &a; c = &b;>

Her peker b på et tegn som lagrer 'g' og c peker på pekeren b.

Void Pointers

Dette er en spesiell type peker tilgjengelig i C++ som representerer fraværet av type. Ugyldige pekere er pekere som peker på en verdi som ikke har noen type (og dermed også en ubestemt lengde og ubestemte dereferensegenskaper). Dette betyr at void-pekere har stor fleksibilitet da de kan peke til alle datatyper. Det er en gevinst for denne fleksibiliteten. Disse pekene kan ikke avvises direkte. De må først transformeres til en annen pekertype som peker på en konkret datatype før de blir referert.

// C++ program to illustrate Void Pointer #include  using namespace std; void increase(void* data, int ptrsize) {  if (ptrsize == sizeof(char)) {  char* ptrchar;  // Typecast data to a char pointer  ptrchar = (char*)data;  // Increase the char stored at *ptrchar by 1  (*ptrchar)++;  cout << '*data points to a char'  << '
';  }  else if (ptrsize == sizeof(int)) {  int* ptrint;  // Typecast data to a int pointer  ptrint = (int*)data;  // Increase the int stored at *ptrchar by 1  (*ptrint)++;  cout << '*data points to an int'  << '
';  } } void geek() {  // Declare a character  char c = 'x';  // Declare an integer  int i = 10;  // Call increase function using a char and int address  // respectively  increase(&c, sizeof(c));  cout << 'The new value of c is: ' << c << '
';  increase(&i, sizeof(i));  cout << 'The new value of i is: ' << i << '
'; } // Driver program int main() { geek(); }>

*data points to a char The new value of c is: y *data points to an int The new value of i is: 11>

Ugyldige pekere

En peker skal peke til en gyldig adresse, men ikke nødvendigvis til gyldige elementer (som for matriser). Disse kalles ugyldige pekere. Ikke-initialiserte pekere er også ugyldige pekere.

int *ptr1; int arr[10]; int *ptr2 = arr+20;>

Her er ptr1 uinitialisert slik at det blir en ugyldig peker og ptr2 er utenfor grensene for arr, så det blir også en ugyldig peker. (Merk: ugyldige pekere gir ikke nødvendigvis kompileringsfeil)

NULL-pekere

EN null-peker er en peker som ikke peker noe sted og ikke bare en ugyldig adresse. Følgende er 2 metoder for å tilordne en peker som NULL;

int *ptr1 = 0; int *ptr2 = NULL;>

Fordeler med Pointers

• Pekere reduserer koden og forbedrer ytelsen. De brukes til å hente strenger, trær, matriser, strukturer og funksjoner.
• Pekere lar oss returnere flere verdier fra funksjoner.
• I tillegg til dette lar pekere oss få tilgang til en minneplassering i datamaskinens minne.

Relaterte artikler:

programmering i c-matriser

• Ugjennomsiktig peker
• Nære, Fjerne og enorme pekere

Quiz:

• Grunnleggende om pekeren
• Avansert peker