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

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.

Men varje variabel, förutom värde, har också sin adress (eller, enkelt uttryckt, där den finns i minnet). Adressen kan hämtas genom att sätta ett et-tecken (&) före variabelnamnet.

Om du skriver ut adressen till en variabel på skärmen kommer den att se ut som ett totalt slumpmässigt tal (desutom kan det vara olika från körning till körning).

Låt oss prova detta i praktiken med pekaren i C-exemplet

Resultatet av detta program är -480613588.

Nu, vad är en pekare? Istället för att lagra ett värde kommer en pekare att lagra adressen till en variabel.

Int *y = &v;

Deklarerar en pekare

Som variabler, pekare in C-programmering måste deklareras innan de kan användas i ditt program. Pekare kan heta 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 typ ä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, deklarerar en pekare.

Låt oss se några giltiga pekardeklarationer i denna handledning för C-pekare:

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 deklarerat en pekare initierar vi den som standardvariabler med en variabel adress. Om pekare i C-programmering är oinitierade och används i ett program, kan resultaten bli oförutsägbara och potentiellt katastrofala.

För att få adressen till en variabel använder vi et-tecken (&)-operatorn, placerad före 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 <stdio.h>
int main()
{
   int a=10;    //variable declaration
   int *p;      //pointer variable declaration
   p=&a;        //store address of variable a in pointer p
   printf("Address stored in a variable p is:%x\n",p);  //accessing the address
   printf("Value stored in a variable p is:%d\n",*p);   //accessing the value
   return 0;
}

Produktion:

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

#include <stdio.h>
int main()
{
	int *p = NULL; 	//null pointer
	printf(“The value inside variable p is:\n%x”,p);
	return 0;
}

The value inside variable p is:
0

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

The size of pointer is:4

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

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

Direkta och indirekta åtkomstpekare

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 <stdio.h>
/* 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 = 1
Indirect access, var = 1

The address of var = 4202496
The address of var = 4202496

Indirect access, var = 48

Pekararitmetik i C

Pekaroperationerna sammanfattas i följande figur

Prioriterad operation (prioritet)

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

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

Om en P-pekare pekar på en X-variabel kan * P användas överallt där X kan skrivas.

Följande uttryck är likvärdiga:

int X =10
int *P = &Y;
For the above code, below expressions are true

I det senare fallet behövs parenteser: eftersom de unära operatorerna * och ++ utvärderas från höger till vänster, utan parenteserna skulle pekaren P ökas, inte objektet som P pekar på.

Tabellen nedan visar den aritmetiska och grundläggande operation som kan användas vid hantering av C-pekare

C Pointers & Arrays med exempel

Traditionellt kommer vi åt arrayelementen med hjälp av dess index, men denna metod kan elimineras genom att använda pekare. Pekare gör det enkelt att komma åt varje arrayelement.

#include <stdio.h>
int main()
{
    int a[5]={1,2,3,4,5};   //array initialization
    int *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 elements
        	p++;    //incrementing to the next element, you can also write p=p+1
    }
    return 0;
}

Produktion:

1
2
3
4
5

Om du lägger till ett visst nummer till en pekare flyttas pekarens plats till det värde som erhålls genom en additionsoperation. Anta att p är en pekare som för närvarande pekar på minnesplatsen 0 om vi utför följande additionsoperation, 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, kommer värdet att bli 1, och därför kommer pekaren att peka på minnesplatsen 1.

C Pekare och strängar med exempel

En sträng är en array av char-objekt som slutar med ett nolltecken '\ 0'. Vi kan manipulera strängar med hjälp av pekare. Den här pekaren i C-exemplet förklarar detta avsnitt

#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);
printf("Printing all the characters in a string\n");
p=str;  //reset the pointer
for(int i=0;i<strlen(str);i++)
{
printf("%c\n",*p);
p++;
}
return 0;
}

Produktion:

First character is:H
Next character is:e
Printing all the characters in a string
H
e
l
l
o

G
u
r
u
9
9
!

Ett annat sätt att hantera strängar är med en rad pekare som i följande program:

#include <stdio.h>
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:
iron
copper
gold

Nackdelar med Pointers i C

• Pekare är lite komplicerade att förstå.
• Pekare kan leda till olika fel som segmenteringsfel eller kan komma åt en minnesplats som inte alls krävs.
• Om ett felaktigt värde ges till en pekare kan det orsaka minneskada.
• Pekare är också ansvariga för minnesläckage.
• Pekare är jämförelsevis långsammare än variablernas.
• Programmerare har mycket svårt att arbeta med pekarna; 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, void-pekare och andra typer av pekare.
• Pekare kan användas med array och sträng för att komma åt element mer effektivt.
• Vi kan skapa funktionspekare för att anropa en funktion dynamiskt.
• Aritmetiska operationer kan göras på en pekare som är känd som pekararitmetik.
• Pekare kan också peka på funktion vilket gör det enkelt att anropa olika funktioner i fallet med att definiera en array av pekare.
• När du vill hantera olika typer av variabeldata kan du använda en typcast void-pekare.