c++ d'une usine automatique de l'enregistrement des types dérivés

Comme beaucoup avant moi, j'essaie donc d'obtenir mon des types dérivés pour enregistrer automatiquement avec mon usine. J'ai lu beaucoup de question et a essayé de se concentrer sur ce que je n'ai pas l'y trouver.

J'ai tout fonctionne bien sauf l'enregistrement automatique.

Mes Objectifs:

  1. enregistrer automatiquement toute classe dérivée de ma classe de base Base
    1. seulement les classes que je marque comme enregistrable
    2. non seulement directe de sous-classes de Base
      • ex: de Base -> Périphérique> Caméra -> Webcam
      • ce serait en utilisant le PFI comme décrit dans cette question dificile
  2. un minimum de changements pour les classes je veux enregistré - les nuls preuve
  3. préférez à l'aide d'un registrator classe que les macros

Ce que j'ai:

template <class T>
class abstract_factory
{
    public:
        template < typename Tsub > static void register_class();
        static T* create( const std::string& name );
    private:
        //allocator<T> is a helper class to create a pointer of correct type
        static std::map<std::string, boost::shared_ptr<allocator<T> > > s_map;
};
  • basé sur un modèle abstrait de l'usine, avec std::string comme type de clé
  • abstract factory a tous les membres et méthodes statique
  • nom de la classe est récupéré automatiquement avec typeid (pas besoin de texte nom lors de l'inscription)
  • enregistrement en appelant: abstract_factory<Base>::register_class<MyDerived>();

Ce que j'ai essayé (ou voudrais, mais ne savez pas comment correctement):

  • registrator<Derived> class: templateded classe est instanciée de façon statique dans Derived.cpp et doit appeler abstract_factory::register_class<Derived>() dans son constructeur
    • n'est jamais appelé ou instancié
    • si je fais une instance de Derived dans main() cela fonctionne -> un peu de défaites le but si
  • déclarer une simple variable statique dans chaque Derived.hpp et le mettre à la statique de la méthode d'enregistrement en Derived.cpp -> encore une fois, n'est jamais appelé.
  • faire abstract_factory un vrai singleton au lieu d'avoir tout ce que statique?

Pourrait utiliser tous les conseils, petits ou grands, merci.

OriginalL'auteur Alex | 2012-04-02

  1. 9

    - Je utiliser un singleton avec un membre de l'enregistrement, en gros:

    template< typename KeyType, typename ProductCreatorType >
class Factory
{
    typedef boost::unordered_map< KeyType, ProductCreatorType > CreatorMap;
    ...
};

    À l'aide de Loki je puis avoir quelque chose le long de ces lignes:

     typedef Loki::SingletonHolder< Factory< StringHash, boost::function< boost::shared_ptr< SomeBase >( const SomeSource& ) > >, Loki::CreateStatic > SomeFactory;

    L'inscription se fait généralement à l'aide d'une macro tels que: 

    #define REGISTER_SOME_FACTORY( type ) static bool BOOST_PP_CAT( type, __regged ) = SomeFactory::Instance().RegisterCreator( BOOST_PP_STRINGIZE( type ), boost::bind( &boost::make_shared< type >, _1 ) );

    Cette configuration a un certain nombre d'avantages:

    • Travaille avec par exemple boost::shared_ptr<>.
    • Ne nécessite pas le maintien d'un énorme fichier pour l'enregistrement besoins.
    • Est très flexible avec le créateur, tout va assez bien.
    • La macro couvre l'utilisation la plus courante de cas, tout en laissant la porte ouverte à des solutions de rechange.

    L'invocation de la macro dans le .fichier cpp est suffisant pour obtenir le type enregistré au démarrage pendant l'initialisation statique. Cela fonctionne dandy enregistrer pour le cas où le type d'enregistrement est une partie d'une bibliothèque statique, auquel cas il ne sera pas inclus dans votre binaire. Les seules solutions qui compile l'enregistrement en tant que partie de la bibliothèque, j'ai vu le travail est d'avoir un énorme fichier de l'enregistrement explicitement comme une partie de une sorte de routine d'initialisation. Au lieu de cela ce que je fais aujourd'hui est d'avoir un dossier client avec ma lib de laquelle l'utilisateur comprend qu'une partie de la binaire construire.

    À partir de votre liste d'exigences, je crois que cela permet de tout enregistrer pour l'utilisation d'un registrator classe.

    Merci pour ça :), j'ai adapté votre exemple et il fonctionne très bien avec des cours dans mon bibliothèque de base. Ce que vous avez souligné à propos des bibliothèques statiques est vrai pour moi, comme la plupart de mes Derived classes sont là. Savez-vous comment gérer à l'exportation de ces symboles de toute façon?
    Salut Ylisar, auriez-vous l'esprit de prendre un coup d'oeil à ma réponse et me dire votre opinion à ce sujet. J'ai un peu l'impression que quelque chose est incorrect avec elle, mais je ne peux pas le nom.
    pouvez-vous préciser ce que vous faites dans la macro pour l'inscription ?
    Notez que cela ne fonctionnera pas si vous vous enregistrez vos usines dans les unités de traduction qui sont compilés dans une bibliothèque statique. L'éditeur de liens est possible de traquer les variables globales parce qu'ils ne sont pas ODR utilisé n'importe où.

    OriginalL'auteur Ylisar

  2. 4

    --- inscription.h ---

    #include <iostream>
#include <typeinfo>
#include <set>
#include <string>
using namespace std;

template<class T>
struct registrar {
        struct proxy { inline proxy();};
        static proxy p;
};

template<class T> typename registrar<T>::proxy registrar<T>::p;



struct factory {
        template <typename T> static T* create() {
               registrar<T>::p;
               return new T();
        }
};

set<string> & types();

template<typename T>
registrar<T>::proxy::proxy() { types().insert(typeid(T).name());}

    --- registration.cpp ---

    #include "registration.h"
#include <boost/foreach.hpp>

set<string> & types() {static set<string> types; return types;} 

int main() {
    BOOST_FOREACH(const string & s, types()) { cout<<s<<"\n";}
        factory::create<int>();
    factory::create<double>();
    factory::create<bool>();
        return 0;
}

    --- registration_ext.cpp ---

    #include "registration.h"

class myclass {};

void phony() {
    factory::create<double>();
    factory::create<myclass>();
}

    Ensuite compilé avec:

    $ g++ registration.cpp registration_ext.cpp -o registration

    Lors de l'exécution à:

    $ ./registration 
7myclass
b
d
i

    Donc, il semble avoir enregistré les classes avant principal est appelé.

    Edit:
    J'ai remarqué que cette solution est dépendant de l'implémentation. En vertu de 3.6.2 la norme C++ dit:

    Elle est mise en œuvre-définir si la dynamique de l'initialisation d'un
    non variable locale statique de la durée de stockage est effectuée avant l'
    premier état de la principale. Si l'initialisation est reporté à certains
    après la première instruction de la main, il doit se produire avant
    la première odr-utilisation (3.2) de toute fonction ou une variable définie dans le
    traduction même unité que la variable est initialisée.

    Je vous remercie pour cela. Il fonctionne bien, unfortunetly, comme Ylisar l'a souligné, un tel mécanisme échoue avec une liaison externe, qui est ce que j'ai. Cool code bien 🙂
    Bon point. C'est plus intéressant, j'ai modifié ma réponse un peu maintenant, et il semble fonctionner avec une liaison externe. Je crois que cette réponse se trouve à la frontière de comportement indéfini terre (probablement à l'intérieur). J'aimerais connaître votre opinion à ce sujet.

    OriginalL'auteur enobayram