Pekare i C: Vad är Pekare i C-programmering? Typer

Vad är en pekare i C?

A pekare I C är en variabel som lagrar adressen till en annan variabel. En pekare kan också referera till en annan pekare eller till en funktion. En pekare kan ökas eller minskas för att peka till nästa eller föregående minnesplats. Syftet med en pekare är att spara minnesutrymme och uppnå snabbare exekveringstid.

Hur man använder pekare i C

Om vi ​​deklarerar en variabel v av typen int, lagrar v ett värde. Varje variabel, förutom sitt värde, har också en adress, det vill säga där den finns i minnet. Adressen kan hämtas genom att sätta ett et-tecken (&) före variabelnamnet. Om man skriver ut adressen till en variabel ser den ut som ett slumptal som kan variera från körning till körning.

Istället för att lagra ett värde lagrar en pekare adressen till en variabel. Till exempel:

int *y = &v;

Deklarerar en pekare

Som variabler, pekare in C-programmering måste deklareras innan de kan användas. En pekardeklaration har följande form:

data_type *pointer_variable_name;

Här, data typ är pekarens bastyp och anger typen av variabel som pekaren pekar på. Asterisken (*), samma symbol som används för multiplikation, är den indirektionsoperator som deklarerar en pekare. Några giltiga pekardeklarationer är:

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

Initiera en pekare

Efter att ha deklarerat en pekare initierar vi den med en variabel adress. Om en pekare inte initieras och används kan resultaten vara oförutsägbara och potentiellt katastrofala. För att få adressen till en variabel, använd et-tecken (&) före variabelnamnet:

pointer = &variable;

Ett enkelt program som illustrerar en pekare ges nedan:

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

Produktion:

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

Typer av pekare i C

Nollpekare

Vi skapar en nullpekare genom att tilldela värdet NULL under deklarationen. Detta är användbart när ingen adress ännu är tilldelad pekaren. En nullpekare innehåller alltid värdet 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-pekare, även kallad en generisk pekare, har ingen standarddatatyp. Den skapas med hjälp av nyckelordet void och kan lagra adressen till vilken variabel som helst:

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

Vild pekare

En pekare kallas en wild-pekare om den inte är initierad till något. Dessa pekare är inte effektiva eftersom de kan peka på en okänd minnesplats, vilket kan orsaka problem och krascha programmet. Var alltid försiktig med wild-pekare:

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

Andra typer av pekare i C inkluderar dinglande pekare, komplex pekare, närpekare, fjärrpekare och enorm pekare.

Direkta och indirekta åtkomstpekare

I C finns det två likvärdiga sätt att komma åt och manipulera en variabels innehåll. Direkt åtkomst använder variabelnamnet direkt, medan indirekt åtkomst använder en pekare till variabeln:

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

Pekararitmetik i C

När du arbetar med pekare, följ dessa prioritetsregler. Operatorerna * och & har samma prioritet som de unära operatorerna (negation !, increment ++, decrement –). I samma uttryck utvärderas de unära operatorerna *, &, !, ++ och — från höger till vänster. Om en pekare P pekar på en variabel X, kan *P användas överallt där X kan skrivas. Följande uttryck är ekvivalenta:

I det sista fallet krävs parenteser: eftersom de unära operatorerna * och ++ utvärderas från höger till vänster, skulle pekaren P utan parenteser ökas, inte objektet den pekar på. De aritmetiska operationerna som är tillgängliga på pekare är tilldelning, ökning och minskning, samt addition eller subtraktion.tracskapar en heltalsförskjutning, vilket flyttar pekaren med så många element (varje steg är lika med storleken i byte för bastypen).

C-pekare och arrayer med exempel

Traditionellt sett använder vi ett index för att komma åt arrayelement, men pekare gör även detta enkelt. En pekare som är satt till arraynamnet pekar på det första 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;
}

Att lägga till ett tal till en pekare flyttar den framåt så många element. Om p pekar på minnesplats 0, så gör p + 1 att pekaren pekar på minnesplats 1.

C Pekare och strängar med exempel

En sträng är en array av char-objekt som slutar med nulltecknet '\0'. Vi kan manipulera strängar med hjälp av pekare:

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

Ett annat sätt att hantera strängar är med en array av pekare:

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

Fördelar med Pointers i C

• Pekare är användbara för att komma åt minnesplatser direkt.
• De erbjuder ett effektivt sätt att komma åt elementen i en array.
• De används för dynamisk minnesallokering och deallokering.
• De används för att skapa komplexa datastrukturer som länkade listor, grafer och träd.

Nackdelar med Pointers i C

• Pekare är lite komplicerade att förstå.
• De kan orsaka fel som segmenteringsfel eller åtkomst till en oavsiktlig minnesplats.
• Ett felaktigt värde som ges till en pekare kan orsaka minnesfel.
• Pekare är också ansvariga för minnesläckor om minne inte frigörs.
• Det är programmerarens ansvar att hantera en pekare varsamt.

Vanliga frågor