Osoittimet C-ohjelmoinnissa: Mikä on osoitin, tyypit ja amp; Esimerkkejä

Mikä on osoitin C: ssä?

Pointer C, on muuttuja, joka tallentaa osoitteen toisen muuttujan. Osoitinta voidaan käyttää myös viittaamaan toiseen osoitintoimintoon. Osoitinta voidaan lisätä / vähentää, eli osoittaa seuraavaan / edelliseen muistipaikkaan. Osoittimen tarkoituksena on säästää muistia ja saavuttaa nopeampi suoritusaika.

Kuinka käyttää osoittimia C.

Jos julistamme muuttujan v tyypin int, v tallentaa arvon.

v on nyt nolla.

Jokaisella muuttujalla on arvon lisäksi myös osoite (tai yksinkertaisesti sanottuna, missä se sijaitsee muistissa). Osoite voidaan noutaa asettamalla ampersandi (&) muuttujan nimen eteen.

Jos tulostat muuttujan osoitteen ruudulle, se näyttää täysin satunnaisluvulta (lisäksi se voi olla erilainen ajon mukaan).

Kokeillaan tätä käytännössä osoittimella C-esimerkissä

Tämän ohjelman tulos on -480613588.

Mikä on osoitin? Arvon tallentamisen sijaan osoitin tallentaa muuttujan osoitteen.

Osoitin Muuttuja

Int * y = & v;

MUUTTAVA	OSOITIN
Arvo tallennetaan nimeltä varastointi / muisti osoite	Muuttuja , joka osoittaa varastointi / muisti-osoite toisen muuttujan

Osoittimen julistaminen

Muuttujien tavoin myös C-ohjelmoinnin osoittimet on ilmoitettava, ennen kuin niitä voidaan käyttää ohjelmassa. Osoittimille voidaan antaa haluamasi nimi, kunhan ne noudattavat C: n nimeämissääntöjä. Osoitinilmoituksella on seuraava muoto.

data_type * pointer_variable_name;

Tässä,

• data_type on osoittimen C-muuttujatyyppien perustyyppi ja osoittaa muuttujan tyypin, johon osoitin osoittaa.
• Tähti (*: sama tähti, jota käytetään kertomiseen), joka on epäsuora operaattori, ilmoittaa osoittimen.

Katsotaanpa joitain kelvollisia osoittimen ilmoituksia tässä C-osoittimen opetusohjelmassa:

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

Alusta osoitin

Kun osoitin osoittimen, alustamme sen kuten vakiomuuttujat muuttuvalla osoitteella. Jos C-ohjelmoinnin osoittimia ei alusteta ja niitä käytetä ohjelmassa, tulokset ovat arvaamattomia ja mahdollisesti tuhoisia.

Muuttujan osoitteen saamiseksi käytämme ampersand (&) -operaattoria, joka sijoitetaan muuttujan nimen eteen, jonka osoitetta tarvitsemme. Osoittimen alustus tehdään seuraavalla syntaksilla.

Osoittimen syntakse

 pointer = &variable; 

Alla on yksinkertainen ohjelma osoittimen kuvaamiseen:

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

Tuotos:

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

Operaattori	Tarkoitus
*	Palvelee 2 tarkoitusta Osoittimen ilmoitus Palauttaa viitatun muuttujan arvon
&	Palvelee vain yhtä tarkoitusta Palauttaa muuttujan osoitteen

Osoittimien tyypit C.

Seuraavassa on erityyppisiä osoittimia C : ssä:

Tyhjä osoitin

Voimme luoda nollaosoittimen osoittamalla nolla-arvon osoittimen ilmoituksen aikana. Tämä menetelmä on hyödyllinen, kun osoittimelle ei ole määritetty osoitetta. Nollaosoitin sisältää aina arvon 0.

Seuraava ohjelma kuvaa nollaosoittimen käyttöä:

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

Tuotos:

The value inside variable p is:0

Tyhjä osoitin

C-ohjelmoinnissa tyhjää osoitinta kutsutaan myös yleiseksi osoittimeksi. Sillä ei ole vakiotietotyyppiä. Tyhjä osoitin luodaan käyttämällä avainsanaa void. Sitä voidaan käyttää minkä tahansa muuttujan osoitteen tallentamiseen.

Seuraava ohjelma havainnollistaa tyhjän osoittimen käyttöä:

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

Tuotos:

The size of pointer is:4

Villi osoitin

Osoittimen sanotaan olevan villi osoitin, jos sitä ei alusteta mihinkään. Tämäntyyppiset C-osoittimet eivät ole tehokkaita, koska ne voivat viitata tuntemattomaan muistipaikkaan, mikä saattaa aiheuttaa ongelmia ohjelmassamme ja se voi johtaa ohjelman kaatumiseen. On aina oltava varovainen työskennellessäsi villien viitteiden kanssa.

Seuraava ohjelma kuvaa villin osoittimen käyttöä:

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

Tuotos

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

Muita osoittimia c: ssä ovat seuraavat:

• Ripustava osoitin
• Monimutkainen osoitin
• Lähellä osoitinta
• Kaukosäädin
• Valtava osoitin

Suorat ja epäsuorat yhteysosoitteet

C: ssä on kaksi vastaavaa tapaa käyttää muuttuvaa sisältöä ja käsitellä sitä

• Suora pääsy: käytämme suoraan muuttujan nimeä
• Epäsuora pääsy: käytämme muuttujan osoitinta

Ymmärretään tämä alla olevan ohjelman avulla

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

Kun ohjelma on koottu ilman virheitä, tulos on:

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

Osoittimen aritmeettisuus C.

Osoitinoperaatiot on tiivistetty seuraavaan kuvaan

Ensisijainen toiminta (etusija)

Kun työskentelemme C-osoittimien kanssa, meidän on noudatettava seuraavia prioriteettisääntöjä:

• Operaattoreilla * ja & on sama prioriteetti kuin unaryoperaattoreilla (negaatio!, Inkrementti ++, decrement--).
• Samassa lausekkeessa unaariset operaattorit *, &,!, ++, - arvioidaan oikealta vasemmalle.

Jos P-osoitin osoittaa X-muuttujaan, * P: tä voidaan käyttää missä tahansa X voidaan kirjoittaa.

Seuraavat lausekkeet vastaavat:

int X = 10 int * P = & Y; Yllä olevan koodin alla olevat lausekkeet ovat totta
Ilmaisu	Vastaava lauseke
Y = * P + 1 * P = * P + 10 * P + = 2 ++ * P (* P) ​​++	Y = X + 1 X = X + 10 X + = 2 ++ X X ++

Jälkimmäisessä tapauksessa tarvitaan sulkeita: koska yksisuuntaiset operaattorit * ja ++ arvioidaan oikealta vasemmalle, ilman sulkeita osoitin P kasvaisi, ei kohde, johon P osoittaa.

Alla olevassa taulukossa on esitetty aritmeettinen ja perustoiminto, jota voidaan käyttää käsiteltäessä C-osoittimia

Operaatio	Selitys
Tehtävä	int * P1, * P2 P1 = P2; P1 ja P2 osoittavat samaan kokonaislukumuuttujaan
Lisäys ja vähennys	Int * P1; P1 ++; P1--;
Offsetin lisääminen (vakio)	Tämän avulla osoitin voi siirtää N elementtiä taulukossa. Osoitinta kasvatetaan tai pienennetään N-kertoimella muuttujatyypin tavujen lukumäärällä. P1 + 5;

C-osoittimet ja taulukot esimerkeillä

Perinteisesti pääsemme matriisielementteihin sen indeksin avulla, mutta tämä menetelmä voidaan eliminoida osoittimilla. Osoittimien avulla on helppo käyttää kutakin taulukkoelementtiä.

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

Tuotos

12345

Tietyn numeron lisääminen osoittimeen siirtää osoittimen sijainnin lisäystoiminnolla saatuun arvoon. Oletetaan, että p on osoitin, joka osoittaa tällä hetkellä muistipaikkaan 0, jos suoritamme lisäysoperaation, p + 1, se suoritetaan tällä tavalla:

Koska p osoittaa tällä hetkellä sijaintiin 0 lisäämisen jälkeen 1, arvosta tulee 1 ja siten osoitin osoittaa muistipaikkaan 1.

C-osoittimet ja merkkijonot esimerkkeineen

Merkkijono on joukko char-objekteja, joka päättyy nollamerkkiin '\ 0'. Voimme manipuloida merkkijonoja osoittimilla. Tämä C-esimerkin osoitin selittää tämän osan

#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
Tuotos
First character is:HNext character is:ePrinting all the characters in a stringHelloGuru99!
Toinen tapa käsitellä merkkijonoja on joukko osoittimia, kuten seuraavassa ohjelmassa:
#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;}
Tuotos:
Please remember these materials:ironcoppergold
 
Osoittimien edut C.

Osoittimet ovat hyödyllisiä muistipaikkojen käytössä.
Osoittimet tarjoavat tehokkaan tavan päästä matriisirakenteen elementteihin.
Osoittimia käytetään sekä dynaamiseen muistin allokointiin että jakeluun.
Osoittimia käytetään muodostamaan monimutkaisia ​​tietorakenteita, kuten linkitetty luettelo, kaavio, puu jne.


C-osoittimien haitat

Osoittimet ovat hieman monimutkaisia ​​ymmärtää.
Osoittimet voivat johtaa erilaisiin virheisiin, kuten segmentointivirheisiin, tai voivat käyttää muistipaikkaa, jota ei tarvita lainkaan.
Jos osoittimelle annetaan väärä arvo, se voi vahingoittaa muistia.
Osoittimet ovat myös vastuussa muistivuodosta.
Osoittimet ovat suhteellisen hitaampia kuin muuttujat.
Ohjelmoijien on vaikea työskennellä osoittimien kanssa; siksi ohjelmoijan vastuulla on manipuloida osoitinta huolellisesti.

Yhteenveto 

Osoitin ei ole muuta kuin muistipaikka, johon tiedot tallennetaan.
Osoitinta käytetään muistipaikan käyttämiseen.
On olemassa erityyppisiä osoittimia, kuten nollaosoitin, villi osoitin, mitätöivä osoitin ja muut osoittimet.
Osoittimia voidaan käyttää matriisin ja merkkijonon kanssa, jotta elementtejä voidaan käyttää tehokkaammin.
Voimme luoda funktion osoittimia kutsua funktion dynaamisesti.
Aritmeettiset operaatiot voidaan suorittaa osoittimella, joka tunnetaan osoittimen aritmeettisena.
Osoittimet voivat myös osoittaa toiminnon, jonka avulla eri toimintojen kutsuminen on helppoa, jos määritetään joukko osoittimia.
Kun haluat käsitellä erilaista muuttuvaa tietotyyppiä, voit käyttää typecast void -osoitinta.