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.

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.