*C++中使用介面

物件導向的語言諸如JAVA提供了Interface來實現介面，但C++卻沒有這樣一個東西，儘管C++ 通過純虛基類實現介面，譬如COM的C++實現就是通過純虛基類實現的（當然MFC的COM實現用了嵌套類），但我們更願意看到一個諸如 Interface的東西。下面就介紹一種解決辦法。

首先我們需要一些宏：//
// Interfaces.h
//

#define Interface class

#define DeclareInterface(name) Interface name { \
          public: \
          virtual ~name() {}

#define DeclareBasedInterface(name, base) class name :
        public base { \
           public: \
           virtual ~name() {}

#define EndInterface };

#define implements public

 有了這些宏，我們就可以這樣定義我們的介面了：//
// IBar.h
//

DeclareInterface(IBar)
   virtual int GetBarData() const = 0;
   virtual void SetBarData(int nData) = 0;
EndInterface

是不是很像MFC訊息映射那些宏啊，熟悉MFC的朋友一定不陌生。

現在我們可以像下面這樣來實現我們的介面了：//
// Foo.h
//

#include "BasicFoo.h"
#include "IBar.h"

class Foo : public BasicFoo, implements IBar
{
// Construction & Destruction
public:
   Foo(int x) : BasicFoo(x)
   {
   }

   ~Foo();

// IBar implementation
public:
   virtual int GetBarData() const
   {
      // add your code here
   }

   virtual void SetBarData(int nData)
   {
      // add your code here
   }
};

怎麼樣，很簡單吧，並不需要做很多的努力我們就可以在C++中使用介面了。然而，由於這並不是語言本身所直接支援的特性，所以我們需要遵循一些規則：
         a)   聲明一個類的時候，如果你的類除了要從介面類繼承外還要從另一個類繼承(結構上的繼承，即is a關係)，則把這個類作為第一個基類，就像我們平時做的一樣，譬如CFrameWnd從CWnd繼承，CBitmapButton從CButton繼承，CMyDialog從CDialong繼承。當你要從MFC類派生的時候，這尤其重要，把他們聲明為第一個基類以避免破壞MFC的RuntimeClass機制。
         b)   其他的基類緊跟其後，有多少就跟多少，如果你需要的話。譬如：class Foo : public BasicFoo, implements IBar, implements IOther, implements IWhatever, ...
         c)   介面類裡面不要聲明任何成員變數。介面類僅用於描述行為而不是資料。當你要作多重繼承時，這樣做可以避免資料成員被從同一個介面類多次繼承。
         d)   介面類的所有成員函數定義為純虛函數。這可以確保你的實作類別來實現這些函數的全部，當然你也可以在抽象類別實現部分函數，只要在你的衍生類別裡實現剩下的函數。
         e)   不要從除了介面類的其他任何類派生你的介面類。DeclareBasedInterface()可以做到這個.普通類可以選擇實現基底介面還是派生的介面，後面一種意味著兩者都要實現。
   f)  將一個指向實現介面的類的指標賦值給一個指向該介面類的指標是不需要強制類型轉換的，但反過來將一個介面類的指標賦值給一個實現該介面的類的指標就需要一個顯式的強制類型轉換。事實上我們可能會使用多重繼承，這樣這些轉換我們就不能使用老式的轉換。不過使用運行時類型資訊(使用/GR選項)和動態類型轉換可以很好的工作當然也更安全。
   g) 此外dynamic_cast為你提供了一種查詢一個對象或介面是否實現了一個指定的介面的途徑。
   h) 你還要非常小心的避免不同介面函數的命名衝突。

如果你仔細觀察DeclareInterface 和 DeclareBasedInterfaca宏你會發現有一個操作是必須的：每個介面類都有一個虛解構函式。你可能認為這不重要，但是如果沒有這個就可能會導致一些問題，看看下面的例子：就像你看到的一樣，這裡有一個類工廠，它根據BarType來建立一個IBar的實現，當你使用完以後你當然希望要delete該對象，你會像下面這樣做：

int main()
{
   IBar* pBar = BarFactory::CreateBar(Foo);

   pBar->SetName("MyFooBar");
   // Use pBar as much as you want,
   // 

   // and then just delete it when it's no longer needed
   delete pBar;    // Oops!
}

delete pBar 做了什麼取決於該對象是否有一個虛解構函式。如果Foo沒有一個虛解構函式，則只有IBar 的隱式的空解構函式被調用，Foo的解構函式不會被調用，這樣就發生了記憶體泄露。介面類裡虛解構函式的聲明避免了這用狀況，它確保每個實現介面的類都有一個虛解構函式。

當你使用DeclareInterfac的時候，記得使用EndInterface和它匹配。Interface 宏和 implements宏僅僅是代替了class和public，這看起來是多餘的，但我認為它們更明確的表達了代碼的意圖。如果我這麼寫：class Foo : public IBar，你可能認為這隻是一個簡單的繼承；但如果我這麼寫：class Foo: implements IBar，你就會看到它實際的價值和意圖---這是對一個介面的實現，而不是簡單的一次繼承。

DeclareInterface(IBar)
   virtual LPCTSTR GetName() const = 0;
   virtual void SetName(LPCTSTR name) = 0;
EndInterface

class Foo : implements IBar
{
// Internal data
private:
   char* m_pName;

// Construction & Destruction
public:
   Foo()
   {
      m_pName = NULL;
   }

   ~Foo()
   {
      ReleaseName();
   }

// Helpers
protected:
   void ReleaseName()
   {

      if (m_pName != NULL)
         free(m_pName);
   }

// IBar implementation
public:
   virtual const char* GetName() const
   {
      return m_pName
   }

   virtual void SetName(const char* name)
   {
      ReleaseName();
      m_pName = _strdup(name);
   }
};

class BarFactory
{
public:
   enum BarType {Faa, Fee, Fii, Foo, Fuu};

   static IBar CreateNewBar(BarType barType)
   {
      switch (barType)
      {
         default:
         case Faa:
            return new Faa;
         case Fee:
            return new Fee;
         case Fii:
            return new Fii;
         case Foo:
            return new Foo;
         case Fuu:
            return new Fuu;
      }
   }
};