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

Ce este un pointer în C?

A indicatorul În C este o variabilă care stochează adresa unei alte variabile. Un pointer se poate referi, de asemenea, la un alt pointer sau la o funcție. Un pointer poate fi incrementat sau decrementat pentru a indica următoarea sau anterioară locație de memorie. Scopul unui pointer este de a economisi spațiu de memorie și de a obține un timp de execuție mai rapid.

Cum să utilizați pointerii în C

Dacă declarăm o variabilă v de tip int, v stochează o valoare. Fiecare variabilă, pe lângă valoarea sa, are și o adresă, adică locul în care se află în memorie. Adresa poate fi recuperată plasând un ampersand (&) înaintea numelui variabilei. Dacă afișăm adresa unei variabile, aceasta arată ca un număr aleator care poate diferi de la o rulare la alta.

În loc să stocheze o valoare, un pointer stochează adresa unei variabile. De exemplu:

int *y = &v;

Declararea unui Pointer

La fel ca variabilele, indicii către programare C trebuie declarate înainte de a putea fi utilizate. O declarație de pointer are următoarea formă:

data_type *pointer_variable_name;

Aici, tip_date este tipul de bază al pointerului și indică tipul variabilei la care indică pointerul. Asteriscul (*), același simbol folosit pentru înmulțire, este operatorul de indirecție care declară un pointer. Câteva declarații valide de pointer sunt:

int    *ptr_thing;       /* pointer to an integer */
int    *ptr1, thing;     /* ptr1 points to an int; thing is an int */
double *ptr2;           /* pointer to a double */
float  *ptr3;           /* pointer to a float */
char   *ch1;            /* pointer to a character */

Inițializarea unui pointer

După declararea unui pointer, îl inițializăm cu o adresă de variabilă. Dacă un pointer este neinițializat și utilizat, rezultatele pot fi imprevizibile și potențial dezastruoase. Pentru a obține adresa unei variabile, utilizați operatorul ampersand (&) înaintea numelui variabilei:

pointer = &variable;

Un program simplu care ilustrează un pointer este prezentat mai jos:

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

ieșire:

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

Tipuri de indicatori în C

Pointer nul

Creăm un pointer nul prin atribuirea valorii NULL în timpul declarării. Acest lucru este util atunci când pointerului nu i-a fost încă atribuită nicio adresă. Un pointer nul conține întotdeauna valoarea 0:

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

Void Pointer

Un pointer void, numit și pointer generic, nu are niciun tip de date standard. Este creat folosind cuvântul cheie void și poate stoca adresa oricărei variabile:

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

Indicator sălbatic

Un pointer se numește pointer wild dacă nu este inițializat la nimic. Acești pointeri nu sunt eficienți deoarece pot indica o locație de memorie necunoscută, ceea ce poate cauza probleme și poate bloca programul. Fiți întotdeauna atenți cu pointerii wild:

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

Alte tipuri de pointeri în C includ pointerul suspendat, pointerul complex, pointerul de apropiere, pointerul de distanță și pointerul imens.

Pointeri de acces direct și indirect

În C, există două modalități echivalente de a accesa și manipula conținutul unei variabile. Accesul direct folosește direct numele variabilei, în timp ce accesul indirect folosește un pointer către variabilă:

#include <stdio.h>
int var = 1;        /* declare and initialize an int variable */
int *ptr;           /* declare a pointer to int */
int main(void)
{
   ptr = &var;       /* point ptr to var */
   printf("\nDirect access, var = %d", var);
   printf("\nIndirect access, var = %d", *ptr);
   *ptr = 48;        /* change var through the pointer */
   printf("\nIndirect access, var = %d", *ptr);
   return 0;
}

Aritmetica pointerului în C

Când lucrați cu pointeri, respectați aceste reguli de prioritate. Operatorii * și & au aceeași prioritate ca și operatorii unari (negație !, incrementare ++, decrementare –). În aceeași expresie, operatorii unari *, &, !, ++ și — sunt evaluați de la dreapta la stânga. Dacă un pointer P indică o variabilă X, atunci *P poate fi utilizat oriunde poate fi scris X. Următoarele expresii sunt echivalente:

În ultimul caz, parantezele sunt necesare: deoarece operatorii unari * și ++ sunt evaluați de la dreapta la stânga, fără paranteze, pointerul P ar fi incrementat, nu obiectul la care indică. Operațiile aritmetice disponibile pe pointeri sunt atribuirea, incrementarea și decrementarea, precum și adunarea sau sub-unitatea.tracaplicarea unui offset întreg, care mută indicatorul cu același număr de elemente (fiecare pas este egal cu dimensiunea în octeți a tipului de bază).

Pointeri și matrici C cu exemple

În mod tradițional, accesăm elementele unui tablou folosind un index, dar și pointerii facilitează acest lucru. Un pointer setat la numele tabloului indică primul element:

#include <stdio.h>
int main()
{
   int a[5] = {1, 2, 3, 4, 5};   // array initialization
   int *p;                       // pointer declaration
   p = a;                       // p points to the first element; same as &a[0]
   for (int i = 0; i < 5; i++)
   {
      printf("%d\n", *p);            // print element
      p++;                      // move to the next element
   }
   return 0;
}

Adăugarea unui număr la un indicator îl mută înainte cu aceleași elemente. Dacă p indică locația de memorie 0, atunci p + 1 face ca indicatorul să indice locația de memorie 1.

C Pointeri și șiruri de caractere cu exemple

Un șir de caractere este o matrice de obiecte char care se termină cu caracterul nul „\0”. Putem manipula șiruri de caractere folosind pointeri:

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

O altă modalitate de a trata șirurile de caractere este cu o matrice de pointeri:

#include <stdio.h>
int main()
{
   char *materials[] = {"iron", "copper", "gold"};
   for (int i = 0; i < 3; i++)
      printf("%s\n", materials[i]);
   return 0;
}

Avantajele Pointerilor în C

• Pointerii sunt utili pentru accesarea directă a locațiilor de memorie.
• Acestea oferă o modalitate eficientă de accesare a elementelor unui tablou.
• Acestea sunt utilizate pentru alocarea și dealocarea dinamică a memoriei.
• Acestea sunt utilizate pentru a forma structuri de date complexe, cum ar fi liste înlănțuite, grafuri și arbori.

Dezavantajele pointerilor în C

• Indicatorii sunt puțin complicat de înțeles.
• Acestea pot cauza erori precum erori de segmentare sau acces la o locație de memorie neintenționată.
• O valoare incorectă dată unui pointer poate cauza coruperea memoriei.
• Pointerii sunt, de asemenea, responsabili pentru pierderi de memorie dacă memoria nu este eliberată.
• Este responsabilitatea programatorului să gestioneze un pointer cu atenție.

Întrebări frecvente