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

Hvad er Pointer i C?

Pointer i C, er en variabel, der gemmer adressen på en anden variabel. En pointer kan også bruges til at henvise til en anden pointerfunktion. En markør kan øges/dekrementeres, dvs. at pege på den næste/forrige hukommelsesplacering. Formålet med pointer er at spare hukommelsesplads og opnå hurtigere eksekveringstid.

Sådan bruges pointere i C

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

Sådan bruges pointere i C

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.

Sådan bruges pointere i C

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

Sådan bruges pointere i C

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.


Pointer variabel

Int *y = &v;

VARIABEL POINTER
A værdi opbevaret i en som hedder lager-/hukommelsesadresse A variabel at peger på lager-/hukommelsesadressen på en variabel

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
OperaTor Betydning
* Har 2 formål

  1. Erklæring af en pointer
  2. Returnerer værdien af ​​den refererede variabel
& Har kun 1 formål

  • Returnerer adressen på en variabel

Typer af pointere i C

Følgende er de forskellige Typer af pointere i C:

Nul Pointer

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

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

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

Output:

The value inside variable p is:
0

Void Pointer

In C programmering, kaldes en void pointer også som en generisk pointer. Den har ikke nogen standard datatype. En void pointer oprettes ved at bruge nøgleordet void. Den kan bruges til at gemme en adresse for enhver variabel.

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

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

Output:

The size of pointer is:4

Vild pointer

En pointer siges at være en vild pointer, hvis den ikke initialiseres til noget. Disse typer C-pointere 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 af programmet. Man skal altid være forsigtig, mens man arbejder med vilde pointere.

Følgende program illustrerer brugen af ​​wild pointer:

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

Output:

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

Andre typer af pointere i 'c' er som følger:

  • Dinglende pointer
  • Kompleks pointer
  • Tæt på pointer
  • Fjern pointer
  • Kæmpe pointer

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

Pointer-aritmetik i C
Pointer Operationer

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
Udtryk Tilsvarende 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 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

Produktion Forklaring
Opgave int *P1,*P2
P1=P2;
P1 og P2 peger på den samme heltalsvariabel
Inkrementering og dekrementering Int *P1;
P1++;P1–;
Tilføjelse af en offset (konstant) Dette gør det muligt for markøren at flytte N elementer i en tabel.
Markøren vil blive forøget eller formindsket med N gange antallet af byte(r) af typen af ​​variabel.
P1+5;

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:

C Pointere & Arrays

Pointer tilføjelse/stigning

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

Fordele ved pointere i C

  • Pointere er nyttige til at få adgang til hukommelsesplaceringer.
  • Pointere giver en effektiv måde at få adgang til elementerne i en matrixstruktur.
  • Pointere bruges til dynamisk hukommelsesallokering såvel som deallokering.
  • Pointere bruges til at danne komplekse datastrukturer såsom linket liste, graf, træ osv.

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.