C Virtual Template Method

Em C , pode ser um desafio combinar polimorfismo de tempo estático (modelos) com polimorfismo de tempo de execução. Isso fica evidente na seguinte classe abstrata:

class AbstractComputation {
    public:
        template  virtual void setData(std::string id, T data);
        template  virtual T getData(std::string id);
};

Esta classe tem como objetivo definir e recuperar dados de um tipo especificado com base em um identificador exclusivo. No entanto, surge um problema ao tentar chamar a função genérica setData com um tipo específico, como setData("foodouble", data).

A linguagem proíbe esta construção porque o compilador teria que dinamicamente despachar um número infinito de possíveis instanciações de modelo. Para resolver esse problema, várias abordagens são possíveis:

Removendo o polimorfismo estático:

• Elimine o polimorfismo estático introduzindo um tipo separado para armazenar o valor-chave mapeamentos. O modelo pode então resolver isso no nível básico, sem a necessidade de polimorfismo:

class AbstractComputation {
public:
   template 
   void setData( std::string const & id, T value ) {
      m_store.setData( id, value );
   }
   template 
   T getData( std::string const & id ) const {
      return m_store.getData( id );
   }
protected:
   ValueStore m_store;
};

Removendo o polimorfismo dinâmico:

• Retenha o polimorfismo de tempo de execução, mas elimine o polimorfismo estático por tipo de apagamento:
• Utilize boost::any, que fornece apagamento de tipo, para armazenar dados de qualquer tipo:

class AbstractComputation {
public:
   template 
   void setData( std::string const & id, T value ) {
      setDataImpl( id, boost::any( value ) );
   }
   template 
   T getData( std::string const & id ) const {
      boost::any res = getDataImpl( id );
      return boost::any_cast( res );
   }
protected:
   virtual void setDataImpl( std::string const & id, boost::any const & value ) = 0;
   virtual boost::any getDataImpl( std::string const & id ) const = 0;
};