Динамически регистрировать методы конструктора в AbstractFactory во время компиляции с использованием шаблонов C ++ - PullRequest
Новая
       16

Динамически регистрировать методы конструктора в AbstractFactory во время компиляции с использованием шаблонов C ++

11 голосов
/ 17 мая 2010

При реализации класса MessageFactory для создания объектов Message я использовал что-то вроде: 

class MessageFactory 
{
  public:
    static Message *create(int type)
    {
       switch(type) {
         case PING_MSG:
            return new PingMessage();
         case PONG_MSG:
            return new PongMessage();
         ....
    }
}

Это работает нормально, но каждый раз, когда я добавляю новое сообщение, мне нужно добавить новый XXX_MSG и изменить оператор switch.

После некоторых исследований я нашел способ динамически обновлять MessageFactory во время компиляции, чтобы я мог добавлять столько сообщений, сколько захочу, без необходимости изменять сам MessageFactory. Это позволяет чище и проще поддерживать код, поскольку мне не нужно изменять три разных места для добавления / удаления классов сообщений: 

#include <stdio.h>                                                                                                                                                                           
#include <stdlib.h>                                                                                                                                                                          
#include <string.h>                                                                                                                                                                          
#include <inttypes.h>                                                                                                                                                                        

class Message                                                                                                                                                                                
{                                                                                                                                                                                            
   protected:                                                                                                                                                                                
      inline Message() {};                                                                                                                                                                   

   public:                                                                                                                                                                                   
      inline virtual ~Message() { }                                                                                                                                                          
      inline int getMessageType() const { return m_type; }                                                                                                                                   
      virtual void say() = 0;                                                                                                                                                                

   protected:                                                                                                                                                                                
      uint16_t m_type;                                                                                                                                                                       
};                                                                                                                                                                                           

template<int TYPE, typename IMPL>                                                                                                                                                            
class MessageTmpl: public Message                                                                                                                                                            
{                                                                                                                                                                                            
   enum { _MESSAGE_ID = TYPE };                                                                                                                                                              
   public:                                                                                                                                                                                   
      static Message* Create() { return new IMPL(); }                                                                                                                                        
      static const uint16_t MESSAGE_ID; // for registration                                                                                                                                  

   protected:                                                                                                                                                                                
      MessageTmpl() { m_type = MESSAGE_ID; } //use parameter to instanciate template                                                                                                         
};                                                                                                                                                                                           

typedef Message* (*t_pfFactory)();                                                                                                                                                           
class MessageFactory⋅                                                                                                                                                                        
{                                                                                                                                                                                            
   public:                                                                                                                                                                                   
     static uint16_t Register(uint16_t msgid, t_pfFactory factoryMethod)                                                                                                                     
     {                                                                                                                                                                                       
       printf("Registering constructor for msg id %d\n", msgid);                                                                                                                             
       m_List[msgid] = factoryMethod;                                                                                                                                                        
       return msgid;                                                                                                                                                                         
     }                                                                                                                                                                                       

     static Message *Create(uint16_t msgid)                                                                                                                                                  
     {                                                                                                                                                                                       
       return m_List[msgid]();                                                                                                                                                               
     }                                                                                                                                                                                       
     static t_pfFactory m_List[65536];                                                                                                                                                       
};  

template <int TYPE, typename IMPL>                                                                                                                                                           
const uint16_t MessageTmpl<TYPE, IMPL >::MESSAGE_ID = MessageFactory::Register(                                                                                                              
     MessageTmpl<TYPE, IMPL >::_MESSAGE_ID, &MessageTmpl<TYPE, IMPL >::Create);                                                                                                              

class PingMessage: public MessageTmpl < 10, PingMessage >                                                                                                                                    
{⋅                                                                                                                                                                                           
  public:                                                                                                                                                                                    
  PingMessage() {}                                                                                                                                                                           
  virtual void say() { printf("Ping\n"); }                                                                                                                                                   
};                                                                                                                                                                                           

class PongMessage: public MessageTmpl < 11, PongMessage >                                                                                                                                    
{⋅                                                                                                                                                                                           
  public:                                                                                                                                                                                    
  PongMessage() {}                                                                                                                                                                           
  virtual void say() { printf("Pong\n"); }                                                                                                                                                   
};                                                                                                                                                                                           

t_pfFactory MessageFactory::m_List[65536];                                                                                                                                                   

int main(int argc, char **argv)                                                                                                                                                              
{                                                                                                                                                                                            
  Message *msg1;                                                                                                                                                                             
  Message *msg2;                                                                                                                                                                             

  msg1 = MessageFactory::Create(10);                                                                                                                                                         
  msg1->say();                                                                                                                                                                               

  msg2 = MessageFactory::Create(11);                                                                                                                                                         
  msg2->say();                                                                                                                                                                               

  delete msg1;                                                                                                                                                                               
  delete msg2;                                                                                                                                                                               

  return 0;                                                                                                                                                                                  
}

Шаблон здесь работает, регистрируя в классе MessageFactory все новые классы сообщений (например, PingMessage и PongMessage), которые подкласс от MessageTmpl.

Это прекрасно работает и упрощает обслуживание кода, но у меня все еще есть некоторые вопросы по поводу этой техники:

  1. Это известная техника / шаблон? Как тебя зовут? Я хочу найти больше информации об этом.

  2. Я хочу создать массив для хранения новых конструкторов MessageFactory :: m_List [65536] std :: map, но при этом программа вызывает segfault даже до достижения main (). Создание массива из 65536 элементов является излишним, но я не нашел способ сделать этот динамический контейнер.

  3. Для всех классов сообщений, которые являются подклассами MessageTmpl, я должен реализовать конструктор Если нет, он не будет зарегистрирован в MessageFactory.

    Например, комментируя конструктор PongMessage: 

     class PongMessage: public MessageTmpl < 11, PongMessage >       
 {                                                                                                                                                                                           
   public:                                                                                                                                                                                    
    //PongMessage() {} /* HERE */                                                                                                                                                                          
    virtual void say() { printf("Pong\n"); }                   
 };

    приведет к тому, что класс PongMessage не будет зарегистрирован в MessageFactory и программа может вызвать ошибку в строке MessageFactory :: Create (11) . Вопрос
    почему класс не регистрируется? Нужно добавить пустую реализацию 100+ сообщения, которые мне нужны, кажутся неэффективными и ненужными.

Ответы [ 7 ]

7 голосов
/ 17 мая 2010

Ответ один

Общий метод получения такого класса - Любопытно повторяющийся шаблон (CRTP) : 

class PingMessage: public MessageTmpl < 10, PingMessage >

Ваш особый метод использования статической инициализации члена класса шаблона для регистрации подклассов этого класса (IMO) просто великолепен, и я никогда раньше такого не видел. Более распространенный подход, используемый средами модульного тестирования, такими как UnitTest ++ и Google Test , заключается в предоставлении макросов, объявляющих как класс, так и отдельную статическую переменную, инициализирующую этот класс.

Ответ два

Статические переменные инициализируются в указанном порядке. Если вы переместите объявление m_List до вызовов MessageFactory :: Register, вы должны быть в безопасности. Также имейте в виду, что если вы начнете объявлять подклассы Message более чем в одном файле, вам придется обернуть m_List как синглтон и проверять его инициализацию перед каждым использованием, из-за статического порядка инициализации C ++ fiasco .

Ответ три

Компиляторы C ++ будут создавать экземпляры только тех элементов шаблона, которые действительно используются. Статические члены шаблонных классов - это не та область C ++, которую я часто использовал, поэтому я могу ошибаться, но похоже, что предоставления конструктора достаточно, чтобы заставить компилятор думать, что используется MESSAGE_ID (таким образом гарантируя, что MessageFactory :: Регистр называется).

Это кажется мне не очень понятным, так что это может быть ошибка компилятора. (Я тестировал это в g ++ 4.3.2; мне любопытно узнать, как, например, Comeau C ++ справляется с этим.)

Достаточно явно создать экземпляр MESSAGE_ID, по крайней мере, в g ++ 4.3.2: 

template const uint16_t PingMessage::MESSAGE_ID;

Но это даже более ненужная работа, чем предоставление пустого конструктора по умолчанию.

Я не могу придумать хорошего решения, использующего ваш текущий подход; Лично у меня было бы желание переключиться на методику (такую ​​как макросы или использование скрипта для генерации части ваших исходных файлов), которая меньше полагалась на продвинутый C ++. (У сценария было бы дополнительное преимущество, заключающееся в упрощении обслуживания MESSAGE_ID.)

В ответ на ваши комментарии:

Синглетоны обычно , которых следует избегать, потому что они часто используются как плохо замаскированные глобальные переменные. Однако в некоторых случаях вам действительно нужна глобальная переменная, и одним из таких случаев является глобальный реестр доступных подклассов сообщений.

Да, предоставленный вами код инициализирует MESSAGE_ID, но я говорил о явном создании экземпляра каждого подкласса MESSAGE_ID. Явное создание экземпляра относится к указанию компилятору создавать экземпляр шаблона, даже если он считает, что этот экземпляр шаблона не будет использован в противном случае.

Я подозреваю, что статическая функция с энергозависимым присваиванием предназначена для того, чтобы обмануть или заставить компилятор сгенерировать присваивание MESSAGE_ID (чтобы обойти проблемы, которые я и dash-tom-bang указали при сбрасывании компилятора или компоновщика или создание экземпляра).

5 голосов
/ 18 мая 2010

Это модифицированная версия, которая использует синглтон MessageFactory и std :: map для хранения конструкторов. Пока он отлично работает, но комментарии приветствуются.

Я все еще пытаюсь найти способ избежать создания конструкторов для каждого класса сообщений. Я знаю, возможно, потому что оригинальная библиотека может сделать это. К сожалению, у меня есть только заголовочные файлы, так что я не знаю подробностей реализации. 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <inttypes.h>
#include <map>

class Message
{
   protected:
      Message() {};

   public:
      virtual ~Message() { }
      int getMessageType() const { return m_type; }
      virtual void say() = 0;

   protected:
      uint16_t m_type;
};

template<int TYPE, typename IMPL>
class MessageTmpl: public Message
{
   enum { _MESSAGE_ID = TYPE };
   public:
     static Message* Create() { return new IMPL(); }
     static const uint16_t MESSAGE_ID; // for registration
     static void Enable() { volatile uint16_t x = MESSAGE_ID; }
   protected:
      MessageTmpl() { m_type = MESSAGE_ID; } //use parameter to instanciate template
};

class MessageFactory 
{
   public:
     typedef Message* (*t_pfFactory)();

     static MessageFactory *getInstance()
     {
       static MessageFactory fact;
       return &fact;
     }

     uint16_t Register(uint16_t msgid, t_pfFactory factoryMethod)
     {
       printf("Registering constructor for msg id %d\n", msgid);
       m_List[msgid] = factoryMethod;
       return msgid;
     }

     Message *Create(uint16_t msgid)
     {
       return m_List[msgid]();
     }

     std::map<uint16_t, t_pfFactory> m_List;

  private:
     MessageFactory() {};
     MessageFactory(MessageFactory const&) {};
     MessageFactory& operator=(MessageFactory const&);
     ~MessageFactory() {};
};

//std::map<uint16_t, t_pfFactory> MessageFactory::m_List;

template <int TYPE, typename IMPL>
const uint16_t MessageTmpl<TYPE, IMPL>::MESSAGE_ID = MessageFactory::getInstance()->Register(
     MessageTmpl<TYPE, IMPL >::_MESSAGE_ID, &MessageTmpl<TYPE, IMPL >::Create);


class PingMessage: public MessageTmpl < 10, PingMessage >
{ 
  public:
  PingMessage() {}
  virtual void say() { printf("Ping\n"); }
};

class PongMessage: public MessageTmpl < 11, PongMessage >
{ 
  public:
  PongMessage() {}
  virtual void say() { printf("Pong\n"); }
};

int main(int argc, char **argv)
{
  Message *msg1;
  Message *msg2;

  msg1 = MessageFactory::getInstance()->Create(10);
  msg1->say();

  msg2 = MessageFactory::getInstance()->Create(11);
  msg2->say();

  delete msg1;
  delete msg2;

  return 0;
}
2 голосов
/ 17 мая 2010

Я думаю, что вы столкнулись с неопределенным поведением, потому что ваши регистрации могут произойти раньше, чем объект, в который вы хотите их вставить. Вы можете получить хорошие результаты, потому что пространство массива встроено в основной стек программы. Кто знает ...

Исправление, которое я использовал, - сделать функцию регистрации либо внешней, либо функцией-членом, чем статической. Затем используйте синглтон Meyers: 


MessageFactory * MessageFactory::instance()
{
  static MessageFactory fact;
  return &fact;
}

Таким образом, ваша фабрика сообщений будет создана при доступе любым другим способом и будет гарантированно доступна, когда вы попытаетесь ее использовать (потому что попытка использовать ее в первый раз создает ее).

1 голос
/ 24 октября 2011

Мне удалось заставить работать код Horacio без использования конструкторов в производных классах. Я вызвал функцию enable внутри функции say производных классов. 

class PingMessage: public MessageTmpl < 10, PingMessage >
{ 
  public:
  //PingMessage () {}
  virtual void say ()
  {
    enable ();  // virtual (not static) function of the template class
    printf ("Ping\n");
  }
};
0 голосов
/ 30 июня 2010

Для всех классов сообщений, которые являются подклассами MessageTmpl, я должен реализовать конструктор. Если нет, он не будет зарегистрирован в MessageFactory.

Я экспериментировал с этой идеей и придумал способ заставить создание экземпляра регистрационной переменной без необходимости создавать что-либо в производном классе. Создайте в шаблоне виртуальную функцию, которая обращается к переменной регистрации. Это заставляет создавать экземпляр функции, потому что виртуальная функция должна быть там, независимо от того, вызывается она или нет.

Вот мой рабочий код: 

#include <boost/array.hpp>
#include <iostream>

struct thingy
{
  virtual ~thingy() {}
  virtual void print_msg() const = 0;
  virtual size_t id() const = 0;

  bool registered_already() const { return registered; }
protected:
  bool registered;
};

struct holder
{
  enum index {
    ID_OPEN
  , ID_SAVE
  , ID_SAVEAS
  , COUNT
  };

  static holder& instance()
  {
    static holder inst;
    return inst;
  }

  thingy& operator[] (size_t i)
  {
    assert(thingys[i] && "Not registered.");
    return *thingys[i];
  }

  bool registered(size_t i) const { return thingys[i] != 0; }

  ~holder() { std::for_each(thingys.begin(), thingys.end(), [](thingy* t) { delete t; }); }

  index reg(thingy* t, index i)
  {
    assert( !thingys[i] && "Thingy registered at this ID already" );
    thingys[i] = t;
    return i;
  }

private:

  holder() : thingys() {}

  boost::array< thingy*, COUNT > thingys;
};

template < typename Derived, holder::index i >
struct registered_thingy : thingy
{
  size_t id() const { return registration; }
private:
  static holder::index registration;
};

template < typename T, holder::index i >
holder::index registered_thingy<T,i>::registration = holder::instance().reg(new T, i);

struct thingy1 : registered_thingy<thingy1,holder::ID_OPEN>
{
  void print_msg() const { std::cout << "thingy1\n"; }
};

struct thingy2 : registered_thingy<thingy2, holder::ID_SAVE>
{
  void print_msg() const { std::cout << "thingy2\n"; }
};

struct thingy3 : registered_thingy<thingy3, holder::ID_SAVEAS>
{
  void print_msg() const { std::cout << "thingy3\n"; }
};



int main()
{
  holder::instance()[holder::ID_OPEN].print_msg();

  std::cin.get();
}
0 голосов
/ 17 мая 2010

здесь слегка измененный список с использованием карты 

#include <map>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <inttypes.h>

//typedef Message *;
class MessageFactory {
 public:
    struct register_base {
        virtual int id() const = 0;
        virtual Message* new_() = 0;
    };
    template<class C>
    struct register_ : register_base {
        static const int ID;
        register_() : id_(ID)  {} // force ID initialization
        int id() const { return C::factory_key; }
        Message* new_() { return new C(); }
    private:
        const int id_;
    };
    static uint16_t Register(register_base* message) {
        printf("Registering constructor for msg id %d\n", message->id());
        m_List[message->id()] = message;
        return message->id();
    }
    static Message *Create(uint16_t msgid) {
        return m_List[msgid]->new_();
    }
    static std::map<int,register_base*> m_List;
};
std::map<int, MessageFactory::register_base*> MessageFactory::m_List;

template<class C>
const int MessageFactory::register_<C>::ID =
    MessageFactory::Register(new MessageFactory::register_<C>());


class Message {
public:
    virtual ~Message() {}
    int getMessageType() const {
        return m_type;
    }
    virtual void say() = 0;
protected:
    uint16_t m_type;
};

class PingMessage: public Message, private MessageFactory::register_<PingMessage> {
public:
    static const int factory_key = 10;
    PingMessage() { } // must call explicitly to register
    virtual void say() {
        printf("Ping\n");
    }
};

class PongMessage:public Message, private MessageFactory::register_<PongMessage> {
public:
    static const int factory_key = 11;
    PongMessage() { }
    void say() {
        printf("Pong\n");
        std::cout   << this->id() << std::endl;
    }
};



int main(int argc, char **argv)
{
    Message *msg1;
    Message *msg2;

    msg1 = MessageFactory::Create(10);
    msg1->say();

    msg2 = MessageFactory::Create(11);
    msg2->say();

    delete msg1;
}
0 голосов
/ 17 мая 2010

2: вы можете использовать динамический контейнер, но тогда вам также придется изменить способ регистрации и т. Д. Например, вы можете использовать карту с int в качестве ключа и указателем на функцию в качестве элемента: 

typedef Message* ( *NewMessageFun )();

template< class tMessage >
Message* NewMessage()
{
  return new tMessage();
};

class PingMessage : public MessageImpl
{
public:
  enum{ _MESSAGE_ID = 10 };
};

class PongMessage
{
public:
  enum{ _MESSAGE_ID = 11 };
}

//factory
std::map< int, NewMessageFun > mymap;
bool Register( const int type, NewMessageFun fun )
{
  if( mymap.contains( type ) )
    return false; //already registered!
  mymap[ type ] = fun;
  return true;
}

template< class tMessage >
bool RegisterAny() //shortcut
{
  return Register( tMessage::_MESSAGE_ID, NewMessage< tMessage > );
}
//

//main
factory.RegisterAny< PingMessage >();
factory.RegisterAny< PongMessage >();
//

Или, в своем текущем коде, просто используйте разумный размер выделения и проверьте границы выполнения, чтобы увидеть, что регистраций слишком много. И, возможно, предоставить метод «Отменить регистрацию».

...