Le pointeur en langage C est une variable qui stocke l'adresse d'une autre variable. Cette variable peut être de type int, char, array, fonction ou tout autre pointeur. La taille du pointeur dépend de l'architecture. Cependant, dans une architecture 32 bits, la taille d'un pointeur est de 2 octets.
Considérons l'exemple suivant pour définir un pointeur qui stocke l'adresse d'un entier.
int n = 10; int* p = &n; // Variable p of type pointer is pointing to the address of the variable n of type integer.
Déclarer un pointeur
Le pointeur en langage C peut être déclaré en utilisant * (symbole astérisque). Il est également connu sous le nom de pointeur d'indirection utilisé pour déréférencer un pointeur.
int *a;//pointer to int char *c;//pointer to char
Exemple de pointeur
Un exemple d'utilisation de pointeurs pour imprimer l'adresse et la valeur est donné ci-dessous.
Comme vous pouvez le voir dans la figure ci-dessus, la variable pointeur stocke l'adresse de la variable numérique, c'est-à-dire fff4. La valeur de la variable numérique est 50. Mais l'adresse de la variable pointeur p est aaa3.
A l'aide de * ( opérateur d'indirection ), nous pouvons imprimer la valeur de la variable pointeur p.
sonu nigam
Voyons l'exemple du pointeur comme expliqué pour la figure ci-dessus.
#include int main(){ int number=50; int *p; p=&number;//stores the address of number variable printf('Address of p variable is %x
',p); // p contains the address of the number therefore printing p gives the address of number. printf('Value of p variable is %d
',*p); // As we know that * is used to dereference a pointer therefore if we print *p, we will get the value stored at the address contained by p. return 0; } Sortir
Address of number variable is fff4 Address of p variable is fff4 Value of p variable is 50
Pointeur vers un tableau
int arr[10]; int *p[10]=&arr; // Variable p of type pointer is pointing to the address of an integer array arr.
Pointeur vers une fonction
void show (int); void(*p)(int) = &display; // Pointer p is pointing to the address of a function
Pointeur vers la structure
struct st { int i; float f; }ref; struct st *p = &ref; 
Avantage du pointeur
1) Pointeur réduit le code et améliore les performances , il est utilisé pour récupérer des chaînes, des arbres, etc. et utilisé avec des tableaux, des structures et des fonctions.
quelles sont les dimensions de mon écran d'ordinateur
2) Nous pouvons renvoyer plusieurs valeurs à partir d'une fonction en utilisant le pointeur.
3) Cela vous permet de accéder à n’importe quel emplacement mémoire dans la mémoire de l'ordinateur.
Utilisation du pointeur
Il existe de nombreuses applications des pointeurs en langage C.
1) Allocation dynamique de mémoire
En langage C, nous pouvons allouer dynamiquement de la mémoire à l'aide des fonctions malloc() et calloc() où le pointeur est utilisé.
2) Tableaux, fonctions et structures
Les pointeurs en langage C sont largement utilisés dans les tableaux, les fonctions et les structures. Cela réduit le code et améliore les performances.
Adresse de (&) opérateur
L'adresse de l'opérateur '&' renvoie l'adresse d'une variable. Mais nous devons utiliser %u pour afficher l’adresse d’une variable.
#include int main(){ int number=50; printf('value of number is %d, address of number is %u',number,&number); return 0; } Sortir
value of number is 50, address of number is fff4
Pointeur nul
Un pointeur auquel aucune valeur n’est affectée mais NULL est appelé pointeur NULL. Si vous n'avez aucune adresse à spécifier dans le pointeur au moment de la déclaration, vous pouvez attribuer une valeur NULL. Cela fournira une meilleure approche.
int *p=NULL;
Dans la plupart des bibliothèques, la valeur du pointeur est 0 (zéro).
10 ml en onces
Programme de pointeur pour échanger deux nombres sans utiliser la 3ème variable.
#include int main(){ int a=10,b=20,*p1=&a,*p2=&b; printf('Before swap: *p1=%d *p2=%d',*p1,*p2); *p1=*p1+*p2; *p2=*p1-*p2; *p1=*p1-*p2; printf('
After swap: *p1=%d *p2=%d',*p1,*p2); return 0; } Sortir
Before swap: *p1=10 *p2=20 After swap: *p1=20 *p2=10
Lecture de pointeurs complexes
Il y a plusieurs choses à prendre en compte lors de la lecture des pointeurs complexes en C. Voyons la préséance et l'associativité des opérateurs utilisés concernant les pointeurs.
| Opérateur | Priorité | Associativité |
|---|---|---|
| (), [] | 1 | De gauche à droite |
| *, identifiant | 2 | De droite à gauche |
| Type de données | 3 | - |
Ici, il faut remarquer que,
- () : Cet opérateur est un opérateur entre crochets utilisé pour déclarer et définir la fonction.
- [] : Cet opérateur est un opérateur d'indice de tableau
- * : Cet opérateur est un opérateur pointeur.
- Identifiant : C'est le nom du pointeur. La priorité y sera toujours attribuée.
- Type de données : le type de données est le type de variable vers laquelle le pointeur est censé pointer. Il inclut également le modificateur comme signé int, long, etc.).
Comment lire le pointeur : int (*p)[10].
architecture de la ruche
Pour lire le pointeur, nous devons voir que () et [] ont la même priorité. Leur associativité doit donc être considérée ici. L'associativité est de gauche à droite, donc la priorité va à ().
À l’intérieur du crochet (), l’opérateur de pointeur * et le nom du pointeur (identifiant) p ont la même priorité. Il faut donc considérer ici leur associativité qui va de droite à gauche, donc la priorité va à p, et la deuxième priorité va à *.
Attribuez la 3ème priorité à [] puisque le type de données a la dernière priorité. Par conséquent, le pointeur ressemblera à ce qui suit.
- caractère -> 4
- * -> 2
- p -> 1
- [10] -> 3
Le pointeur sera lu comme p est un pointeur vers un tableau d’entiers de taille 10.
Exemple
Comment lire le pointeur suivant ?
int (*p)(int (*)[2], int (*)void))
Explication
Ce pointeur sera lu comme p est un pointeur vers une fonction qui accepte le premier paramètre comme pointeur vers un tableau unidimensionnel d'entiers de taille deux et le deuxième paramètre comme pointeur vers une fonction dont le paramètre est vide et le type de retour est l'entier.