Pekere i C-programmering: Hva er peker, typer & Eksempler

Hva er Pointer in C?

Den Pointer i C, er en variabel som lagrer adressen til en annen variabel. En peker kan også brukes til å referere til en annen pekerfunksjon. En peker kan inkrementeres / dekrementeres, dvs. for å peke på neste / forrige minneplassering. Hensikten med pekeren er å spare minne og oppnå raskere utføringstid.

Hvordan bruke pekere i C

Hvis vi erklærer en variabel v av typen int, vil v faktisk lagre en verdi.

v er lik null nå.

Imidlertid har hver variabel, bortsett fra verdi, også sin adresse (eller rett og slett, der den ligger i minnet). Adressen kan hentes ved å sette et bokstav (&) foran variabelnavnet.

Hvis du skriver ut adressen til en variabel på skjermen, vil den se ut som et helt tilfeldig tall (dessuten kan det være forskjellig fra løp til løp).

La oss prøve dette i praksis med pekeren i eksempel C

Resultatet av dette programmet er -480613588.

Nå, hva er en peker? I stedet for å lagre en verdi, vil en peker lagre adressen til en variabel.

Markørvariabel

Int * y = & v;

VARIABEL	VINKEL
En verdi lagret i en navngitt lagrings- / minneadresse	En variabel som peker på lagrings- / minneadressen til en annen variabel

Erklære en peker

I likhet med variabler må pekere i C-programmering erklæres før de kan brukes i programmet ditt. Pekere kan navngis hva du vil så lenge de overholder Cs navneregler. En pekererklæring har følgende skjema.

data_type * pointer_variable_name;

Her,

• data_type er pekerens basetype av Cs variabeltyper og indikerer typen av variabelen som pekeren peker på.
• Stjernen (*: den samme stjernen som brukes til multiplikasjon) som er indireksjonsoperator, erklærer en peker.

La oss se noen gyldige pekererklæringer i denne veiledningen for C-pekere:

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

Initialiser en peker

Etter å ha erklært en peker initialiserer vi den som standardvariabler med en variabel adresse. Hvis pekere i C-programmering ikke er uinitialisert og brukes i programmet, er resultatene uforutsigbare og potensielt katastrofale.

For å få adressen til en variabel, bruker vi ampersand (&) -operatøren, plassert foran navnet på en variabel hvis adresse vi trenger. Pekerinitialisering gjøres med følgende syntaks.

Pekersyntaks

 pointer = &variable; 

Et enkelt program for pekerillustrasjon er gitt nedenfor:

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

Produksjon:

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

Operatør	Betydning
*	Serverer 2 formål Erklæring om en peker Returnerer verdien av den refererte variabelen
&	Serverer bare 1 formål Returnerer adressen til en variabel

Typer av pekere i C

Følgende er de forskjellige typene pekere i C :

Null Pointer

Vi kan opprette en nullpeker ved å tildele nullverdi under pekererklæringen. Denne metoden er nyttig når du ikke har tildelt noen adresse til pekeren. En nullpeker inneholder alltid verdien 0.

Følgende program illustrerer bruken av en nullpeker:

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

Produksjon:

The value inside variable p is:0

Ugyldig peker

I C-programmering kalles også en tom peker som en generisk peker. Den har ingen standard datatype. En ugyldig peker opprettes ved å bruke nøkkelordet ugyldig. Den kan brukes til å lagre en adresse til en hvilken som helst variabel.

Følgende program illustrerer bruken av en tom peker:

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

Produksjon:

The size of pointer is:4

Villpekeren

En peker sies å være en villpeker hvis den ikke initialiseres til noe. Disse typene C-pekere er ikke effektive fordi de kan peke på noe ukjent minneplassering som kan forårsake problemer i programmet vårt, og det kan føre til at programmet krasjer. Man bør alltid være forsiktig når man arbeider med ville pekere.

Følgende program illustrerer bruken av villpekeren:

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

Produksjon

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

Andre typer pekere i 'c' er som følger:

• Hangende pekeren
• Kompleks peker
• Nær pekeren
• Lang pekepinn
• Stor pekepinn

Direkte og indirekte tilgangspekere

I C er det to like måter å få tilgang til og manipulere et variabelt innhold

• Direkte tilgang: vi bruker variabelnavnet direkte
• Indirekte tilgang: vi bruker en peker til variabelen

La oss forstå dette ved hjelp av programmet nedenfor

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

Etter å ha samlet programmet uten feil, er resultatet:

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

Pointer Arithmetics i C

Markøroperasjonene er oppsummert i følgende figur

Prioritert drift (forrang)

Når vi arbeider med C-pekere, må vi følge følgende prioritetsregler:

• Operatørene * og & har samme prioritet som de unære operatørene (negasjonen !, inkrementasjonen ++, dekrement--).
• I samme uttrykk blir de unære operatorene *, &,!, ++, - evaluert fra høyre til venstre.

Hvis en P-peker peker på en X-variabel, kan * P brukes hvor som helst X kan skrives.

Følgende uttrykk er ekvivalente:

int X = 10 int * P = & Y; For ovennevnte kode er uttrykkene nedenfor sanne
Uttrykk	Tilsvarende uttrykk
Y = * P + 1 * P = * P + 10 * P + = 2 ++ * P (* P) ​​++	Y = X + 1 X = X + 10 X + = 2 ++ X X ++

I sistnevnte tilfelle er parenteser nødvendig: ettersom de unære operatorene * og ++ blir evaluert fra høyre til venstre, uten parentesene, vil pekeren P bli inkrementert, ikke objektet som P peker på.

Tabellen nedenfor viser den aritmetiske og grunnleggende operasjonen som kan brukes når du arbeider med C-pekere

Operasjon	Forklaring
Oppdrag	int * P1, * P2 P1 = P2; P1 og P2 peker på samme heltallvariabel
Inkrementering og dekrementering	Int * P1; P1 ++; P1--;
Legge til en forskyvning (konstant)	Dette gjør at pekeren kan flytte N-elementer i en tabell. Pekeren økes eller reduseres med N ganger antall byte (r) av variabeltypen. P1 + 5;

C Pekere og matriser med eksempler

Tradisjonelt får vi tilgang til matriseelementene ved hjelp av indeksen, men denne metoden kan elimineres ved å bruke pekere. Pekere gjør det enkelt å få tilgang til hvert matriseelement.

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

Produksjon

12345

Når du legger til et bestemt tall i en peker, flyttes pekerposisjonen til verdien som oppnås ved en tilleggsoperasjon. Anta at p er en peker som for tiden peker til minneplasseringen 0 hvis vi utfører følgende tilleggsoperasjon, p + 1, så vil den utføres på denne måten:

Siden p for tiden peker på plasseringen 0 etter å ha lagt til 1, blir verdien 1, og derav vil pekeren peke på minneplasseringen 1.

C Pekere og strenger med eksempler

En streng er en rekke tegnobjekter som ender med nulltegnet '\ 0'. Vi kan manipulere strenger ved hjelp av pekere. Denne pekeren i C-eksemplet forklarer denne delen

#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
Produksjon
First character is:HNext character is:ePrinting all the characters in a stringHelloGuru99!
En annen måte å håndtere strenger på er med en rekke pekere som i følgende 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;}
Produksjon:
Please remember these materials:ironcoppergold
 
Fordeler med pekere i C

Pekere er nyttige for å få tilgang til minneplasseringer.
Pekere gir en effektiv måte å få tilgang til elementene i en matrisestruktur.
Pekere brukes til dynamisk minnetildeling så vel som deallocation.
Pekere brukes til å danne komplekse datastrukturer som koblet liste, graf, tre, etc.


Ulemper med pekere i C

Pekere er litt komplekse å forstå.
Pekere kan føre til forskjellige feil, for eksempel segmenteringsfeil, eller få tilgang til et minneplassering som ikke er nødvendig i det hele tatt.
Hvis en peker blir gitt feil verdi, kan det føre til minnekorrupsjon.
Pekere er også ansvarlige for minnelekkasje.
Pekere er relativt tregere enn variablene.
Programmører synes det er veldig vanskelig å jobbe med pekepinnene; derfor er det programmererens ansvar å manipulere en peker nøye.

Sammendrag 

En peker er ikke noe annet enn et minneplassering der data lagres.
En peker brukes til å få tilgang til minneplasseringen.
Det er forskjellige typer pekere, for eksempel en nullpeker, villpeker, ugyldig peker og andre typer pekere.
Pekere kan brukes med matrise og streng for å få tilgang til elementer mer effektivt.
Vi kan lage funksjonspekere for å påkalle en funksjon dynamisk.
Aritmetiske operasjoner kan gjøres på en peker som er kjent som pekere aritmetikk.
Pekere kan også peke på funksjon som gjør det enkelt å ringe forskjellige funksjoner i tilfelle å definere en rekke pekere.
Når du vil håndtere annen variabel datatype, kan du bruke en ugyldig peker for typecast.