C++的靜態多型

class Foo : public Base<Foo>
{
};

在上例中，類別Foo繼承自類別Base，類別Base有一個Template參數，而在此例中是以類別Foo作為參數傳入。以上這個宣告是合法的，根據C++的標準規格，當類別Foo宣告之後，Foo這個名字就算是已被定義了，所以能夠立即被拿來餵給類別Base作為參數使用。

template<class T>
class B
{
public:
  void sayHello()
  {
    T* pThis = static_cast<T*>(this);
    pThis->hello();
  }

  // 可被子類別覆寫(overridable)
  void hello()
  {
    cout << "B::hello" << endl;
  }
};

class D1 : public B<D1>
{
};

class D2 : public B<D2>
{
public:
  void hello()
  {
    cout << "D2::hello" << endl;
  }
};

int main()
{
  D1 d1;
  D2 d2;

  d1.sayHello(); // 印出 "B::hello"
  d2.sayHello(); // 印出 "D2::hello"

  return 0;
}

在上面的範例中我們宣告了一個類別B，還有二個繼承類別B的類別D1和類別D2。類別D1和類別D2以上面所提到的方式，以自己為參數繼承template類別B。類別B中有個sayHello公開函式，它會呼叫一個叫作hello的函式。hello函式在類別B中有一個預設的實作，會在畫面上列印出"B::hello"的文字訊息，而這個函式hello可以被子類別所覆寫。如果子類別有覆寫hello函式實作自己的版本，則在呼叫sayHello時子類別的實作就會被呼叫到，否則就會呼叫到預設的類別B的版本。

這裡使用到的關鍵技巧就在於static_cast<T*>(this)這一行的地方。

它把this指標轉型成參數T所指的型別。在這個例子中，參數T不是類別D1就是類別D2，而類別D1或類別D2都是類別B的子類別，所以這樣的轉型是合法且安全的。透過pThis指標來呼叫到的hello實作品會根據參數T的型別而定，如果參數T有一個自己的hello實作，則這個hello實作就會被呼叫，若沒有則會呼叫到類別B自己的hello實作。因為這裡面使用到泛型程式設計，所以這個動作是在編譯時期決定的。而這樣的行為和執行時期的多型非常類似，因為是在編譯時期決定，是靜態的，所以我們才會稱它作靜態多型。

但是如果參數T是有問題的參數呢？比如說在此例中我們不是傳入類別D1或類別D2呢？假如是這樣子的話，會有底下二種可能的情況發生。

1.傳入的參數T類別正好有個叫作hello函式，所以沒問題編譯可以過，只不過類別的行為是不是會變得異常就不得而知了。

2.傳入的參數T類別本身找不到一個叫作hello的函式(包含類別T的基礎類別)，這時候編譯器就會直接告訴你一個找不到hello的定義的錯誤因而編譯失敗。所以這不構成什麼問題。

繼續回到原來的範例。類別D1只單純繼承類別B而沒有覆寫hello，所以物件d1在呼叫sayHello時會呼叫到類別B的hello，因此畫面上打印出"B::hello"文字訊息。而類別D2有自己的hello實作，所以物件d2在呼叫sayHello時就會呼叫到自己的hello函式，因此畫面上打印出"D2::hello"文字訊息。

使用靜態多型的技術(或把它叫作技巧)有以下幾個好處。

1.類別就不再需要額外的vtbl了，因為沒有任何虛擬函式。而因為不是執行期多型，所以呼叫更快，類別體積也較小。

2.在執行時期不可能透過一個null指標去呼叫靜態"虛擬函式"，因為指標都是有效的this指標轉型而來的。

3.所有的呼叫都是在編譯時期決定，所以編譯器有更多機會作最佳化。