Pointeurs dans la programmation C: Qu'est-ce que le pointeur, les types & Exemples

Qu'est-ce que le pointeur en C?

Le pointeur en C, est une variable qui stocke l'adresse d'une autre variable. Un pointeur peut également être utilisé pour faire référence à une autre fonction de pointeur. Un pointeur peut être incrémenté / décrémenté, c'est-à-dire pour pointer vers l'emplacement mémoire suivant / précédent. Le but du pointeur est d'économiser de l'espace mémoire et d'accélérer le temps d'exécution.

Comment utiliser des pointeurs en C

Si nous déclarons une variable v de type int, v stockera en fait une valeur.

v est maintenant égal à zéro.

Cependant, chaque variable, en dehors de la valeur, a également son adresse (ou, simplement, où elle se trouve dans la mémoire). L'adresse peut être récupérée en plaçant une esperluette (&) avant le nom de la variable.

Si vous imprimez l'adresse d'une variable à l'écran, cela ressemblera à un nombre totalement aléatoire (de plus, il peut être différent d'une exécution à l'autre).

Essayons ceci en pratique avec un pointeur dans l'exemple C

La sortie de ce programme est -480613588.

Maintenant, qu'est-ce qu'un pointeur? Au lieu de stocker une valeur, un pointeur y stockera l'adresse d'une variable.

Variable de pointeur

Int * y = & v;

VARIABLE	AIGUILLE
Une valeur stockée dans une adresse de stockage / mémoire nommée	Une variable qui pointe vers l'adresse de stockage / mémoire d' une autre variable

Déclaration d'un pointeur

Comme les variables, les pointeurs en programmation C doivent être déclarés avant de pouvoir être utilisés dans votre programme. Les pointeurs peuvent être nommés comme vous le souhaitez tant qu'ils obéissent aux règles de dénomination de C. Une déclaration de pointeur a la forme suivante.

data_type * pointer_variable_name;

Ici,

• data_type est le type de base du pointeur des types de variables de C et indique le type de la variable vers laquelle pointe le pointeur.
• L'astérisque (*: le même astérisque utilisé pour la multiplication) qui est l'opérateur d'indirection, déclare un pointeur.

Voyons quelques déclarations de pointeurs valides dans ce didacticiel sur les pointeurs C:

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 */

Initialiser un pointeur

Après avoir déclaré un pointeur, nous l'initialisons comme des variables standard avec une adresse de variable. Si les pointeurs en programmation C ne sont pas non initialisés et utilisés dans le programme, les résultats sont imprévisibles et potentiellement désastreux.

Pour obtenir l'adresse d'une variable, nous utilisons l'opérateur esperluette (&), placé avant le nom d'une variable dont nous avons besoin. L'initialisation du pointeur est effectuée avec la syntaxe suivante.

Syntaxe du pointeur

 pointer = &variable; 

Un programme simple pour l'illustration du pointeur est donné ci-dessous:

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

Production:

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

Opérateur	Sens
*	Sert 2 buts Déclaration d'un pointeur Renvoie la valeur de la variable référencée
&	Sert seulement 1 but Renvoie l'adresse d'une variable

Types de pointeurs en C

Voici les différents types de pointeurs en C :

Pointeur nul

Nous pouvons créer un pointeur nul en attribuant une valeur nulle lors de la déclaration du pointeur. Cette méthode est utile lorsque aucune adresse n'est attribuée au pointeur. Un pointeur nul contient toujours la valeur 0.

Le programme suivant illustre l'utilisation d'un pointeur nul:

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

Production:

The value inside variable p is:0

Pointeur du Vide

En programmation C, un pointeur void est également appelé comme un pointeur générique. Il n'a aucun type de données standard. Un pointeur void est créé à l'aide du mot clé void. Il peut être utilisé pour stocker une adresse de n'importe quelle variable.

Le programme suivant illustre l'utilisation d'un pointeur void:

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

Production:

The size of pointer is:4

Pointeur sauvage

Un pointeur est dit être un pointeur sauvage s'il n'est initialisé à rien. Ces types de pointeurs C ne sont pas efficaces car ils peuvent pointer vers un emplacement mémoire inconnu qui peut causer des problèmes dans notre programme et entraîner un plantage du programme. Il faut toujours être prudent lorsque l'on travaille avec des pointeurs sauvages.

Le programme suivant illustre l'utilisation du pointeur sauvage:

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

Production

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

Les autres types de pointeurs dans 'c' sont les suivants:

• Pointeur pendant
• Pointeur complexe
• Pointeur proche
• Pointeur éloigné
• Énorme pointeur

Pointeurs d'accès direct et indirect

En C, il existe deux manières équivalentes d'accéder et de manipuler un contenu variable

• Accès direct: on utilise directement le nom de la variable
• Accès indirect: nous utilisons un pointeur vers la variable

Comprenons cela avec l'aide du programme ci-dessous

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

Après avoir compilé le programme sans aucune erreur, le résultat est:

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

Arithmétique de pointeur en C

Les opérations du pointeur sont résumées dans la figure suivante

Opération prioritaire (priorité)

Lorsque vous travaillez avec des pointeurs C, nous devons respecter les règles de priorité suivantes:

• Les opérateurs * et & ont la même priorité que les opérateurs unaires (la négation !, l'incrémentation ++, décrément-).
• Dans la même expression, les opérateurs unaires *, &,!, ++, - sont évalués de droite à gauche.

Si un pointeur P pointe vers une variable X, alors * P peut être utilisé partout où X peut être écrit.

Les expressions suivantes sont équivalentes:

int X = 10 int * P = & Y; Pour le code ci-dessus, les expressions ci-dessous sont vraies
Expression	Expression équivalente
Y = * P + 1 * P = * P + 10 * P + = 2 ++ * P (* P) ​​++	Y = X + 1 X = X + 10 X + = 2 ++ X X ++

Dans ce dernier cas, les parenthèses sont nécessaires: comme les opérateurs unaires * et ++ sont évalués de droite à gauche, sans les parenthèses le pointeur P serait incrémenté, pas l'objet sur lequel P pointe.

Le tableau ci-dessous montre les opérations arithmétiques et de base qui peuvent être utilisées lors du traitement des pointeurs C

Opération	Explication
Mission	int * P1, * P2 P1 = P2; P1 et P2 pointent vers la même variable entière
Incrémentation et décrémentation	Int * P1; P1 ++, P1--;
Ajout d'un décalage (constante)	Cela permet au pointeur de déplacer N éléments dans une table. Le pointeur sera augmenté ou diminué de N fois le nombre d'octet (s) du type de la variable. P1 + 5;

Pointeurs et tableaux C avec exemples

Traditionnellement, nous accédons aux éléments du tableau en utilisant son index, mais cette méthode peut être éliminée en utilisant des pointeurs. Les pointeurs facilitent l'accès à chaque élément du tableau.

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

Production

12345

L'ajout d'un nombre particulier à un pointeur déplacera l'emplacement du pointeur vers la valeur obtenue par une opération d'addition. Supposons que p est un pointeur qui pointe actuellement vers l'emplacement mémoire 0 si nous effectuons l'opération d'addition suivante, p + 1 alors il s'exécutera de cette manière:

Puisque p pointe actuellement vers l'emplacement 0 après avoir ajouté 1, la valeur deviendra 1, et par conséquent le pointeur pointera vers l'emplacement de mémoire 1.

Pointeurs et chaînes en C avec exemples

Une chaîne est un tableau d'objets char, se terminant par un caractère nul '\ 0'. Nous pouvons manipuler des chaînes à l'aide de pointeurs. Ce pointeur dans l'exemple C explique cette section

#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
Production
First character is:HNext character is:ePrinting all the characters in a stringHelloGuru99!
Une autre façon de traiter les chaînes est d'utiliser un tableau de pointeurs comme dans le programme suivant:
#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;}
Production:
Please remember these materials:ironcoppergold
 
Avantages des pointeurs en C

Les pointeurs sont utiles pour accéder aux emplacements de mémoire.
Les pointeurs fournissent un moyen efficace d'accéder aux éléments d'une structure de tableau.
Les pointeurs sont utilisés pour l'allocation dynamique de la mémoire ainsi que la désallocation.
Les pointeurs sont utilisés pour former des structures de données complexes telles qu'une liste chaînée, un graphique, un arbre, etc.


Inconvénients des pointeurs en C

Les pointeurs sont un peu complexes à comprendre.
Les pointeurs peuvent conduire à diverses erreurs telles que des erreurs de segmentation ou peuvent accéder à un emplacement mémoire qui n'est pas du tout nécessaire.
Si une valeur incorrecte est fournie à un pointeur, cela peut entraîner une corruption de la mémoire.
Les pointeurs sont également responsables des fuites de mémoire.
Les pointeurs sont comparativement plus lents que ceux des variables.
Les programmeurs trouvent très difficile de travailler avec les pointeurs; il est donc de la responsabilité du programmeur de manipuler un pointeur avec soin.

Résumé 

Un pointeur n'est rien d'autre qu'un emplacement de mémoire où les données sont stockées.
Un pointeur est utilisé pour accéder à l'emplacement mémoire.
Il existe différents types de pointeurs tels qu'un pointeur nul, un pointeur sauvage, un pointeur vide et d'autres types de pointeurs.
Les pointeurs peuvent être utilisés avec un tableau et une chaîne pour accéder plus efficacement aux éléments.
Nous pouvons créer des pointeurs de fonction pour appeler une fonction de manière dynamique.
Les opérations arithmétiques peuvent être effectuées sur un pointeur appelé arithmétique de pointeur.
Les pointeurs peuvent également pointer vers une fonction, ce qui facilite l'appel de différentes fonctions dans le cas de la définition d'un tableau de pointeurs.
Lorsque vous souhaitez traiter un type de données variable différent, vous pouvez utiliser un pointeur vide de transtypage.