Pointeri în programarea C: Ce este Pointer, Tipuri & Exemple

Ce este Pointer în C?

Pointer în C, este o variabilă care stochează adresa unei alte variabile. Un pointer poate fi, de asemenea, utilizat pentru a se referi la o altă funcție de pointer. Un indicator poate fi incrementat / decrementat, adică pentru a indica către locația de memorie următoare / anterioară. Scopul indicatorului este de a economisi spațiu de memorie și de a obține un timp de execuție mai rapid.

Cum se utilizează pointerele în C

Dacă declarăm o variabilă v de tip int, v va stoca de fapt o valoare.

v este egal cu zero acum.

Cu toate acestea, fiecare variabilă, în afară de valoare, are și adresa sa (sau, pur și simplu, unde se află în memorie). Adresa poate fi recuperată prin punerea unui semn cu semn (&) înaintea numelui variabilei.

Dacă imprimați adresa unei variabile pe ecran, aceasta va arăta ca un număr total aleatoriu (în plus, poate fi diferit de la o rulare la alta).

Să încercăm acest lucru în practică cu pointerul în exemplul C.

Rezultatul acestui program este -480613588.

Acum, ce este un indicator? În loc să stocheze o valoare, un pointer va stoca adresa unei variabile.

Pointer Variable

Int * y = & v;

VARIABIL	POINTER
O valoare stocată într-o adresă de stocare / memorie denumită	O variabilă care indică adresa de stocare / memorie a altei variabile

Declararea unui indicator

La fel ca variabilele, indicatoarele din programarea C trebuie declarate înainte de a putea fi utilizate în programul dvs. Pointerii pot fi numiți orice doriți, atâta timp cât respectă regulile de numire ale lui C. O declarație pointer are următoarea formă.

data_type * pointer_variable_name;

Aici,

• data_type este tipul de bază al indicatorului pentru tipurile de variabile C și indică tipul variabilei către care indică indicatorul.
• Asteriscul (*: același asterisc utilizat pentru multiplicare) care este operator de indirecție, declară un pointer.

Să vedem câteva declarații valide ale indicatorului în acest tutorial de indicatori C:

int *ptr_thing; /* pointer to an integer */int *ptr1,thing;/* ptr1 is a pointer to type integer and thing is an integer variable */double *ptr2; /* pointer to a double */float *ptr3; /* pointer to a float */char *ch1 ; /* pointer to a character */float *ptr, variable;/*ptr is a pointer to type float and variable is an ordinary float variable */

Inițializați un pointer

După declararea unui pointer, îl inițializăm ca variabile standard cu o adresă variabilă. Dacă indicii în programarea C nu sunt inițializați și folosiți în program, rezultatele sunt imprevizibile și potențial dezastruoase.

Pentru a obține adresa unei variabile, folosim operatorul ampersand (&), plasat înaintea numelui unei variabile a cărei adresă avem nevoie. Inițializarea indicatorului se face cu următoarea sintaxă.

Sintaxa indicatorului

 pointer = &variable; 

Un program simplu pentru ilustrarea indicatorului este dat mai jos:

#include int main(){int a=10; //variable declarationint *p; //pointer variable declarationp=&a; //store address of variable a in pointer pprintf("Address stored in a variable p is:%x\n",p); //accessing the addressprintf("Value stored in a variable p is:%d\n",*p); //accessing the valuereturn 0;}

Ieșire:

Address stored in a variable p is:60ff08Value stored in a variable p is:10

Operator	Sens
*	Are 2 scopuri Declarația unui indicator Returnează valoarea variabilei la care se face referire
&	Are doar un scop Returnează adresa unei variabile

Tipuri de indicatori în C

Următoarele sunt diferitele tipuri de indicatori în C :

Indicator nul

Putem crea un pointer nul atribuind valoare nulă în timpul declarației pointerului. Această metodă este utilă atunci când nu aveți nicio adresă atribuită indicatorului. Un indicator nul conține întotdeauna valoarea 0.

Programul următor ilustrează utilizarea unui pointer nul:

#include int main(){int *p = NULL; //null pointerprintf(“The value inside variable p is:\n%x”,p);return 0;}

Ieșire:

The value inside variable p is:0

Indicator gol

În programarea C, un pointer gol este, de asemenea, numit ca un pointer generic. Nu are niciun tip de date standard. Un pointer gol este creat utilizând cuvântul cheie gol. Poate fi folosit pentru a stoca o adresă a oricărei variabile.

Programul următor ilustrează utilizarea unui pointer gol:

#include int main(){void *p = NULL; //void pointerprintf("The size of pointer is:%d\n",sizeof(p));return 0;}

Ieșire:

The size of pointer is:4

Pointer sălbatic

Se spune că un pointer este un pointer sălbatic dacă nu este inițializat la nimic. Aceste tipuri de indicatoare C nu sunt eficiente, deoarece pot indica o locație de memorie necunoscută, care poate provoca probleme în programul nostru și poate duce la blocarea programului. Ar trebui să fii întotdeauna atent în timp ce lucrezi cu indicatori sălbatici.

Programul următor ilustrează utilizarea indicatorului sălbatic:

#include int main(){int *p; //wild pointerprintf("\n%d",*p);return 0;}

Ieșire

timeout: the monitored command dumped coresh: line 1: 95298 Segmentation fault timeout 10s main

Alte tipuri de indicatori din „c” sunt după cum urmează:

• Indicator suspendat
• Pointer complex
• Aproape indicatorul
• Pointer îndepărtat
• Pointer imens

Indicatoare de acces direct și indirect

În C, există două moduri echivalente de a accesa și manipula un conținut variabil

• Acces direct: folosim direct numele variabilei
• Acces indirect: folosim un pointer către variabilă

Să înțelegem acest lucru cu ajutorul programului de mai jos

#include /* Declare and initialize an int variable */int var = 1;/* Declare a pointer to int */int *ptr;int main( void ){/* Initialize ptr to point to var */ptr = &var;/* Access var directly and indirectly */printf("\nDirect access, var = %d", var);printf("\nIndirect access, var = %d", *ptr);/* Display the address of var two ways */printf("\n\nThe address of var = %d", &var);printf("\nThe address of var = %d\n", ptr);/*change the content of var through the pointer*/*ptr=48;printf("\nIndirect access, var = %d", *ptr);return 0;}

După compilarea programului fără erori, rezultatul este:

Direct access, var = 1Indirect access, var = 1The address of var = 4202496The address of var = 4202496Indirect access, var = 48

Aritmetica indicatorului în C

Operațiunile indicatorului sunt rezumate în figura următoare

Operație prioritară (prioritate)

Când lucrăm cu indicii C, trebuie să respectăm următoarele reguli de prioritate:

• Operatorii * și & au aceeași prioritate ca operatorii unari (negația !, incrementarea ++, diminuarea--).
• În aceeași expresie, operatorii unari *, &,!, ++, - sunt evaluați de la dreapta la stânga.

Dacă un indicator P indică o variabilă X, atunci * P poate fi folosit oriunde se poate scrie X.

Următoarele expresii sunt echivalente:

int X = 10 int * P = & Y; Pentru codul de mai sus, expresiile de mai jos sunt adevărate
Expresie	Expresie echivalentă
Y = * P + 1 * P = * P + 10 * P + = 2 ++ * P (* P) ​​++	Y = X + 1 X = X + 10 X + = 2 ++ X X ++

În acest din urmă caz, sunt necesare paranteze: deoarece operatorii unari * și ++ sunt evaluați de la dreapta la stânga, fără paranteze ar fi incrementat indicatorul P, nu obiectul pe care P indică.

Tabelul de mai jos prezintă operația aritmetică și de bază care poate fi utilizată atunci când se tratează cu indicii C.

Operațiune	Explicaţie
Misiune	int * P1, * P2 P1 = P2; P1 și P2 indică aceeași variabilă întreagă
Incrementare și decrementare	Int * P1; P1 ++; P1--;
Adăugarea unui offset (constant)	Aceasta permite indicatorului să deplaseze N elemente într-un tabel. Pointerul va fi mărit sau micșorat de N ori numărul de octeți de tipul variabilei. P1 + 5;

C Pointeri și tablouri cu exemple

În mod tradițional, accesăm elementele matrice folosind indexul său, dar această metodă poate fi eliminată folosind pointeri. Pointerii facilitează accesul la fiecare element de matrice.

#include int main(){int a[5]={1,2,3,4,5}; //array initializationint *p; //pointer declaration/*the ptr points to the first element of the array*/p=a; /*We can also type simply ptr==&a[0] */printf("Printing the array elements using pointer\n");for(int i=0;i<5;i++) //loop for traversing array elements{printf("\n%x",*p); //printing array elementsp++; //incrementing to the next element, you can also write p=p+1}return 0;}

Ieșire

12345

Adăugarea unui anumit număr la un pointer va muta locația indicatorului la valoarea obținută printr-o operație de adăugare. Să presupunem că p este un indicator care indică în prezent locația memoriei 0 dacă efectuăm operația de adăugare următoare, p + 1, atunci se va executa în acest mod:

Deoarece p indică în prezent locația 0 după adăugarea 1, valoarea va deveni 1 și, prin urmare, indicatorul va indica locația de memorie 1.

C Pointeri și șiruri cu exemple

Un șir este o matrice de obiecte char, care se termină cu un caracter nul '\ 0'. Putem manipula șirurile folosind pointeri. Acest indicator din exemplul C explică această secțiune

#include #include int main(){char str[]="Hello Guru99!";char *p;p=str;printf("First character is:%c\n",*p);p =p+1;printf("Next character is:%c\n",*p);printf("Printing all the characters in a string\n");p=str; //reset the pointerfor(int i=0;i
Ieșire
First character is:HNext character is:ePrinting all the characters in a stringHelloGuru99!
O altă modalitate de a trata șirurile este cu o serie de indicatori ca în următorul program:
#include int main(){char *materials[ ] = { "iron", "copper", "gold"};printf("Please remember these materials :\n");int i ;for (i = 0; i < 3; i++) {printf("%s\n", materials[ i ]);}return 0;}
Ieșire:
Please remember these materials:ironcoppergold
 
Avantajele indicatoarelor în C

Indicatoarele sunt utile pentru accesarea locațiilor de memorie.
Indicatoarele oferă o modalitate eficientă de accesare a elementelor unei structuri matrice.
Pointerele sunt utilizate pentru alocarea dinamică a memoriei, precum și pentru alocare.
Pointerii sunt folosiți pentru a forma structuri de date complexe, cum ar fi lista legată, graficul, arborele etc.


Dezavantajele indicatoarelor în C

Indicatorii sunt puțin complexi de înțeles.
Pointerii pot duce la diverse erori, cum ar fi erori de segmentare sau pot accesa o locație de memorie care nu este deloc necesară.
Dacă este indicată o valoare incorectă unui pointer, aceasta poate cauza deteriorarea memoriei.
Indicatorii sunt responsabili și pentru scurgerile de memorie.
Indicatoarele sunt comparativ mai lente decât cele ale variabilelor.
Programatorilor le este foarte greu să lucreze cu indicatorii; de aceea este responsabilitatea programatorului să manipuleze cu atenție un indicator.

rezumat 

Un indicator nu este altceva decât o locație de memorie în care sunt stocate datele.
Un pointer este folosit pentru a accesa locația memoriei.
Există diferite tipuri de pointeri, cum ar fi un pointer nul, un pointer sălbatic, un pointer gol și alte tipuri de pointeri.
Pointerii pot fi folosiți cu matrice și șiruri pentru a accesa elementele mai eficient.
Putem crea indicatori de funcții pentru a invoca o funcție dinamic.
Operațiile aritmetice pot fi efectuate pe un pointer care este cunoscut sub numele de pointer aritmetic.
Pointerii pot indica, de asemenea, funcția, ceea ce face mai ușor să apelați diferite funcții în cazul definirii unei matrice de pointeri.
Când doriți să tratați diferite tipuri de date variabile, puteți utiliza un pointer tipid vid.