Вопросы Теги

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

При реализации класса MessageFactory к instatiate Объектам сообщения я использовал что-то как:

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

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

После некоторого исследования я нашел способ динамично обновить 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] станд.:: карта, но выполнение так вызывает программу к segfault даже прежде, чем достигнуть основной (). Создание массива 65 536 элементов является излишеством, но я не нашел способ сделать это динамическим контейнером.

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

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

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

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

11
задан Horacio 17 May 2010 в 15:09
поделиться

6 ответов

Ответ один

Общая техника создания такого класса - это Curiously Recurring Template Pattern (CRTP):

class PingMessage: public MessageTmpl < 10, PingMessage >

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

Ответ второй

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

Ответ третий

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

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

Явного инстанцирования MESSAGE_ID также достаточно, по крайней мере, в g++ 4.3.2:

template const uint16_t PingMessage::MESSAGE_ID;

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

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

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

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

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

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

8
ответ дан 3 December 2019 в 07:36
поделиться

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 >();
//

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

0
ответ дан 3 December 2019 в 07:36
поделиться

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

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


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

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

2
ответ дан 3 December 2019 в 07:36
поделиться

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

#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
ответ дан 3 December 2019 в 07:36
поделиться

Это модифицированная версия, которая использует синглтон 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;
}
5
ответ дан 3 December 2019 в 07:36
поделиться

Для всех классов сообщений, которые являются подклассами 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
ответ дан 3 December 2019 в 07:36
поделиться
Другие вопросы по тегам:

Похожие вопросы: