Pointere er symbolske repræsentationer af adresser. De gør det muligt for programmer at simulere call-by-reference samt at skabe og manipulere dynamiske datastrukturer. Iteration over elementer i arrays eller andre datastrukturer er en af ​​de vigtigste anvendelser af pointere.

Adressen på den variabel, du arbejder med, er tildelt den pointervariabel, der peger på den samme datatype (såsom en int eller streng).

1 million i cifre

Syntaks:

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

Hvordan bruger man en pointer?

• Definer en pointervariabel
• Tildeling af adressen på en variabel til en markør ved hjælp af den unære operator (&), som returnerer adressen på den pågældende variabel.
• Adgang til værdien gemt i adressen ved hjælp af unær operator (*), som returnerer værdien af ​​variablen placeret på adressen specificeret af dens operand.

Grunden til at vi forbinder datatype med en pointer er at den ved, hvor mange bytes dataene er gemt i . Når vi øger en markør, øger vi markøren med størrelsen af ​​den datatype, som den peger på.

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

Referencer og pointer

Der er 3 måder at overføre C++ argumenter til en funktion:

• Call-By-Value
• Call-By-Reference med et pointer-argument
• Call-By-Reference med et referenceargument

// 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 argumenter som standard efter værdi, og ændringerne i den kaldte funktion vil ikke afspejle i den beståede variabel. Ændringerne laves til en klon lavet af den kaldte funktion. Hvis du ønsker at ændre den originale kopi direkte (især ved at passere store objekter eller array) og/eller undgå overhead ved kloning, bruger vi pass-by-reference. Pass-by-Reference med referenceargumenter kræver ikke nogen klodset syntaks til reference og dereference.

• Funktionsmarkører i C
• Peger til en funktion

Arraynavn som pointere

An array navn indeholder adressen på det første element i arrayet, der fungerer som en konstant pointer. Det betyder, at den adresse, der er gemt i array-navnet, ikke kan ændres. For eksempel, hvis vi har et array ved navn val så val og &val[0] kan bruges i flæng.

// 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 pointer ptr sendes til en funktion som et argument, kan array-værdien tilgås på lignende måde. Pointer vs Array

Pointer udtryk og pointer aritmetik

Et begrænset sæt af aritmetik operationer kan udføres på pointere, som er:

string.format i java

• øget (++)
• formindsket (— )
• et heltal kan tilføjes til en markør (+ eller +=)
• et heltal kan trækkes fra en pointer (– eller -= )
• forskel mellem to pointere (p1-p2)

( Bemærk: Pointer-aritmetik er meningsløs, medmindre den udføres på en matrix.)

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

Avanceret markørnotation

Overvej pointernotation for de todimensionelle numeriske arrays. overveje følgende erklæring

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

Generelt svarer nums[ i ][ j ] til *(*(nums+i)+j)

Pointere og strenge bogstaver

Strengliteraler er arrays, der indeholder nulterminerede tegnsekvenser. Strengliteraler er arrays af typen karakter plus afsluttende null-tegn, hvor hvert af elementerne er af typen const char (da strengens tegn ikke kan ændres).

>

Dette erklærer et array med den bogstavelige repræsentation for nørd, og derefter tildeles en pointer til dets første element til ptr. Hvis vi forestiller os, at nørd er gemt på de hukommelsessteder, der starter ved adresse 1800, kan vi repræsentere den tidligere erklæring som:

indstillingsmenu for Android

Da pointere og arrays opfører sig på samme måde i udtryk, kan ptr bruges til at få adgang til tegnene i en streng literal. For eksempel:

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

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

Pointer til pointer

I C++ kan vi oprette en pointer til en pointer, der igen kan pege på data eller en anden pointer. Syntaksen kræver simpelthen den unære operator (*) for hvert indirektionsniveau, mens markøren erklæres.

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

Her peger b på et tegn, der gemmer 'g', og c peger på markøren b.

Ugyldige pointer

Dette er en speciel type pointer tilgængelig i C++, som repræsenterer fraværet af type. Ugyldige pointer er pointere, der peger på en værdi, der ikke har nogen type (og dermed også en ubestemt længde og ubestemte dereferencende egenskaber). Dette betyder, at void pointers har stor fleksibilitet, da de kan pege på enhver datatype. Der er en gevinst for denne fleksibilitet. Disse pejlemærker kan ikke afledes direkte. De skal først transformeres til en anden pointertype, der peger på en konkret datatype, før de dereferences.

// 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 pointer

En pointer skal pege på en gyldig adresse, men ikke nødvendigvis til gyldige elementer (som for arrays). Disse kaldes ugyldige pointere. Ikke-initialiserede pointere er også ugyldige pointere.

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

Her er ptr1 uinitialiseret, så det bliver en ugyldig pointer og ptr2 er uden for arr's grænser, så det bliver også en ugyldig pointer. (Bemærk: ugyldige pointere giver ikke nødvendigvis kompileringsfejl)

NULL pointere

EN nul pointer er en pointer, der ikke peger nogen steder og ikke kun en ugyldig adresse. Følgende er 2 metoder til at tildele en pointer som NULL;

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

Fordele ved pointere

• Pointere reducerer koden og forbedrer ydeevnen. De bruges til at hente strenge, træer, arrays, strukturer og funktioner.
• Pointere giver os mulighed for at returnere flere værdier fra funktioner.
• Ud over dette giver pointere os mulighed for at få adgang til en hukommelsesplacering i computerens hukommelse.

Relaterede artikler:

spærrede numre

• Uigennemsigtig pointer
• Nær, fjern og enorme pointere

Quizzer:

• Grundlæggende om pointer
• Avanceret pointer