Refactorización de una clase

Question

Tengo dos clases casi idénticas, de hecho, cada función miembro es idéntica, cada miembro es idéntico, cada función miembro hace exactamente lo mismo. La única diferencia entre estas clases es la manera de que pueda definir la variable de su tipo:

AllocFactorScientific<102,-2> scientific; 
AllocFactorLinear<1.2> linear; 

Aquí están encabezados por ellos:

template<double&& Factor> 
struct AllocFactorLinear; 

template<short Mantissa, short Exponent, short Base = 10> 
struct AllocFactorScientific 

Mi pregunta es ¿cómo puedo refactorizar las funciones de esas clases eso me permitiría tener solo un conjunto de funciones y no dos conjuntos de funciones idénticas.

Answer 1

extraer todo el comportamiento común en una tercera clase (estoy omitiendo los argumentos de plantilla en mi respuesta en aras de la claridad):

class CommonImpl 
{ 
public: 
    void doSomething() {/* ... */ } 
}; 

entonces veo dos opciones (que son, desde mi punto de vista al menos, más o menos equivalente):

• Hacer AllocFactorLinear y AllocFactorScientific hereda privada de esta clase, y llevar las funciones miembro que desea exponer en su alcance con un using directivas:

  class AllocFactorLinear : CommonImpl 
  { 
  public: 
      using CommonImpl::doSomething; 
  }; 
  

• agregado la clase de implementación en AllocFactorLinear y AllocFactorScientific y desviar todas las llamadas a la puesta en práctica privada:

  class AllocFactorLinear 
  { 
  public: 
      void doSomething() { impl_.doSomething(); } 
  private: 
      CommonImpl impl_; 
  }; 
  

me iría personalmente por la primera solución.

Answer 2

Quizás intente crear alguna clase base con estas funciones y haga esto 2 clases con plantillas sobre la herencia de esta clase base.

Answer 3

¿Por qué usa una clase de plantilla para esto? ¿No pudiste usar una clase no listada con 2 constructores diferentes?

Answer 4

creo que sería algo así como:

template <typename Type> 
struct AllocFactor {...}; 

y entonces puede tener Type, por ejemplo:

template <double&& Factor> 
struct LinearConfig 
{ 
    static double value() { return Factor;} 
}; 

y:

template <short Mantissa, short Exponent, short Base = 10> 
struct FactorScientificConfig 
{ 
    static double value() 
    { 
     return some_expression_to_get_factor; 
    } 
}; 

puede crear el AllocFactor usando AllocFactor<LinearConfig<1.2>> y el correspondiente con el FactorScientificConfig. Luego puede usar la función de miembro estático para devolver el valor calculado para ambas clases, de modo que AllocFactor<T> pueda usar T::value() como el valor informado por la clase config.