Pekare är symboliska representationer av adresser. De gör det möjligt för program att simulera call-by-referens samt att skapa och manipulera dynamiska datastrukturer. Att iterera över element i arrayer eller andra datastrukturer är en av de huvudsakliga användningarna av pekare.

Adressen till variabeln du arbetar med tilldelas pekarvariabeln som pekar på samma datatyp (som en int eller sträng).

js settimeout

Syntax:

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

Hur använder man en pekare?

• Definiera en pekarvariabel
• Tilldela adressen för en variabel till en pekare med den unära operatorn (&) som returnerar adressen för den variabeln.
• Åtkomst till värdet lagrat i adressen med hjälp av unary operator (*) som returnerar värdet på variabeln som finns på adressen som anges av dess operand.

Anledningen till att vi associerar datatyp med en pekare är att den vet hur många byte data lagras i . När vi ökar en pekare ökar vi pekaren med storleken på den datatyp som den pekar mot.

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

Referenser och tips

Det finns tre sätt att skicka C++-argument till en funktion:

• Call-By-Value
• Call-by-Reference med ett pekarargument
• Call-By-Reference med ett referensargument

// 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++ skickas som standard argument av värde och ändringarna som görs i den anropade funktionen kommer inte att återspeglas i den överförda variabeln. Ändringarna görs till en klon gjord av den anropade funktionen. Om du vill modifiera originalkopian direkt (särskilt genom att passera stora objekt eller array) och/eller undvika kloning, använder vi pass-by-referens. Pass-by-Reference with Reference Argument kräver ingen klumpig syntax för referenser och därav.

• Funktionspekare i C
• Pekare till en funktion

Arraynamn som pekare

En array name innehåller adressen till det första elementet i arrayen som fungerar som en konstant pekare. Det betyder att adressen som är lagrad i arraynamnet inte kan ändras. Till exempel, om vi har en array som heter val då val och &val[0] kan användas omväxlande.

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

Om pekaren ptr skickas till en funktion som ett argument, kan arrayvärdet nås på liknande sätt. Pointer vs Array

Pekaruttryck och Pekararitmetik

En begränsad uppsättning aritmetisk operationer kan utföras på pekare som är:

importera skanner java

• ökat (++)
• minskat (—)
• ett heltal kan läggas till en pekare ( + eller += )
• ett heltal kan subtraheras från en pekare (– eller -= )
• skillnad mellan två pekare (p1-p2)

( Notera: Pekarritmetik är meningslös om den inte utförs på en matris.)

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

Avancerad pekarnotation

Överväg pekarnotation för de tvådimensionella numeriska arrayerna. överväga följande förklaring

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

I allmänhet är nums[ i ][ j ] ekvivalent med *(*(nums+i)+j)

Pekare och strängbokstavar

Strängliteraler är arrayer som innehåller nollterminerade teckensekvenser. Strängliteraler är matriser av typen tecken plus avslutande null-tecken, där vart och ett av elementen är av typen const char (eftersom strängens tecken inte kan modifieras).

>

Detta deklarerar en array med den bokstavliga representationen för nörd, och sedan tilldelas en pekare till dess första element till ptr. Om vi ​​föreställer oss att nörden är lagrad på minnesplatserna som börjar på adress 1800, kan vi representera den tidigare deklarationen som:

är proteinfett

Eftersom pekare och arrayer beter sig på samma sätt i uttryck, kan ptr användas för att komma åt tecknen i en bokstavlig sträng. Till exempel:

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

Här innehåller både x och y k lagrat vid 1803 (1800+3).

Pekare till pekare

I C++ kan vi skapa en pekare till en pekare som i sin tur kan peka på data eller en annan pekare. Syntaxen kräver helt enkelt den unära operatorn (*) för varje nivå av inriktning samtidigt som pekaren deklareras.

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

Här pekar b på ett tecken som lagrar 'g' och c pekar på pekaren b.

Void Pointers

Detta är en speciell typ av pekare tillgänglig i C++ som representerar frånvaron av typ. Tom pekare är pekare som pekar på ett värde som inte har någon typ (och därmed även en obestämd längd och obestämda avledningsegenskaper). Detta innebär att void-pekare har stor flexibilitet eftersom de kan peka på vilken datatyp som helst. Det finns en vinst för denna flexibilitet. Dessa pekare kan inte direkt borthänvisas. De måste först omvandlas till någon annan pekartyp som pekar på en konkret datatyp innan de avhänvisas.

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

Ogiltiga pekare

En pekare bör peka på en giltig adress men inte nödvändigtvis på giltiga element (som för arrayer). Dessa kallas ogiltiga pekare. Oinitierade pekare är också ogiltiga pekare.

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

Här är ptr1 oinitierad så det blir en ogiltig pekare och ptr2 är utanför gränserna för arr så det blir också en ogiltig pekare. (Obs: ogiltiga pekare leder inte nödvändigtvis till kompileringsfel)

NULL-pekare

A nollpekare är en pekare som inte pekar någonstans och inte bara en ogiltig adress. Följande är 2 metoder för att tilldela en pekare som NULL;

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

Fördelar med Pointers

• Pekare minskar koden och förbättrar prestandan. De används för att hämta strängar, träd, arrayer, strukturer och funktioner.
• Pekare låter oss returnera flera värden från funktioner.
• Utöver detta tillåter pekare oss att komma åt en minnesplats i datorns minne.

Relaterade artiklar:

hur man väljer kolumner från olika tabeller i sql

• Ogenomskinlig pekare
• Nära, fjärran och enorma pekare

Frågesporter:

• Pointer Grunderna
• Avancerad pekare