Pointeurs C++ avec exemples

Que sont les pointeurs ?

En C++, un pointeur fait référence à une variable qui contient l'adresse d'une autre variable. Comme les variables régulières, les pointeurs ont un type de données. Par exemple, un pointeur de type entier peut contenir l'adresse d'une variable de type entier. Un pointeur de type caractère peut contenir l'adresse d'une variable de type caractère.

Vous devriez voir un pointeur comme une représentation symbolique d'une adresse mémoire. Avec les pointeurs, les programmes peuvent simuler l'appel par référence. Ils peuvent également créer et manipuler des structures de données dynamiques. En C++, une variable de pointeur fait référence à une variable pointant vers une adresse spécifique dans une mémoire pointée par une autre variable.

Dans ce didacticiel C++, vous apprendrez :

• Que sont les pointeurs ?
• Adresses en C++
• Syntaxe de déclaration de pointeur
• Opérateur de référence (&) et opérateur de déférence (*)
• Pointeurs et tableaux
• Pointeur NULL
• Pointeurs de variables
• Application des pointeurs
• Avantages de l'utilisation des pointeurs

Adresses en C++

Pour comprendre les pointeurs C++, vous devez comprendre comment les ordinateurs stockent les données.

Lorsque vous créez une variable dans votre programme C++, un certain espace lui est attribué dans la mémoire de l'ordinateur. La valeur de cette variable est stockée à l'emplacement attribué.

Pour connaître l'emplacement dans la mémoire de l'ordinateur où les données sont stockées, C++ fournit le & opérateur (de référence). L'opérateur renvoie l'adresse occupée par une variable.

Par exemple, si x est une variable, &x renvoie l'adresse de la variable.

Syntaxe de déclaration de pointeur

La déclaration de C++ prend la syntaxe suivante :

datatype *variable_name; 

• Le type de données est le type de base du pointeur qui doit être un type de données C++ valide.
• Le variable_name doit être le nom de la variable de pointeur.
• L'astérisque utilisé ci-dessus pour la déclaration du pointeur est similaire à l'astérisque utilisé pour effectuer une opération de multiplication. C'est l'astérisque qui marque la variable comme un pointeur.

Voici un exemple de déclarations de pointeur valides en C++ :

int    *x;    // a pointer to integer
double *x;    // a pointer to double
float  *x;    // a pointer to float
char   *ch     // a pointer to a character

Opérateur de référence (&) et Opérateur de déférence (*)

L'opérateur de référence (&) renvoie l'adresse de la variable.

L'opérateur de déréférencement (*) nous aide à obtenir la valeur qui a été stockée dans une adresse mémoire.

Par exemple :

Si nous avons une variable nommée num, stockée à l'adresse 0x234 et stockant la valeur 28.

L'opérateur de référence (&) renverra 0x234.

L'opérateur de déréférencement (*) renverra 5.

Exemple 1 :

#include <iostream>
using namespace std;
int main() {
	int  x = 27;  
	int  *ip;        
	ip = &x;       
	cout << "Value of x is : ";
	cout << x << endl;
	cout << "Value of ip is : ";
	cout << ip<< endl;
	cout << "Value of *ip is : ";
	cout << *ip << endl;
	return 0;
}

Sortie :

Comment cela fonctionne :

Voici une capture d'écran du code :

Explication du code :

1. Importez le fichier d'en-tête iostream. Cela nous permettra d'utiliser les fonctions définies dans le fichier d'en-tête sans avoir d'erreurs.
2. Incluez l'espace de noms std pour utiliser ses classes sans l'appeler.
3. Appelez la fonction main(). La logique du programme doit être ajoutée dans le corps de cette fonction. Le { marque le début du corps de la fonction.
4. Déclarez une variable entière x et attribuez-lui la valeur 27.
5. Déclarez une variable de pointeur *ip.
6. Stocker l'adresse de la variable x dans la variable pointeur.
7. Imprimez du texte sur la console.
8. Imprimez la valeur de la variable x à l'écran.
9. Imprimez du texte sur la console.
10. Afficher l'adresse de la variable x. La valeur de l'adresse était stockée dans la variable ip.
11. Imprimez du texte sur la console.
12. Imprime la valeur de stockée à l'adresse du pointeur.
13. Le programme doit renvoyer une valeur en cas d'exécution réussie.
14. Fin du corps de la fonction main().

Pointeurs et tableaux

Les tableaux et les pointeurs fonctionnent sur la base d'un concept connexe. Il y a différentes choses à noter lorsque vous travaillez avec des tableaux ayant des pointeurs. Le nom du tableau lui-même indique l'adresse de base du tableau. Cela signifie que pour affecter l'adresse d'un tableau à un pointeur, vous ne devez pas utiliser d'esperluette (&).

Par exemple :

p = arr;

Ce qui précède est correct puisque arr représente l'adresse des tableaux. Voici un autre exemple :

p = &arr;

Ce qui précède est incorrect.

Nous pouvons implicitement convertir un tableau en un pointeur. Par exemple :

int arr [20];
int * ip;

Ci-dessous une opération valide :

ip = arr;

Après la déclaration ci-dessus, ip et arr seront équivalents et partageront des propriétés. Cependant, une adresse différente peut être attribuée à ip, mais nous ne pouvons rien attribuer à arr.

Exemple 2 :

Cet exemple montre comment parcourir un tableau à l'aide de pointeurs :

#include <iostream>
using namespace std;
int main() {
	int *ip;
	int arr[] = { 10, 34, 13, 76, 5, 46 };
	ip = arr;
	for (int x = 0; x < 6; x++) {
		cout << *ip << endl;
		ip++;
	}
	return 0;
}

Sortie :

Voici une capture d'écran du code :

Explication du code :

1. Déclarez une variable de pointeur entier ip.
2. Déclarez un tableau nommé arr et stockez-y 6 entiers.
3. Attribuez arr à ip. L'ip et l'arr deviendront équivalents.
4. Créer une boucle pour une. La variable de boucle x a été créée pour parcourir les éléments du tableau de l'index 0 à 5.
5. Imprimer les valeurs stockées à l'adresse IP du pointeur. Une valeur sera renvoyée par itération, et un total de 6 répétitions seront effectuées. Le endl est un mot-clé C++ qui signifie la ligne de fin. Cette action vous permet de déplacer le curseur à la ligne suivante après l'impression de chaque valeur. Chaque valeur sera imprimée sur une ligne individuelle.
6. Pour déplacer le pointeur vers la position int suivante après chaque itération.
7. Fin de la boucle for a.
8. Le programme doit renvoyer quelque chose en cas d'exécution réussie.
9. Fin du corps de la fonction main().

Pointeur NULL

S'il n'y a pas d'adresse exacte à affecter, alors la variable de pointeur peut être affectée d'une valeur NULL. Il doit être fait lors de la déclaration. Un tel pointeur est appelé pointeur nul. Sa valeur est zéro et est définie dans de nombreuses bibliothèques standard comme iostream.

Exemple 3 :

#include <iostream>
using namespace std;
int main() {
	int  *ip = NULL;
	cout << "Value of ip is: " << ip;
	return 0;
}

Sortie :

Voici une capture d'écran du code :

Explication du code :

1. Déclarez une variable de pointeur ip et attribuez-lui la valeur NULL.
2. Imprime la valeur de la variable de pointeur ip à côté d'un texte sur la console.
3. Le programme doit renvoyer une valeur en cas de réussite.
4. Fin du corps de la fonction main().

Pointeurs de Variables

Avec C++, vous pouvez manipuler des données directement à partir de la mémoire de l'ordinateur.

L'espace mémoire peut être affecté ou réaffecté à volonté. Ceci est rendu possible par les variables Pointer.

Les variables de pointeur pointent vers une adresse spécifique dans la mémoire de l'ordinateur pointée par une autre variable.

Il peut être déclaré comme suit :

int *p;

Ou,

int* p;

Dans l'exemple you, nous avons déclaré la variable de pointeur p.

Il contiendra une adresse mémoire.

L'astérisque est l'opérateur de déréférencement qui désigne un pointeur vers.

Le pointeur p pointe sur une valeur entière dans l'adresse mémoire.

Exemple 4 :

#include <iostream>

using namespace std;
int main() {
	int *p, x = 30;
	p = &x;
	cout << "Value of x is: " << *p;
	return 0;
}

Sortie :

Voici une capture d'écran du code :

Explication du code :

1. Déclarez une variable de pointeur p et une variable x avec une valeur de 30.
2. Attribuez l'adresse de la variable x à p.
3. Affiche la valeur de la variable de pointeur p à côté d'un texte sur la console.
4. Le programme doit renvoyer une valeur en cas de réussite.
5. Fin du corps de la fonction main().

Application des pointeurs

Les fonctions en C++ ne peuvent renvoyer qu'une seule valeur. De plus, toutes les variables déclarées dans une fonction sont allouées sur la pile des appels de fonction. Dès que la fonction revient, toutes les variables de la pile sont détruites.

Les arguments de la fonction sont passés par valeur, et toute modification effectuée sur les variables ne change pas la valeur des variables réelles qui sont passées. L'exemple suivant aide à illustrer ce concept :-

Exemple 5 :

#include <iostream>

using namespace std;
void test(int*, int*);
int main() {
	int a = 5, b = 5;
	cout << "Before changing:" << endl;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	test(&a, &b);

	cout << "\nAfter changing" << endl;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	return 0;
}

void test(int* n1, int* n2) {
	*n1 = 10;
	*n2 = 11;
}

Sortie :

Voici une capture d'écran du code :

Explication du code :

1. Créez un prototype de fonction nommée test qui prendra deux paramètres entiers.
2. Appelez la fonction main(). Nous ajouterons la logique du programme dans son corps.
3. Déclarez deux variables entières a et b, chacune avec une valeur de 5.
4. Imprimez du texte sur la console. La fin (fin de ligne) déplacera le curseur pour commencer l'impression à la ligne suivante.
5. Imprimez la valeur de la variable a sur la console à côté d'un autre texte. La fin (fin de ligne) déplacera le curseur pour commencer l'impression à la ligne suivante.
6. Imprimez la valeur de la variable b sur la console à côté d'un autre texte. La fin (fin de ligne) déplacera le curseur pour commencer l'impression à la ligne suivante.
7. Créez une fonction nommée test() qui prend les adresses des variables a et b comme paramètres.
8. Imprimez du texte sur la console. Le \n créera une nouvelle ligne vierge avant que le texte ne soit imprimé. La fin (ligne de fin) déplacera le curseur pour commencer l'impression à la ligne suivante après l'impression du texte.
9. Imprimez la valeur de la variable a sur la console à côté d'un autre texte. La fin (fin de ligne) déplacera le curseur pour commencer l'impression à la ligne suivante.
10. Imprimez la valeur de la variable b sur la console à côté d'un autre texte. La fin (fin de ligne) déplacera le curseur pour commencer l'impression à la ligne suivante.
11. Le programme doit renvoyer une valeur en cas de réussite.
12. Fin du corps de la fonction main().
13. Définition de la fonction test(). La fonction doit prendre deux variables de pointeur entier *n1 et *n2.
14. Attribuer à la variable de pointeur *n1 la valeur 10.
15. Attribuer à la variable de pointeur *n2 la valeur 11.
16. Fin du corps de la fonction test().

Même si de nouvelles valeurs sont attribuées aux variables a et b dans le test de fonction, une fois l'appel de fonction terminé, cela ne se reflète pas dans la fonction externe principale.

L'utilisation de pointeurs comme arguments de fonction permet de transmettre l'adresse réelle de la variable dans la fonction, et toutes les modifications effectuées sur la variable seront reflétées dans la fonction externe.

Dans le cas ci-dessus, la fonction 'test' a pour adresse les variables 'a' et 'b.' Ces deux variables sont directement accessibles depuis la fonction 'test', et donc toute modification apportée à ces variables est répercutée dans la fonction appelante 'principal.'

Avantages de l'utilisation des pointeurs

Voici les avantages/avantages de l'utilisation des pointeurs

• Les pointeurs sont des variables qui stockent l'adresse d'autres variables en C++.
• Plusieurs variables peuvent être modifiées et renvoyées par la fonction à l'aide de pointeurs.
• La mémoire peut être allouée et désallouée dynamiquement à l'aide de pointeurs.
• Les pointeurs aident à simplifier la complexité du programme.
• La vitesse d'exécution d'un programme s'améliore en utilisant des pointeurs.

Résumé :

• Un pointeur fait référence à une variable contenant l'adresse d'une autre variable.
• Chaque pointeur a un type de données valide.
• Un pointeur est une représentation symbolique d'une adresse mémoire.
• Les pointeurs permettent aux programmes de simuler l'appel par référence et de créer et manipuler des structures de données dynamiques.
• Les tableaux et les pointeurs utilisent un concept apparenté.
• Le nom du tableau indique la base du tableau.
• Si vous souhaitez attribuer l'adresse d'un tableau à un pointeur, n'utilisez pas d'esperluette (&).
• S'il n'y a pas d'adresse spécifique pour attribuer une variable de pointeur, attribuez-lui une valeur NULL.