Kazalci v programiranju C: Kaj je kazalec, vrste & Primeri

Kaj je kazalec v C?

Kazalec v C, je spremenljivka, ki shranjuje obravnavajo druge spremenljivke. Kazalec se lahko uporablja tudi za sklicevanje na drugo funkcijo kazalca. Kazalec je mogoče povečati / zmanjšati, to je, da kaže na naslednje / prejšnje mesto v pomnilniku. Namen kazalca je prihraniti pomnilniški prostor in doseči hitrejši čas izvedbe.

Kako uporabljati kazalce v jeziku C.

Če prijavimo spremenljivko v tipa int, bo v dejansko shranil vrednost.

v je zdaj enako nič.

Vendar ima vsaka spremenljivka poleg vrednosti tudi svoj naslov (ali, preprosto rečeno, kje se nahaja v pomnilniku). Naslov je mogoče dobiti tako, da pred imenom spremenljivke postavite znak & (&).

Če naslov spremenljivke natisnete na zaslon, bo videti kot povsem naključna številka (poleg tega se lahko razlikuje od teka do teka).

Preizkusimo to v praksi s kazalcem v primeru C

Rezultat tega programa je -480613588.

Kaj je kazalec? Namesto da shrani vrednost, bo kazalec y shranil naslov spremenljivke.

Kazalec Spremenljivka

Int * y = & v;

SPREMENLJIVO	KAZALEC
Vrednost shranjena v imenovan za shranjevanje / pomnilniški naslov	Spremenljivi , da kaže na skladiščenje / pomnilniški naslov v druge spremenljivke

Razglasitev kazalca

Tako kot spremenljivke je treba tudi v programu programirati napotke za C. Kazalce lahko imenujemo karkoli želite, če upoštevajo pravila imenovanja C. Izjava kazalca ima naslednji obrazec.

data_type * pointer_variable_name;

Tukaj,

• data_type je osnovni tip kazalca tipov spremenljivk C in označuje tip spremenljivke, na katero kaže kazalec.
• Zvezdica (*: ista zvezdica, uporabljena za množenje), ki je posrednik, razglasi kazalec.

Oglejmo si nekaj veljavnih deklaracij kazalcev v tej vadnici kazalcev 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 */

Inicializirajte kazalec

Po razglasitvi kazalca ga inicializiramo kot standardne spremenljivke z naslovom spremenljivke. Če kazalci v programiranju C niso neinicializirani in uporabljeni v programu, so rezultati nepredvidljivi in ​​potencialno katastrofalni.

Da dobimo naslov spremenljivke, uporabimo operater ampersand (&), postavljen pred imenom spremenljivke, katere naslov potrebujemo. Inicializacija kazalca se izvede z naslednjo sintakso.

Sintaksa kazalca

 pointer = &variable; 

Preprost program za ponazoritev kazalca je podan spodaj:

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

Izhod:

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

Operater	Pomen
*	Služi 2 namenu Izjava kazalca Vrne vrednost referenčne spremenljivke
&	Služi le enemu namenu Vrne naslov spremenljivke

Vrste kazalcev v jeziku C

Sledijo različne vrste kazalcev v C :

Ničelni kazalec

Ničelni kazalec lahko ustvarimo tako, da med deklaracijo kazalca dodelimo ničelno vrednost. Ta metoda je uporabna, če kazalcu ni dodeljen noben naslov. Ničelni kazalnik vedno vsebuje vrednost 0.

Naslednji program ponazarja uporabo ničelnega kazalca:

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

Izhod:

The value inside variable p is:0

Kazalec za praznino

Pri programiranju C se kazalec praznine imenuje tudi kot splošni kazalec. Nima nobene standardne vrste podatkov. Kazalnik praznine se ustvari z uporabo ključne besede void. Uporablja se lahko za shranjevanje naslova katere koli spremenljivke.

Naslednji program ponazarja uporabo kazalca void:

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

Izhod:

The size of pointer is:4

Divji kazalec

Kazalec naj bi bil divji kazalec, če ni nič inicializiran. Te vrste kazalcev C niso učinkovite, ker lahko kažejo na neko neznano mesto v pomnilniku, kar lahko povzroči težave v našem programu in lahko povzroči zrušitev programa. Pri delu z divjimi kazalci je treba biti vedno previden.

Naslednji program ponazarja uporabo nadomestnega kazalca:

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

Izhod

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

Druge vrste kazalcev v 'c' so naslednje:

• Viseči kazalec
• Kompleksni kazalec
• Blizu kazalca
• Daleč kazalec
• Ogromen kazalec

Kazalci na neposreden in posreden dostop

V C-ju obstajata dva enakovredna načina za dostop in spreminjanje spremenljive vsebine

• Neposreden dostop: uporabljamo neposredno ime spremenljivke
• Posredni dostop: uporabljamo kazalec na spremenljivko

Razumimo to s pomočjo spodnjega programa

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

Po sestavi programa brez napak je rezultat:

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

Kazalna aritmetika v jeziku C

Operacije kazalcev so povzete na naslednji sliki

Prednostna operacija (prednost)

Pri delu s kazalci C moramo upoštevati naslednja prednostna pravila:

• Operatorja * in & imata enako prednost kot unarni operatorji (negacija !, prirastek ++, dekrement--).
• V istem izrazu se unarni operatorji *, &,!, ++, - ovrednotijo ​​od desne proti levi.

Če kazalec P kaže na spremenljivko X, potem lahko * P uporabljamo povsod, kjer lahko X zapišemo.

Naslednji izrazi so enakovredni:

int X = 10 int * P = & Y; Za zgornjo kodo so spodnji izrazi resnični
Izraz	Enakovreden izraz
Y = * P + 1 * P = * P + 10 * P + = 2 ++ * P (* P) ​​++	Y = X + 1 X = X + 10 X + = 2 ++ X X ++

V slednjem primeru so potrebni oklepaji: ker se unarni operatorja * in ++ ovrednotita od desne proti levi, se brez oklepajev poveča kazalnik P in ne objekt, na katerega kaže P.

Spodnja tabela prikazuje aritmetično in osnovno operacijo, ki jo lahko uporabimo pri obravnavi kazalcev C.

Delovanje	Pojasnilo
Dodelitev	int * P1, * P2 P1 = P2; P1 in P2 kažeta na isto celoštevilčno spremenljivko
Povečanje in zmanjševanje	Int * P1; P1 ++; P1--;
Dodajanje odmika (konstantno)	To kazalcu omogoča premikanje N elementov v tabeli. Kazalec se bo povečal ali zmanjšal za N-kratno število bajtov vrste spremenljivke. P1 + 5;

C Kazalci in nizi s primeri

Tradicionalno do elementov matrike dostopamo z uporabo njenega indeksa, vendar je to metodo mogoče odpraviti z uporabo kazalcev. Kazalci olajšajo dostop do vsakega elementa matrike.

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

Izhod

12345

Če dodate določeno število kazalcu, se mesto kazalca premakne na vrednost, pridobljeno z operacijo seštevanja. Recimo, da je p kazalec, ki trenutno kaže na pomnilniško mesto 0, če izvedemo naslednjo operacijo seštevanja, p + 1, nato pa se izvede na ta način:

Ker p po dodajanju 1 trenutno kaže na lokacijo 0, bo vrednost postala 1, zato bo kazalec kazal na pomnilniško lokacijo 1.

C Kazalci in nizi z primeri

Niz je niz objektov char, ki se konča z ničelnim znakom '\ 0'. Z nizi lahko manipuliramo s kazalci. Ta kazalec v primeru C pojasnjuje to poglavje

#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
Izhod
First character is:HNext character is:ePrinting all the characters in a stringHelloGuru99!
Drug način za obravnavanje nizov je vrsta nizov, kot je v naslednjem programu:
#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;}
Izhod:
Please remember these materials:ironcoppergold
 
Prednosti kazalcev v jeziku C.

Kazalci so uporabni za dostop do pomnilniških mest.
Kazalci omogočajo učinkovit način dostopa do elementov matrične strukture.
Kazalci se uporabljajo za dinamično dodeljevanje pomnilnika in sprostitev.
Kazalci se uporabljajo za oblikovanje zapletenih podatkovnih struktur, kot so povezani seznam, graf, drevo itd.


Slabosti kazalcev v jeziku C

Kazalci so malo zapleteni za razumevanje.
Kazalci lahko vodijo do različnih napak, kot so napake segmentacije, ali pa lahko dostopajo do pomnilniške lokacije, ki sploh ni potrebna.
Če je kazalcu podana napačna vrednost, lahko to povzroči poškodbe pomnilnika.
Kazalci so odgovorni tudi za uhajanje spomina.
Kazalci so sorazmerno počasnejši od spremenljivk.
Programerji zelo težko delajo s kazalci; zato je odgovornost programerja skrbno ravnati s kazalcem.

Povzetek 

Kazalec ni nič drugega kot pomnilniško mesto, kjer so shranjeni podatki.
Kazalec se uporablja za dostop do mesta v pomnilniku.
Obstajajo različne vrste kazalcev, kot so ničelni kazalec, divji kazalnik, prazni kazalec in druge vrste kazalcev.
Kazalci se lahko uporabljajo z matriko in nizom za učinkovitejši dostop do elementov.
Ustvarimo lahko kazalce funkcij za dinamično priklic funkcije.
Aritmetične operacije lahko izvajate na kazalcu, ki je znan kot kazalna aritmetika.
Kazalci lahko kažejo tudi na funkcije, ki olajšajo klic različnih funkcij v primeru definiranja niza kazalcev.
Če želite obravnavati različne spremenljivke podatkovnih vrst, lahko uporabite kazalec praznine typecast.