爲家庭子類

Question

鑑於傳統代碼的覆蓋方法，該系統具有的類層次結構如下：

  Base 
     ^
      | 
----------+--------------- 
^ ^ ^ ^ ^
|  |  |  |  | 
A1  B1 C1 D1 E1 
^ ^ ^ ^ ^
|  |  |  |  | 
A2  B2 C2 D2 E2 
....... 
^ ^ ^ ^ ^
|  |  |  |  | 
An  Bn Cn Dn En 

層次結構表示在某些特定域的消息。

基地類當然是所有消息的基類。 A1..E1是屬於版本1的域的消息，A2..E2到版本2等等。請注意，An必須直接從An-1繼承，因爲An覆蓋了An-1的特定方法。

所有消息都有一些共同的功能，所以它被定義爲Base :: PerformFunctionality。功能的某些部分僅限於版本n，所以存在虛擬功能Base :: SpecificPartOfFunctionality，其被Base :: PerformFunctionality調用。

所以我的問題是如何覆蓋所有An..En的Base :: SpecificPartOfFunctionality。

我看到2個可能的解決方案，我不喜歡太：

1. 實施基地::每個SpecificPartOfFunctionality和每個An..En。

   該解決方案的問題是，對於每個類的實現應該是完全相同，所以我只是重複該代碼。

   其他問題是，如果引入了新類Fn，開發人員可能會忘記執行SpecificPartOfFunctionality。

2. 從基地介紹BASEN類導出，而每個從An..En BASEN太導出：

   class BaseN : public Base { 
       //... 
       SpecificPartOfFunctionality() { ...} 
   }; 
   
   class An: public An-1, public BaseN { .. } 
   

   這種解決方案的問題是，它引入了金剛石問題。

   另外一個問題是會發生什麼，如果其他一些版本米需要重寫基地:: SpecificPartOfFunctionality了。繼解決方案後，我們將介紹BaseM，這將覆蓋Base :: SpecificPartOfFunctionality。所以哪個SpecificPartOfFunctionality將要求 - 的基本N或基本N。這是完全混亂。

有什麼建議嗎？

Answer 1

struct Base { 
    virtual void PerformFunctionality() { 
    stuff(); 
    SpecificPartOfFunctionality(); 
    more_stuff(); 
    } 
private: 
    virtual void SpecificPartOfFunctionality() {} 
}; 

template<class Prev> 
struct Version3 : Prev { 
protected: // Not private if v4's override might need to call this. 
    virtual void SpecificPartOfFunctionality() { 
    v3_specific_stuff(); 
    } 
}; 

struct A1 : Base {}; 
struct A2 : A1 {}; 
struct A3 : Version3<A2> {}; 

struct B1 : Base {}; 
struct B2 : B1 {}; 
struct B3 : Version3<B2> {}; 

唯一的缺點是你不能輕易向前當前的C++構造，並可能將永遠使用默認的構造函數A2和B2只是爲了簡單起見。

在C++ 0x中，但是，您可以轉發構造函數：

template<class Prev> 
struct Version3 : Prev { 
    using Prev::Prev; 
    //... 
}; 

struct C2 : C1 { 
    C2(int); // No default constructor. 
}; 
struct C3 : Version3<C2> { 
    C3() : Version3<C2>(42) {} 
}; 

---

請注意，必須直接從-1繼承，由於覆蓋的-1的具體方法。

你誤會了一些東西。 An不需要從An-1直接繼承。例如，這工作得很好：

struct Example { 
    virtual void f(); 
}; 

template<class B> 
struct Intermediate : B {}; 

struct Concrete : Intermediate<Example> { 
    virtual void f(); // Overrides Example::f. 
}; 

請記住，如果這個沒有的工作，那麼你的無法從你的基類擺在首位覆蓋SpecificPartOfFunctionality！在您的任何示例中，An不會直接從Base繼承。

Answer 2

在全局範圍內定義一個實現該功能的朋友函數，並且只需調用它即可。例如。

void FunctionalityN(Base* b) 
{ 
    b->DoThings(); 
    ... 
} 

class An : public Base 
{ 
    friend void FunctionalityN(); 
    virtual void SpecificPartOfFunctionality() { FunctionalityN(this); } 
    .... 
}; 

嚴格來說FunctionalityN甚至不需要成爲朋友，儘管它會讓事情變得簡單。這使得直接延伸到Fn，Gn等，並且隨後用NewFunctionalityN替代FunctionalityN也很容易。