Création d'une interface pour un modèle de classe abstraite en C++

Question

J'ai le code comme ci-dessous. J'ai une classe de modèle abstrait Foo et deux sous-classes (Foo1 et Foo2) qui dérivent des instanciations du modèle. Je souhaite utiliser des pointeurs dans mon programme pouvant pointer vers des objets de type Foo1 ou Foo2, d'où j'ai créé une interface IFoo.

Mon problème est que je ne suis pas sûr de savoir comment inclure la fonctionB dans l'interface, car elle dépend de l'instanciation du modèle. Est-il même possible de rendre la fonction B accessible via l'interface, ou est-ce que je tente l'impossible?

Merci beaucoup pour votre aide.

class IFoo { 
    public: 
     virtual functionA()=0; 

}; 

template<class T> 
class Foo : public IFoo{ 
    public: 
     functionA(){ do something; }; 
     functionB(T arg){ do something; }; 
}; 

class Foo1 : public Foo<int>{ 
... 
}; 

class Foo2 : public Foo<double>{ 
... 
}; 

Answer 1

Je ne pense pas que vous pouvez obtenir ce que vous voulez. Pensez à ceci si vous implémentez votre suggestion: si vous avez un pointeur vers une instance IFoo et que vous appelez le functionB(), quel paramètre de type devriez-vous lui donner? Le problème sous-jacent est que Foo1::functionB et Foo2::functionB ont des signatures différentes et font des choses différentes.

Answer 2

Le moyen le plus simple est de rendre votre interface modélisée.

template <class T> 
class IFoo { 
    public: 
     virtual void functionA()=0; 
     virtual void functionB(T arg){ do something; }; 
}; 

template<class T> 
class Foo : public IFoo<T>{ 
    public: 
     void functionA(){ do something; }; 
     void functionB(T arg){ do something; }; 
}; 

Answer 3

Depuis le type d'argument de functionB doit être connu à l'avance, vous avez un seul choix: Faites un type qui peut contenir tous les arguments possibles. Ceci est parfois appelé un "type supérieur" et les bibliothèques boost ont le type any qui est assez proche de ce que ferait un type supérieur. Voici ce qui pourrait fonctionner:

#include <boost/any.hpp> 
#include <iostream> 
using namespace boost; 

class IFoo { 
    public: 
    virtual void functionA()=0; 
    virtual void functionB(any arg)=0; //<-can hold almost everything 
}; 

template<class T> 
class Foo : public IFoo{ 
    public: 
     void functionA(){ }; 
     void real_functionB(T arg) 
     { 
     std::cout << arg << std::endl; 
     }; 
     // call the real functionB with the actual value in arg 
     // if there is no T in arg, an exception is thrown! 

     virtual void functionB(any arg) 
     { 
      real_functionB(any_cast<T>(arg)); 
     } 
}; 

int main() 
{ 
    Foo<int> f_int; 
    IFoo &if_int=f_int; 

    if_int.functionB(10); 

    Foo<double> f_double; 
    IFoo &if_double=f_double; 
if_int.functionB(10.0); 

} 

Malheureusement, any_cast ne connaît pas les conversions habituelles. Par exemple, any_cast<double>(any(123)) lève une exception car il n'essaie même pas de convertir l'entier 123 en double. Si cela ne concerne pas les conversions, car il est impossible de toutes les répliquer de toute façon. Il y a donc quelques limitations, mais il est possible de trouver des solutions de contournement si nécessaire.

Answer 4

Vous tentez l'impossible.

Le cœur même de la question est simple: virtual et template ne se mélangent pas bien.

• template concerne la génération de code à la compilation. Vous pouvez le considérer comme une sorte de macros typées + quelques astuces saupoudrées pour la programmation méta.
• virtual est à propos de la décision d'exécution, et cela nécessite un peu de travail.

virtual est généralement implémenté en utilisant une table virtuelle (pensez à une table qui liste les méthodes). Le nombre de méthodes doit être connu au moment de la compilation et est défini dans la classe de base. Cependant, avec vos besoins, nous aurions besoin d'une table virtuelle de taille infinie, contenant des méthodes pour les types que nous n'avons pas encore vus et qui ne seront définis que dans les années à venir ... c'est malheureusement impossible.

Et si c'était possible?

Eh bien, cela n'aurait aucun sens. Que se passe-t-il lorsque j'appelle Foo2 avec un int? Ce n'est pas fait pour ça!Par conséquent, il rompt le principe que Foo2 implémente toutes les méthodes de IFoo.

Ainsi, il serait mieux si vous avez déclaré le vrai problème, de cette façon nous pourrions vous aider à un niveau de conception plutôt que sur le plan technique :)