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

Hva er en peker i C?

A pekeren I C er en variabel som lagrer adressen til en annen variabel. En peker kan også referere til en annen peker eller til en funksjon. En peker kan økes eller reduseres for å peke til neste eller forrige minneplassering. Hensikten med en peker er å spare minneplass og oppnå raskere utførelsestid.

Hvordan bruke pekere i C

Hvis vi deklarerer en variabel v av typen int, lagrer v en verdi. Hver variabel, i tillegg til verdien, har også en adresse, det vil si der den er plassert i minnet. Adressen kan hentes ved å sette et &-tegn (&) foran variabelnavnet. Hvis du skriver ut adressen til en variabel, ser den ut som et tilfeldig tall som kan variere fra kjøring til kjøring.

I stedet for å lagre en verdi, lagrer en peker adressen til en variabel. For eksempel:

int *y = &v;

Erklærer en peker

Som variabler, pekere inn C programmering må deklareres før de kan brukes. En pekerdeklarasjon har følgende form:

data_type *pointer_variable_name;

Her data-type er pekerens basistype og indikerer typen variabel som pekeren peker til. Stjernen (*), det samme symbolet som brukes for multiplikasjon, er indirekteoperatoren som deklarerer en peker. Noen gyldige pekerdeklarasjoner er:

int    *ptr_thing;       /* pointer to an integer */
int    *ptr1, thing;     /* ptr1 points to an int; thing is an int */
double *ptr2;           /* pointer to a double */
float  *ptr3;           /* pointer to a float */
char   *ch1;            /* pointer to a character */

Initialiser en peker

Etter å ha deklarert en peker, initialiserer vi den med en variabel adresse. Hvis en peker ikke initialiseres og brukes, kan resultatene være uforutsigbare og potensielt katastrofale. For å få adressen til en variabel, bruk ampersand (&)-operatoren før variabelnavnet:

pointer = &variable;

Et enkelt program som illustrerer en peker er gitt nedenfor:

#include <stdio.h>
int main()
{
   int a = 10;     // variable declaration
   int *p;         // pointer variable declaration
   p = &a;        // store address of a in pointer p
   printf("Address stored in p is: %x\n", p);  // access the address
   printf("Value stored in p is: %d\n", *p);    // access the value
   return 0;
}

Utgang:

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

Typer pekere i C

Null-peker

Vi oppretter en nullpeker ved å tilordne verdien NULL under deklarasjonen. Dette er nyttig når ingen adresse er tilordnet pekeren ennå. En nullpeker inneholder alltid verdien 0:

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

Void Pointer

En void-peker, også kalt en generisk peker, har ingen standard datatype. Den opprettes ved hjelp av nøkkelordet void og kan lagre adressen til en hvilken som helst variabel:

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

Vill peker

En peker kalles en jokerpeker hvis den ikke er initialisert til noe. Disse pekerne er ikke effektive fordi de kan peke til en ukjent minneplassering, noe som kan forårsake problemer og få programmet til å krasje. Vær alltid forsiktig med jokerpekere:

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

Andre typer pekere i C inkluderer dinglende peker, kompleks peker, nærpeker, fjernpeker og stor peker.

Direkte og indirekte tilgangspekere

I C finnes det to likeverdige måter å få tilgang til og manipulere innholdet i en variabel på. Direkte tilgang bruker variabelnavnet direkte, mens indirekte tilgang bruker en peker til variabelen:

#include <stdio.h>
int var = 1;        /* declare and initialize an int variable */
int *ptr;           /* declare a pointer to int */
int main(void)
{
   ptr = &var;       /* point ptr to var */
   printf("\nDirect access, var = %d", var);
   printf("\nIndirect access, var = %d", *ptr);
   *ptr = 48;        /* change var through the pointer */
   printf("\nIndirect access, var = %d", *ptr);
   return 0;
}

Pekeraritmetikk i C

Når du arbeider med pekere, må du følge disse prioritetsreglene. Operatorene * og & har samme prioritet som de unære operatorene (negasjon !, økning ++, reduksjon –). I samme uttrykk evalueres de unære operatorene *, &, !, ++ og — fra høyre mot venstre. Hvis en peker P peker på en variabel X, kan *P brukes overalt hvor X kan skrives. Følgende uttrykk er likeverdige:

I det siste tilfellet kreves parenteser: fordi de unære operatorene * og ++ evalueres fra høyre mot venstre, ville pekeren P bli inkrementert uten parenteser, ikke objektet den peker til. De aritmetiske operasjonene som er tilgjengelige på pekere er tildeling, inkrementering og dekrementering, og addisjon eller subtraksjon.tracet heltallsforskyvning, som flytter pekeren med det antallet elementer (hvert trinn tilsvarer størrelsen i byte av basistypen).

C-pekere og -matriser med eksempler

Tradisjonelt sett bruker vi en indeks til å få tilgang til array-elementer, men pekere gjør dette også enkelt. En peker satt til array-navnet peker til det første elementet:

#include <stdio.h>
int main()
{
   int a[5] = {1, 2, 3, 4, 5};   // array initialization
   int *p;                       // pointer declaration
   p = a;                       // p points to the first element; same as &a[0]
   for (int i = 0; i < 5; i++)
   {
      printf("%d\n", *p);            // print element
      p++;                      // move to the next element
   }
   return 0;
}

Å legge til et tall til en peker flytter den så mange elementer fremover. Hvis p peker på minneplassering 0, vil p + 1 få pekeren til å peke på minneplassering 1.

C Pekere og strenger med eksempler

En streng er en matrise av char-objekter som slutter med nulltegnet '\0'. Vi kan manipulere strenger ved hjelp av pekere:

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

En annen måte å håndtere strenger på er med en rekke pekere:

#include <stdio.h>
int main()
{
   char *materials[] = {"iron", "copper", "gold"};
   for (int i = 0; i < 3; i++)
      printf("%s\n", materials[i]);
   return 0;
}

Fordeler med Pointers i C

• Pekere er nyttige for å få direkte tilgang til minneplasseringer.
• De gir en effektiv måte å få tilgang til elementene i en matrise.
• De brukes til dynamisk minneallokering og deallokering.
• De brukes til å danne komplekse datastrukturer som koblede lister, grafer og trær.

Ulemper med Pointers i C

• Pekere er litt komplekse å forstå.
• De kan forårsake feil som segmenteringsfeil eller tilgang til en utilsiktet minneplassering.
• En feil verdi gitt til en peker kan føre til minnefeil.
• Pekere er også ansvarlige for minnelekkasjer hvis minne ikke frigjøres.
• Det er programmererens ansvar å håndtere en peker forsiktig.

Spørsmål og svar