Le retour covariant n'est qu'un moyen d'écrire
class BaseProperty {
public:
BaseProperty* type() { return type_(); }
protected:
virtual BaseProperty* type_() { return this; }
};
template <typename U>
class Property: public BaseProperty {
public:
Property* type() { return static_cast<Property*>(type_()); }
protected:
BaseProperty* type_() { return this; }
};
Et ne change rien à la vision statique du code.
Le retour covariant n'est qu'un moyen d'écrire
class BaseProperty {
public:
BaseProperty* type() { return type_(); }
protected:
virtual BaseProperty* type_() { return this; }
};
template <typename U>
class Property: public BaseProperty {
public:
Property* type() { return static_cast<Property*>(type_()); }
protected:
BaseProperty* type_() { return this; }
};
Et ne change rien à la vision statique du code.
Le retour covariant n'est qu'un moyen d'écrire
class BaseProperty {
public:
BaseProperty* type() { return type_(); }
protected:
virtual BaseProperty* type_() { return this; }
};
template <typename U>
class Property: public BaseProperty {
public:
Property* type() { return static_cast<Property*>(type_()); }
protected:
BaseProperty* type_() { return this; }
};
Et ne change rien à la vision statique du code.
Jean-Marc Bourguet wrote:Le retour covariant n'est qu'un moyen d'écrire
class BaseProperty {
public:
BaseProperty* type() { return type_(); }
protected:
virtual BaseProperty* type_() { return this; }
};
template <typename U>
class Property: public BaseProperty {
public:
Property* type() { return static_cast<Property*>(type_()); }
protected:
BaseProperty* type_() { return this; }
};
Et ne change rien à la vision statique du code.
C'est une bonne façon de l'envisager, même si je crois que
l'implémentation la plus répandue correspond plutôt à :
template< typename T >
class Property : public BaseProperty
{
public:
Property* type() { return this ; } ;
protected:
BaseProperty* type_() { return type() ; }
} ;
Jean-Marc Bourguet wrote:
Le retour covariant n'est qu'un moyen d'écrire
class BaseProperty {
public:
BaseProperty* type() { return type_(); }
protected:
virtual BaseProperty* type_() { return this; }
};
template <typename U>
class Property: public BaseProperty {
public:
Property* type() { return static_cast<Property*>(type_()); }
protected:
BaseProperty* type_() { return this; }
};
Et ne change rien à la vision statique du code.
C'est une bonne façon de l'envisager, même si je crois que
l'implémentation la plus répandue correspond plutôt à :
template< typename T >
class Property : public BaseProperty
{
public:
Property* type() { return this ; } ;
protected:
BaseProperty* type_() { return type() ; }
} ;
Jean-Marc Bourguet wrote:Le retour covariant n'est qu'un moyen d'écrire
class BaseProperty {
public:
BaseProperty* type() { return type_(); }
protected:
virtual BaseProperty* type_() { return this; }
};
template <typename U>
class Property: public BaseProperty {
public:
Property* type() { return static_cast<Property*>(type_()); }
protected:
BaseProperty* type_() { return this; }
};
Et ne change rien à la vision statique du code.
C'est une bonne façon de l'envisager, même si je crois que
l'implémentation la plus répandue correspond plutôt à :
template< typename T >
class Property : public BaseProperty
{
public:
Property* type() { return this ; } ;
protected:
BaseProperty* type_() { return type() ; }
} ;
(*_owner).getvalue();}
// affectation d'un type T à un objet ReturnValue
(*_owner).getvalue()=rhs;}
private :
(*_owner).getvalue();}
// affectation d'un type T à un objet ReturnValue
(*_owner).getvalue()=rhs;}
private :
(*_owner).getvalue();}
// affectation d'un type T à un objet ReturnValue
(*_owner).getvalue()=rhs;}
private :
hélas, je n'ai pas réussi à faire marcher ton code pour obtenir un T comme
type de retour
voilà ce que j'ai recopié/légèrement modifié :
class BaseProperty {
public :
//--------------------------------------------------------------------------------------------
class ReturnValue {
public :
ReturnValue(BaseProperty* owner) : _owner(owner) {}
// opérateur de conversion en type T d'un objet ReturnValue
template<typename T>
operator T() const { return dynamic_cast< Property<T>&(*_owner).getvalue();}
// affectation d'un type T à un objet ReturnValue
template<typename T>
void operator=(T const& rhs) { dynamic_cast< Property<T>&(*_owner).getvalue()=rhs;}
private :
BaseProperty* _owner;
};
//--------------------------------------------------------------------------------------------
virtual ReturnValue value(void)=0;
};
template <typename T>
class Property : public BaseProperty {
public :
Property(T* t) : _t(t) {}
virtual ReturnValue value(void) { return ReturnValue(this); }
T getvalue(void) { return *_t; }
protected :
T* _t;
};
et après, j'ai pas compris ta surcharge de l'operator& de ReturnValue pour
qu'il
renvoie encore un proxy...
TypeObjet y=...;
Property<TypeObjet > x(&y);
BaseProperty *xx=&x;
et je cherche à obtenir d'une manière ou d'une autre un objet de type
TypeObjet à partir de xx
si j'écris xx->value(), j'ai un objet ReturnValue et je ne sais pas a
priori quelle est la bonne conversion...
même si (TypeObjet)xx->value() est ok, face à un objet ReturnValue, je ne le
sais pas !
Il y a t-il une solution à mon problème ?
hélas, je n'ai pas réussi à faire marcher ton code pour obtenir un T comme
type de retour
voilà ce que j'ai recopié/légèrement modifié :
class BaseProperty {
public :
//--------------------------------------------------------------------------------------------
class ReturnValue {
public :
ReturnValue(BaseProperty* owner) : _owner(owner) {}
// opérateur de conversion en type T d'un objet ReturnValue
template<typename T>
operator T() const { return dynamic_cast< Property<T>&
(*_owner).getvalue();}
// affectation d'un type T à un objet ReturnValue
template<typename T>
void operator=(T const& rhs) { dynamic_cast< Property<T>&
(*_owner).getvalue()=rhs;}
private :
BaseProperty* _owner;
};
//--------------------------------------------------------------------------------------------
virtual ReturnValue value(void)=0;
};
template <typename T>
class Property : public BaseProperty {
public :
Property(T* t) : _t(t) {}
virtual ReturnValue value(void) { return ReturnValue(this); }
T getvalue(void) { return *_t; }
protected :
T* _t;
};
et après, j'ai pas compris ta surcharge de l'operator& de ReturnValue pour
qu'il
renvoie encore un proxy...
TypeObjet y=...;
Property<TypeObjet > x(&y);
BaseProperty *xx=&x;
et je cherche à obtenir d'une manière ou d'une autre un objet de type
TypeObjet à partir de xx
si j'écris xx->value(), j'ai un objet ReturnValue et je ne sais pas a
priori quelle est la bonne conversion...
même si (TypeObjet)xx->value() est ok, face à un objet ReturnValue, je ne le
sais pas !
Il y a t-il une solution à mon problème ?
hélas, je n'ai pas réussi à faire marcher ton code pour obtenir un T comme
type de retour
voilà ce que j'ai recopié/légèrement modifié :
class BaseProperty {
public :
//--------------------------------------------------------------------------------------------
class ReturnValue {
public :
ReturnValue(BaseProperty* owner) : _owner(owner) {}
// opérateur de conversion en type T d'un objet ReturnValue
template<typename T>
operator T() const { return dynamic_cast< Property<T>&(*_owner).getvalue();}
// affectation d'un type T à un objet ReturnValue
template<typename T>
void operator=(T const& rhs) { dynamic_cast< Property<T>&(*_owner).getvalue()=rhs;}
private :
BaseProperty* _owner;
};
//--------------------------------------------------------------------------------------------
virtual ReturnValue value(void)=0;
};
template <typename T>
class Property : public BaseProperty {
public :
Property(T* t) : _t(t) {}
virtual ReturnValue value(void) { return ReturnValue(this); }
T getvalue(void) { return *_t; }
protected :
T* _t;
};
et après, j'ai pas compris ta surcharge de l'operator& de ReturnValue pour
qu'il
renvoie encore un proxy...
TypeObjet y=...;
Property<TypeObjet > x(&y);
BaseProperty *xx=&x;
et je cherche à obtenir d'une manière ou d'une autre un objet de type
TypeObjet à partir de xx
si j'écris xx->value(), j'ai un objet ReturnValue et je ne sais pas a
priori quelle est la bonne conversion...
même si (TypeObjet)xx->value() est ok, face à un objet ReturnValue, je ne le
sais pas !
Il y a t-il une solution à mon problème ?
Si tu veux une vérification dynamique:
TypeObjet z = xx->value();
devrait fonctionner et jeter une exception si ce n'est pas du bon type.
oui, mais
cout<<xx->value();
par exemple ne fonctionnera opas,
même si << est redéfini pour TypeObjet
il faut écrire
cout<<(TypeObjet)xx->value();
et en plus, je souhaiterais éventuellement modifier la donnée
pointée/adressée (comme les getters/setters)
Si tu veux une vérification dynamique:
TypeObjet z = xx->value();
devrait fonctionner et jeter une exception si ce n'est pas du bon type.
oui, mais
cout<<xx->value();
par exemple ne fonctionnera opas,
même si << est redéfini pour TypeObjet
il faut écrire
cout<<(TypeObjet)xx->value();
et en plus, je souhaiterais éventuellement modifier la donnée
pointée/adressée (comme les getters/setters)
Si tu veux une vérification dynamique:
TypeObjet z = xx->value();
devrait fonctionner et jeter une exception si ce n'est pas du bon type.
oui, mais
cout<<xx->value();
par exemple ne fonctionnera opas,
même si << est redéfini pour TypeObjet
il faut écrire
cout<<(TypeObjet)xx->value();
et en plus, je souhaiterais éventuellement modifier la donnée
pointée/adressée (comme les getters/setters)
je vais étudier ta solution plus en détail et l'implémenter dans mo n cas
précis.
Si ça marche, tu me sauve la vie...
pour t'expliquer mon problème en général, je développe un interpr éteur, avec
des objets et donc des propriétés associées à ces objets
exemple au hasard :
UnObjetInt x=5;
x.value; // retourne 5
x.name; // propriété valide, retourne un std::string
x.nimportequoi; // erreur , la propriété n'existe pas
et pour chaque propriété publiable, je cherche à définir des obje ts
"propriétés" qui représente des références vers les objets "mod ifiables"
voilà mon problème de façon simplifiée...
Marc
je vais étudier ta solution plus en détail et l'implémenter dans mo n cas
précis.
Si ça marche, tu me sauve la vie...
pour t'expliquer mon problème en général, je développe un interpr éteur, avec
des objets et donc des propriétés associées à ces objets
exemple au hasard :
UnObjetInt x=5;
x.value; // retourne 5
x.name; // propriété valide, retourne un std::string
x.nimportequoi; // erreur , la propriété n'existe pas
et pour chaque propriété publiable, je cherche à définir des obje ts
"propriétés" qui représente des références vers les objets "mod ifiables"
voilà mon problème de façon simplifiée...
Marc
je vais étudier ta solution plus en détail et l'implémenter dans mo n cas
précis.
Si ça marche, tu me sauve la vie...
pour t'expliquer mon problème en général, je développe un interpr éteur, avec
des objets et donc des propriétés associées à ces objets
exemple au hasard :
UnObjetInt x=5;
x.value; // retourne 5
x.name; // propriété valide, retourne un std::string
x.nimportequoi; // erreur , la propriété n'existe pas
et pour chaque propriété publiable, je cherche à définir des obje ts
"propriétés" qui représente des références vers les objets "mod ifiables"
voilà mon problème de façon simplifiée...
Marc
Mon problème d'une manière très générale.
Je développe un interpréteur et dans mon langage, je suis susceptible de
manipuler des objets de différents type (peu importe le type) et avec d es
propriétés (en lecture/écriture ou les 2)
je peux avoir par exemple un truc du genre
Type1 x;
puis
int y=x.size;
mon problème est de savoir rapidement et simplement si la propriété size
existe pour Type1 et d'obtenir "facilement" une référence (constante le cas
échéant) vers la donnée membre correspondante (par exemple).
D'où mon idée de développer une classe Property, avec l'idée de l 'utiliser
comme suit
// ne dispose que de données membres static
template <typename T>
class CObjectWithProperty {
template <typename U>
static void add_property(Property<U> const&); // "j'enregistre"
des propriétés
// etc...
};
je ne développe pas ici la classe CObjectWithProperty mais l'idée c'e st
qu'elle gère une liste de propriétés accessibles pour un objet, ave c leur
nom associé (CObjectWithProperty<Type1> classe associée aux objets Ty pe1)
Seulement on ne construit malheureusement pas une liste avec des objets
hétérogènes.
Ma liste contient donc des objets de la seule classe de base de Property et
mon problème c'est d'obtenir un objet un objet T à partir de la classe
BaseProperty , classe de base de Property<T>
J'ai conscience que j'esplique pas trop bien, hélas...
Pour mieux comprendre, regarde le code 2 niveaux + haut.
En fait, le type ReturnValue convient comme lvalue (donc setter) en
redéfinissant l'opérateur = dans ReturnValue
Mon problème, c'est plutôt comme rvalue
ex :
Type1 x;
Type1 y;
int m= x.size*y.size // je fais quoi là :-(
-> je suis obligé de redéfinir tous les opérateurs
mais comme tu sais on peut définir ses propres opérateurs pour un type
d'objet et d'une manière générique, je suis incapable de le savoir. ...
J'espère que tu m'as compris !
Marc A +
Mon problème d'une manière très générale.
Je développe un interpréteur et dans mon langage, je suis susceptible de
manipuler des objets de différents type (peu importe le type) et avec d es
propriétés (en lecture/écriture ou les 2)
je peux avoir par exemple un truc du genre
Type1 x;
puis
int y=x.size;
mon problème est de savoir rapidement et simplement si la propriété size
existe pour Type1 et d'obtenir "facilement" une référence (constante le cas
échéant) vers la donnée membre correspondante (par exemple).
D'où mon idée de développer une classe Property, avec l'idée de l 'utiliser
comme suit
// ne dispose que de données membres static
template <typename T>
class CObjectWithProperty {
template <typename U>
static void add_property(Property<U> const&); // "j'enregistre"
des propriétés
// etc...
};
je ne développe pas ici la classe CObjectWithProperty mais l'idée c'e st
qu'elle gère une liste de propriétés accessibles pour un objet, ave c leur
nom associé (CObjectWithProperty<Type1> classe associée aux objets Ty pe1)
Seulement on ne construit malheureusement pas une liste avec des objets
hétérogènes.
Ma liste contient donc des objets de la seule classe de base de Property et
mon problème c'est d'obtenir un objet un objet T à partir de la classe
BaseProperty , classe de base de Property<T>
J'ai conscience que j'esplique pas trop bien, hélas...
Pour mieux comprendre, regarde le code 2 niveaux + haut.
En fait, le type ReturnValue convient comme lvalue (donc setter) en
redéfinissant l'opérateur = dans ReturnValue
Mon problème, c'est plutôt comme rvalue
ex :
Type1 x;
Type1 y;
int m= x.size*y.size // je fais quoi là :-(
-> je suis obligé de redéfinir tous les opérateurs
mais comme tu sais on peut définir ses propres opérateurs pour un type
d'objet et d'une manière générique, je suis incapable de le savoir. ...
J'espère que tu m'as compris !
Marc A +
Mon problème d'une manière très générale.
Je développe un interpréteur et dans mon langage, je suis susceptible de
manipuler des objets de différents type (peu importe le type) et avec d es
propriétés (en lecture/écriture ou les 2)
je peux avoir par exemple un truc du genre
Type1 x;
puis
int y=x.size;
mon problème est de savoir rapidement et simplement si la propriété size
existe pour Type1 et d'obtenir "facilement" une référence (constante le cas
échéant) vers la donnée membre correspondante (par exemple).
D'où mon idée de développer une classe Property, avec l'idée de l 'utiliser
comme suit
// ne dispose que de données membres static
template <typename T>
class CObjectWithProperty {
template <typename U>
static void add_property(Property<U> const&); // "j'enregistre"
des propriétés
// etc...
};
je ne développe pas ici la classe CObjectWithProperty mais l'idée c'e st
qu'elle gère une liste de propriétés accessibles pour un objet, ave c leur
nom associé (CObjectWithProperty<Type1> classe associée aux objets Ty pe1)
Seulement on ne construit malheureusement pas une liste avec des objets
hétérogènes.
Ma liste contient donc des objets de la seule classe de base de Property et
mon problème c'est d'obtenir un objet un objet T à partir de la classe
BaseProperty , classe de base de Property<T>
J'ai conscience que j'esplique pas trop bien, hélas...
Pour mieux comprendre, regarde le code 2 niveaux + haut.
En fait, le type ReturnValue convient comme lvalue (donc setter) en
redéfinissant l'opérateur = dans ReturnValue
Mon problème, c'est plutôt comme rvalue
ex :
Type1 x;
Type1 y;
int m= x.size*y.size // je fais quoi là :-(
-> je suis obligé de redéfinir tous les opérateurs
mais comme tu sais on peut définir ses propres opérateurs pour un type
d'objet et d'une manière générique, je suis incapable de le savoir. ...
J'espère que tu m'as compris !
Marc A +
Est-ce que le nom et le nombre des propriétés sont connus et plutôt
fixes ou bien est-ce qu'ils sont inconnus ou amené à fréquemment
changer lors de la mise à jour du code, sa maintenance, etc... ?
Est-ce que le nom et le nombre des propriétés sont connus et plutôt
fixes ou bien est-ce qu'ils sont inconnus ou amené à fréquemment
changer lors de la mise à jour du code, sa maintenance, etc... ?
Est-ce que le nom et le nombre des propriétés sont connus et plutôt
fixes ou bien est-ce qu'ils sont inconnus ou amené à fréquemment
changer lors de la mise à jour du code, sa maintenance, etc... ?
