Pointers in C Programming: Wat is Pointer, Types & Voorbeelden

Wat is Pointer in C?

De aanwijzer in C is een variabele die het adres van een andere variabele opslaat. Een aanwijzer kan ook worden gebruikt om naar een andere aanwijzerfunctie te verwijzen. Een aanwijzer 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.

Pointers gebruiken in C.

Als we een variabele v van het type int declareren, zal v feitelijk een waarde opslaan.

v is nu gelijk aan nul.

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

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 aanwijzer in C-voorbeeld

De output van dit programma is -480613588.

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

Aanwijzervariabele

Int * y = & v;

VARIABEL	WIJZER
Een waarde die is opgeslagen in een benoemd opslag- / geheugenadres	Een variabele die verwijst naar het opslag- / geheugenadres van een andere variabele

Een aanwijzer aangeven

Net als variabelen, moeten pointers in C-programmering worden gedeclareerd voordat ze in uw programma kunnen worden gebruikt. Aanwijzers kunnen elke naam krijgen die u wilt, zolang ze maar voldoen aan de naamgevingsregels van C. Een pointer-declaratie heeft de volgende vorm.

data_type * pointer_variable_name;

Hier,

• data_type is het basistype van de C-variabeletypen van de aanwijzer en geeft het type variabele aan waarnaar de aanwijzer verwijst.
• De asterisk (*: dezelfde asterisk die wordt gebruikt voor vermenigvuldiging) die de indirecte operator is, geeft een aanwijzer aan.

Laten we enkele geldige pointer-declaraties bekijken in deze C-pointers-zelfstudie:

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 verwijzingen in C-programmering niet niet worden geïnitialiseerd en in het programma worden gebruikt, zijn de resultaten onvoorspelbaar en mogelijk rampzalig.

Om het adres van een variabele te krijgen, gebruiken we de ampersand (&) operator, geplaatst voor de naam van een variabele waarvan we het adres nodig hebben. Aanwijzerinitialisatie wordt uitgevoerd met de volgende syntaxis.

Pointer-syntaxis

 pointer = &variable; 

Een eenvoudig programma ter illustratie van de aanwijzer wordt hieronder gegeven:

#include int main(){int a=10; //variable declarationint *p; //pointer variable declarationp=&a; //store address of variable a in pointer pprintf("Address stored in a variable p is:%x\n",p); //accessing the addressprintf("Value stored in a variable p is:%d\n",*p); //accessing the valuereturn 0;}

Uitgang:

Address stored in a variable p is:60ff08Value stored in a variable p is:10

Operator	Betekenis
​	Dient voor 2 doeleinden Verklaring van een wijzer Retourneert de waarde van de variabele waarnaar wordt verwezen
​	Dient maar 1 doel Retourneert het adres van een variabele

Soorten aanwijzingen in C.

Hieronder volgen de verschillende soorten aanwijzers in C :

Nul punten

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

Het volgende programma illustreert het gebruik van een null-pointer:

#include int main(){int *p = NULL; //null pointerprintf(“The value inside variable p is:\n%x”,p);return 0;}

Uitgang:

The value inside variable p is:0

Ongeldige aanwijzer

In C-programmering wordt een lege aanwijzer ook wel een generieke aanwijzer genoemd. Het heeft geen standaard gegevenstype. Een leegte-aanwijzer wordt gemaakt door het trefwoord void te gebruiken. Het kan worden gebruikt om een ​​adres van een willekeurige variabele op te slaan.

Het volgende programma illustreert het gebruik van een leegte pointer:

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

Uitgang:

The size of pointer is:4

Wilde aanwijzer

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

Het volgende programma illustreert het gebruik van wild pointer:

#include int main(){int *p; //wild pointerprintf("\n%d",*p);return 0;}

Uitvoer

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

Andere soorten verwijzingen in 'c' zijn als volgt:

• Bungelende wijzer
• Complexe aanwijzer
• Dichtbij wijzer
• Verre aanwijzer
• Enorme aanwijzer

Directe en indirecte toegangspunten

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

• Directe toegang: we gebruiken direct de variabelenaam
• Indirecte toegang: we gebruiken een pointer naar de variabele

Laten we dit begrijpen met behulp van het onderstaande programma

#include /* 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;}

Na het compileren van het programma zonder fouten, is het resultaat:

Direct access, var = 1Indirect access, var = 1The address of var = 4202496The address of var = 4202496Indirect access, var = 48

Aanwijzerrekenen in C

De aanwijzerbewerkingen worden samengevat in de volgende afbeelding

Prioritaire bewerking (prioriteit)

Bij het werken met C-pointers moeten we de volgende prioriteitsregels in acht nemen:

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

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

De volgende uitdrukkingen zijn equivalent:

int X = 10 int * P = & Y; Voor de bovenstaande code zijn onderstaande uitdrukkingen waar
Uitdrukking	Equivalente expressie
Y = * 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 opgehoogd, niet het object waarop P wijst.

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

Operatie	Uitleg
Toewijzing	int * P1, * P2 P1 = P2; P1 en P2 wijzen naar dezelfde integer-variabele
Toename en afname	Int * P1; P1 ++; P1--;
Een offset toevoegen (constante)	Hierdoor kan de aanwijzer N elementen in een tabel verplaatsen. De aanwijzer wordt verhoogd of verlaagd met N keer het aantal byte (n) van het type variabele. P1 + 5;

C Pointers & Arrays met voorbeelden

Traditioneel hebben we toegang tot de array-elementen met behulp van de index, maar deze methode kan worden geëlimineerd door pointers te gebruiken. Aanwijzers maken het gemakkelijk om toegang te krijgen tot elk array-element.

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

Uitvoer

12345

Als u een bepaald nummer aan een aanwijzer toevoegt, 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 de volgende optelbewerking uitvoeren, p + 1, dan zal het op deze manier worden uitgevoerd:

Aangezien p momenteel naar de locatie 0 wijst na het toevoegen van 1, wordt de waarde 1, en daarom zal de pointer naar de geheugenlocatie 1 wijzen.

C Pointers en strings met voorbeelden

Een string is een array van char-objecten, eindigend met een null-teken '\ 0'. We kunnen strings manipuleren met behulp van pointers. Deze aanwijzer in C-voorbeeld legt dit gedeelte uit

#include #include 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 pointerfor(int i=0;i
Uitvoer
First character is:HNext character is:ePrinting all the characters in a stringHelloGuru99!
Een andere manier om strings uit te wisselen, is met een reeks aanwijzers, zoals in het volgende programma:
#include 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;}
Uitgang:
Please remember these materials:ironcoppergold
 
Voordelen van Pointers in C

Aanwijzers zijn handig om toegang te krijgen tot geheugenlocaties.
Aanwijzers bieden een efficiënte manier om toegang te krijgen tot de elementen van een matrixstructuur.
Pointers worden zowel voor dynamische geheugentoewijzing als voor deallocation gebruikt.
Aanwijzers worden gebruikt om complexe datastructuren te vormen, zoals een gekoppelde lijst, grafiek, boom, enz.


Nadelen van Pointers in C

Aanwijzingen zijn een beetje ingewikkeld om te begrijpen.
Aanwijzers kunnen leiden tot verschillende fouten, zoals segmentatiefouten, of kunnen toegang krijgen tot een geheugenlocatie die helemaal niet nodig is.
Als een aanwijzer een onjuiste waarde krijgt, kan dit geheugenbeschadiging veroorzaken.
Aanwijzers 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.

Overzicht 

Een aanwijzer is niets anders dan een geheugenlocatie waar gegevens worden opgeslagen.
Een aanwijzer wordt gebruikt om toegang te krijgen tot de geheugenlocatie.
Er zijn verschillende soorten aanwijzers, zoals een nulaanwijzer, een wilde aanwijzer, een lege aanwijzer en andere soorten aanwijzers.
Pointers kunnen worden gebruikt met array en string om efficiënter toegang te krijgen tot elementen.
We kunnen functiewijzers maken om een ​​functie dynamisch aan te roepen.
Rekenkundige bewerkingen kunnen worden uitgevoerd op een aanwijzer die bekend staat als aanwijzer rekenkunde.
Aanwijzers kunnen ook verwijzen naar functies, waardoor het gemakkelijk is om verschillende functies aan te roepen in het geval van het definiëren van een reeks aanwijzers.
Als u een ander variabel gegevenstype wilt behandelen, kunt u een typecast void pointer gebruiken.