Question const sur pointeur

Bonjour,

j'ai une fonction de ce type :

Code:

---

1 2 3 4

fun(MA_STRUCT * const Panne){   *Panne = VAR; }

---

MA_STRUCT est un type struct (surprenant, n'est-ce pas ?), et VAR une structure par défaut.

Le const signifie que le pointeur d'adresse ne sera pas modifié, mais que les valeurs à l'adresse pointée peuvent être modifiée, c'est bien ça ?

Merci.

A titre de comparaison :

const T* p <=> std::unique_ptr<const T>.
T* const p <=> const std::unique_ptr<T>.

Type * const nom; Se lit pointeur constant sur un Type. Donc le pointeur est constant (on ne peut pas modifier sa valeur) contrairement à l'objet pointé.

const Type * nom; Se lit pointeur sur un Type constant. Le pointeur pourra donc être modifié contrairement à l'objet pointé qui est considéré comme constant et qui ne pourra pas être modifié par le biais de ce pointeur.

Je me permettrai d'ajouter qu'il faudrait ajouter un gros panneau attention devant cette déclaration, parce que, justement, elle exploite un point assez méconnu de la norme. Et que mettre le pointeur const ne sert ici strictement à rien pour l'appelant.

Salut,

Un petit rappel concernant le mot clé const :

D'après la norme, il s'applique à ce qui se trouve à sa gauche, sauf (il s'agit donc bel et bien d'une exception à la règle :D ) s'il n'y a rien à sa gauche, auquel cas il s'applique à se qui se trouve à sa droite ;)

Quand ont déclare un pointeur, il y a donc quatre possibilités:

1. Type * ptr un pointeur non constant sur vers un objet non constant de type Type : on peut aussi modifier l'adresse contenue par le pointeur (comprendre : le faire pointer sur un autre objet) que modifier l'objet pointé par le pointeur
2. Type * const ptr un pointeur constant sur vers un objet non constant de type Type : on ne peut pas faire pointer le pointeur sur un autre objet, mais on peut, en revanche, modifier l'objet pointé
3. Type * ptr const un pointeur non constant sur vers un objet constant de type Type : on peut pas faire pointer le pointeur sur un autre objet, mais on ne peut pas, en revanche, modifier l'objet pointé
4. Type * const ptr const un pointeur constant sur vers un objet constant de type Type : on ne peut ni faire pointer le pointeur vers un autre objet, ni modifier l'objet pointé

Par exception à la règle, il existe deux autres possibilités:

1. const Type * ptr un pointeur constant sur vers un objet non constant de type Type : on ne peut pas faire pointer le pointeur sur un autre objet, mais on peut, en revanche, modifier l'objet pointé
2. const Type * ptr const un pointeur constant sur vers un objet constant de type Type : on ne peut ni faire pointer le pointeur vers un autre objet, ni modifier l'objet pointé

hope it helps ;)

Citation:

---

Envoyé par koala01

Salut,

Un petit rappel concernant le mot clé const :

D'après la norme, il s'applique à ce qui se trouve à sa gauche, sauf (il s'agit donc bel et bien d'une exception à la règle :D ) s'il n'y a rien à sa gauche, auquel cas il s'applique à se qui se trouve à sa droite ;)

Quand ont déclare un pointeur, il y a donc quatre possibilités:

1. Type * ptr un pointeur non constant sur vers un objet non constant de type Type : on peut aussi modifier l'adresse contenue par le pointeur (comprendre : le faire pointer sur un autre objet) que modifier l'objet pointé par le pointeur
2. Type * const ptr un pointeur constant sur vers un objet non constant de type Type : on ne peut pas faire pointer le pointeur sur un autre objet, mais on peut, en revanche, modifier l'objet pointé
3. Type * ptr const un pointeur non constant sur vers un objet constant de type Type : on peut pas faire pointer le pointeur sur un autre objet, mais on ne peut pas, en revanche, modifier l'objet pointé
4. Type * const ptr const un pointeur constant sur vers un objet constant de type Type : on ne peut ni faire pointer le pointeur vers un autre objet, ni modifier l'objet pointé

Par exception à la règle, il existe deux autres possibilités:

1. const Type * ptr un pointeur constant sur vers un objet non constant de type Type : on ne peut pas faire pointer le pointeur sur un autre objet, mais on peut, en revanche, modifier l'objet pointé
2. const Type * ptr const un pointeur constant sur vers un objet constant de type Type : on ne peut ni faire pointer le pointeur vers un autre objet, ni modifier l'objet pointé

hope it helps ;)

---

Euh, y a pas une erreur ici ?
Ce ne serait pas plutôt :

• 1. ok
• 2. ok
• 3. Type const * ptr
• 4. Type const * const ptr

pareil pour les deux autre :

• 1. const Type * ptr c'est l'inverse ici non, la variable pointée est constante, mais pas le pointeur (donc *ptr = tmp interdit, mais ptr = pointeur autorisé)
• 2. const Type * const ptr

Ou alors j'ai loupé quelque chose :mouarf:

Ok, je suis donc dans le cas 2.

Merci :)

Citation:

---

D'après la norme, il s'applique à ce qui se trouve à sa gauche, sauf (il s'agit donc bel et bien d'une exception à la règle ) s'il n'y a rien à sa gauche, auquel cas il s'applique à se qui se trouve à sa droite

---

Désolé de relancer un peu le sujet, mais je m'étonne de cette phrase.

Le code suivant :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

#include <windows.h> #include <psapi.h> #include <iostream>   int f(int const p1, int p2 const) { return p1 + p2; }   int main(void) { const int a = 2; int const b = 3;   int c const = 4; // invalide   return f(a,b); }

---

génère 2 erreurs.

Je ne suis pas spécialiste du C++ mais on ne peut utiliser const suivi de rien mais précédé de quelque chose uniquement si ce quelque chose est une méthode, non ?

Salut,

Citation:

---

on ne peut utiliser const suivi de rien mais précédé de quelque chose uniquement si ce quelque chose est une méthode, non ?

---

Je ne penses pas qu'on puisse le formuler comme ça non, ne serait-ce que pour la définition de fonctions :

Code:

---

void nothing(int const); // Ca compile,mais ce n'est "suivi de rien"

---

Il faut surtout que ce qui soit à gauche soit un type, une déclaration de pointeur (*), ou une méthode (pas sur que ce soit le même const que les deux précédents), mais pas le nom de la variable .

1. int const i;
2. int * const i;
3. void MaCLasse::MaMethode() const

const s'applique au type qui se trouve à sa gauche (ou, à défaut, à sa droite).
p2 n'est pas un type.
int, int*, const int* et int const* sont des types, const peut donc s'y appliquer.

Quant au const en fin de méthode, il s'applique au this de l'objet sur lequel s'applique la méthode. Si une classe Object définit une méthode const, cela veut dire que cette méthode manipulera un pointeur this de type const Object* const au lieu du type Object* const habituel. Ça veut bien dire ce que ça veut dire : le pointeur this est constant quoiqu'il arrive, mais l'objet qu'il pointe ne l'est pas forcément. Dans le premier cas on précise que l'objet désigné par ce pointeur est lui aussi constant, c'est pourquoi une méthode const ne modifie pas l'état de l'objet.

Ok merci :)