C programavimo rodyklės: kas yra žymeklis, tipai ir amp; Pavyzdžiai

Kas yra žymeklis C?

Pointer C, yra kintamasis, parduotuvės adresas kito kintamojo. Žymeklis taip pat gali būti naudojamas kitai rodyklės funkcijai nurodyti. Žymeklį galima padidinti / sumažinti, ty nukreipti į kitą / ankstesnę atminties vietą. Rodyklės tikslas - taupyti atminties vietą ir pasiekti greitesnį vykdymo laiką.

Kaip naudoti rodykles C

Jei paskelbsime int tipo kintamąjį v, v iš tikrųjų išsaugos vertę.

v dabar lygus nuliui.

Tačiau kiekvienas kintamasis, išskyrus vertę, taip pat turi savo adresą (arba, paprasčiau tariant, kur jis yra atmintyje). Adresą galima gauti prieš kintamojo pavadinimą įdėjus ampersandą (&).

Jei ekrane atspausdinsite kintamojo adresą, jis atrodys kaip visiškai atsitiktinis skaičius (be to, jis gali skirtis nuo paleidimo iki paleidimo).

Išbandykime tai praktikoje naudodami žymeklį C pavyzdyje

Šios programos išvestis yra -480613588.

Kas dabar yra rodyklė? Užuot saugojusi vertę, žymeklis y išsaugos kintamojo adresą.

Rodyklės kintamasis

Int * y = & v;

KINTAMAS	POINTERIS
Vertė saugomi pavadintas sandėliavimo / atminties adresą	Kintamos , kad atkreipia dėmesį į saugojimo / atminties adresą kito kintamojo

Pareiškėjo paskelbimas

Kaip ir kintamuosius, C programavimo rodykles reikia deklaruoti, kad jas būtų galima naudoti jūsų programoje. Rodyklės gali būti pavadintos bet kuo, jei tik jos laikosi C vardų suteikimo taisyklių. Rodyklės deklaracijos forma yra tokia.

data_type * pointer_variable_name;

Čia

• data_type yra žymeklio bazinis C kintamųjų tipų tipas ir nurodo kintamojo tipą, į kurį žymeklis rodo.
• Žvaigždutė (*: ta pati žvaigždutė, naudojama dauginimui), kuri yra netiesioginis operatorius, skelbia rodyklę.

Pažiūrėkime keletą galiojančių rodyklių deklaracijų šioje C žymeklių pamokoje:

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

Inicializuokite žymeklį

Paskelbę rodyklę, mes jį inicijuojame kaip standartinius kintamuosius su kintamuoju adresu. Jei C programavimo rodikliai nėra inicializuoti ir naudojami programoje, rezultatai yra nenuspėjami ir gali būti pražūtingi.

Norėdami gauti kintamojo adresą, mes naudojame ampersand (&) operatorių, dedamą prieš kintamojo, kurio adresą mums reikia, pavadinimą. Žymeklio inicijavimas atliekamas naudojant šią sintaksę.

Rodyklės sintaksė

 pointer = &variable; 

Žemiau pateikiama paprasta rodyklių iliustravimo programa:

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

Išvestis:

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

operatorius	Reikšmė
*	Tarnauja 2 tikslams Rodyklės deklaracija Grąžina nurodyto kintamojo vertę
&	Tarnauja tik 1 tikslui Grąžina kintamojo adresą

Rodyklių tipai C

Toliau pateikiami skirtingi C rodyklių tipai :

Null pointeris

Mes galime sukurti nulinį žymeklį, priskirdami nulinę vertę rodyklės deklaracijos metu. Šis metodas yra naudingas, kai žymekliui nėra priskirtas adresas. Nuliniame rodyklėje visada yra 0 reikšmė.

Ši programa iliustruoja nulinio rodyklės naudojimą:

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

Išvestis:

The value inside variable p is:0

Tuštybė žymeklis

Programuojant C, tuščiasis rodyklė taip pat vadinama bendruoju rodikliu. Jis neturi jokio standartinio duomenų tipo. Tuščias rodyklė sukuriama naudojant raktinį žodį negaliojantis. Jis gali būti naudojamas bet kurio kintamojo adresui išsaugoti.

Ši programa iliustruoja tuščio rodyklės naudojimą:

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

Išvestis:

The size of pointer is:4

Laukinis rodyklė

Laikoma, kad rodyklė yra laukinė rodyklė, jei ji nėra nieko inicijuojama. Šie C rodyklių tipai nėra efektyvūs, nes jie gali nurodyti nežinomą atminties vietą, kuri gali sukelti problemų mūsų programoje ir tai gali sukelti programos gedimą. Dirbant su laukiniais rodyklėmis visada reikia būti atsargiems.

Ši programa iliustruoja laukinio žymeklio naudojimą:

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

Rezultatas

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

Kiti „c“ žymeklių tipai yra šie:

• Kabantis rodyklė
• Kompleksinis rodyklė
• Netoli rodyklė
• Tolimas rodyklė
• Didžiulis rodyklė

Tiesioginės ir netiesioginės prieigos rodyklės

C kalboje yra du lygiaverčiai būdai, kaip pasiekti ir valdyti kintamą turinį

• Tiesioginė prieiga: mes tiesiogiai naudojame kintamojo pavadinimą
• Netiesioginė prieiga: naudojame kintamojo rodyklę

Supraskime tai naudodamiesi toliau pateikta 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;}

Sukūrus programą be klaidų, rezultatas yra:

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

Rodyklės aritmetika C

Rodyklės operacijos apibendrintos šiame paveikslėlyje

Prioritetinė operacija (pirmenybė)

Dirbdami su C rodyklėmis turime laikytis šių prioritetinių taisyklių:

• Operatoriai * ir turi tą patį prioritetą kaip irariniai operatoriai (neigimas!, Prieaugis ++, mažinimas--).
• Ta pačia išraiška vienarūšiai operatoriai *, &,!, ++, - vertinami iš dešinės į kairę.

Jei P rodyklė rodo į X kintamąjį, tada * P galima naudoti visur, kur galima parašyti X.

Šios išraiškos yra lygiavertės:

int X = 10 int * P = & Y; Aukščiau nurodytam kodui žemiau pateiktos išraiškos yra teisingos
Išraiška	Lygiavertė išraiška
Y = * P + 1 * P = * P + 10 * P + = 2 ++ * P (* P) ​​++	Y = X + 1 X = X + 10 X + = 2 ++ X X ++

Pastaruoju atveju reikalingi skliaustai: kadangi vienarūšiai operatoriai * ir ++ vertinami iš dešinės į kairę, be skliaustų rodyklė P būtų padidinta, o ne objektas, ant kurio P taškas.

Žemiau esančioje lentelėje pateikiama aritmetinė ir pagrindinė operacija, kurią galima naudoti dirbant su C rodyklėmis

Operacija	Paaiškinimas
Užduotis	int * P1, * P2 P1 = P2; P1 ir P2 nurodo tą patį sveiko skaičiaus kintamąjį
Padidėjimas ir sumažinimas	Int * P1; P1 ++; P1--;
Poslinkio pridėjimas (pastovus)	Tai leidžia žymekliui perkelti N elementus lentelėje. Rodyklė bus padidinta arba sumažinta N kartų kintamojo tipo baitų skaičiumi. P1 + 5;

C žymekliai ir masyvai su pavyzdžiais

Tradiciškai prieiname prie masyvo elementų naudodami jo indeksą, tačiau šį metodą galima pašalinti naudojant rodykles. Žymekliai palengvina prieigą prie kiekvieno masyvo elemento.

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

Rezultatas

12345

Pridėjus konkretų skaičių prie žymiklio, žymeklio vieta bus perkelta į vertę, gautą atlikus pridėjimo operaciją. Tarkime, kad p yra rodyklė, kuri šiuo metu nurodo atminties vietą 0, jei atliksime šią papildymo operaciją, p + 1, tada ji bus vykdoma tokiu būdu:

Kadangi p pridėjus 1 šiuo metu rodo į vietą 0, reikšmė taps 1, taigi žymeklis parodys 1 atminties vietą.

C žymekliai ir eilutės su pavyzdžiais

Eilutė yra char objektų masyvas, baigiantis nuliniu simboliu „\ 0“. Mes galime manipuliuoti eilutėmis naudodami rodykles. Šis žymeklis C pavyzdyje paaiškina šį skyrių

#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
Rezultatas
First character is:HNext character is:ePrinting all the characters in a stringHelloGuru99!
Kitas būdas spręsti eilutes yra daugybė rodyklių, panašių į šią 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;}
Išvestis:
Please remember these materials:ironcoppergold
 
Rodyklių C pranašumai

Rodyklės yra naudingos norint pasiekti atminties vietas.
Rodyklės yra efektyvus būdas pasiekti masyvo struktūros elementus.
Rodyklės naudojamos dinaminiam atminties paskirstymui, taip pat paskirstymui.
Rodyklės naudojamos sudarant sudėtingas duomenų struktūras, tokias kaip susietas sąrašas, grafikas, medis ir kt.


Rodyklių C trūkumai

Rodyklės yra šiek tiek sudėtingos suprasti.
Rodyklės gali sukelti įvairių klaidų, tokių kaip segmentavimo gedimai, arba gali pasiekti atminties vietą, kuri visai nereikalinga.
Jei rodyklei pateikiama neteisinga reikšmė, tai gali sugadinti atmintį.
Rodyklės taip pat yra atsakingos už atminties nutekėjimą.
Rodyklės yra palyginti lėtesnės nei kintamųjų.
Programuotojams labai sunku dirbti su rodyklėmis; todėl programuotojo pareiga yra kruopščiai manipuliuoti rodykle.

Santrauka 

Rodyklė yra ne kas kita, o atminties vieta, kurioje saugomi duomenys.
Rodyklė naudojama norint pasiekti atminties vietą.
Yra įvairių tipų rodyklių, tokių kaip „null pointer“, „wild pointer“, „void pointer“ ir kitų tipų rodyklių.
Norint efektyviau pasiekti elementus, rodyklės gali būti naudojamos su masyvu ir eilute.
Mes galime sukurti funkcijų rodykles, kad funkcija būtų dinamiškai iškviesta.
Aritmetines operacijas galima atlikti žymikliu, kuris žinomas kaip rodiklio aritmetika.
Žymekliai taip pat gali nurodyti funkciją, kuri palengvina skirtingų funkcijų iškvietimą apibrėžiant rodyklių masyvą.
Jei norite išspręsti skirtingo tipo duomenis, galite naudoti tupecast void pointer.

                    


                    

                      

                        
                          
Share on Facebook
                            

                          
                        
                      
                      

                        
                          
Share on Twitter