Surcharge de l'opérateur T

Version imprimable

Bonjour à tous :)

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

Code:

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:

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

16/10/2009, 16h56
ram-0000
cela permet d'écrire quelque chose comme cela
Code:

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
16/10/2009, 17h02
Lavock

Ben peut-être la surcharge de l'opérateur const.
16/10/2009, 17h17
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 ?
16/10/2009, 17h23
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:

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:

1 2 3 4 CAttribute<int> attr; //... int i = attr; // conversion
16/10/2009, 17h23
Lavock

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

[Edit] Maintenant que tu le dis oO !
18/10/2009, 01h37
Alp

Code:

<quelquechose> operator() (arguments);

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

Code:

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.
18/10/2009, 11h49
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:

1 2 shared_ptr<CAttribute<int> > monIntPtr(new CAttribute<int>(10));
Après au lieu de faire
Code:

1 2 int monInt = monIntPtr->getValue();
Et bien on peut faire ça
Code:

1 2 int monInt = *monIntPtr;
Topic résolu :D
Kromagg