Pointeurs C
Pointeurs C
Dans ce didacticiel, vous découvrirez les pointeurs ; ce que sont les pointeurs, comment les utilisez-vous et les erreurs courantes que vous pourriez rencontrer lorsque vous travaillez avec eux à l'aide d'exemples.
Les pointeurs sont des fonctionnalités puissantes de la programmation C et C++. Avant d'apprendre les pointeurs, découvrons les adresses en programmation C.
Adresse en C
Si vous avez une variable var dans votre programme, &var vous donnera son adresse dans la mémoire.
Nous avons utilisé l'adresse à plusieurs reprises en utilisant le scanf() fonction.
scanf("%d", &var); Ici, la valeur saisie par l'utilisateur est stockée dans l'adresse de var variable. Prenons un exemple concret.
#include <stdio.h>
int main()
{
int var = 5;
printf("var: %d\n", var);
// Notice the use of & before var
printf("address of var: %p", &var);
return 0;
}
Sortie
var: 5 address of var: 2686778
Remarque : Vous obtiendrez probablement une adresse différente lorsque vous exécuterez le code ci-dessus.
Pointeurs C
Les pointeurs (variables de pointeur) sont des variables spéciales utilisées pour stocker des adresses plutôt que des valeurs.
Syntaxe du pointeur
Voici comment nous pouvons déclarer des pointeurs.
int* p;
Ici, nous avons déclaré un pointeur p sur int saisir.
Vous pouvez également déclarer des pointeurs de ces manières.
int *p1;
int * p2;
Prenons un autre exemple de déclaration de pointeurs.
int* p1, p2; Ici, nous avons déclaré un pointeur p1 et une variable normale p2 .
Attribuer des adresses aux pointeurs
Prenons un exemple.
int* pc, c;
c = 5;
pc = &c;
Ici, 5 est assigné au c variable. Et, l'adresse de c est affecté au pc pointeur.
Obtenir la valeur de la chose pointée par des pointeurs
Pour obtenir la valeur de la chose pointée par les pointeurs, on utilise le * opérateur. Par exemple :
int* pc, c;
c = 5;
pc = &c;
printf("%d", *pc); // Output: 5
Ici, l'adresse de c est affecté au pc aiguille. Pour obtenir la valeur stockée dans cette adresse, nous avons utilisé *pc .
Remarque : Dans l'exemple ci-dessus, pc est un pointeur, pas *pc . Vous ne pouvez pas et ne devriez pas faire quelque chose comme *pc = &c;
Au fait, * est appelé l'opérateur de déréférencement (lorsque vous travaillez avec des pointeurs). Il opère sur un pointeur et donne la valeur stockée dans ce pointeur.
Modification de la valeur pointée par des pointeurs
Prenons un exemple.
int* pc, c;
c = 5;
pc = &c;
c = 1;
printf("%d", c); // Output: 1
printf("%d", *pc); // Ouptut: 1 Nous avons attribué l'adresse de c au pc pointeur.
Ensuite, nous avons changé la valeur de c à 1. Depuis pc et l'adresse de c est le même, *pc nous donne 1.
Prenons un autre exemple.
int* pc, c;
c = 5;
pc = &c;
*pc = 1;
printf("%d", *pc); // Ouptut: 1
printf("%d", c); // Output: 1
Nous avons attribué l'adresse de c au pc pointeur.
Ensuite, nous avons changé *pc à 1 en utilisant *pc = 1; . Depuis pc et l'adresse de c est le même, c sera égal à 1.
Prenons un autre exemple.
int* pc, c, d;
c = 5;
d = -15;
pc = &c; printf("%d", *pc); // Output: 5
pc = &d; printf("%d", *pc); // Ouptut: -15
Initialement, l'adresse de c est affecté au pc pointeur utilisant pc = &c; . Depuis c est 5, *pc nous donne 5.
Ensuite, l'adresse de d est affecté au pc pointeur utilisant pc = &d; . Depuis d est -15, *pc nous donne -15.
Exemple :Fonctionnement des pointeurs
Prenons un exemple concret.
#include <stdio.h>
int main()
{
int* pc, c;
c = 22;
printf("Address of c: %p\n", &c);
printf("Value of c: %d\n\n", c); // 22
pc = &c;
printf("Address of pointer pc: %p\n", pc);
printf("Content of pointer pc: %d\n\n", *pc); // 22
c = 11;
printf("Address of pointer pc: %p\n", pc);
printf("Content of pointer pc: %d\n\n", *pc); // 11
*pc = 2;
printf("Address of c: %p\n", &c);
printf("Value of c: %d\n\n", c); // 2
return 0;
}
Sortie
Address of c: 2686784 Value of c: 22 Address of pointer pc: 2686784 Content of pointer pc: 22 Address of pointer pc: 2686784 Content of pointer pc: 11 Address of c: 2686784 Value of c: 2
Explication du programme
int* pc, c;
Ici, un pointeur pc et une variable normale c , tous deux de typeint, est créé.
Depuis pc et c ne sont pas initialisés au départ, pointeur pc pointe vers aucune adresse ou vers une adresse aléatoire. Et, la variable c a une adresse mais contient une valeur poubelle aléatoire.
c = 22;
Cela affecte 22 à la variable c . Autrement dit, 22 est stocké dans l'emplacement mémoire de la variable c .
pc = &c;
Ceci assigne l'adresse de la variable c au pointeur pc .
c = 11;
Cela affecte 11 à la variable c .
*pc = 2;
Cela change la valeur à l'emplacement mémoire pointé par le pointeur pc à 2.
Erreurs courantes lors de l'utilisation de pointeurs
Supposons que vous vouliez pointeur pc pour pointer vers l'adresse de c . Ensuite,
int c, *pc;
// pc is address but c is not
pc = c; // Error
// &c is address but *pc is not
*pc = &c; // Error
// both &c and pc are addresses
pc = &c; // Not an error
// both c and *pc values
*pc = c; // Not an error Voici un exemple de syntaxe de pointeur que les débutants trouvent souvent déroutante.
#include <stdio.h>
int main() {
int c = 5;
int *p = &c;
printf("%d", *p); // 5
return 0;
}
Pourquoi n'avons-nous pas obtenu d'erreur lors de l'utilisation de int *p = &c; ?
C'est parce que
int *p = &c; est équivalent à
int *p:
p = &c;
Dans les deux cas, nous créons un pointeur p (pas *p ) et en attribuant &c à elle.
Pour éviter cette confusion, nous pouvons utiliser l'instruction comme celle-ci :
int* p = &c; Maintenant que vous savez ce que sont les pointeurs, vous apprendrez comment les pointeurs sont liés aux tableaux dans le prochain didacticiel.
Langue C