De aanwijzer in C-taal is een variabele die het adres van een andere variabele opslaat. Deze variabele kan van het type int, char, array, function of een andere pointer zijn. De grootte van de aanwijzer is afhankelijk van de architectuur. In een 32-bits architectuur is de grootte van een pointer echter 2 byte.

Beschouw het volgende voorbeeld om een ​​pointer te definiëren die het adres van een geheel getal opslaat.

 int n = 10; int* p = &n; // Variable p of type pointer is pointing to the address of the variable n of type integer. 

Een aanwijzer declareren

De aanwijzer in c-taal kan worden gedeclareerd met * (sterretje). Het is ook bekend als indirecte aanwijzer die wordt gebruikt om een ​​aanwijzer te derefereren.

 int *a;//pointer to int char *c;//pointer to char 

Aanwijzer voorbeeld

Hieronder vindt u een voorbeeld van het gebruik van pointers om het adres en de waarde af te drukken.

Zoals u in de bovenstaande afbeelding kunt zien, slaat de pointervariabele het adres van de getalvariabele op, dat wil zeggen fff4. De waarde van de getalvariabele is 50. Maar het adres van de pointervariabele p is aaa3.

Met de hulp van * ( indirecte operator ), kunnen we de waarde van de pointervariabele p afdrukken.

Java instellen

Laten we het aanwijzervoorbeeld bekijken zoals uitgelegd voor de bovenstaande afbeelding.

 #include int main(){ int number=50; int *p; p=&number;//stores the address of number variable printf('Address of p variable is %x 
',p); // p contains the address of the number therefore printing p gives the address of number. printf('Value of p variable is %d 
',*p); // As we know that * is used to dereference a pointer therefore if we print *p, we will get the value stored at the address contained by p. return 0; } 

Uitvoer

 Address of number variable is fff4 Address of p variable is fff4 Value of p variable is 50 

Aanwijzer naar array

 int arr[10]; int *p[10]=&arr; // Variable p of type pointer is pointing to the address of an integer array arr. 

Verwijzing naar een functie

 void show (int); void(*p)(int) = &display; // Pointer p is pointing to the address of a function 

Wijzer naar structuur

 struct st { int i; float f; }ref; struct st *p = &ref; 

Voordeel van wijzer

1) Aanwijzer verkleint de code En verbetert de prestaties , het wordt gebruikt voor het ophalen van strings, bomen, enz. en wordt gebruikt met arrays, structuren en functies.

java-bestand openen

2) Dat kunnen we retourneer meerdere waarden van een functie met behulp van de aanwijzer.

3) Het maakt je daartoe in staat toegang tot elke geheugenlocatie in het geheugen van de computer.

Gebruik van aanwijzer

Er zijn veel toepassingen van pointers in c-taal.

1) Dynamische geheugentoewijzing

In c-taal kunnen we geheugen dynamisch toewijzen met behulp van malloc() en calloc() functies waarbij de aanwijzer wordt gebruikt.

2) Arrays, functies en structuren

Pointers in c-taal worden veel gebruikt in arrays, functies en structuren. Het vermindert de code en verbetert de prestaties.

Adres van (&) exploitant

Het adres van operator '&' retourneert het adres van een variabele. Maar we moeten %u gebruiken om het adres van een variabele weer te geven.

 #include int main(){ int number=50; printf('value of number is %d, address of number is %u',number,&number); return 0; } 

Uitvoer

 value of number is 50, address of number is fff4 

Nul punten

Een aanwijzer waaraan geen andere waarde dan NULL is toegewezen, staat bekend als de NULL-aanwijzer. Als u op het moment van declaratie geen adres in de pointer hoeft op te geven, kunt u een NULL-waarde toekennen. Het zal een betere aanpak opleveren.

 int *p=NULL; 

In de meeste bibliotheken is de waarde van de aanwijzer 0 (nul).

wat maakt een pc snel

Pointer Programma om twee getallen te verwisselen zonder de derde variabele te gebruiken.

 #include int main(){ int a=10,b=20,*p1=&a,*p2=&b; printf('Before swap: *p1=%d *p2=%d',*p1,*p2); *p1=*p1+*p2; *p2=*p1-*p2; *p1=*p1-*p2; printf('
After swap: *p1=%d *p2=%d',*p1,*p2); return 0; } 

Uitvoer

 Before swap: *p1=10 *p2=20 After swap: *p1=20 *p2=10 

Complexe aanwijzingen lezen

Er zijn verschillende dingen waarmee rekening moet worden gehouden bij het lezen van de complexe pointers in C. Laten we eens kijken naar de prioriteit en associativiteit van de operatoren die worden gebruikt met betrekking tot pointers.

Hier moeten we opmerken dat,

• (): Deze operator is een haakjesoperator die wordt gebruikt om de functie te declareren en te definiëren.
• []: deze operator is een array-subscriptoperator
• * : Deze operator is een pointer-operator.
• Identificatie: Dit is de naam van de aanwijzer. Hieraan zal altijd prioriteit worden toegekend.
• Gegevenstype: Gegevenstype is het type variabele waarnaar de pointer moet verwijzen. Het bevat ook de modifier zoals ondertekend int, long, enz.).

Hoe de aanwijzer te lezen: int (*p)[10].

generiekheid in Java

Om de aanwijzer te lezen, moeten we zien dat () en [] dezelfde prioriteit hebben. Daarom moet hier rekening worden gehouden met hun associativiteit. De associativiteit is van links naar rechts, dus de prioriteit gaat naar ().

Binnen het haakje () hebben de pointeroperator * en de pointernaam (identifier) ​​p dezelfde prioriteit. Daarom moet hier rekening worden gehouden met hun associativiteit, van rechts naar links, dus de prioriteit gaat naar p, en de tweede prioriteit gaat naar *.

Wijs de derde prioriteit toe aan [], aangezien het gegevenstype de laatste prioriteit heeft. Daarom ziet de aanwijzer er als volgt uit.

• teken -> 4
• * -> 2
• p -> 1
• [10] -> 3

De pointer wordt gelezen als p een pointer is naar een array van gehele getallen van grootte 10.

Voorbeeld

Hoe de volgende aanwijzer lezen?

 int (*p)(int (*)[2], int (*)void)) 

Uitleg

Deze pointer wordt gelezen omdat p een pointer is naar een functie die de eerste parameter accepteert als de pointer naar een eendimensionale array van gehele getallen van grootte twee en de tweede parameter als de pointer naar een functie waarvan de parameter ongeldig is en het retourtype is het gehele getal.