Pointerii în C: Ce este Pointerul în programarea C? Tipuri

Cum să utilizați pointerii în C

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

v este egal cu zero acum.

Totuși, fiecare variabilă, în afară de valoare, are și adresa ei (sau, pur și simplu, unde se află în memorie). Adresa poate fi preluată punând un ampersand (&) înaintea numelui variabilei.

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

Să încercăm acest lucru în practică cu indicatorul î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.

Int *y = &v;

Declararea unui Pointer

La fel ca variabilele, indicii către programare C trebuie să fie declarate înainte de a putea fi utilizate în programul dumneavoastră. 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,

• tip_date este tipul de bază al indicatorului pentru tipurile de variabile ale lui C și indică tipul variabilei către care indică indicatorul.
• Asteriscul (*: același asterisc folosit pentru înmulțire) care este operator de indirectă, declară un pointer.

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

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 indicator

După declararea unui pointer, îl inițializam ca variabilele standard cu o adresă de variabilă. Dacă pointerii din programarea C sunt neinițializați și utilizați într-un program, rezultatele pot fi 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 pointerului se face cu următoarea sintaxă.

Sintaxa pointerului

 pointer = &variable;

Un program simplu pentru ilustrarea indicatorului este prezentat mai jos:

#include <stdio.h>
int main()
{
   int a=10;    //variable declaration
   int *p;      //pointer variable declaration
   p=&a;        //store address of variable a in pointer p
   printf("Address stored in a variable p is:%x\n",p);  //accessing the address
   printf("Value stored in a variable p is:%d\n",*p);   //accessing the value
   return 0;
}

ieșire:

Address stored in a variable p is:60ff08
Value stored in a variable p is:10

#include <stdio.h>
int main()
{
	int *p = NULL; 	//null pointer
	printf(“The value inside variable p is:\n%x”,p);
	return 0;
}

The value inside variable p is:
0

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

The size of pointer is:4

#include <stdio.h>
int main()
{
int *p; 	//wild pointer
printf("\n%d",*p);
return 0;
}

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

Pointeri de acces direct și indirect

În C, există două moduri echivalente de a accesa și de a 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 <stdio.h>
/* 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 = 1
Indirect access, var = 1

The address of var = 4202496
The address of var = 4202496

Indirect access, var = 48

Aritmetica pointerului în C

Operațiile cu pointerul sunt rezumate în figura următoare

Operațiune prioritară (precedentă)

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

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

Dacă un pointer P indică o variabilă X, atunci * P poate fi folosit oriunde poate fi scris X.

Următoarele expresii sunt echivalente:

int X =10
int *P = &Y;
For the above code, below expressions are true

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

Tabelul de mai jos arată operația aritmetică și de bază care poate fi utilizată atunci când se lucrează cu pointerii C

C Pointere și tablouri cu exemple

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

#include <stdio.h>
int main()
{
    int a[5]={1,2,3,4,5};   //array initialization
    int *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 elements
        	p++;    //incrementing to the next element, you can also write p=p+1
    }
    return 0;
}

ieșire:

1
2
3
4
5

Adăugarea unui anumit număr la un indicator va muta locația indicatorului la valoarea obținută printr-o operație de adăugare. Să presupunem că p este un pointer care indică în prezent locația de memorie 0 dacă efectuăm următoarea operație de adăugare, 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 de caractere cu exemple

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

#include <stdio.h>
#include <string.h>
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 pointer
for(int i=0;i<strlen(str);i++)
{
printf("%c\n",*p);
p++;
}
return 0;
}

ieșire:

First character is:H
Next character is:e
Printing all the characters in a string
H
e
l
l
o

G
u
r
u
9
9
!

O altă modalitate de a trata șiruri este cu o matrice de pointeri ca în următorul program:

#include <stdio.h>
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:
iron
copper
gold

Dezavantajele pointerilor în C

• Indicatorii sunt puțin complicat 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ă o valoare incorectă este furnizată unui pointer, aceasta poate cauza coruperea memoriei.
• Pointerii sunt, de asemenea, responsabili pentru pierderile de memorie.
• Indicatorii sunt comparativ mai lenți decât variabilele.
• Programatorilor le este foarte greu să lucreze cu pointerii; prin urmare, este responsabilitatea programatorului să manipuleze un pointer cu atenție.

Rezumat

• Un pointer nu este altceva decât o locație de memorie în care sunt stocate datele.
• Un pointer este folosit pentru a accesa locația de memorie.
• Există diferite tipuri de indicatori, cum ar fi un pointer nul, un indicator sălbatic, un indicator nul și alte tipuri de indicatori.
• Pointerii pot fi utilizați cu matrice și șir pentru a accesa elementele mai eficient.
• Putem crea indicatori de funcție pentru a invoca o funcție în mod dinamic.
• Operațiile aritmetice pot fi efectuate pe un pointer care este cunoscut sub numele de aritmetică pointer.
• Pointerii pot indica, de asemenea, către o funcție, ceea ce facilitează apelarea diferitelor 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 tip tip void.