Pointere i C: Hvad er Pointer i C-programmering? Typer

Hvad er en pointer i C?

A pointer I C er en variabel, der lagrer adressen på en anden variabel. En pointer kan også referere til en anden pointer eller til en funktion. En pointer kan øges eller dekrementeres for at pege på den næste eller forrige hukommelsesplacering. Formålet med en pointer er at spare hukommelsesplads og opnå hurtigere udførelsestid.

Sådan bruges pointere i C

Hvis vi deklarerer en variabel v af typen int, gemmer v en værdi. Hver variabel har, udover dens værdi, også en adresse, det vil sige der, hvor den er placeret i hukommelsen. Adressen kan hentes ved at sætte et og-tegn (&) foran variabelnavnet. Hvis du skriver adressen på en variabel, ser den ud som et tilfældigt tal, der kan variere fra kørsel til kørsel.

I stedet for at gemme en værdi, gemmer en pointer adressen på en variabel. For eksempel:

int *y = &v;

Erklærer en pointer

Ligesom variabler, peger ind C programmering skal deklareres, før de kan bruges. En pointerdeklaration har følgende form:

data_type *pointer_variable_name;

Her, datatype er pointerens basistype og angiver typen af ​​den variabel, som pointeren peger på. Stjernen (*), det samme symbol, der bruges til multiplikation, er den indirekte operator, der deklarerer en pointer. Nogle gyldige pointeredeklarationer 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 pointer

Efter at have deklareret en pointer, initialiserer vi den med en variabel adresse. Hvis en pointer ikke initialiseres og bruges, kan resultaterne være uforudsigelige og potentielt katastrofale. For at få adressen på en variabel skal du bruge ampersand (&)-operatoren før variabelnavnet:

pointer = &variable;

Et simpelt program, der illustrerer en pointer, er givet 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;
}

Output:

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

Typer af pointere i C

Nul Pointer

Vi opretter en null-pointer ved at tildele værdien NULL under deklarationen. Dette er nyttigt, når der endnu ikke er tildelt nogen adresse til pointeren. En null-pointer indeholder altid værdien 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-pointer, også kaldet en generisk pointer, har ingen standard datatype. Den oprettes ved hjælp af nøgleordet void og kan gemme adressen på enhver variabel:

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

Vild pointer

En pointer kaldes en wild-pointer, hvis den ikke er initialiseret til noget. Disse pointere er ikke effektive, fordi de kan pege på en ukendt hukommelsesplacering, hvilket kan forårsage problemer og få programmet til at gå ned. Vær altid forsigtig med wild-pointere:

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

Andre typer pegere i C inkluderer den dinglende peger, den kompleks peger, den nære peger, den fjerne peger og den enorme peger.

Direkte og indirekte adgangsmarkører

I C er der to ækvivalente måder at tilgå og manipulere en variabels indhold på. Direkte adgang bruger variabelnavnet direkte, mens indirekte adgang bruger en pointer til variablen:

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

Pointer-aritmetik i C

Når du arbejder med pointere, skal du overholde disse prioritetsregler. Operatorerne * og & har samme prioritet som de unære operatorer (negation !, increment ++, decrement –). I det samme udtryk evalueres de unære operatorer *, &, !, ++ og — fra højre mod venstre. Hvis en pointer P peger på en variabel X, kan *P bruges overalt, hvor X kan skrives. Følgende udtryk er ækvivalente:

I sidste tilfælde kræves parenteser: fordi de unære operatorer * og ++ evalueres fra højre mod venstre, ville pointeren P blive forøget uden parenteser, ikke det objekt, den peger på. De aritmetiske operationer, der er tilgængelige på pointere, er tildeling, forøgelse og formindskelse samt addition eller subtraktion.tracat indtaste et heltalsforskydning, som flytter markøren med det pågældende antal elementer (hvert trin er lig med størrelsen i bytes af basistypen).

C-pointere og -arrays med eksempler

Traditionelt tilgår vi array-elementer ved hjælp af et indeks, men pointere gør dette også nemt. En pointer, der er sat til array-navnet, peger på det første element:

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

Hvis man tilføjer et tal til en pointer, flyttes den det antal elementer fremad. Hvis p peger på hukommelseslokation 0, så får p + 1 pointeren til at pege på hukommelseslokation 1.

C Pointer og strenge med eksempler

En streng er et array af char-objekter, der slutter med et null-tegn '\0'. Vi kan manipulere strenge ved hjælp af pointere:

#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 anden måde at håndtere strenge på er med et array af pointere:

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

Fordele ved pointere i C

• Pointere er nyttige til at få direkte adgang til hukommelsesplaceringer.
• De giver en effektiv måde at få adgang til elementerne i et array.
• De bruges til dynamisk hukommelsesallokering og deallokering.
• De bruges til at danne komplekse datastrukturer såsom sammenkædede lister, grafer og træer.

Ulemper ved pointere i C

• Pointers er lidt komplekse at forstå.
• De kan forårsage fejl såsom segmenteringsfejl eller adgang til en utilsigtet hukommelsesplacering.
• En forkert værdi givet til en pointer kan forårsage hukommelseskorruption.
• Pointere er også ansvarlige for hukommelseslækager, hvis hukommelse ikke frigøres.
• Det er programmørens ansvar at håndtere en pointer omhyggeligt.

Ofte Stillede Spørgsmål