Bonjour,
 
J'aurai besoin de pouvoir détecter si la valeur d'une variable a été modifiée.
 
Je pensais pour cela encapsuler ma variable dans une classe template (pour avoir une seul classe pour les différents types de base) surchargant les différents opérateurs d'affectation (pour pouvoir utiliser l'objet de la même manière qu'un type de base), et qui modifierait un flag en cas de modification de la valeur de la variable.
 
Est-ce que ca vous parrait être une solution valable ou y a-t-il plus simple?

Salut !
 
Moi ce qui me paraitrait plus simple c'est a la place de la surchage de tes opérateurs c'est de faire tout bêtement une copie de ta variable et la comparer ensuite a chaque fois avec ta variable initiale.

C'est plus simple c'est sur, mais j'aimerais bien avoir un système plus transparent Je vais expliquer en gros le contexte:
 
Dans un objet donné (dérivant tous d'une classe de base), pouvoir définir des variables dont tout changement de valeur pourra être détecté par cet objet.
Et ce sans obliger le programmeur qui crée la classe à gérer lui même ces tests.
 
Le but final étant de récupérer les variables modifiées afin de pouvoir répercuter ces modifs sur une copie de cet objet situé sur un autre ordinateur.

Un pattern observer/observable ?

Tu veux faire dans le sens où les variables sont les observables, et ma classe est l'observer?
 
Ca reviendrait donc plus ou moins à ma 1ere solution, sans qu'au lieu de se mettre un flag, la variable signale son changement à sa classe via une methode de la classe de base.....effectivement c'est pas une mauvaise idée
 
Sinon ce que je dis n'est peut être pas très clair
Donc en gros j'essaie d'implémenter un système de ce type là :
http://developer.valvesoftware.com [...] _Variables

 
ca voudrait dire que ta classe contenant la variable s'enregristre auprès d'un observer qui réagit en fonction de l'observation.
 
C'est un pattern particulier et bien défini, qui est largement documenté dans le Grand Ternet.

et il fonctionne comment l'observer dans ce cas ? Il faut bien le prévenir au moment d'affecter une nouvelle valeur à la variable observée...
 
Et il est dit que c'est l'objet lui-même qui doit être capable de détecter tout changement => surcharge du =

J'ai un petit souci au niveau de la surcharge des opérateurs binaires...
Je les définis en dehors de la classe de la manière suivante :
 
template <typename U,typename V>
claNetVar<int> operator+(const claNetVar<U> &c1, const claNetVar<V> &c2)
{
    claNetVar<char> result = c1.getValue()+c2.getValue();
    return result;
}
 
Mais j'aimerais bien renvoyer le type réel résultant de l'opération, donc :
 
float+int=float
int+int=int
 
Je présume que le seul moyen est de surcharger l'opérateur + pour chaque type qu'on lui envoie? donc :
 
claNetVar<int> operator+(const claNetVar<int> &c1, const claNetVar<int> &c2)
claNetVar<float> operator+(const claNetVar<float> &c1, const claNetVar<int> &c2)
claNetVar<float> operator+(const claNetVar<int> &c1, const claNetVar<float> &c2)
...
 
Assez lourd quoi

non, utilise des traits :
 

 
A affiner avec des detrompeur template et regarde du coté de boost::traits ou de LOKI.