Markører i C-programmering: Hvad er pointer, typer & Eksempler

Hvad er pointer i C?

Den Pointer i C, er en variabel, der gemmer adressen på en anden variabel. En markør kan også bruges til at henvise til en anden markørfunktion. En markør kan forøges / dekrementeres, dvs. for at pege på den næste / forrige hukommelsesplacering. Pointerens formål er at spare hukommelsesplads og opnå hurtigere udførelsestid.

Sådan bruges markører i C

Hvis vi erklærer en variabel v af typen int, gemmer v faktisk en værdi.

v er lig med nul nu.

Imidlertid har hver variabel bortset fra værdi også sin adresse (eller simpelthen, hvor den er placeret i hukommelsen). Adressen kan hentes ved at placere et ampersand (&) foran variabelnavnet.

Hvis du udskriver adressen på en variabel på skærmen, vil den se ud som et helt tilfældigt tal (det kan desuden være forskelligt fra løb til løb).

Lad os prøve dette i praksis med pointer i C-eksempel

Resultatet af dette program er -480613588.

Hvad er nu en markør? I stedet for at gemme en værdi vil en markør y gemme adressen på en variabel.

Markørvariabel

Int * y = & v;

VARIABEL	POEGER
En værdi, der er gemt i en navngivet lager- / hukommelsesadresse	En variabel, der peger på lager- / hukommelsesadressen for en anden variabel

Erklæring om en markør

Ligesom variabler skal markører i C-programmering erklæres, før de kan bruges i dit program. Markører kan navngives alt, hvad du vil, så længe de overholder Cs navngivningsregler. En markørerklæring har følgende form.

data_type * pointer_variable_name;

Her,

• data_type er markørens basistype af C's variabeltyper og angiver den type variabel, som markøren peger på.
• Stjernen (*: den samme stjerne, der bruges til multiplikation), som er indirektionsoperator, erklærer en markør.

Lad os se nogle gyldige markørerklæringer i denne C-pointers tutorial:

int *ptr_thing; /* pointer to an integer */int *ptr1,thing;/* ptr1 is a pointer to type integer and thing is an integer variable */double *ptr2; /* pointer to a double */float *ptr3; /* pointer to a float */char *ch1 ; /* pointer to a character */float *ptr, variable;/*ptr is a pointer to type float and variable is an ordinary float variable */

Initialiser en markør

Efter at have erklæret en markør initialiserer vi den som standardvariabler med en variabeladresse. Hvis markører i C-programmering ikke er uinitialiseret og bruges i programmet, er resultaterne uforudsigelige og potentielt katastrofale.

For at få adressen på en variabel bruger vi ampersand (&) operatoren, placeret foran navnet på en variabel, hvis adresse vi har brug for. Pointerinitialisering udføres med følgende syntaks.

Pointer-syntaks

 pointer = &variable; 

Et simpelt program til pointerillustration er givet nedenfor:

#include int main(){int a=10; //variable declarationint *p; //pointer variable declarationp=&a; //store address of variable a in pointer pprintf("Address stored in a variable p is:%x\n",p); //accessing the addressprintf("Value stored in a variable p is:%d\n",*p); //accessing the valuereturn 0;}

Produktion:

Address stored in a variable p is:60ff08Value stored in a variable p is:10

Operatør	Betyder
*	Serverer 2 formål Erklæring om en markør Returnerer værdien af ​​den refererede variabel
&	Serverer kun 1 formål Returnerer adressen på en variabel

Typer af markører i C

Følgende er de forskellige typer markører i C :

Null Pointer

Vi kan oprette en nul pointer ved at tildele nulværdi under pointerdeklarationen. Denne metode er nyttig, når du ikke har tildelt nogen adresse til markøren. En nul pointer indeholder altid værdi 0.

Følgende program illustrerer brugen af ​​en nul pointer:

#include int main(){int *p = NULL; //null pointerprintf(“The value inside variable p is:\n%x”,p);return 0;}

Produktion:

The value inside variable p is:0

Ugyldig markør

I C-programmering kaldes en ugyldig markør også som en generisk markør. Den har ikke nogen standard datatype. En ugyldig markør oprettes ved hjælp af nøgleordet ugyldigt. Den kan bruges til at gemme en adresse på enhver variabel.

Følgende program illustrerer brugen af ​​en ugyldig markør:

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

Produktion:

The size of pointer is:4

Vilde markør

En markør siges at være en vildmarkør, hvis den ikke initialiseres til noget. Disse typer C-markører er ikke effektive, fordi de kan pege på en ukendt hukommelsesplacering, som kan forårsage problemer i vores program, og det kan føre til nedbrud på programmet. Man skal altid være forsigtig, når man arbejder med vilde pegepinde.

Følgende program illustrerer brugen af ​​vildmarkør:

#include int main(){int *p; //wild pointerprintf("\n%d",*p);return 0;}

Produktion

timeout: the monitored command dumped coresh: line 1: 95298 Segmentation fault timeout 10s main

Andre typer markører i 'c' er som følger:

• Hængende markør
• Kompleks markør
• Tæt på markøren
• Fjern markør
• Enorm markør

Direkte og indirekte adgangspunkter

I C er der to ækvivalente måder at få adgang til og manipulere med et variabelt indhold

• Direkte adgang: vi bruger variabelnavnet direkte
• Indirekte adgang: vi bruger en markør til variablen

Lad os forstå dette ved hjælp af nedenstående program

#include /* Declare and initialize an int variable */int var = 1;/* Declare a pointer to int */int *ptr;int main( void ){/* Initialize ptr to point to var */ptr = &var;/* Access var directly and indirectly */printf("\nDirect access, var = %d", var);printf("\nIndirect access, var = %d", *ptr);/* Display the address of var two ways */printf("\n\nThe address of var = %d", &var);printf("\nThe address of var = %d\n", ptr);/*change the content of var through the pointer*/*ptr=48;printf("\nIndirect access, var = %d", *ptr);return 0;}

Efter kompilering af programmet uden fejl er resultatet:

Direct access, var = 1Indirect access, var = 1The address of var = 4202496The address of var = 4202496Indirect access, var = 48

Pointer Arithmetics i C

Markørhandlingerne er opsummeret i følgende figur

Prioriteret operation (forrang)

Når vi arbejder med C-markører, skal vi overholde følgende prioritetsregler:

• Operatørerne * og & har samme prioritet som de unære operatører (negationen !, inkrementeringen ++, dekrement--).
• I samme udtryk evalueres de unære operatorer *, &,!, ++, - fra højre til venstre.

Hvis en P-peger peger på en X-variabel, kan * P bruges hvor som helst X kan skrives.

Følgende udtryk er ækvivalente:

int X = 10 int * P = & Y; For ovenstående kode er nedenstående udtryk sande
Udtryk	Ækvivalent udtryk
Y = * P + 1 * P = * P + 10 * P + = 2 ++ * P (* P) ​​++	Y = X + 1 X = X + 10 X + = 2 ++ X X ++

I sidstnævnte tilfælde er der brug for parenteser: da de unære operatorer * og ++ vurderes fra højre mod venstre, uden parenteserne, vil markøren P blive inkrementeret, ikke det objekt, som P peger på.

Nedenstående tabel viser den aritmetiske og grundlæggende funktion, der kan bruges, når man har at gøre med C-markører

Operation	Forklaring
Opgave	int * P1, * P2 P1 = P2; P1 og P2 peger på den samme heltalsvariabel
Forøgelse og nedbrydning	Int * P1; P1 ++; P1--;
Tilføjelse af en forskydning (konstant)	Dette gør det muligt for markøren at flytte N-elementer i en tabel. Markøren øges eller formindskes med N gange antallet af byte (r) af typen af ​​variablen. P1 + 5;

C Markører og arrays med eksempler

Traditionelt har vi adgang til matrixelementerne ved hjælp af dets indeks, men denne metode kan elimineres ved hjælp af markører. Markører gør det let at få adgang til hvert array-element.

#include int main(){int a[5]={1,2,3,4,5}; //array initializationint *p; //pointer declaration/*the ptr points to the first element of the array*/p=a; /*We can also type simply ptr==&a[0] */printf("Printing the array elements using pointer\n");for(int i=0;i<5;i++) //loop for traversing array elements{printf("\n%x",*p); //printing array elementsp++; //incrementing to the next element, you can also write p=p+1}return 0;}

Produktion

12345

Tilføjelse af et bestemt tal til en markør flytter markørens placering til den værdi, der opnås ved en tilføjelsesoperation. Antag at p er en markør, der i øjeblikket peger på hukommelsesplaceringen 0, hvis vi udfører følgende tilføjelsesoperation, p + 1, så udføres den på denne måde:

Da p i øjeblikket peger på placeringen 0 efter tilføjelse af 1, bliver værdien 1, og markøren vil derfor pege på hukommelsesplaceringen 1.

C Pointer og strenge med eksempler

En streng er en matrix af char-objekter, der slutter med et null-tegn '\ 0'. Vi kan manipulere strenge ved hjælp af pegepinde. Denne markør i C-eksemplet forklarer dette afsnit

#include #include 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);printf("Printing all the characters in a string\n");p=str; //reset the pointerfor(int i=0;i
Produktion
First character is:HNext character is:ePrinting all the characters in a stringHelloGuru99!
En anden måde at håndtere strenge på er med en række markører som i følgende program:
#include int main(){char *materials[ ] = { "iron", "copper", "gold"};printf("Please remember these materials :\n");int i ;for (i = 0; i < 3; i++) {printf("%s\n", materials[ i ]);}return 0;}
Produktion:
Please remember these materials:ironcoppergold
 
Fordele ved markører i C.

Markører er nyttige til at få adgang til hukommelsesplaceringer.
Markører giver en effektiv måde at få adgang til elementerne i en matrixstruktur.
Markører bruges til dynamisk hukommelsesallokering samt deallocation.
Markører bruges til at danne komplekse datastrukturer såsom linket liste, graf, træ osv.


Ulemper ved markører i C.

Markører er lidt komplekse at forstå.
Markører kan føre til forskellige fejl såsom segmenteringsfejl eller kan få adgang til en hukommelsesplacering, der slet ikke er påkrævet.
Hvis der vises en forkert værdi til en markør, kan det forårsage hukommelseskorruption.
Markører er også ansvarlige for hukommelseslækage.
Markører er forholdsvis langsommere end variablerne.
Programmører finder det meget vanskeligt at arbejde med henvisningerne; derfor er det programmørens ansvar at manipulere en markør omhyggeligt.

Resumé 

En markør er intet andet end en hukommelsesplacering, hvor data lagres.
En markør bruges til at få adgang til hukommelsesplaceringen.
Der er forskellige typer markører, såsom en nulmarkør, vildmarkør, ugyldig markør og andre typer markører.
Markører kan bruges med array og streng for at få adgang til elementer mere effektivt.
Vi kan oprette funktionspegere for at påkalde en funktion dynamisk.
Aritmetiske operationer kan udføres på en markør, der er kendt som pointer aritmetik.
Markører kan også pege på funktion, som gør det let at kalde forskellige funktioner i tilfælde af at definere en række markører.
Når du vil håndtere forskellige variable datatyper, kan du bruge en ugyldig markør for typecast.