Pointers in C: Wat is Pointer in C-programmering? Soorten

Wat is aanwijzer in C?

Het Wijzer in C is een variabele die het adres van een andere variabele opslaat. Een pointer kan ook worden gebruikt om naar een andere pointerfunctie te verwijzen. Een pointer kan worden verhoogd/verlaagd, dwz om naar de volgende/vorige geheugenlocatie te wijzen. Het doel van pointer is om geheugenruimte te besparen en een snellere uitvoeringstijd te bereiken.

Aanwijzingen gebruiken in C

Als we een variabele v van het type int declareren, slaat v feitelijk een waarde op.

Aanwijzingen gebruiken in C

v is nu gelijk aan nul.

Elke variabele heeft echter, behalve de waarde, ook een adres (of, simpel gezegd, waar deze zich in het geheugen bevindt). Het adres kan worden opgehaald door een ampersand (&) voor de naam van de variabele te plaatsen.

Aanwijzingen gebruiken in C

Als u het adres van een variabele op het scherm afdrukt, ziet het eruit als een totaal willekeurig getal (bovendien kan het van run tot run verschillen).

Laten we dit in de praktijk proberen met de aanwijzer in het C-voorbeeld

Aanwijzingen gebruiken in C

De uitvoer van dit programma is -480613588.

Wat is nu een aanwijzer? In plaats van een waarde op te slaan, slaat een pointer het adres van een variabele op.


Aanwijzervariabele

Int *y = &v;

VARIABELE PUNT
A waarde opgeslagen in een genoemd opslag-/geheugenadres A variabele dat wijst het opslag-/geheugenadres van ander variabele

Een aanwijzer declareren

Net als variabelen, verwijzingen naar binnen C programmeren moeten worden gedeclareerd voordat ze in uw programma kunnen worden gebruikt. Pointers kunnen elke gewenste naam krijgen, zolang ze maar voldoen aan de naamgevingsregels van C. Een pointer-declaratie heeft het volgendewing vorm.

data_type * pointer_variable_name;

Hier

  • data type is het basistype van de aanwijzer van de variabeletypen van C en geeft het type variabele aan waarnaar de aanwijzer verwijst.
  • Het sterretje (*: hetzelfde sterretje dat wordt gebruikt voor vermenigvuldiging), wat een indirectie-operator is, declares een wijzer.

Laten we enkele geldige pointerdeclaraties bekijken in deze 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 */

Initialiseer een aanwijzer

Nadat we een pointer hebben gedeclareerd, initialiseren we deze als standaardvariabelen met een variabel adres. Als pointers in C-programmering niet niet-geïnitialiseerd zijn en in het programma worden gebruikt, zijn de resultaten onvoorspelbaar en mogelijk rampzalig.

Om het adres van een variabele te achterhalen, gebruiken we de ampersand (&)-operator, geplaatst vóór de naam van een variabele waarvan we het adres nodig hebben. Pointer-initialisatie wordt gedaan met de following syntaxis.

Aanwijzersyntaxis

 pointer = &variable;

Hieronder vindt u een eenvoudig programma voor aanwijzerillustratie:

#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 Betekenis
* Dient 2 doeleinden

  1. Verklaring van een aanwijzer
  2. Retourneert de waarde van de variabele waarnaar wordt verwezen
& Dient slechts 1 doel

  • Retourneert het adres van een variabele

Soorten aanwijzingen in C

Following zijn de verschillende Soorten aanwijzingen in C:

Nul punten

We kunnen een null-pointer maken door een nulwaarde toe te wijzen tijdens de pointer-declaratie. Deze methode is handig als er geen adres aan de aanwijzer is toegewezen. Een nulwijzer bevat altijd de waarde 0.

Following programma illustreert het gebruik van een nulaanwijzer:

#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

Ongeldige aanwijzer

In C programmeren, wordt een lege aanwijzer ook wel een generieke aanwijzer genoemd. Het heeft geen standaard gegevenstype. Een void-aanwijzer wordt gemaakt met behulp van het trefwoord void. Het kan worden gebruikt om een ​​adres van elke variabele op te slaan.

Following programma illustreert het gebruik van een lege aanwijzer:

#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

Wilde aanwijzer

Er wordt gezegd dat een aanwijzer een wilde aanwijzer is als deze nergens op wordt geïnitialiseerd. Dit soort C-pointers zijn niet efficiënt omdat ze naar een onbekende geheugenlocatie kunnen verwijzen, wat problemen in ons programma kan veroorzaken en kan leiden tot het crashen van het programma. Men moet altijd voorzichtig zijn bij het werken met wilde wijzers.

Following programma illustreert het gebruik van 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

Andere soorten verwijzingen in 'c' zijn als volgt:

  • Bungelende wijzer
  • complex wijzer
  • In de buurt van aanwijzer
  • Verre wijzer
  • Enorme wijzer

Directe en indirecte toegangsaanwijzers

In C zijn er twee gelijkwaardige manieren om toegang te krijgen tot variabele inhoud en deze te manipuleren

  • Directe toegang: we gebruiken rechtstreeks de naam van de variabele
  • Indirecte toegang: we gebruiken een verwijzing naar de variabele

Laten we dit begrijpen met behulp van het onderstaande programma

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

Nadat het programma zonder fouten is gecompileerd, is het resultaat:

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

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

Indirect access, var = 48

Wijzer Rekenen in C

De aanwijzerbewerkingen worden in het volgende samengevatwing figuur

Wijzer Rekenen in C
Aanwijzerbewerkingen

Prioritaire bewerking (voorrang)

Wanneer we met C-aanwijzers werken, moeten we het volgende in acht nemenwing prioriteitsregels:

  • De operatoren * en & hebben dezelfde prioriteit als de unaire operatoren (de negatie!, de incrementatie++, decrement–).
  • In dezelfde uitdrukking worden de unaire operatoren *, &,!, ++, – van rechts naar links geëvalueerd.

Als een P-aanwijzer naar een X-variabele wijst, kan * P overal worden gebruikt waar X kan worden geschreven.

De following uitdrukkingen zijn gelijkwaardig:

int X =10
int *P = &Y;
For the above code, below expressions are true
Uitdrukking Gelijkwaardige expressie
J=*P+1

*P=*P+10

*P+=2

+**P

(*P)++

Y=X+1

X=X+10

X+=2

++X

X++

In het laatste geval zijn haakjes nodig: aangezien de unaire operatoren * en ++ van rechts naar links worden geëvalueerd, zou zonder de haakjes de aanwijzer P worden verhoogd, en niet het object waarnaar P wijst.

De onderstaande tabel toont de rekenkundige en basisbewerkingen die kunnen worden gebruikt bij het omgaan met C-pointers

Werking Uitleg
Toewijzing int *P1,*P2
P1=P2;
P1 en P2 wijzen naar dezelfde gehele variabele
Verhoging en verlaging Int *P1;
P1++;P1– ;
Een offset toevoegen (constant) Hierdoor kan de aanwijzer N elementen in een tabel verplaatsen.
De pointer wordt verhoogd of verlaagd met N maal het aantal byte(s) van het type variabele.
P1+5;

C-aanwijzers en arrays met voorbeelden

Traditioneel benaderen we de array-elementen met behulp van de index, maar deze methode kan worden geëlimineerd door pointers te gebruiken. Pointers maken het gemakkelijk om toegang te krijgen tot elk 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

Door een bepaald getal aan een aanwijzer toe te voegen, wordt de aanwijzerlocatie verplaatst naar de waarde die is verkregen door een optelbewerking. Stel dat p een pointer is die momenteel naar de geheugenlocatie 0 wijst als we follo uitvoerenwing optelbewerking, p+1, dan wordt het op deze manier uitgevoerd:

C-aanwijzers en arrays

Aanwijzer toevoegen/verhogen

Omdat p momenteel naar de locatie 0 wijst na het optellen van 1, wordt de waarde 1, en daarom wijst de aanwijzer naar de geheugenlocatie 1.

C Pointers en strings met voorbeelden

Een string is een array van char-objecten, eindigend met een nulteken '\ 0'. We kunnen strings manipuleren met behulp van pointers. Deze aanwijzer in het C-voorbeeld legt deze sectie uit

#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
!

Een andere manier om met strings om te gaan is met een reeks pointers, zoals in het onderstaande voorbeeldwing programma:

#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

Voordelen van pointers in C

  • Aanwijzers zijn handig voor toegang tot geheugenlocaties.
  • Pointers bieden een efficiënte manier om toegang te krijgen tot de elementen van een arraystructuur.
  • Pointers worden gebruikt voor dynamische geheugentoewijzing en voor deallocatie.
  • Pointers worden gebruikt om com te vormenplex datastructuren zoals gekoppelde lijst, grafiek, boom, enz.

Nadelen van pointers in C

  • Pointers zijn een kleine complex begrijpen.
  • Pointers kunnen tot verschillende fouten leiden, zoals segmentatiefouten, of kunnen toegang krijgen tot een geheugenlocatie die helemaal niet nodig is.
  • Als een onjuiste waarde aan een pointer wordt gegeven, kan dit geheugenbeschadiging veroorzaken.
  • Pointers zijn ook verantwoordelijk voor geheugenlekkage.
  • Pointers zijn relatief langzamer dan die van de variabelen.
  • Programmeurs vinden het erg moeilijk om met de pointers te werken; daarom is het de verantwoordelijkheid van de programmeur om een ​​aanwijzer zorgvuldig te manipuleren.

Samengevat

  • Een pointer is niets anders dan een geheugenlocatie waar gegevens worden opgeslagen.
  • Er wordt een aanwijzer gebruikt om toegang te krijgen tot de geheugenlocatie.
  • Er zijn verschillende soorten pointers, zoals een nulpointer, wild pointer, void pointer en andere soorten pointers.
  • Pointers kunnen worden gebruikt met array en string om efficiënter toegang te krijgen tot elementen.
  • We kunnen functieaanwijzers maken om een ​​functie dynamisch aan te roepen.
  • Rekenkundige bewerkingen kunnen worden uitgevoerd op een aanwijzer die bekend staat als aanwijzerberekening.
  • Pointers kunnen ook naar een functie verwijzen, waardoor het gemakkelijk wordt om verschillende functies aan te roepen bij het definiëren van een array van pointers.
  • Als u met verschillende variabele gegevenstypen wilt omgaan, kunt u een typecast void pointer gebruiken.