Pekere i C: Hva er Peker i C-programmering? Typer

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, enkelt sagt, der den er plassert i minnet). Adressen kan hentes ved å sette et og-tegn (&) foran variabelnavnet.

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

La oss prøve dette i praksis med peker i C-eksempel

Utgangen av dette programmet er -480613588.

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

Int *y = &v;

Erklærer en peker

Som variabler, pekere inn C programmering må deklareres før de kan brukes i programmet ditt. Pekere kan kalles hva du vil så lenge de overholder Cs navneregler. En pekererklæring har følgende form.

data_type * pointer_variable_name;

Her

• data-type er pekerens grunntype av Cs variabeltyper og angir typen variabel som pekeren peker på.
• Stjernen (*: den samme stjernen som brukes for multiplikasjon) som er indirektionsoperator, erklærer en peker.

La oss se noen gyldige pekererklæringer i denne C-pekeropplæringen:

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 initialisert og brukt i et program, kan resultatene være uforutsigbare og potensielt katastrofale.

For å få adressen til en variabel bruker vi og-tegnet (&)-operatoren, 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 <stdio.h>
int main()
{
   int a=10;    //variable declaration
   int *p;      //pointer variable declaration
   p=&a;        //store address of variable a in pointer p
   printf("Address stored in a variable p is:%x\n",p);  //accessing the address
   printf("Value stored in a variable p is:%d\n",*p);   //accessing the value
   return 0;
}

Utgang:

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

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

The value inside variable p is:
0

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

The size of pointer is:4

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

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

Direkte og indirekte tilgangspekere

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

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

La oss forstå dette ved hjelp av programmet nedenfor

#include <stdio.h>
/* 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 kompilert programmet uten feil, er resultatet:

Direct access, var = 1
Indirect access, var = 1

The address of var = 4202496
The address of var = 4202496

Indirect access, var = 48

Pekeraritmetikk i C

Pekeroperasjonene er oppsummert i følgende figur

Prioritert operasjon (prioritet)

Når vi arbeider med C-pekere, må vi overholde følgende prioriteringsregler:

• Operatorene * og & har samme prioritet som de unære operatorene (negasjonen!, inkrementeringen++, dekrementeringen–).
• I det samme uttrykket blir de unære operatorene *, &,!, ++, – evaluert fra høyre til venstre.

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

Følgende uttrykk er likeverdige:

int X =10
int *P = &Y;
For the above code, below expressions are true

I det siste tilfellet er det nødvendig med parenteser: ettersom de unære operatorene * og ++ evalueres fra høyre til venstre, uten parentesene ville 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

C Pekere og matriser med eksempler

Tradisjonelt får vi tilgang til array-elementene ved å bruke indeksen, men denne metoden kan elimineres ved å bruke pekere. Pekere gjør det enkelt å få tilgang til hvert array-element.

#include <stdio.h>
int main()
{
    int a[5]={1,2,3,4,5};   //array initialization
    int *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 elements
        	p++;    //incrementing to the next element, you can also write p=p+1
    }
    return 0;
}

Utgang:

1
2
3
4
5

Å legge til et bestemt tall til en peker vil flytte pekerplasseringen til verdien oppnådd ved en addisjonsoperasjon. Anta at p er en peker som for øyeblikket peker til minneplasseringen 0 hvis vi utfører følgende addisjonsoperasjon, p+1, så vil den utføres på denne måten:

Siden p for øyeblikket peker til posisjonen 0 etter å ha lagt til 1, vil verdien bli 1, og derfor vil pekeren peke til minneplasseringen 1.

C Pekere og strenger med eksempler

En streng er en rekke char-objekter, som slutter med et nulltegn '\ 0'. Vi kan manipulere strenger ved å bruke pekere. Denne pekeren i C-eksemplet forklarer denne delen

#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);
printf("Printing all the characters in a string\n");
p=str;  //reset the pointer
for(int i=0;i<strlen(str);i++)
{
printf("%c\n",*p);
p++;
}
return 0;
}

Utgang:

First character is:H
Next character is:e
Printing all the characters in a string
H
e
l
l
o

G
u
r
u
9
9
!

En annen måte å håndtere strenger på er med en rekke pekere som i følgende program:

#include <stdio.h>
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;}

Utgang:

Please remember these materials:
iron
copper
gold

Ulemper med Pointers i C

• Pekere er litt komplekse å forstå.
• Pekere kan føre til forskjellige feil som segmenteringsfeil eller kan få tilgang til en minneplassering som ikke er nødvendig i det hele tatt.
• Hvis en feil verdi gis til en peker, kan det føre til minnekorrupsjon.
• Pekere er også ansvarlige for minnelekkasje.
• Pekere er relativt langsommere enn variablene.
• Programmerere synes det er veldig vanskelig å jobbe med pekerne; derfor er det programmerers ansvar å manipulere en peker forsiktig.

Sammendrag

• En peker er ikke annet enn et minnested der data lagres.
• En peker brukes for å få tilgang til minneplasseringen.
• Det finnes ulike typer pekere som en null-peker, wild-peker, void-peker og andre typer pekere.
• Pekere kan brukes med array 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 pekeraritmetikk.
• Pekere kan også peke til funksjon som gjør det enkelt å kalle forskjellige funksjoner i tilfelle av å definere en rekke pekere.
• Når du ønsker å håndtere forskjellige variable datatyper, kan du bruke en typecast void-peker.