Tableau en l_value ou r_value pour mise à jour d'instance
2 réponses
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+=Degre_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++).
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 :)
In article <53906d06$0$2138$426a74cc@news.free.fr>,
Dominique MICOLLET <anonymous@invalid.fr> wrote:
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 :)
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
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.
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.
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.
