面向對象的語言諸如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宏你會發現有一個操作是必須的：每個接口類都有一個虛析構函數。你可能認為這不重要，但是如果沒有這個就可能會導致一些問題，看看下面的例子：
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;
}
}
};
就像你看到的一樣，這里有一個類工廠，它根據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，你就會看到它實際的價值和意圖---這是對一個接口的實現，而不是簡單的一次繼承。