Refactoring einer Klasse

Question

Ich habe zwei fast identische Klassen, in der Tat ist jede Member-Funktion identisch, jedes Mitglied ist identisch, jede Member-Funktion macht genau das gleiche. Der einzige Unterschied zwischen diesen Klassen ist die Art, wie ich Variable ihrer Art definieren:

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

Hier sind Header für sie:

template<double&& Factor> 
struct AllocFactorLinear; 

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

Meine Frage ist, wie kann ich diese Funktionen aus diesen Klassen Refactoring das würde mir erlauben, nur einen Satz von Funktionen und nicht zwei Sätze von identischen Funktionen zu haben.

Answer 1

Extrahieren Sie die alle gängigen Verhalten in einer dritten Klasse (Ich bin aus Gründen der Klarheit die Vorlage Argumente in meiner Antwort Weglassen):

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

Ich sehe zwei Möglichkeiten dann (was von meinem Punkt sind zumindest aus Sicht, das entspricht ziemlich genau):

• Make AllocFactorLinear und AllocFactorScientific vererben privat aus dieser Klasse, und bringen die Mitgliederfunktionen Sie mit einer 0 in Umfang aussetzen möchtenRichtlinien:

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

• Aggregate die Implementierungsklasse in AllocFactorLinear und AllocFactorScientific und leitet alle Anrufe an die privaten Umsetzung:

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

ich persönlich für die erste Lösung gehen würde.

Answer 2

Vielleicht versuchen Sie mit der Erstellung einiger Basisklasse mit diesen Funktionen und tun dies 2 Klassen mit Vorlagen zur Vererbung dieser Basisklasse.

Answer 3

Warum verwenden Sie eine Vorlagenklasse? Könnten Sie nicht eine untemplated Klasse mit 2 verschiedenen Konstruktoren verwenden?

Answer 4

denke ich, es so etwas wie wäre:

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

und dann können Sie Type zum Beispiel haben:

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

und:

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

Sie können die AllocFactor erstellen mit AllocFactor<LinearConfig<1.2>> und die entsprechende mit der FactorScientificConfig. Anschließend können Sie die statische Elementfunktion verwenden, um den für beide Klassen berechneten Wert zurückzugeben, sodass AllocFactor<T>T::value() als den Wert verwenden kann, der von der Config-Klasse gemeldet wird.