Pokazivači u C-u: Što je pokazivač u C programiranju? Vrste

Što je pokazivač u C-u?

A pokazivač U C-u je varijabla koja pohranjuje adresu druge varijable. Pokazivač se također može odnositi na drugi pokazivač ili na funkciju. Pokazivač se može povećavati ili smanjivati ​​kako bi pokazivao na sljedeću ili prethodnu lokaciju u memoriji. Svrha pokazivača je ušteda memorijskog prostora i postizanje bržeg vremena izvršavanja.

Kako koristiti pokazivače u C

Ako deklariramo varijablu v tipa int, v pohranjuje vrijednost. Svaka varijabla, osim svoje vrijednosti, ima i adresu, odnosno mjesto gdje se nalazi u memoriji. Adresa se može dohvatiti stavljanjem znaka & (&) ispred imena varijable. Ako ispišete adresu varijable, ona izgleda kao slučajni broj koji se može razlikovati od pokretanja do pokretanja.

Umjesto pohranjivanja vrijednosti, pokazivač pohranjuje adresu varijable. Na primjer:

int *y = &v;

Deklariranje pokazivača

Poput varijabli, pokazivači u C programiranje moraju se deklarirati prije nego što se mogu koristiti. Deklaracija pokazivača ima sljedeći oblik:

data_type *pointer_variable_name;

Ovdje, tip podataka je osnovni tip pokazivača i označava tip varijable na koju pokazivač pokazuje. Zvjezdica (*), isti simbol koji se koristi za množenje, je operator indirekcije koji deklarira pokazivač. Neke valjane deklaracije pokazivača su:

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

Inicijaliziraj pokazivač

Nakon što deklariramo pokazivač, inicijaliziramo ga adresom varijable. Ako pokazivač nije inicijaliziran i koristi se, rezultati mogu biti nepredvidivi i potencijalno katastrofalni. Da biste dobili adresu varijable, upotrijebite operator ampersand (&) ispred naziva varijable:

pointer = &variable;

Jednostavan program koji ilustrira pokazivač dan je u nastavku:

#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;
}

Izlaz:

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

Vrste pokazivača u C-u

Nulti pokazivač

Null pokazivač stvaramo dodjeljivanjem vrijednosti NULL tijekom deklaracije. To je korisno kada pokazivaču još nije dodijeljena adresa. Null pokazivač uvijek sadrži vrijednost 0:

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

Pokazivač praznine

Pokazivač praznog polja, također nazvan generički pokazivač, nema standardni tip podataka. Stvara se pomoću ključne riječi void i može pohraniti adresu bilo koje varijable:

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

Divlji pokazivač

Pokazivač se naziva wild pokazivač ako nije inicijaliziran ni na što. Ovi pokazivači nisu učinkoviti jer mogu pokazivati ​​na nepoznatu lokaciju u memoriji, što može uzrokovati probleme i rušenje programa. Uvijek budite oprezni s wild pokazivačima:

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

Druge vrste pokazivača u C-u uključuju viseći pokazivač, kompleksni pokazivač, bliski pokazivač, daleki pokazivač i ogromni pokazivač.

Izravni i neizravni pristupni pokazivači

U C-u postoje dva ekvivalentna načina pristupa i manipuliranja sadržajem varijable. Izravni pristup izravno koristi naziv varijable, dok neizravni pristup koristi pokazivač na varijablu:

#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;
}

Aritmetika pokazivača u C-u

Pri radu s pokazivačima, pridržavajte se ovih pravila prioriteta. Operatori * i & imaju isti prioritet kao i unarni operatori (negacija !, inkrement ++, dekrement –). U istom izrazu, unarni operatori *, &, !, ++ i — se procjenjuju s desna na lijevo. Ako pokazivač P pokazuje na varijablu X, tada se *P može koristiti gdje god se može napisati X. Sljedeći izrazi su ekvivalentni:

U posljednjem slučaju, zagrade su potrebne: budući da se unarni operatori * i ++ procjenjuju s desna na lijevo, bez zagrada bi se povećavao pokazivač P, a ne objekt na koji pokazuje. Aritmetičke operacije dostupne na pokazivačima su dodjeljivanje, povećanje i smanjenje te zbrajanje ili oduzimanje.traczadavanjem cjelobrojnog pomaka, koji pomiče pokazivač za toliko elemenata (svaki korak jednak je veličini osnovnog tipa u bajtovima).

C pokazivači i nizovi s primjerima

Tradicionalno, elementima niza pristupamo pomoću indeksa, ali pokazivači to također olakšavaju. Pokazivač postavljen na naziv niza pokazuje na prvi 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;
}

Dodavanje broja pokazivaču pomiče ga za toliko elemenata naprijed. Ako p pokazuje na memorijsku lokaciju 0, tada p + 1 čini da pokazivač pokazuje na memorijsku lokaciju 1.

C pokazivači i nizovi s primjerima

Niz znakova je niz objekata tipa char koji završava s null znakom '\0'. Nizovima znakova možemo manipulirati pomoću pokazivača:

#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;
}

Drugi način rada sa stringovima je pomoću niza pokazivača:

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

Prednosti pokazivača u C-u

• Pokazivači su korisni za izravan pristup memorijskim lokacijama.
• Oni pružaju učinkovit način pristupa elementima niza.
• Koriste se za dinamičku alokaciju i dealokaciju memorije.
• Koriste se za formiranje složenih struktura podataka kao što su povezane liste, grafovi i stabla.

Nedostaci pokazivača u C-u

• Pokazivači su malo složeni za razumijevanje.
• Mogu uzrokovati pogreške poput segmentacijskih grešaka ili pristupa neželjenoj memorijskoj lokaciji.
• Netočna vrijednost dana pokazivaču može uzrokovati oštećenje memorije.
• Pokazivači su također odgovorni za curenje memorije ako se memorija ne oslobodi.
• Programerova je odgovornost pažljivo rukovati pokazivačem.

Pitanja i odgovori