Pekare i C-programmering: Vad är pekare, typer & Exempel

Vad är Pointer in C?

Den pekare i C, är en variabel som lagrar adress av en annan variabel. En pekare kan också användas för att hänvisa till en annan pekfunktion. En pekare kan ökas / minskas, dvs för att peka på nästa / föregående minnesplats. Syftet med pekaren är att spara minnesutrymme och uppnå snabbare körningstid.

Hur man använder pekare i C

Om vi ​​deklarerar en variabel v av typen int, kommer v faktiskt att lagra ett värde.

v är lika med noll nu.

Emellertid har varje variabel, förutom värde, också sin adress (eller helt enkelt uttryckt där den finns i minnet). Adressen kan hämtas genom att placera ett ampersand (&) framför variabelnamnet.

Om du skriver ut adressen till en variabel på skärmen ser den ut som ett helt slumpmässigt tal (det kan dessutom vara annorlunda från körning till körning).

Låt oss pröva detta i praktiken med pekaren i C-exemplet

Resultatet av detta program är -480613588.

Vad är en pekare nu? I stället för att lagra ett värde lagrar en pekare adressen till en variabel.

Pekervariabel

Int * y = & v;

VARIABEL	PEKARE
Ett värde som lagras i en namngiven lagrings- / minnesadress	En variabel som pekar på lagrings- / minnesadressen för en annan variabel

Förklara en pekare

Liksom variabler måste pekare i C-programmering deklareras innan de kan användas i ditt program. Pekare kan namnges vad du vill så länge de följer C: s namnregler. En pekardeklaration har följande form.

data_type * pointer_variable_name;

Här,

• data_type är pekarens bastyp av C: s variabeltyper och anger vilken typ av variabel som pekaren pekar på.
• Asterisken (*: samma asterisk som används för multiplikation) som är indirektionsoperator, förklarar en pekare.

Låt oss se några giltiga pekardeklarationer i denna C-pekarehandledning:

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

Initiera en pekare

Efter att ha förklarat en pekare initialiserar vi den som standardvariabler med en variabeladress. Om pekare i C-programmering inte är oinitialiserade och används i programmet är resultaten oförutsägbara och potentiellt katastrofala.

För att få adressen till en variabel använder vi ampersand (&) -operatören, placerad framför namnet på en variabel vars adress vi behöver. Pekarinitiering görs med följande syntax.

Pekarsyntax

 pointer = &variable; 

Ett enkelt program för pekareillustration ges nedan:

#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	Menande
*	Serverar två syften Deklaration av en pekare Returnerar värdet på den refererade variabeln
&	Serverar endast 1 syfte Returnerar adressen till en variabel

Typer av pekare i C.

Följande är de olika typerna av pekare i C :

Nollpekare

Vi kan skapa en nollpekare genom att tilldela nollvärde under pekardeklarationen. Denna metod är användbar när du inte har någon adress tilldelad pekaren. En nollpekare innehåller alltid värdet 0.

Följande program illustrerar användningen av en nollpekare:

#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

Ogiltig pekare

I C-programmering kallas också en tom pekare som en generisk pekare. Den har ingen standarddatatyp. En ogiltig pekare skapas med hjälp av nyckelordet tom. Den kan användas för att lagra en adress för vilken variabel som helst.

Följande program illustrerar användningen av en tom pekare:

#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

Vild pekare

En pekare sägs vara en vild pekare om den inte initialiseras till någonting. Dessa typer av C-pekare är inte effektiva eftersom de kan peka på någon okänd minnesplats som kan orsaka problem i vårt program och det kan leda till att programmet kraschar. Man bör alltid vara försiktig när man arbetar med vilda pekare.

Följande program illustrerar användningen av vildpekare:

#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

Andra typer av pekare i 'c' är följande:

• Hängande pekare
• Komplex pekare
• Nära pekaren
• Lång pekare
• Stor pekare

Pekare för direkt och indirekt åtkomst

I C finns det två likvärdiga sätt att komma åt och manipulera ett variabelt innehåll

• Direkt åtkomst: vi använder variabelnamnet direkt
• Indirekt åtkomst: vi använder en pekare till variabeln

Låt oss förstå detta med hjälp av programmet nedan

#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 att ha kompilerat programmet utan några fel är resultatet:

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

Pointer Arithmetics i C

Pekarens funktioner sammanfattas i följande bild

Prioriterad operation (företräde)

När vi arbetar med C-pekare måste vi följa följande prioritetsregler:

• Operatörerna * och & har samma prioritet som de unära operatörerna (negationen !, inkrementeringen ++, dekrement--).
• I samma uttryck utvärderas de unara operatorerna *, &,!, ++, - från höger till vänster.

Om en P-pekare pekar på en X-variabel kan * P användas varhelst X kan skrivas.

Följande uttryck är ekvivalenta:

int X = 10 int * P = & Y; För ovanstående kod är nedanstående uttryck sanna
Uttryck	Motsvarande uttryck
Y = * P + 1 * P = * P + 10 * P + = 2 ++ * P (* P) ​​++	Y = X + 1 X = X + 10 X + = 2 ++ X X ++

I det sistnämnda fallet är parenteser nödvändiga: eftersom de unara operatorerna * och ++ utvärderas från höger till vänster, utan parenteser skulle pekaren P ökas, inte objektet på vilket P pekar.

Nedanstående tabell visar aritmetik och grundläggande funktion som kan användas vid hantering av C-pekare

Drift	Förklaring
Uppdrag	int * P1, * P2 P1 = P2; P1 och P2 pekar på samma heltalsvariabel
Inkrementering och minskning	Int * P1; P1 ++; P1--;
Lägga till en förskjutning (konstant)	Detta gör att pekaren kan flytta N-element i en tabell. Pekaren kommer att ökas eller minskas med N gånger antalet byte (er) av typen av variabeln. P1 + 5;

C Pekare och matriser med exempel

Traditionellt kommer vi åt arrayelementen med hjälp av dess index, men den här metoden kan elimineras med hjälp av pekare. Pekare gör det enkelt att komma åt varje arrayelement.

#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

Om du lägger till ett visst nummer i en pekare flyttas pekarens plats till det värde som erhålls genom en tilläggsoperation. Antag att p är en pekare som för närvarande pekar på minnesplatsen 0 om vi utför följande tilläggsoperation, p + 1 så kommer den att köras på detta sätt:

Eftersom p för närvarande pekar på platsen 0 efter att ha lagt till 1 blir värdet 1 och därmed pekaren peka på minnesplatsen 1.

C Pekare och strängar med exempel

En sträng är en matris med char-objekt som slutar med ett null-tecken '\ 0'. Vi kan manipulera strängar med hjälp av pekare. Denna pekare i C-exemplet förklarar detta avsnitt

#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!
Ett annat sätt att hantera strängar är med en rad pekare som i följande 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
 
Fördelar med pekare i C

Pekare är användbara för åtkomst till minnesplatser.
Pekare ger ett effektivt sätt att komma åt elementen i en matrisstruktur.
Pekare används för dynamisk minnesallokering såväl som deallocation.
Pekare används för att bilda komplexa datastrukturer som länkad lista, diagram, träd etc.


Nackdelar med pekare i C.

Pekare är lite komplexa att förstå.
Pekare kan leda till olika fel såsom segmenteringsfel eller kan komma åt en minnesplats som inte alls behövs.
Om en pekare tillhandahåller ett felaktigt värde kan det orsaka minneskador.
Pekare är också ansvariga för minnesläckage.
Pekare är relativt långsammare än för variablerna.
Programmerare tycker det är mycket svårt att arbeta med pekare; därför är det programmerarens ansvar att manipulera en pekare noggrant.

Sammanfattning 

En pekare är inget annat än en minnesplats där data lagras.
En pekare används för att komma åt minnesplatsen.
Det finns olika typer av pekare som en nollpekare, vildpekare, ogiltiga pekare och andra typer av pekare.
Pekare kan användas med array och sträng för att få tillgång till element mer effektivt.
Vi kan skapa funktionspekare för att anropa en funktion dynamiskt.
Aritmetiska operationer kan utföras på en pekare som är känd som pekare-aritmetik.
Pekare kan också peka på funktion som gör det enkelt att anropa olika funktioner om man definierar en rad pekare.
När du vill hantera olika variabla datatyper kan du använda en typecast-tomrumspekare.