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

Wat is aanwijzer 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, d.w.z. om naar de volgende/vorige geheugenlocatie te wijzen. Het doel van de aanwijzer is om geheugenruimte te besparen en een snellere uitvoeringstijd te bereiken.

Aanwijzers gebruiken in C

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

v is nu gelijk aan nul.

Elke variabele heeft echter, behalve waarde, ook zijn adres (of, simpel gezegd, waar het 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 uitvoer van dit programma is -480613588.

Wat is nu een wijzer? In plaats van een waarde op te slaan, zal een aanwijzer het adres van een variabele opslaan.

Aanwijzervariabele

Int *y =&v;

VARIABLEPOINTERA waarde opgeslagen in een named opslag-/geheugenadresA variabele dat wijst naar het opslag-/geheugenadres van een ander variabele

Een aanwijzer declareren

Net als variabelen moeten pointers in C-programmering worden gedeclareerd voordat ze in uw programma kunnen worden gebruikt. Pointers kunnen elke naam krijgen die je wilt, zolang ze maar voldoen aan de naamgevingsregels van C. Een pointerdeclaratie heeft de volgende 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.
• De asterisk (*:dezelfde asterisk die wordt gebruikt voor vermenigvuldiging) die een indirecte operator is, declareert een pointer.

Laten we eens kijken naar enkele geldige pointer-declaraties 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 */

Een aanwijzer initialiseren

Na het declareren van een aanwijzer, 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 krijgen, gebruiken we de ampersand-operator (&), geplaatst voor de naam van een variabele waarvan we het adres nodig hebben. Aanwijzer initialisatie wordt gedaan met de volgende syntaxis.

Aanwijzersyntaxis

 pointer = &variable;

Hieronder vindt u een eenvoudig programma voor het illustreren van de aanwijzer:

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

Uitvoer:

Address stored in a variable p is:60ff08
Value stored in a variable p is:10

Operator Betekenis *Dient 2 doelen

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 aanwijzers in C

Hieronder volgen de verschillende Typen aanwijzers in C :

Null-aanwijzer

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

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

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

Uitvoer:

The value inside variable p is:
0

Aanwijzer ongeldig

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

Het volgende 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;
}

Uitvoer:

The size of pointer is:4

Wild pointer

Er wordt gezegd dat een aanwijzer een wilde aanwijzer is 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 in ons programma kan veroorzaken en het programma kan laten crashen. Je moet altijd voorzichtig zijn bij het werken met wilde wijzers.

Het volgende programma illustreert het gebruik van de wilde aanwijzer:

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

Uitvoer:

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

Andere soorten aanwijzers in 'c' zijn als volgt:

• Bloeiende aanwijzer
• Complexe aanwijzer
• In de buurt van aanwijzer
• Verre aanwijzer
• Grote 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 aanwijzer 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;}

Na het compileren van het programma zonder fouten, 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

Aanwijzer rekenen in C

De aanwijzerbewerkingen zijn samengevat in de volgende afbeelding

Prioriteitsbewerking (voorrang)

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 incrementation++, decrement–).
• In dezelfde uitdrukking worden de unaire operatoren *, &,!, ++, – geëvalueerd van rechts naar links.

Als een P-aanwijzer naar een X-variabele wijst, dan 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

ExpressionEquivalent ExpressionY=*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, niet het object waarop P wijst.

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

Operatie Uitleg Opdrachtint *P1,*P2
P1=P2;
P1 en P2 verwijzen naar dezelfde integer variabeleIncrementation en decrementationInt *P1;
P1++;P1–;Een offset toevoegen (Constant)Hiermee kan de aanwijzer N elementen in een tabel verplaatsen.
De aanwijzer 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. Aanwijzers 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;
}

Uitvoer:

1
2
3
4
5

Als u een bepaald getal 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 optellen van 1, wordt de waarde 1, en daarom wijst de aanwijzer naar de geheugenlocatie 1.

C-aanwijzers 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 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;
}

Uitvoer:

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 strings af te handelen is met een array van pointers zoals in het volgende 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;}

Uitvoer:

Please remember these materials:
iron
copper
gold

Voordelen van aanwijzers in C

• Aanwijzers zijn handig voor toegang tot geheugenlocaties.
• Aanwijzers bieden een efficiënte manier om toegang te krijgen tot de elementen van een arraystructuur.
• Aanwijzers worden gebruikt voor zowel dynamische geheugentoewijzing als dealtoewijzing.
• Aanwijzers worden gebruikt om complexe gegevensstructuren te vormen, zoals gekoppelde lijsten, grafieken, bomen, enz.

Nadelen van aanwijzers 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 onjuiste waarde aan een aanwijzer wordt gegeven, kan dit geheugenbeschadiging veroorzaken.
• Aanwijzers zijn ook verantwoordelijk voor geheugenlekken.
• Aanwijzers 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.

Samenvatting:

• 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 null-aanwijzer, een wilde aanwijzer, een lege aanwijzer en andere soorten aanwijzers.
• Aanwijzers 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 aanwijzerberekeningen.
• Aanwijzers kunnen ook naar een functie wijzen, waardoor het gemakkelijk is om verschillende functies aan te roepen in het geval van het definiëren van een reeks aanwijzers.
• Als u verschillende typen variabele gegevens wilt behandelen, kunt u een typecast void pointer gebruiken.