Pointeurs C ++ avec exemples

Table des matières:

Anonim

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 integer peut contenir l'adresse d'une variable de type integer. 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 des pointeurs, les programmes peuvent simuler un appel par référence. Ils peuvent également créer et manipuler des structures de données dynamiques. En 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.

Dans ce didacticiel C ++, vous apprendrez:

  • Que sont les pointeurs?
  • Adresses en C ++
  • Syntaxe de la déclaration du pointeur
  • Opérateur de référence (&) et opérateur de déférence (*)
  • Pointeurs et tableaux
  • Pointeur nul
  • Pointeurs de variables
  • Application de 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 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 l' opérateur & (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 la déclaration du pointeur

La déclaration de C ++ utilise 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 nom_variable doit être le nom de la variable du pointeur.
  • L'astérisque utilisé ci-dessus pour la déclaration du pointeur est similaire à l'astérisque utilisé pour effectuer l'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 integerdouble *x; // a pointer to doublefloat *x; // a pointer to floatchar *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 portant le nom num, stockée dans 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 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;}

Production:

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 une valeur de 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. Imprimez l'adresse de la variable x. La valeur de l'adresse a été 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 lors de l'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 car 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 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;}

Production:

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 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 d'index 0 à 5.
  5. Imprimez les valeurs stockées à l'adresse du pointeur IP. Une valeur sera renvoyée par itération et un total de 6 répétitions sera effectué. Le endl est un mot-clé C ++ qui signifie la ligne de fin. Cette action vous permet de déplacer le curseur sur 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 prochaine position int après chaque itération.
  7. Fin de la boucle for a.
  8. Le programme doit renvoyer quelque chose après une 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 zéro et est définie dans de nombreuses bibliothèques standard comme iostream.

Exemple 3:

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

Production:

Voici une capture d'écran du code:

Explication du code:

  1. Déclarez une variable de pointeur ip et lui attribuez la valeur NULL.
  2. Affiche la valeur de la variable de pointeur ip à côté du texte sur la console.
  3. Le programme doit renvoyer une valeur une fois terminé.
  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 attribué 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 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 using namespace std;int main() {int *p, x = 30;p = &x;cout << "Value of x is: " << *p;return 0;}

Production:

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 avec du texte sur la console.
  4. Le programme doit renvoyer une valeur une fois terminé.
  5. Fin du corps de la fonction main ().

Application de 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 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 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 permet d'illustrer ce concept: -

Exemple 5:

#include 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;}

Production:

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. La fin (ligne de fin) 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 (ligne de fin) 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 (ligne de fin) 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 (ligne de fin) 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 (ligne de fin) déplacera le curseur pour commencer l'impression à la ligne suivante.
  11. Le programme doit renvoyer une 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 entier * n1 et * n2.
  14. Attribuer à la variable de pointeur * n1 une valeur de 10.
  15. Attribuer à la variable de pointeur * n2 une valeur de 11.
  16. Fin du corps du test de fonction ().

Même si de nouvelles valeurs sont affecté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 main.

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 à partir de 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 en C ++.
  • Plusieurs variables peuvent être modifiées et renvoyées par une 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.

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 un 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 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 affecter une variable de pointeur, attribuez-lui une valeur NULL.