Probleme de const

Bonjour,

Je suis actuellement en train de réaliser une petite application. Ce message d'erreur est apparu à la compilation :

Code:

---

1 2 3

error: passing ‘const XXX’ as ‘this’ argument of ‘void XXX::Load(std::ifstream&)’ discards qualifiers [-fpermissive] _XXX->Load(flux); ^

---

XXX est un pointeur d'objet déclaré comme ceci dans la classe:

Code:

---

const XXX _XXX;

---

Dans chacune des méthodes de la classe je passe bien un const XXX.
J'avoue que la je suis un peu perdu et la résolution du problème m'échappe

Merci d'avance pour l'aide ou piste de solution que vous pourriez m'apporter

Bonjour.

Si XXX est le nom d'une classe alors, quand tu écris const XXX _XXX;, _XXX n'est pas un pointeur, mais une instance de classe de type const XXX.
Alors, pour appeler une fonction void XXX::FonctionConstante() const avec _XXX, la syntaxe n'est pas _XXX->FonctionConstante() mais _XXX.FonctionConstante().
Attention : Comme _XXX est constant, alors on ne peut appeler que des fonctions constantes. Dans ton message, on voit que void XXX::Load(std::ifstream&) n'est pas constante, ce qui est normal, puisqu'une fonction qui charge des données dans un objet modifie cet objet. Donc, avec ton code actuel, _XXX.Load(flux) ne compilera pas.

La solution dépend de ton code. Peut-être que la solution suivante conviendra :
Dans ta classe XXX, si tu ajoutes un constructeur qui prend en paramètre std::ifstream& flux et qui appelle Load(flux), alors tu pourras construire un objet de type const XXX avec l'instruction const XXX _XXX{flux};.
En général, quand un objet a besoin de charger des données, il vaut mieux les charger dans le constructeur. Comme ça, on garantie que le chargement des données se fait bien avant l'utilisation de l'objet.

Merci de votre réponse

Il est possible que je change la déclaration de mon objet par ceci:

Code:

---

const XXX* _XXX;

---

Est-ce qu'une autre solution peut être envisager avec cette modification ?

Ton pointeur pointe toujours vers un objet constant donc seules les fonctions const peuvent être appelées.
- pourquoi le membre serait const ?
- load est sensé charger un objet depuis des données et n'a aucune chance d'être const si la logique tient..
- pourquoi tu chargerais/modifierais un objet const ?:weird:

Salut,

Ce qu'il faut comprendre, c'est que le mot clé const agit comme un grand panneau triangulaire rouge "attention, cette donnée ne peut pas être modifiée" pour le compilateur. C'est une règle que tu lui donne à laquelle il ne pourra contrevenir sous aucun prétexte. Quand tu appliques ce mot clé à une instance de classe, par exemple, en déclarant une variable sous la forme de

Code:

---

Maclasse const obj;

---

le compilateur acceptera que tu ne fasse appel qu'aux fonctions membres de MaClasse qui se sont explicitement engagées à ne pas modifier l'instance en cours. Comment:question: en faisant suivre l'accolade (edit) la parenthèse fermante de la fonction du mot clé const. Allez, un petit exemple pour t'aider à comprendre:

Mettons que j'écrive une classe proche de

Code:

---

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

class MaClasse{ public: MaClasse(int i):m_i{i}{} /* cette fonction ne s'engage pas à ne pas modifier l'instance courante   * et c'est tant mieux, car elle modifie la valeur de m_i   */ void add3(){ m_i+=3; } /* par contre, cette fonction s'engage EXPLICITEMENT à ne pas modifier   * l'instance en cours car elle est suivie du mot clé const   */ int get() const{ return m_i; } private: int m_i; };

---

Cette classe pourrait être utilisée sous la forme de

Code:

---

1 2 3 4 5

int main(){ MaClasse c{4}; // c.m_i vaut 4; c.add3(); // c.m_i vaut maintenant 7 std::cout<<"Après appel de add3(), m_i vaut "<<c.get(); }

---

Ce code sera accepté car c n'est pas considéré comme étant constante. on peut donc "sans aucun problème" faire appel à toutes les fonctions exposées par MaClasse.

Par contre, si tu déclares ta une variable (de type MaClasse) comme étant constante, le compilateur refusera que tu fasse appel à toute fonction susceptible de modifier l'instance de la classe. Et comment le détermine-t-il au niveau des fonctions membres :question: Pour lui, c'est très simple : toute fonction qui ne s'est pas explicitement engagée à ne pas modifier l'instance courante risque de le faire.

Si bien que, dans mon exemple, il n'y a que la fonction get qui ne modifiera effectivement pas (aux yeux du compilateur) l'instance courante.
Ainsi, un code proche de

Code:

---

1 2 3 4 5 6

int main(){ MaClasse const c{4}; // c est CONSTANTE on ne peut appeler // QUE DES FONCTIONS QUI NE MODIFIENT PAS c std::cout<<"c.i vaut "<<c.get(); //OK: get s'est engagé à ne pas modifier l'instance courante   }

---

sera accepté. Par contre, un code proche de

Code:

---

1 2 3 4 5

int main(){ MaClasse const c{4}; // c est CONSTANTE on ne peut appeler // QUE DES FONCTIONS QUI NE MODIFIENT PAS c c.add3(); // NOK: add3() modifie c... et on a dit que c ne POUVAIT PAS ÊTRE MODIFIE }

---

sera refusé car l'appel à add3() "désactive le qualificateur de constance".

Il n'est pas question de pointeur Vs valeur VS référence dans le cas présent. Il est juste question du fait que quelque chose qui est déclaré comme constant ne peut par définition même ... pas être modifié ;)

Citation:

---

Il est possible que je change la déclaration de mon objet par ceci:

Code:

---

const XXX* _XXX;

---

---

Attention! il y a une énorme différence entre déclarer une variable sous la forme de

Code:

---

XXX _xxx;

---

et le fait de la délcarer sous la forme de

Code:

---

XXX * _xxx;

---

(la présence ou l'absence du mot clé const étant ici "anecdotique"):

Dans le premier cas, tu déclare une valeur de type XXX appelée _xxx, dans le deuxième cas, tu déclares un pointeur sensé représenté l'adresse à laquelle tu trouvera un élément de type XXX et qui s'appelle _xxx.

De manière générale, on préférera éviter le recours aux pointeurs autant que faire se peut. Mieux encore : on décidera de n'avoir recours aux pointeurs que si on n'a pas d'autre choix. Or, avec la notion de référence et les classes comme std::reference_wrapper ou d'autres, on se retrouve à n'avoir que de moins en moins souvent besoin de recourir aux pointeurs.

Et, quoi qu'il en soit, chaque fois que l'on y aura recours, on préféreras les "englober" dans des classes qui se chargeront de libérer correctement la ressource pointée en temps opportuns comme std::unique_ptr ou std::shared_ptr

Merci à vous deux pour les éclaircissement apportées

L'idée que j'avais au départ était absurde, j'ai enlevé les const qui n'avait rien a faire et tout tourne :)

Merci aussi du rappel de théorie qui m'a beaucoup aidé j'ai sauvé ca dans un word

Je me demande si ce que tu cherchais n'était pas un truc de ce genre:

Code:

---

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

class MyClass { unique_ptr<const XXX> xxx_; };   unique_ptr<XXX> LoadXXX(...) { unique_ptr<XXX> xxx = new XXX{}; xxx->Load(...); return move(xxx); };   ...   obj->xxx_ = move(LoadXXX());

---

(si je me souviens bien, unique_ptr<A> est implicitement convertible en unique_ptr<const A>)

Bonsoir,

Je ne connais absolument pas ce genre d'instruction. Quel est son objectif ?

La classe template std::unique_ptr<> est un pointeur intelligent avec une sémantique de transfert: Il ne peut y avoir qu'un seul "propriétaire" de l'objet pointé, et lorsque le pointeur intelligent est détruit, il fait automatiquement un delete sur l'objet pointé.

C'est super comme instruction
je ne connaissais absolument pas
Merci :)

Ce n'est pas une instruction, c'est une classe.
Si tu ne sais pas ce qu'est un template, tu as encore beaucoup à apprendre du C++.