Pointere i C: Hvad er Pointer i C-programmering? Typer

Sådan bruges pointere i C

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

v er lig nul nu.

Men hver variabel, bortset fra værdi, har også sin adresse (eller ganske enkelt sagt, hvor den er placeret i hukommelsen). Adressen kan hentes ved at sætte et og-tegn (&) før variabelnavnet.

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

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

Outputtet af dette program er -480613588.

Hvad er nu en pointer? I stedet for at gemme en værdi, vil en pointer gemme adressen på en variabel.

Int *y = &v;

Erklærer en pointer

Ligesom variabler, peger ind C programmering skal deklareres, før de kan bruges i dit program. Pointere kan navngives hvad du vil, så længe de overholder C's navngivningsregler. En pointererklæring har følgende form.

data_type * pointer_variable_name;

Her,

• datatype er pointerens basistype af Cs variabeltyper og angiver typen af ​​den variabel, som markøren peger på.
• Stjernen (*: den samme stjerne, der bruges til multiplikation), som er indirektionsoperator, erklærer en pointer.

Lad os se nogle gyldige pointer-erklæ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 pointer

Efter at have erklæret en pointer, initialiserer vi den som standardvariabler med en variabel adresse. Hvis pointere i C-programmering ikke er initialiseret og brugt i et program, kan resultaterne være uforudsigelige og potentielt katastrofale.

For at få adressen på en variabel bruger vi og-tegnet (&)-operator, placeret foran navnet på en variabel, hvis adresse vi skal bruge. Pointerinitialisering udføres med følgende syntaks.

Pointer syntaks

 pointer = &variable;

Et simpelt program til pointerillustration er givet nedenfor:

#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;
}

Output:

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

Direkte og indirekte adgangsmarkører

I C er der to tilsvarende måder at få adgang til og manipulere et variabelt indhold på

• Direkte adgang: vi bruger variabelnavnet direkte
• Indirekte adgang: vi bruger en pointer til variablen

Lad os forstå dette ved hjælp af programmet nedenfor

#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 kompilering af programmet uden fejl, er resultatet:

Direct access, var = 1
Indirect access, var = 1

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

Indirect access, var = 48

Pointer-aritmetik i C

Pegeroperationerne er opsummeret i den følgende figur

Prioriteret operation (prioritet)

Når vi arbejder med C-pointere, skal vi overholde følgende prioriteringsregler:

• Operatorerne * og & har samme prioritet som unære operatorer (negationen!, inkrementering++, dekrement–).
• I det samme udtryk evalueres de unære operatorer *, &,!, ++, – fra højre mod venstre.

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

Følgende udtryk er ækvivalente:

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

I sidstnævnte tilfælde er der behov for parenteser: da unære operatorer * og ++ evalueres fra højre mod venstre, uden parenteserne ville markøren P blive inkrementeret, ikke objektet, som P peger på.

Nedenstående tabel viser den aritmetiske og grundlæggende operation, der kan bruges, når man arbejder med C-pointere

C Pointere og arrays med eksempler

Traditionelt får vi adgang til array-elementerne ved hjælp af dets indeks, men denne metode kan elimineres ved at bruge pointere. Pointers gør det nemt at få adgang til hvert array-element.

#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;
}

Output:

1
2
3
4
5

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

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

C Pointer og strenge med eksempler

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

#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;
}

Output:

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
!

En anden måde at håndtere strenge på er med en række pointere som i følgende 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;}

Output:

Please remember these materials:
iron
copper
gold

Ulemper ved pointere i C

• Pointers er lidt komplekse at forstå.
• Pointere kan føre til forskellige fejl såsom segmenteringsfejl eller kan få adgang til en hukommelsesplacering, som slet ikke er påkrævet.
• Hvis der angives en forkert værdi til en markør, kan det forårsage hukommelseskorruption.
• Pointere er også ansvarlige for hukommelseslækage.
• Pointere er forholdsvis langsommere end variablernes.
• Programmører har meget svært ved at arbejde med pointerne; derfor er det programmørens ansvar at manipulere en markør omhyggeligt.

Resumé

• En pointer er intet andet end en hukommelsesplacering, hvor data gemmes.
• En markør bruges til at få adgang til hukommelsesplaceringen.
• Der er forskellige typer af pointere, såsom en null pointer, wild pointer, void pointer og andre typer pointer.
• Pointere kan bruges med array og streng for at få mere effektiv adgang til elementer.
• Vi kan oprette funktionspointere for at påkalde en funktion dynamisk.
• Aritmetiske operationer kan udføres på en pointer, der er kendt som pointer-aritmetik.
• Pointere kan også pege på funktion, hvilket gør det nemt at kalde forskellige funktioner i tilfælde af at definere et array af pointere.
• Når du ønsker at håndtere forskellige variable datatyper, kan du bruge en typecast void pointer.