Bonjour à tous, je suis confronté au problème suivant.
Je dispose d'une classe qui est un template et qui définit un Multiton:

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
 
template<typename T>
    class Multiton
    {
        public:
 
            /*! \brief Retourne l'instance spécifiée de la classe */
            static T* instance( const int pId )
            {...}
..............
}
Je veux écrire une classe qui dérive de ce template, mais qui reste abstraite, avec des fonctions virtuelles pures:
OperModeManagerGeneric. Cette classe ne sera pas instanciable du fait de ses fonctions vp, donc j'en fais également un template, qui sera donc délégué au Multiton:

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
 
 template<typename U>
    /*!
     * \brief Cette classe définit le socle d'un manager d'oper modes
     */
    class OperModeManagerGeneric : public Multiton<U>
    {
        public:
             .....
              virtual void fonctionAReimplementer() = 0 ;
             ...........
}
De fait, je voudrais dans du code plus spécifique avoir une classe qui dérive de OperModeManagerGeneric, comme par exemple:

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
 
    class OperModeManager : public OperModeManagerGeneric<OperModeManager>
    {
 
        public:
             .....
              virtual void fonctionAReimplementer();
             ...........   
}
Et ainsi, mon OperModeManager peut hériter de OperModeManagerGeneric en concrétisant le template, qui concrétise en meme temps le template du Multiton.

Est-ce que tout ceci est possible ?

Et par ailleurs, j'ai d'autres classes qui doivent se servir d'un pointeur sur un OperModeManagerGeneric, voici un exemple:

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
 
template<typename W>
 
    class OperModeFinalState
    {
 
        public:
 
 
            explicit OperModeFinalState ( const OperModeManagerGeneric<W>* pParent, );
 
        protected:
 
          .....
 
        private:
 
            const OperModeManagerGeneric<W>* mParent;        //!< Machine a état parent
 
    };
Est-ce que c'est bon ?

Côté implémentation du constructeur, j'ai écrit ça:

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
 
 OperModeFinalState<class W>::OperModeFinalState ( const OperModeManagerGeneric<class W>* pParent ) :
        mParent( pParent )
    {
    }
Ca ne compile pas ==> opermodefinalstate.cpp:30: erreur: too few template-parameter-lists

ou encore
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
 
template<typename W>
    OperModeFinalState<W>::OperModeFinalState ( const OperModeManagerGeneric<W>* pParent, QState* pParentState ) :
        QFinalState( pParentState ),
        mParent( pParent )
    {
    }
Est-ce que ce code serait meilleur ?
(En gros pour le moment je ne compile pas pour d'autre raison, mais je ne pense pas que la façon se faire soit bonne ?).

Merci pour l'aide, gros cafouillage de ma part !