Menu

Markører og markørfunktioner i C ++

pointers pointer operations c

Prøv Vores Instrument Til At Fjerne Problemer

En intensiv undersøgelse af markører og deres anvendelse i C ++.

En markør er en af ​​de mest kraftfulde funktioner i C ++ sprog. En markør hjælper med at manipulere variablerne gennem dens adresse.

bedste mobiltelefon spion til Android

I denne vejledning vil vi udforske alt om markører og dets anvendelser i C ++ i detaljer.

=> Hold øje med den enkle C ++ træningsserie her.

Tip i c ++

Hvad du lærer:

Hvad er en markør?

En markør er en variabel, der indeholder adressen på en hukommelsesplacering. Vi ved, at alle de variabler, vi erklærer, har en bestemt adresse i hukommelsen. Vi erklærer en markørvariabel, der peger på disse adresser i hukommelsen.

Den generelle syntaks til erklæring af en markørvariabel er:

datatype * variable_name;

For eksempel, erklæringen int * ptr;

Dette betyder, at ptr er en markør, der peger på en variabel af typen int. Derfor indeholder en markørvariabel altid en hukommelsesplacering eller -adresse. Lad os se, hvordan pointervariabler fungerer nedenfor.

Overvej, 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

I hukommelsen vil disse erklæringer blive repræsenteret som følger:

hukommelsesallokering af markører

Dette er den interne repræsentation af markøren i hukommelsen. Når vi tildeler adressevariablen til markørvariablen, peger den på variablen som vist i repræsentationen ovenfor.

Da ptr har en adresse på variablen p, vil * ptr give værdien af ​​variablen p (variabel, som markørvariablen ptr peger på).

Bemærk: Operatøren *, som vi bruger med markøren, bruges til at angive, at det er en markørvariabel.

Lad os se nogle af de pointerkoncepter, der bruges i C ++.

Pointer Arithmetic

Vi ved, at en markørvariabel altid peger på adressen i hukommelsen. Blandt de operationer, vi kan udføre, har vi følgende aritmetiske operationer, der udføres på markører.

  • Forøgelsesoperator (++)
  • Nedskrivningsoperatør (-)
  • Tilføjelse (+)
  • Subtraktion (-)

Lad os se brugen af ​​disse operationer 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<

Produktion:

Første element i arrayet: 2
næste element i arrayet: 4
næste element i arrayet: 6
næste element i arrayet: 4
næste element i arrayet: 2

Vi har set de aritmetiske operationer udført på pegepinde. Bemærk, at inkrementoperatoren ++ forøger markøren og peger på det næste element i arrayet. Tilsvarende reducerer operatoren for dekrementering markørvariablen med 1, så den peger på det forrige element i arrayet.

Vi bruger også + og - operatorer. Først har vi tilføjet 1 til markørvariablen. Resultatet viser, at det peger på det næste element i arrayet. På samme måde gør - operator markøren variabel til at pege på det forrige element i arrayet.

Bortset fra disse aritmetiske operatorer kan vi også bruge sammenligningsoperatorer som ==,.

Nul og ugyldige henvisninger

Hvis der i tilfælde af, at en markørvariabel ikke tildeles en adresse til en variabel, er det en god praksis at tildele en NULL-værdi til markørvariablen. Markørvariabel med en NULL-værdi kaldes NULL-markøren.

En nul pointer er en konstant pointer med værdien nul defineret i iostream headeren. Hukommelsen på adresse 0 er reserveret af operativsystemet, og vi kan ikke få adgang til denne placering.

Ved hjælp af nulmarkøren kan vi undgå misbrug af ubrugte markører og forhindre, at markørvariabler får nogle skraldværdier tildelt dem.

Ugyldige markører er de specielle markører, der peger på værdier uden type. Tømmerpegerne er mere fleksible, da de kan pege på enhver type. Men de kan ikke direkte refereres til. For derferference skal tomrumsmarkøren konverteres til en markør, der peger på en værdi med den konkrete datatype.

Vi har vist funktionen af ​​NULL-markøren og ugyldighedsmarkøren i følgende kodeeksempel.

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

Produktion:

NULL-markørværdi: 0
Ugyldig markør vptr peger på: A
Ugyldig markør vptr peger på: 10

I ovenstående program erklærer vi først et heltalsmarkør, der tildeles en værdi NULL. Når vi udskriver denne markør, ser vi, at værdien er 0, som vi har diskuteret tidligere.

Dernæst erklærer vi en ugyldig markør. Først tildeler vi en adresse til tegnvariabler til denne ugyldige markør. Derefter tildeler vi en ugyldig markør til en tegnmarkør og skriver den med char *. Dernæst udskriver vi charptr-værdi, der peger på char A, som var en tegnvariabel, som vi erklærede tidligere og peges af tomrumsmarkøren.

Dernæst har vi tildelt en tom variabel til tomrumsmarkøren, og derefter udfører vi de samme trin for at henvise denne ugyldige markør ved hjælp af et heltal markør.

Arrays And Pointers

Arrays og pegepinde er stærkt forbundet med hinanden. Vi ved, at arrayets navn peger på det første element i arrayet, og dette er en konstant markør.

Vi kan tildele denne markør til en markørvariabel og derefter få adgang til arrayet enten ved at reducere markøren eller ved at bruge abonnementsoperatoren.

Vi ser denne sammenhæng mellem markørvariablen og arrayet 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; }

Produktion:

1 1 2 3 5

I ovenstående program tildeler vi matrixnavnet til en markørvariabel. Da arraynavnet peger på det første element i arrayet, kan vi udskrive indholdet af hele arrayet ved hjælp af en markørvariabel og inkrementere det ved hjælp af ++ -operatøren. Dette vises i output.

Array Of Pointers

Nogle gange har vi brug for mere end en markørvariabel i et program. I stedet for at erklære hver enkelt markørvariabel, kan vi erklære en række markører.

Lad os straks tage et eksempel for at demonstrere en række markører.

#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ærdien af ​​myarray (0) = 2
Værdien af ​​myarray (1) = 4
Værdien af ​​myarray (2) = 6
Værdien af ​​myarray (3) = 8
Værdien af ​​myarray (4) = 10

I erklæringen i ovenstående

int * ptr (5);

graf implementering c ++ tilstødelsesliste

Vi kan fortolke som; ptr er en matrix med 5 heltalsmarkører. Derfor vil hvert element i ptr pege på en variabel af typen heltal.

Vi bruger et heltal array og tildeler adressen til hvert element i arrayet til hvert af ptr-elementerne. Derefter viser vi indholdet af ptr-array ved at udsende “* ptr (i)”.

Pointer Of Pointers

Markøren til markører er intet andet end flere indirektioner. Det er en slags kæde af pointer. Når vi definerer en markør med markører, har den første markør en adresse til den anden markør, som igen har adressen på den variabel, som den peger på.

I hukommelsen vil dette blive repræsenteret som:

Pointer of Pointers Memory Allocation

En pointer med markører erklæres som følger:

int** intptr;

Vi tager direkte et kodeeksempel for bedre at forstå pointerens markør.

#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
Markør til variabel: 10
Markør til Markør til en variabel: 10

I ovenstående program erklærer vi en heltalsvariabel, en heltalsmarkør og en markør af en markør til et heltal. Som vist i programmet tildeles markørvariablen værdien af ​​en variabel. Markøren til markørvariablen tildeles adressen til markørvariablen.

I sidste ende udskriver vi de tre variabler, der viser den samme værdi 10 svarende til en heltalsvariabel.

Videregivelse af markører til funktioner

At overføre markører til funktion er det samme som andre teknikker til parameteroverføring, hvor vi sender markørvariabler til funktionen.

Vi besøger vores ombytning af to værdier og ændrer det for at videregive markørvariabler som parametre.

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

På samme måde, da vi har pegepunkter til variabler, arrays osv., kan vi også have pegepunkter til funktioner. Men forskellen er, at funktionsmarkøren peger på den eksekverbare kode og ikke på data som variabler eller arrays.

Vi tager et eksempel for at demonstrere funktionspegere.

#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ærdien af ​​a er 100

hvad er den bedste software til rengøring af computere

I ovenstående program har vi en funktion 'displayVal', der bare udskriver en heltalsværdi, der sendes til den. I hovedfunktionen har vi defineret en funktionsmarkør 'func_ptr', der tager et int som et argument og returnerer en ugyldig type.

ugyldigt (* func_ptr) (int)

Bemærk: Vi er nødt til at vedlægge funktionsmarkøren inde (). Hvis vi udelader det, bliver det en funktionsprototype.

Vi har tildelt funktionen til funktionen 'displayVal' til denne funktionsmarkør. Brug derefter denne funktionsmarkør 'func_ptr', vi videregiver argumentværdien 100, der svarer til at kalde displayVal med argument 100.

Hvis vi nu har en anden funktion med den samme prototype, kan vi bruge den samme funktionsmarkør ved at tildele funktionen til funktionen til den. Dette er den største brug af funktionsmarkører.

Konklusion

Dette handler om henvisningerne, dens definitioner og anvendelser i C ++.

I vores næste tutorial lærer vi mere om referencer i C ++. Referencer har også særlig brug i C ++ og bruges ofte som aliaser for variabler.

=> Klik her for den absolutte C ++ træningsserie.

Anbefalet læsning

^