Tableau en l_value ou r_value pour mise à jour d'instance

Le
Dominique MICOLLET
Bonjour,

Soit la classe suivante :
#include <vector>

typedef unsigned char T_Degre;

class Empreinte : private std::vector <T_Degre>
{
private :
T_Degre Degre;
public :
Empreinte(size_t Nombre_Variables):std::vector <T_Degre>(Nombre_Variables){
Degre=0;};
T_Degre Quel_Degre(){return Degre;};
std::string Chaine();
size_type Quel_Nombre_Variables() {return size();};
void push_back(T_Degre Degre_Variable){std::vector
<T_Degre>::push_back(Degre_Variable); Degre+Þgre_Variable;};
// Les opérateurs suivants ne modifient pas correctement le membre Degre
T_Degre & operator[](size_t n){return this->std::vector
<T_Degre>::operator[](n);};
const T_Degre & operator[](size_t n) const {return this->std::vector
<T_Degre>::operator[](n);};

};

Dans cette classe, le membre Degre est supposé être la somme des éléments du
membre Empreinte.

En supposant avoir déclaré une instance Test de la classe Empreinte :
Empreinte Test(3);
je voudrais que
Test[2]=3 ;
mette Degre à jour, mais que
Truc=Test[2];
ne le fasse pas.

Je ne vois comment m'y prendre.
Pour être plus précis, je ne sais pas comment traiter dans l'opérateur [] le
fait que l'instance est une l_value, et non une partie d'une r_value.


Quelqu'un aurait une suggestion ?
J'écouterai aussi tout commentaire quand à cette classe (je débute en C++).

Cordialement

Dominique.
Vidéos High-Tech et Jeu Vidéo
Téléchargements
Vos réponses
Gagnez chaque mois un abonnement Premium avec GNT : Inscrivez-vous !
Trier par : date / pertinence
espie
Le #26178752
In article Dominique MICOLLET
// Les opérateurs suivants ne modifient pas correctement le membre Degre
T_Degre & operator[](size_t n){return this->std::vector
<T_Degre>::operator[](n);};
const T_Degre & operator[](size_t n) const {return this->std::vector
<T_Degre>::operator[](n);};
Je ne vois comment m'y prendre.
Pour être plus précis, je ne sais pas comment traiter dans l'opérateur [] le
fait que l'instance est une l_value, et non une partie d'une r_value.


Quelqu'un aurait une suggestion ?



En resumant, ton probleme m'a l'air d'etre un probleme classique: comment
avoir deux operator [] distincts, l'un qui correspond a une valeur que tu
vas modifier, l'autre qui est une constante, e.g., distinguer entre

t[i] = v;

et cout << t[i]+5;

Si c'est bien ca, c'est un probleme classique, connu et maitrise: on ne peut
pas le faire directement, il faut un niveau d'indirection de plus.
On definit l'operator [](int idx) pour renvoyer un truc intermediaire, avec
un type qui va juste etre une reference sur l'element concerne, e.g., myRef
et c'est ce type qui saura si on veut juste sa valeur, ou le modifier:
donc un operator T_degre qui convertit myRef en T_degre (lvalue). Et un
operator=(T_degre) qui correspond a la partie rvalue.
(et on met l'enorme majorite de la definition de cette classe intermediaire en
inline, vu que c'est juste un artifice pour resoudre ce probleme).

En exemple concret, la classe String de qt passe par une classe CharRef pour
distinguer rvalue/lvalue.


Si j'ai lu ta question en diagonale, et si ton probleme est plus complexe,
bah, desole :)
Dominique MICOLLET
Le #26180132
Bonjour,

Marc Espie wrote:

Si j'ai lu ta question en diagonale, et si ton probleme est plus complexe,
bah, desole :)



Vous avez parfaitement compris mon problème.
Par contre, la solution m'apparait plus nébuleuse : je vais essayer de
comprendre comment marche [] dans QString.h.

Merci

Cordialement

Dominique.
Publicité
Poster une réponse
Anonyme