C-markører (med eksempler)

Indholdsfortegnelse

I denne vejledning lærer du om markører; hvad der er henvisninger til, hvordan bruger du dem og de almindelige fejl, du kan blive udsat for, når du arbejder med dem ved hjælp af eksempler.

Markører er kraftfulde funktioner i C og C ++ programmering. Før vi lærer henvisninger, lad os lære om adresser i C-programmering.

Adresse i C

Hvis du har en variabel var i dit program, &vargiver den dig sin adresse i hukommelsen.

Vi har brugt adresse adskillige gange, mens vi bruger scanf()funktionen.

 scanf("%d", &var);

Her gemmes den værdi, der er indtastet af brugeren, i adressen på variabeln. Lad os tage et fungerende eksempel.

 #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 adresse på var: 2686778

Bemærk: Du får sandsynligvis en anden adresse, når du kører ovenstående kode.

C markører

Markører (markørvariabler) er specielle variabler, der bruges til at gemme adresser i stedet for værdier.

Pointer-syntaks

Sådan kan vi erklære pegepinde.

 int* p;

Her har vi erklæret en pointer p af inttypen.

Du kan også erklære markører på disse måder.

 int *p1; int * p2;

Lad os tage et andet eksempel på at erklære pegepinde.

 int* p1, p2;

Her har vi deklareret en markør p1 og en normal variabel p2.

Tildeling af adresser til markører

Lad os tage et eksempel.

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

Her tildeles 5 variablen c. Og adressen på c er tildelt pc-markøren.

Få værdi af ting peget af pointer

For at få værdien af ​​den ting, som pegerne peger på, bruger vi *operatøren. For eksempel:

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

Her ctildeles adressen til pc-markøren. For at få værdien gemt i den adresse brugte vi * pc.

Bemærk: I ovenstående eksempel er pc en markør, ikke *pc. Du kan ikke og bør ikke gøre noget som *pc = &c;

Forresten *kaldes derferenceoperatøren (når man arbejder med pegepinde). Den fungerer på en markør og giver den værdi, der er gemt i markøren.

Ændring af værdi peget af pegepinde

Lad os tage et eksempel.

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

Vi har tildelt adressen til c til pc-markøren.

Derefter ændrede vi værdien på c til 1. Da pc og adressen på c er den samme, *pcgiver os 1.

Lad os tage et andet eksempel.

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

Vi har tildelt adressen til c til pc-markøren.

Derefter skiftede vi *pctil 1 ved hjælp af *pc = 1;. Da pc og adressen på c er den samme, vil c være lig med 1.

Lad os tage endnu et eksempel.

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

Oprindeligt tildeles adressen til c pc-markøren ved hjælp af pc = &c;. Da c er 5, *pcgiver os 5.

Derefter tildeles adressen til d til pc-markøren ved hjælp af pc = &d;. Da d er -15, *pcgiver os -15.

Eksempel: Arbejde med markører

Lad os tage et fungerende eksempel.

 #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

 Adresse på c: 2686784 Værdi på c: 22 Adresse på markør pc: 2686784 Indhold på markør pc: 22 Adresse på markør pc: 2686784 Indhold på markør pc: 11 Adresse på c: 2686784 Værdi på c: 2

Forklaring af 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 begge tilfælde opretter vi en markør p(ikke *p) og tildeler &cden.

For at undgå denne forvirring kan vi bruge udsagnet således:

 int* p = &c;

Nu ved du hvad markører er, du lærer, hvordan markører er relateret til arrays i den næste vejledning.

Interessante artikler...