Discussion :

[Kromagg]

Bonjour à tous

Alors voila en parcourant quelques lignes de code j'ai pu voir ceci :

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
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
    template<class T>
    class CAttribute
    {
    protected:
 
        /// Type de l'attribut.
        Ogre::String mType;
 
        /// Valeur de l'attribut.
        T mValue;
 
    public:
 
 
        CAttribute(const Ogre::String& type = "null", T value = T()):
        mType(type),
        mValue(value)
        {}
 
        //! Destructeur.
        virtual ~CAttribute(void)
        {}
 
        ...
        ...
 
        T getValue(void) const { return mValue; }
 
        T operator() (void) { return mValue; }
 
        virtual operator T() const { return getValue(); }
    };

Que signifie les surcharges de l'opérateur suivantes

Code :

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

1
2
3
 
T operator() (void) { return mValue; }
virtual operator T() const { return getValue(); }

Sachant que un CAttribute est encapsulé dans un boost::shared_ptr<>

Kromagg

[ram-0000]

cela permet d'écrire quelque chose comme cela

Code :

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

1
2
3
4
5
6
CAttribute<int> mon_attribut;
 
int val = mon_attribut();
 
//qui est strictement équivalent à
int val = mon_attribut.getValue();

Par contre, je ne comprends pas l'intérêt d'avoir une version 'virtual' et une version non 'virtual' de la même fonction

[Lavock]

Ben peut-être la surcharge de l'opérateur const.

[ram-0000]

Je suis d'accord pour 2 versions, une avec const et une autre sans const. Mais pourquoi 1 virtuelle et pas l'autre ?

[Arzar]

Ce ne sont pas les mêmes opérateurs.

Le premier est un opérateur() renvoyant un T ou encore opérateur "d'appel de fonction". Il permet d'avoir du code comme celui-ci :

Code :

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

1
2
3
4
 
CAttribute<int> attr;
//...
int i = attr(); // syntaxe en (), comme un appel de fonction

Le deuxième est un opérateur de conversion, ici conversion vers T, qui permet d'avoir du code comme celui-ci :

Code :

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

1
2
3
4
 
CAttribute<int> attr;
//...
int i = attr; // conversion

[Lavock]

Il laisse soin à ces descendant de modifier le getters tant que sa garantie un comportement constant ?

[Edit] Maintenant que tu le dis oO !

[Alp]

Code :

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

<quelquechose> operator() (arguments);

est une définition de l'opérateur () pour ta classe, qui retourne un "truc" de type <quelquechose>.

Code :

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

operator <quelquechose>();

(avec ou sans virtual)
est un opérateur de conversion vers le type <quelquechose>. Ca permet de dire au compilo : si l'occasion se présente, si t'as besoin de convertir ma classe en un <quelquechose>, utilise ceci, c'est fait pour.

[Kromagg]

Merci à tous pour vos réponses

En fait c'était surtout la 2ème surcharge qui me posée problème. Et le gars l'utilise bien pour une conversion. En fait chaque CAttribute<T> est mis dans un boost::shared_ptr<>

Du coup si je fais pas exemple

Code :

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

1
2
 
shared_ptr<CAttribute<int> > monIntPtr(new CAttribute<int>(10));

Après au lieu de faire

Code :

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

1
2
 
int monInt = monIntPtr->getValue();

Et bien on peut faire ça

Code :

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

1
2
 
int monInt = *monIntPtr;

Topic résolu
Kromagg