const en C++ - Page 1

Bon, je suis en train de me battre avec les Object const & name, const Object & name, etc.... dans Qt4.
En C, ça fait des warnings et on s'en sort avec des casts, mais là c'est carrément des erreurs.
CA VEUT DIRE QUOI!!

là par exemple j'ai écrit:

const GeoPoint operator+(const GeoPoint & a, const GeoPoint & b)
{
	return GeoPoint(a.lat()+b.lat(),a.lon()+b.lon());
}

ce qui fait:
geopoint.cpp:52: error: passing `const GeoPoint' as `this' argument of `qreal GeoPoint::lat()' discards qualifiers

et j'y pige... RIEN

je veux juste ajouter 2 points, j'ai mis des consts là ou ils sont dans les opérateurs de QPointF, cf la doc de Qt:
const QPointF operator+ ( const QPointF & p1, const QPointF & p2 )

edit: bon j'ai réussi à compiler avec:

GeoPoint operator+(GeoPoint a, GeoPoint b)
{
	return GeoPoint(a.lat()+b.lat(),a.lon()+b.lon());
}

mais je pige toujours pas l'utilisation de const.

j'ai même vu des:
Object function(params) const
const Object function(params)

C'est quoi la différence ?


ai écrit:QPointF gps=geo.toQPointF();autre souci: quelque part j'
intF(this->lon(),this->lat()); }

et dans la classe GeoPoint j'ai:QPointF GeoPoint::toQPointF()
{
	return QPo

)' discards qualifierset ça me fait un beau:model.cpp:416: error: passing `const GeoPoint' as `this' argument of `QPointF GeoPoint::toQPointF(
Donc il faut bien des const quelque part, mais je sais pas où, à part dlc du C++.

C'est quelle ligne qui casse tout ?
Sinon, pourquoi retourner un objet const ?

J'en ai aucune idée, mais cf l'edit, y'en a besoin.

C'est la ligne citée qui bloque.

Object Classe::function(params) const

est une méthode en lecture seule (<=> qui n'a pas le droit de modifier les attributs)

const Object Classe::function(params)

renvoit un Object constant


tu peux avoir sans problème une méthode du genre

const Object Classe::function( const Object2* const objName) const

renvoit un Object constant, paramètre objName n'a pas le droit dêtre modifié (ni l'objet Object2 pointé par objName), et enfin la fonction "Classe::function" n'a accès aux attributs de la classe qu'en lecteure seule.
Voilà.


Pour le reste du post, je n'ai pas le temps de le lire maintenant.

Bon j'ai trouvé c'est parce que j'ai écrit ça:

QPointF Model::geoToScreen(GeoPoint const & geo)
{
	QPointF gps=geo.toQPointF();
...

Donc j'ai enlevé le const, mais ailleurs j'ai écrit:
GeoPoint gps=this->screenToGeo(objn->getPos());
ce qui me produit aussitot:

model.cpp:596: error: no matching function for call to `Model::screenToGeo(QPointF)'
model.cpp:435: note: candidates are: GeoPoint Model::screenToGeo(QPointF&)

merde!

Pen^2 (./4) :

Object Classe::function(params) const

est une méthode en lecture seule ( qui n'a pas le droit de modifier les attributs)

Ah! ça, c'est intéressant! je comprends mieux! merci. Bon on va voir.

edit: bon je vais virer les références partout, ça me fout trop la merde, et tant pis si j'envoie des tas de conneries dans la pile.

Pour résoudre ton problème il faut pas supprimer les const il faut en rajouter : pour indiquer qu'une méthode ne modifie pas *this il faut mettre const après les arguments, donc il faut le rajouter à lat() par exemple. Et puis dans ton premier exemple operator+() devrait être statique.

squalyl (./1) :
geopoint.cpp:52: error: passing `const GeoPoint' as `this' argument of `qreal GeoPoint::lat()' discards qualifiers

si je ne dis pas de bêtise, il faudrait que lat soit une fonction const (genre "ObjRet lat() const")
Parce qu'on n'a pas le droit d'appeler une fonction non const sur un objec const (elle risque de modifier les attributs de l'objet alors qu'il est const !!)

OK ./7 et ./8 sont corrélés, je vais faire ça

et si tu ne peux pas modifier lat, tu peux t'en sortir avec un cast (mais c'est pas beau)

((GeoPoint)b).lat()

et en plus lat rique de modifier ton objet b alors que tu voudrais qu'il soit const...

bref le mieux c'est d'ajouter le const à lat si tu le peux.

PS : les const en C++ c'est bien si tu en met partout où c'est utile dès le début du projet. Sinon c'est vraiment la merde

squalyl (./6) :
edit: bon je vais virer les références partout, ça me fout trop la merde, et tant pis si j'envoie des tas de conneries dans la pile.

surtout pas
(surtout qu'en dehors des raisons de performance tous les types ne sont pas forcément copiables, donc il faut savoir utiliser les références)

pen^2:

je vois ça

j'ai mis qreal lat() const.

mais comment on sait qu'un objet est constant?

(pollux: oué, en fait non, j'ai mis ça parce que j'étais énervé, je vais corriger plus subtilement )

squalyl (./13) :
mais comment on sait qu'un objet est constant?

comment ça ?

non en fait je pense qu'il manquait des const aux getters, j'en ai casé quelques un et ça y est, ça compile

bon, bref. si j'ai d'autres soucis je vous ferai chier encore

squalyl (./13) :
pphd:

(il s'appelle Pen^2 )

je vois ça

j'ai mis qreal lat() const.

mais comment on sait qu'un objet est constant?

Tu veux dire comment savoir si tu dois déclarer une méthode comme const ? Il suffit de voir si elle est modifie ou devra modifier à l'avenir des champs de l'objet : si c'est juste faire un calcul à partir des champs de l'objet il faut la déclarer comme const.

et tous les getters bien sûr.

ben un getter c'est une fonction qui fait "un calcul à partir des champs de l'objet", aussi simple soit-il

Pollux (./16) :
(il s'appelle Pen^2 )

oué, dsl

bien vu pour les consts. merci.

Pollux (./16) :

squalyl (./13) :
pphd:

(il s'appelle Pen^2 )

lol, je n'avais pas vu (hélas, ça tient probablement plus à la signature qu'à mon érudition cplusplèsque )

Pollux (./18) :
ben un getter c'est une fonction qui fait "un calcul à partir des champs de l'objet", aussi simple soit-il

mouais si tu veux

t1 j'ai besoin de sommeil

qreal operator*(QPointF a, QPointF b)
{
	return a.x()*b.x()+a.y()+b.y();
}

class Toto {
  private:
    mutable int x_;
    int y_;
  
  public:
    Toto(int x, int y) : x_(x), y_(y) {}
    int x() const {return x_;}
    int y() const {return y_;}
    void setX(int x) const {x_ = x;} // Fonctionne grâce à x_ toujours modifiable (mutable)
    void setX(int x) {x_ = x;}
    void setY(int y) {y_ = y;}
};

int main() {
  const Toto t(41, 42);
  t.setX(36); //OK (alors que t est constant)
  t.setY(20); //KO

  // Avoir une référence non constante sur t
  Toto& tRef = const_cast<Toto&>(t);
  tRef.setX(54); //OK
  tRef.setY(1564); //OK
  ...
}

Comme quoi l'utilisation de const est vicieuse et qu'il faut l'utiliser correctement histoire d'éviter d'avoir des const_cast partout...

Ton deuxième appel à setY() n'est pas OK non plus, tu n'as pas le droit de faire ça même si ça peut marcher avec ton compilo :

The referent of a const-qualified expression shall not be modified (through that expression), except that if it is of class type and has a mutable component, that component can be modified (7.1.5.1).

(par contre je pense que ton deuxième appel à setX() est OK, même si tu appelles la version non const de setX() elle ne modifie pas de membres non mutables donc ça va : enfin c'est pas propre du tout, parce qu'à moins d'avoir le code de setX() sous les yeux c'est pas garanti)

Oui j'ai pas dit que le code était propre, bien au contraire.
Et donc si j'ai bien compris, il n'est pas possible de modifier t même en faisant une référence non constante vers celui-ci ?
Mon code marche avec g++ mais il n'est pas garantie qu'il fonctionne sur d'autres compilateur (c'est bon à savoir ça).

Même avec g++ y a rien de garanti : un code plus compliqué pourra très bien crasher parce qu'il supposera que tel truc est constant alors qu'en fait il ne l'est pas, du coup il pourra accéder à de la mémoire n'importe où, etc.

squalyl (./22) :
qreal operator*(QPointF a, QPointF b) {
return a.x()*b.x()+a.y()+b.y(); }

Tu es sur du calcul ? (bon je sais pas ce que tu es sensé calculer, mais je trouve bizzare)

c'est pas pour rien qu'il a mis "t1 j'ai besoin de sommeil"

Godzil (./27) :
Tu es sur du calcul ? (bon je sais pas ce que tu es sensé calculer, mais je trouve bizzare)

Un produit scalaire ?

ué

et t'as le droit de trouver mon code bizarre

corrigé ça donne plutot x1*x2+y1*y2 en fait ^^