Je voudrais construire une API qui fournit une interface de classe à la fonctionnalité (fichier d'en-tête) et cacher l'implémentation pour toutes les bonnes raisons standard. Je prévois d'utiliser une fabrique d'objets pour renvoyer des pointeurs d'objet dérivés d'objets "nouveaux" qui se conforment à l'interface.C++ Construire une API en utilisant des classes d'interfaces, des templates et des fabriques d'objets
Ma classe d'API de base varie en fonction des vecteurs std :: de types numériques intégrés (char, uchar, short, ushort, int, uint, float et double). Donc, un modèle semble être un ajustement naturel. Je vais mettre un modèle de classe d'interface à la disposition des utilisateurs de mon API et j'en dériverai dans le modèle de classe d'implémentation qui sera caché. Comme mon modèle de classe visible par l'utilisateur est une classe d'interface, je voudrais déclarer toutes les méthodes purement virtuelles, mais je comprends qu'il peut y avoir des problèmes avec les instanciations/exportations de modèles requis dans les DLL, les objets partagés, etc. Je vais juste les définir virtuellement et leur donner des corps de méthodes vides dans la classe d'interface de base. Quelque part le long de la ligne, j'ai besoin de créer une méthode d'usine statique de modèle (ou une fonction de modèle) qui va créer les objets des classes dérivées et les renvoyer à l'appelant. Le problème est que je ne peux pas mettre l'implémentation de la méthode d'usine d'objet statique dans le fichier d'en-tête de l'interface, car elle doit créer des objets des classes dérivées qui doivent être cachées. Donc, je voudrais mettre ces usines d'objets statiques dans l'en-tête de l'implémentation ou dans un fichier source.
Voici un en-tête de la mise en œuvre conceptuelle
#ifndef INTERFACE_H
#define INTERFACE_H
#ifdef DLL_EXPORTS
#define DLL_API __declspec(dllexport)
#else
#define DLL_API __declspec(dllimport)
#endif
// This interface class is exported from the dll.
template < typename T >
class DLL_API InterfaceClass {
public:
static InterfaceClass* factoryMethod();
virtual ~InterfaceClass () { }
virtual void someMethod(T aParam){ };
protected:
InterfaceClass () { }
private:
InterfaceClass (const InterfaceClass &);
InterfaceClass& operator=(const InterfaceClass &);
};
#endif
Voici une classe de mise en œuvre dérivée conceptuelle
#ifndef IMPLEMENTATION_H
#define IMPLEMENTATION_H
#include <vector>
#include "interface.h"
template < typename T >
class DerivedClass : public InterfaceClass<T> {
public:
DerivedClass(const T& aDataVector) : InterfaceClass<T>() { /*...*/ }
virtual ~DerivedClass() { /*...*/ }
virtual void someMethod(T aParam) { /*...*/ }
private:
std::vector<T> _dataVector;
};
Note: En réalité, je vais utiliser TR1 :: shared_ptr au lieu de pointeurs bruts.
Mes questions sont les suivantes:
1) Où puis-je définir la méthode statique "factoryMethod()" (ou de implementation.h implementation.cpp)?
2) À quoi ressemble cette implémentation de méthode?
3) Y a-t-il d'autres problèmes que je dois connaître pour que mes utilisateurs API ou moi-même n'obtenions pas de temps de liaison ou d'erreurs d'exécution?
merci d'avance!
Je l'ai eu pour fonctionner sous Visual Studio 2008 – intensifi