Exam-Lib: Pointeurs et constante en C++ | Exam-Lib
  1. This site uses cookies. By continuing to use this site, you are agreeing to our use of cookies. Learn More.
Dismiss Notice
Welcome to our Education website, plz like our page facebook to support us. Thank You and wish you good navigation

Pointeurs et constante en C++

abdelouafiNov 25, 2018

    1. abdelouafi

      abdelouafi Administrator Staff Member

      Messages:
      724
      Likes Received:
      14
      Trophy Points:
      38
      Joined
      Sep 13, 2016
      Pointant vers des variables const

      Jusqu'à présent, tous les pointeurs que vous avez vus sont des pointeurs non constants vers des valeurs non constantes:
      Code:
      int value = 5;
      int *ptr = &value;
      *ptr = 6; // change value to 6
      Cependant, que se passe-t-il si la valeur est const?
      Code:
      const int value = 5; // value is const
      int *ptr = &value; // compile error: cannot convert const int* to int*
      *ptr = 6; // change value to 6
      L’extrait ci-dessus ne sera pas compilé - nous ne pouvons pas définir un pointeur non-const sur une variable const. Cela a du sens: une variable const est une variable dont la valeur ne peut pas être changée. En théorie, si nous pouvions définir un pointeur non-const sur une valeur const, nous pourrions alors déréférencer le pointeur non-const et modifier la valeur. Cela violerait l'intention de const.

      Pointeur sur la valeur const

      Un pointeur sur une valeur const est un pointeur (non-const) qui pointe sur une valeur constante.

      Pour déclarer un pointeur sur une valeur const, utilisez le mot-clé const avant le type de données:
      Code:
      const int value = 5;
      const int *ptr = &value; // this is okay, ptr is a non-const pointer that is pointing to a "const int"
      *ptr = 6; // not allowed, we can't change a const value
      Dans l'exemple ci-dessus, ptr pointe sur un const int.

      Jusqu'ici, tout va bien, non? Considérons maintenant l'exemple suivant:
      Code:
      int value = 5; // value is not constant
      const int *ptr = &value; // this is still okay
      Un pointeur sur une variable constante peut pointer sur une variable non constante (telle que la valeur de la variable dans l'exemple ci-dessus). Pensez-y de cette façon: un pointeur sur une variable constante traite la variable comme constante quand on y accède par le biais du pointeur, que la variable ait été définie initialement comme const ou non.

      Ainsi, ce qui suit est correct:
      Code:
      int value = 5;
      const int *ptr = &value; // ptr points to a "const int"
      value = 6; // the value is non-const when accessed through a non-const identifier
      Mais ce qui suit n'est pas:
      Code:
      int value = 5;
      const int *ptr = &value; // ptr points to a "const int"
      *ptr = 6; // ptr treats its value as const, so changing the value through ptr is not legal
      Étant donné qu'un pointeur sur une valeur const n'est pas lui-même (il pointe uniquement sur une valeur const), le pointeur peut être redirigé pour pointer sur d'autres valeurs:
      Code:
      int value1 = 5;
      const int *ptr = &value1; // ptr points to a const int
      int value2 = 6;
      ptr = &value2; // okay, ptr now points at some other const int
      Pointeurs Const

      Nous pouvons également faire un pointeur lui-même constant. Un pointeur const est un pointeur dont la valeur ne peut pas être modifiée après l'initialisation

      Pour déclarer un pointeur const, utilisez le mot-clé const situé entre l'astérisque et le nom du pointeur:
      Code:
      int value = 5;
      int *const ptr = &value;
      Tout comme une variable const normale, un pointeur const doit être initialisé à une valeur lors de la déclaration. Cela signifie qu'un pointeur const pointera toujours vers la même adresse. Dans le cas ci-dessus, ptr indiquera toujours l'adresse de valeur (jusqu'à ce que ptr soit hors de portée et soit détruit).
      Code:
      int value1 = 5;
      int value2 = 6;
      int * const ptr = &value1; // okay, the const pointer is initialized to the address of value1
      ptr = &value2; // not okay, once initialized, a const pointer can not be changed.
      Cependant, étant donné que la valeur pointée est toujours non-const, il est possible de changer la valeur pointée en déréférencant le pointeur const:
      Code:
      int value = 5;
      int *const ptr = &value; // ptr will always point to value
      *ptr = 6; // allowed, since ptr points to a non-const int
      Const pointeur sur une valeur const

      Enfin, il est possible de déclarer un pointeur const sur une valeur const en utilisant le mot-clé const à la fois avant le type et avant le nom de la variable:
      Code:
      int value = 5;
      const int *const ptr = &value;
      Un pointeur const vers une valeur const ne peut pas être défini pour pointer vers une autre adresse, pas plus que la valeur qu'il pointe ne peut être modifiée via le pointeur.

      Recapotage

      Pour résumer, il vous suffit de vous rappeler 4 règles, et elles sont plutôt logiques:

      • Un pointeur non-const peut être redirigé pour pointer vers d'autres adresses.
      • Un pointeur const pointe toujours vers la même adresse et cette adresse ne peut pas être modifiée.
      • Un pointeur sur une valeur non constante peut modifier la valeur sur laquelle il pointe. Ceux-ci ne peuvent pas pointer sur une valeur const.
      • Un pointeur sur une valeur const traite la valeur en tant que const (même si ce n'est pas le cas) et ne peut donc pas changer la valeur pointée.
      Garder la syntaxe de déclaration droite peut être difficile. Rappelez-vous simplement que le type de valeur indiqué par le pointeur est toujours à l'extrême gauche:
      Code:
      int value = 5;
      const int *ptr1 = &value; // ptr1 points to a "const int", so this is a pointer to a const value.
      int *const ptr2 = &value; // ptr2 points to an "int", so this is a const pointer to a non-const value.
      const int *const ptr3 = &value; // ptr3 points to a "const int", so this is a const pointer to a const value.
      Conclusion

      Les pointeurs vers les valeurs const sont principalement utilisés dans les paramètres de fonction (par exemple, lors du passage d’un tableau à une fonction) afin de s’assurer que la fonction ne modifie pas par inadvertance l’argument passé. Nous en discuterons plus loin dans la section sur les fonctions.
       
      Loading...

      Merci de partager ce post sur facebook

    2. Merci d'aimer notre facebook page

Share This Page