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 variableDé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:10Opérateur Signification * Sert à 2 fins
- Déclaration d'un pointeur
- Renvoie la valeur de la variable référencée
- 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
Langue C
- Variables C# et types de données (primitifs)
- Types de fonctions définies par l'utilisateur dans la programmation C
- Pointeurs C
- Pointeurs C++ avec exemples
- Qu'est-ce que l'impression 3D ? Principe de fonctionnement | Types | Candidatures
- Java - Types de variables
- C - Pointeurs
- Types de variables C++
- Python - Types de variables