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

Aanwijzingen gebruiken in C

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

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.

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

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.

Int *y = &v;

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 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 voor vermenigvuldiging wordt gebruikt), een indirecte operator, declareert een pointer.

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 geïnitialiseerd zijn en in een programma worden gebruikt, kunnen de resultaten onvoorspelbaar en potentieel rampzalig zijn.

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. Pointerinitialisatie wordt gedaan met de volgende 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

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

The value inside variable p is:
0

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

The size of pointer is:4

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

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

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 pointerbewerkingen worden samengevat in de volgende afbeelding

Prioriteitsbewerking (precedentie)

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

• De operatoren * en & hebben dezelfde prioriteit als de unitaire operatoren (de negatie!, de incrementatie++, decrement–).
• In dezelfde uitdrukking worden de unitaire 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 volgende uitdrukkingen zijn equivalent:

int X =10
int *P = &Y;
For the above code, below expressions are true

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

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

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

Het toevoegen van een bepaald getal aan een pointer verplaatst de pointerlocatie 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 wordt deze op deze manier uitgevoerd:

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

Output:

Please remember these materials:
iron
copper
gold

Nadelen van pointers in C

• Pointers zijn wat lastig te 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.

Samenvatting

• 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 op een aanwijzer worden uitgevoerd, wat ook wel pointerrekenen wordt genoemd.
• 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.