const en fin de déclaration ???

9 octobre 2006 à 19:58:31

Bonjour,

Voici un petit bout de la classe Vector3D qui est mise à notre disposition dans le dernier tuto OpenGL :

class Vector3D
{
Vector3D & operator+= (const Vector3D & v);
Vector3D operator+ (const Vector3D & v) const;
Vector3D & operator-= (const Vector3D &v);
Vector3D operator- (const Vector3D & v) const;
Vector3D & operator*= (const double a);
Vector3D operator* (const double a) const;
friend Vector3D operator* (const double a, const Vector3D & v);
Vector3D & operator/= (const double a);
Vector3D operator/ (const double a) const;
Vector3D crossProduct(const Vector3D & v) const;
double length() const;
Vector3D & normalize();
};

Je ne comprend pas l'utilité du const qui est placé à la fin de certaines lignes. Il est présent sur les surdéfinitions des opérateurs +, -, * et / ainsi que sur la déclaration de la méthode crossProduct et celle de lenght.

J'ai un peu de mal à trouver de l'info car en recherchant "const" sur google, je ne tombe que sur des pages qui expliquent son utilité (déclarer et initialiser une variable constante) quand on l'utilise de la manière suivante :

const int entier_constant = 5;

Si quelqu'un peut m'aider à y voir plus clair, je suis en serait très reconnaissant !

Dernière petite question... je pense avoir compris mais j'aimerais confirmation : je vois qu'on a surchargé l'opérateur de multiplication à deux reprises (un avec un seul paramètre et l'autre avec deux paramètres et le mot clé "friend")... j'imagine que c'est pour donner un sens à une expression telle que :

Vector3D v1 = new Vector3D();
Vector3D v2 = new Vector3D(1.0, 0.0, 0.0);
v1 = v2 * 0.5;

... mais également à une expression telle que la suivante ???

v1 = 0.5 * v2;

Merci à vous !

asmanur

9 octobre 2006 à 20:07:54

class A
{
void une_methode () const ;
};

C'est de ce const là dont tu parles ?
Si oui il signifie que cette méthode de modifie pas l'instance 'this'.
Exemple :

A instance;
instance.une_methode ();
// On est sur que tous les membres de 'instance' sont les mêmes qu'avant l'appel

Firya

9 octobre 2006 à 20:30:03

Donc, si j'ai bien compris, c'est pour déclarer une fonction membre et s'assurer qu'elle ne modifiera pas les données de l'objet (constant ou non) sur lequel elle va opérer ?

Sur base de ce que tu m'as dit, j'ai fait une petite recherche et j'ai lu que si on veut tout de même autoriser certaines modifications, on qualifie les données membres en question avec le mot clé "mutable" ... tu confirmes ? :euh:

Sinon, j'ai également lu qui dit que cela sert également à autoriser la fonction membre à opérer sur un objet constant... ca donnerait ca :

class POPO
{
private:
int p;

public:
void affiche();
void affiche_constant() const;
}

void main()
{
const POPO p1;
POPO p2;

p1.affiche(); // Erreur.
p1.affiche_constant(); // OK.
p2.affiche(); // OK.
p2.affiche_constant(); // OK car il est autorisé de traiter un objet non-constant comme s'il était constant.
}

Je suis dans le bon ou... ? :euh:

Merci beaucoup !

asmanur

9 octobre 2006 à 20:37:25

Citation : Firya

Donc, si j'ai bien compris, c'est pour déclarer une fonction membre et s'assurer qu'elle ne modifiera pas les données de l'objet (constant ou non) sur lequel elle va opérer ?

Sur base de ce que tu m'as dit, j'ai fait une petite recherche et j'ai lu que si on veut tout de même autoriser certaines modifications, on qualifie les données membres en question avec le mot clé "mutable" ... tu confirmes ?

Sinon, j'ai également lu qui dit que cela sert également à autoriser la fonction membre à opérer sur un objet constant... ca donnerait ca :

class POPO
{
private:
int p;

public:
void affiche();
void affiche_constant() const;
}

void main()
{
const POPO p1;
POPO p2;

p1.affiche(); // Erreur.
p1.affiche_constant(); // OK.
p2.affiche(); // OK.
p2.affiche_constant(); // OK car il est autorisé de traiter un objet non-constant comme s'il était constant.
}

Je suis dans le bon ou... ?

Merci beaucoup !

Euh je n'ai qu'une connaissance (très) limitée du C++ mais je dirais que c'est ça. Par contre pour mutable, jamais entendu parler :S

lexou

9 octobre 2006 à 21:27:04

Const c'est pour spécifier que la méthode ne modifiera pas l'objet this (important et indispensable si tu décides d'appliquer cette méthode sur un objet déclaré const, par exemple).

((Mutable je crois (sans trop de certitude) que c'est lié aux threads, rien à voir donc.)) => erreur voir plus bas

tif-tof

9 octobre 2006 à 21:56:39

D'après quelque test rapide, mutable sert en effet pour permettre aux fonctions membres (const) d'opérer tout de même sur des variables membres

#include <iostream>

class A {
public:
bool GetV(void) const { return V; }
void SetV(bool nV) const { V = nV; }

bool GetV2(void) const { return V2; }
void SetV2(bool nV) const { V2 = nV; }

private:
mutable bool V;
// Enlevez le mutable de bool V2 et il y aura une erreur du compilateur
mutable bool V2;
};

int main(int argc,char ** argv) {
A Temp;
Temp.SetV(true);
Temp.SetV2(true);

return 0;
}

@lexou
Comme il n'y aucun moyen de gérer les thread avec les bibliothèques standarts, mutable ne peut pas être utilisé pour les threads :-°

(Mais bon, j'étais même pas au courant que ce mot-clef servait à sa avant

)

lexou

9 octobre 2006 à 23:32:16

J'ai dit ca (sans aucune certitude encore une fois) car j'ai vu ça dans un topic sur les threads QT voila tout.

En tout cas il y à l'air d'y avoir une contradiction quelque part : pourquoi vouloir spécifier const une méthode qui modifie l'instance en question... ?

EDIT : Voila la réponse que j'ai trouvé dans la bible C++

Le spécificateur mutable signale qu'un membre "ne peut jamais être const".

L'interet en fait est de pouvoir appliquer une méthode spécifiée const à une instance d'un objet tout en pouvant modifier un ou plusieurs membres qui ne modifie pas "logiquement" l'objet. Malgré les modifications effectués il demeure "logiquement" const. Prenons par exemple une valeur qui est incrémenté à chaque fois qu'on utilise une méthode, on peut la spécifier mutable si l'on veut pouvoir l'incrémenter depuis une fonction const.

Voila !