Discussion :

[Krishna]

Bonsoir,
J'aimerais stocker dans un <vector> des objets CVecteur. Voici le patron de ma classe:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class CVecteur
{
    public:
    //constructeur et destructeur
   /.../
    //surcharges
    CVecteur& operator=(const CVecteur&);
    /.../
    protected:
    const int m_x;
    const int m_y;
    int m_xtemp;
    int m_ytemp;
};

Tout d'abord le compilateur m'a demandé de surcharger operator=. Ce que j'ai fait comme suit:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
CVecteur& CVecteur::operator=(const CVecteur& v)
{
    m_x=v._x();m_y=v._y();
    m_xtemp=v._xtemp();m_ytemp=v._ytemp();
    return *this;
}

Mais une fois operator= implementé, le compilateur m'annonce:

/home/.../CVecteur.cc||In member function ‘CVecteur& CVecteur::operator=(const CVecteur&)’
/home/.../CVecteur.cc|10|erreur: assignment of read-only data-member ‘CVecteur::m_x’|
/home/.../CVecteur.cc|10|erreur: assignment of read-only data-member ‘CVecteur::m_y’|

J'ai donc été contraint de supprimer les 'const' pour que ça passe.
- Y-a-t'il un moyen de contourner cela? J'aimerais malgré tout que ces membres restent 'const'
- Dans un fichier d'en tête "constantes.h" j'ai également déclaré des "CVecteur" comme suit:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
//vecteurs type
static const CVecteur FOU1=CVecteur(1,1);
static const CVecteur FOU2=CVecteur(1,-1);
static const CVecteur FOU3=CVecteur(-1,-1);
/.../

Cela sert-il à quelque chose de déclarer des objets d'une classe 'const' sachant que ces mêmes objets possèdent des fonctions susceptibles de modifier les valeurs de certains de leurs membres ?

[Luc Hermitte]

Cela veut juste dire qu'ils n'ont pas à être déclarés immuables ... s'ils peuvent l'être.

[Krishna]

Excuse moi mais peux-tu préciser? Je ne comprend pas.

[Luc Hermitte]

Avec const, tu dis "promis, jamais, mais alors vraiment jamais je ne modifierai cette donnée". Et à la première affectation venue, paf!, tu le fais. Cela n'a pas de sens.

[Krishna]

Je crois que j'ai saisi pour le 'const'. Mon problème est que j'aimerais conserver ces membres tel que.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

const int m_x etc...

Y-a-t'il un conteneur qui le permette? Ou ai-je mal implémenté operator=?

[Mat007]

Salut,

Comme le dit Luc, ça n'a pas de sens : tu ne peux pas à la fois dire que ta classe a des membres constants et permet l'affectation puisque par définition l'affectation modifie les membres...
Ce que tu peux faire par contre c'est stocker des pointeurs et non directement des objets dans le std::vector, du coup plus besoin d'affectation.

Au passage es-tu sûr que tu veux mettre ces données en protected ?
Tu vas vraiment dériver la classe ?

MAT.

[SmOkEiSBaD]

Ce que tu peux faire par contre c'est stocker des pointeurs et non directement des objets dans le std::vector, du coup plus besoin d'affectation.

Ou alors ne rien modifier

[Krishna]

Bonjour,
Je crois que vais utiliser des pointeurs comme tu l'as dit.
En fait, j'ai inscrit ces membres comme 'protected' et 'const' puisqu'ils ne doivent jamais être modifié et que l'on y accède pas directement. Ce qui semble être deux bonnes raisons non?

[SmOkEiSBaD]

Protected donne l'accès aux "classes filles" de ta classe CVecteur et seulement aux "classes filles".
Après c'est à toi de voir ce que tu veux en faire.

Public donne l'accès à tout le monde (via les accesseurs)

Private personne à part la classe elle même peut accéder à ses attributs.

[Krishna]

Et quel est votre avis sur le fait de déclarer une classe "const" sachant qu'elle possède la propriété de modifier la valeur de certains de ses membres?

[SmOkEiSBaD]

Je ne crois pas que ce soit la classe qui soit constante mais les objets (instances) de ta classe, cela signifie juste que ces objets ne peuvent être modifiés, cela dépend vraiment de ce que tu veux en faire.
Si ta classe n'est jamais instanciée et qu'aucun objet va être créé à partir de ta classe, tu peux utiliser une classe abstraite (avec une fonction virtuelle pure), dans ce cas seules les classes filles seront instanciées.

Que veux-tu faire avec ta classe ?

[Krishna]

Il s'agit d'une classe CVecteur qui contient 4 points. Certains de ces CVecteur étant utilisé souvent je veux les mettre dans en fichier d'en tête comme suit:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
static const CVecteur FOU1=CVecteur(1,1);
static const CVecteur FOU2=CVecteur(1,-1);
static const CVecteur FOU3=CVecteur(-1,-1);

Et j'ai l'impression que static et const à la fois font beaucoup de bruit pour rien...

[Médinoc]

Ce sont donc des objets constants.
Je déconseille de mettre leurs initialisations dans un fichier d'en-tête. Si tu veux en faire des variables globales, fais-en de vraies variables globales constantes, ou bien des membres statiques d'une classe...

[SmOkEiSBaD]

Quand tu dit "utilisés souvent" je suppose que c'est en écriture ?
Dans ce cas s'ils sont constants tu ne peux pas les "utilisés souvent" du moins pas en écriture, tu ne peux pas les modifier.

Jette un coup d'oeil la dessus, tu aura peut-être des réponses :
http://cpp.developpez.com/faq/cpp/?page=static

[SmOkEiSBaD]

Ce sont donc des objets constants.
Je déconseille de mettre leurs initialisation dans un fichier d'en-tête. Si tu veux en faire des variables globales, fais-en de vraies variables globales constantes, ou bien des membres statiques d'une classe...

+1

[Krishna]

Comment fait-on pour déclarer de "vraies variables globales constantes"?

[Médinoc]

Sans doute un truc de ce genre:

Code globals.h :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
extern const CUneClasse g_uneGlobale;
extern const CUneClasse g_uneAutreGlobale;

Code globals.cpp :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
#include "globals.h"
 
const CUneClasse g_uneGlobale(blabla);
const CUneClasse g_uneAutreGlobale(toto);

[Krishna]

En fait je ne connaissais pas la commande "externe".