C++ Pointeurs avec exemples

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

Adresses en C++

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

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

Pour connaître l'emplacement dans la mémoire de l'ordinateur où sont stockées les données, C++ Fournit le & (référence) opérateur. 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 valide C++ type de données.
• Le nom_variable doit être le nom de la variable 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 pointeur.

Voici un exemple de déclarations de pointeurs valides dans 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 ça marche:

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 obtenir 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. Stockez 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. Imprime 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. Imprimer 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 comportant des pointeurs. Le nom du tableau lui-même indique l'adresse de base du tableau. Cela signifie que pour attribuer 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 pointeur. Par exemple:

int arr [20];
int * ip;

Voici 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éez une boucle for. La variable de boucle x a été créée pour parcourir les éléments du tableau de l'index 0 à 5.
5. Imprime 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. La fin est un C++ mot-clé qui signifie la ligne de fin. Cette action vous permet de déplacer le curseur vers 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 nul

S'il n'y a pas d'adresse exacte à attribuer, la variable de pointeur peut se voir attribuer une valeur NULL. Cela devrait être fait lors de la déclaration. Un tel pointeur est appelé pointeur nul. Sa valeur est nulle et est définie dans de nombreuses bibliothèques standards 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. Imprimez la valeur de la variable de pointeur ip à côté du texte sur la console.
3. Le programme doit renvoyer de la valeur une fois terminé.
4. Fin du corps de la fonction main().

Pointeurs de variables

et C++, vous pouvez manipuler les données directement depuis la mémoire de l'ordinateur.

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

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é ainsi :

int *p;

Ou,

int* p;

Dans votre exemple, nous avons déclaré la variable pointeur p.

Il contiendra une adresse mémoire.

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

Le pointeur p pointe vers 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. Imprimez la valeur de la variable de pointeur p à côté du texte sur la console.
4. Le programme doit renvoyer de la valeur une fois terminé.
5. Fin du corps de la fonction main().

Application des pointeurs

Fonctions dans C++ ne peut renvoyer qu’une seule valeur. De plus, toutes les variables déclarées dans une fonction sont allouées sur la pile d'appels de fonction. Dès le retour de la fonction, toutes les variables de la pile sont détruites.

Les arguments de la fonction sont transmis par valeur, et toute modification effectuée sur les variables ne change pas la valeur des variables réelles transmises. L'exemple suivant permet d'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 d'une fonction nommée test qui prendra deux paramètres entiers.
2. Appelez la fonction main(). Nous ajouterons la logique du programme à l'intérieur de 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. Le endl (fin de ligne) déplacera le curseur pour commencer l'impression dans la ligne suivante.
5. Imprimez la valeur de la variable a sur la console avec un autre texte. Le endl (fin de ligne) déplacera le curseur pour commencer l'impression dans la ligne suivante.
6. Imprimez la valeur de la variable b sur la console avec un autre texte. Le endl (fin de ligne) déplacera le curseur pour commencer l'impression dans 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 vide avant que le texte ne soit imprimé. Le endl (ligne de fin) déplacera le curseur pour commencer l'impression sur la ligne suivante après l'impression du texte.
9. Imprimez la valeur de la variable a sur la console avec un autre texte. Le endl (fin de ligne) déplacera le curseur pour commencer l'impression dans la ligne suivante.
10. Imprimez la valeur de la variable b sur la console avec un autre texte. Le endl (fin de ligne) déplacera le curseur pour commencer l'impression dans la ligne suivante.
11. Le programme doit renvoyer de la valeur une fois terminé.
12. Fin du corps de la fonction main().
13. Définition de la fonction test(). La fonction doit prendre deux variables de pointeur entiers *n1 et *n2.
14. Attribuer à la variable pointeur *n1 une valeur de 10.
15. Attribuer à la variable pointeur *n2 une valeur de 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é, la même chose n'est pas reflétée 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 l'adresse des variables « a » et « b ». Ces deux variables sont directement accessibles depuis la fonction « test », et donc toute modification apportée à ces variables est reflétée dans la fonction appelante « main ».

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 dans 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 grâce à l'utilisation de pointeurs.

Synthèse

• 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 un appel par référence et de créer et manipuler des structures de données dynamiques.
• Arrays et les pointeurs utilisent un concept connexe.
• 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.