Pointeurs en C :Qu'est-ce qu'un pointeur en programmation C ? Les types

Qu'est-ce qu'un 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'obtenir un temps d'exécution plus rapide.

Comment utiliser les pointeurs en C

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

v est égal à zéro maintenant.

Cependant, chaque variable, en dehors de la valeur, a également son adresse (ou, tout 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 cela 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

Entier *y =&v;

VARIABLEPOINTERA valeur stocké dans un nommé adresse de stockage/mémoireUne variable qui pointe vers l'adresse de stockage/mémoire d'un autre variable

Déclarer 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 voulez tant qu'ils obéissent aux règles de nommage de C. Une déclaration de pointeur a la forme suivante.

data_type * pointer_variable_name;

Ici,

• type_données 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 un opérateur d'indirection, déclare un pointeur.

Voyons quelques déclarations de pointeur valides dans ce tutoriel 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 de l'adresse. L'initialisation du pointeur se fait avec la syntaxe suivante.

Syntaxe du pointeur

 pointer = &variable;

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

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

Sortie :

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

Opérateur Signification * Sert à 2 fins

1. Déclaration d'un pointeur
2. Renvoie la valeur de la variable référencée

&Ne sert qu'à 1 objectif

• 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 vous n'avez aucune adresse assignée au pointeur. Un pointeur nul contient toujours la valeur 0.

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

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

Sortie :

The value inside variable p is:
0

Pointeur vide

En programmation C, un pointeur vide est également appelé pointeur générique. Il n'a pas de type de données standard. Un pointeur vide est créé en utilisant le 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 vide :

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

Sortie :

The size of pointer is:4

Pointeur sauvage

Un pointeur est dit 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 le 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 <stdio.h>
int main()
{
int *p; 	//wild pointer
printf("\n%d",*p);
return 0;
}

Sortie :

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

Les autres types de pointeurs en "c" sont les suivants :

• Pointeur suspendu
• Pointeur complexe
• À proximité du pointeur
• Pointeur lointain
• É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 :nous utilisons 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 <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;}

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

Direct access, var = 1
Indirect access, var = 1

The address of var = 4202496
The address of var = 4202496

Indirect access, var = 48

Arithmétique des pointeurs 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++, la décrémentation–).
• 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 :

entier X =10

entier *P =&Y;

Pour le code ci-dessus, les expressions ci-dessous sont vraies

ExpressionEquivalent ExpressionY=*P+1

*P=*P+10

*P+=2

+****P

(*P)++

Y=X+1

X=X+10

X+=2

+XX

X++

Dans ce dernier cas, des 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é, et non l'objet sur lequel pointe P.

Le tableau ci-dessous montre les opérations arithmétiques et de base qui peuvent être utilisées lorsqu'il s'agit de pointeurs C

Fonctionnement Explication Affectationint *P1,*P2
P1=P2 ;
P1 et P2 pointent vers le même entier variableIncrementation et decrementationInt *P1 ;
P1++;P1–;Ajout d'un décalage (Constante)Cela permet au pointeur de déplacer N éléments dans un tableau.
Le pointeur sera incrémenté ou décrémenté de N fois le nombre d'octet(s) du type de la variable.
P1+5 ;

Pointeurs C et tableaux 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 <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;
}

Sortie :

1
2
3
4
5

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 soit 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 donc le pointeur pointera vers l'emplacement mémoire 1.

Pointeurs C et chaînes 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 <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;
}

Sortie :

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
!

Une autre façon de traiter les chaînes consiste à utiliser un tableau de pointeurs comme dans le programme suivant :

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

Sortie :

Please remember these materials:
iron
copper
gold

Avantages des pointeurs en C

• Les pointeurs sont utiles pour accéder aux emplacements de mémoire.
• Les pointeurs offrent un moyen efficace d'accéder aux éléments d'une structure de tableau.
• Les pointeurs sont utilisés pour l'allocation dynamique de mémoire ainsi que pour 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 entraîner diverses erreurs telles que des défauts de segmentation ou peuvent accéder à un emplacement de 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 qu'il est très difficile de travailler avec les pointeurs ; il est donc de la responsabilité du programmeur de manipuler un pointeur avec précaution.

Résumé :

• Un pointeur n'est rien d'autre qu'un emplacement mémoire où les données sont stockées.
• Un pointeur est utilisé pour accéder à l'emplacement de la 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 invoquer une fonction dynamiquement.
• 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 différents types de données variables, vous pouvez utiliser un pointeur vide de typecast.

Fonctions en programmation C avec exemples :récursif et en ligne Pointeurs de fonctions en programmation C avec exemples