C-pekare (med exempel)

I den här handledningen lär du dig om pekare; vad pekare är, hur använder du dem och de vanliga misstagen du kan möta när du arbetar med dem med hjälp av exempel.

Pekare är kraftfulla funktioner i C- och C ++ -programmering. Innan vi lär oss tips, låt oss lära oss om adresser i C-programmering.

Adress i C

Om du har en variabel var i ditt program, &varkommer den att ge dig adressen i minnet.

Vi har använt adress flera gånger när vi använder scanf()funktionen.

 scanf("%d", &var);

Här lagras det värde som användaren anger i adressen till variabeln var. Låt oss ta ett fungerande exempel.

 #include int main() ( int var = 5; printf("var: %d", var); // Notice the use of & before var printf("address of var: %p", &var); return 0; )

Produktion

 var: 5 adress för var: 2686778

Obs! Du kommer förmodligen att få en annan adress när du kör ovanstående kod.

C Pekare

Pekare (pekvariabler) är speciella variabler som används för att lagra adresser snarare än värden.

Pekarsyntax

Så här kan vi förklara pekare.

 int* p;

Här har vi förklarat en pekare p av inttypen.

Du kan också deklarera pekare på dessa sätt.

 int *p1; int * p2;

Låt oss ta ett annat exempel på att förklara pekare.

 int* p1, p2;

Här har vi förklarat en pekare p1 och en normal variabel p2.

Tilldela adresser till pekare

Låt oss ta ett exempel.

 int* pc, c; c = 5; pc = &c;

Här tilldelas 5 variabeln c. Och adressen till c tilldelas PC-pekaren.

Få värde av det som pekas av pekare

För att få värdet av det som pekarna pekar på använder vi *operatören. Till exempel:

 int* pc, c; c = 5; pc = &c; printf("%d", *pc); // Output: 5

Här ctilldelas adressen till PC-pekaren. För att få värdet lagrat i den adressen använde vi * pc.

Obs! I ovanstående exempel är pc en pekare, inte *pc. Du kan inte och bör inte göra något liknande *pc = &c;

Förresten, *kallas dereference-operatören (när man arbetar med pekare). Den fungerar på en pekare och ger värdet som är lagrat i den pekaren.

Ändra värde pekat av pekare

Låt oss ta ett exempel.

 int* pc, c; c = 5; pc = &c; c = 1; printf("%d", c); // Output: 1 printf("%d", *pc); // Ouptut: 1

Vi har tilldelat adressen till c till pc-pekaren.

Sedan ändrade vi värdet på c till 1. Eftersom pc och adressen till c är densamma, *pcger oss 1.

Låt oss ta ett annat exempel.

 int* pc, c; c = 5; pc = &c; *pc = 1; printf("%d", *pc); // Ouptut: 1 printf("%d", c); // Output: 1

Vi har tilldelat adressen till c till pc-pekaren.

Sedan ändrade vi *pctill 1 med *pc = 1;. Eftersom pc och adressen till c är desamma kommer c att vara lika med 1.

Låt oss ta ytterligare ett exempel.

 int* pc, c, d; c = 5; d = -15; pc = &c; printf("%d", *pc); // Output: 5 pc = &d; printf("%d", *pc); // Ouptut: -15

Ursprungligen tilldelas c-adressen till datorns pekare med pc = &c;. Eftersom c är 5, *pcger oss 5.

Därefter tilldelas d-adressen till PC-pekaren med pc = &d;. Eftersom d är -15, *pcger oss -15.

Exempel: Arbeta med pekare

Låt oss ta ett fungerande exempel.

 #include int main() ( int* pc, c; c = 22; printf("Address of c: %p", &c); printf("Value of c: %d", c); // 22 pc = &c; printf("Address of pointer pc: %p", pc); printf("Content of pointer pc: %d", *pc); // 22 c = 11; printf("Address of pointer pc: %p", pc); printf("Content of pointer pc: %d", *pc); // 11 *pc = 2; printf("Address of c: %p", &c); printf("Value of c: %d", c); // 2 return 0; )

Produktion

 Adress av c: 2686784 Värde av c: 22 Adress av pekare pc: 2686784 Innehåll av pekare pc: 22 Adress av pekare pc: 2686784 Innehåll av pekare pc: 11 Adress av c: 2686784 Värde av c: 2

Förklaring av programmet

  1. int* pc, c;

    Here, a pointer pc and a normal variable c, both of type int, is created.
    Since pc and c are not initialized at initially, pointer pc points to either no address or a random address. And, variable c has an address but contains random garbage value.
  2. c = 22;

    This assigns 22 to the variable c. That is, 22 is stored in the memory location of variable c.
  3. pc = &c;

    This assigns the address of variable c to the pointer pc.
  4. c = 11;

    This assigns 11 to variable c.
  5. *pc = 2;

    This change the value at the memory location pointed by the pointer pc to 2.

Common mistakes when working with pointers

Suppose, you want pointer pc to point to the address of c. Then,

 int c, *pc; // pc is address but c is not pc = c; // Error // &c is address but *pc is not *pc = &c; // Error // both &c and pc are addresses pc = &c; // both c and *pc values *pc = c;

Here's an example of pointer syntax beginners often find confusing.

 #include int main() ( int c = 5; int *p = &c; printf("%d", *p); // 5 return 0; )

Why didn't we get an error when using int *p = &c;?

It's because

 int *p = &c;

is equivalent to

 int *p: p = &c;

I båda fallen skapar vi en pekare p(inte *p) och tilldelar &cden.

För att undvika denna förvirring kan vi använda uttalandet så här:

 int* p = &c;

Nu vet du vad pekare är, du lär dig hur pekare är relaterade till matriser i nästa handledning.

Intressanta artiklar...