在用C++寫要導出類的庫時，我們經常只想暴露接口，而隱藏類的實現細節。也就是說我們提供的頭文件里只提供要暴露的公共成員函數的聲明，類的其他所有信息都不會在這個頭文件里面顯示出來。這個時候就要用到接口與實現分離的技術。

　　下面用一個最簡單的例子來說明。

 
　　 類ClxExp是我們要導出的類，其中有一個私有成員變量是ClxTest類的對象，各個文件內容如下：

　　lxTest.h文件內容：

class ClxTest 
{
public:
    ClxTest();
    virtual ~ClxTest();
 
    void DoSomething();
};

　　lxTest.cpp文件內容：

#include "lxTest.h"

#include <iostream>
using namespace std;

ClxTest::ClxTest()
{
}

ClxTest::~ClxTest()
{
}

void ClxTest::DoSomething()
{
    cout << "Do something in class ClxTest!" << endl;
}

///////////////////////////////////////////////////////////////////////////////

　　 lxExp.h文件內容：

#include "lxTest.h"

class ClxExp 
{
public:
    ClxExp();
    virtual ~ClxExp();

    void DoSomething();

private:
    ClxTest m_lxTest;

    void lxTest();
};

　　 lxExp.cpp文件內容：

#include "lxExp.h"

ClxExp::ClxExp()
{
}

ClxExp::~ClxExp()
{
}

//  其實該方法在這里并沒有必要，這樣只是為了說明調用關系
void ClxExp::lxTest()
{
    m_lxTest.DoSomething();
}

void ClxExp::DoSomething()
{
    lxTest();
}

　　為了讓用戶能使用我們的類ClxExp，我們必須提供lxExp.h文件，這樣類ClxExp的私有成員也暴露給用戶了。而且，僅僅提供lxExp.h文件是不夠的，因為lxExp.h文件include了lxTest.h文件，在這種情況下，我們還要提供lxTest.h文件。那樣ClxExp類的實現細節就全暴露給用戶了。另外，當我們對類ClxTest做了修改（如添加或刪除一些成員變量或方法）時，我們還要給用戶更新lxTest.h文件，而這個文件是跟接口無關的。如果類ClxExp里面有很多像m_lxTest那樣的對象的話，我們就要給用戶提供N個像lxTest.h那樣的頭文件，而且其中任何一個類有改動，我們都要給用戶更新頭文件。還有一點就是用戶在這種情況下必須進行重新編譯！上面是非常小的一個例子，重新編譯的時間可以忽略不計。但是，如果類ClxExp被用戶大量使用的話，那么在一個大項目中，重新編譯的時候我們就有時間可以去喝杯咖啡什么的了。當然上面的種種情況不是我們想看到的！你也可以想像一下用戶在自己程序不用改動的情況下要不停的更新頭文件和編譯時，他們心里會罵些什么。其實對用戶來說，他們只關心類ClxExp的接口DoSomething()方法。那我們怎么才能只暴露類ClxExp的DoSomething()方法而不又產生上面所說的那些問題呢？答案就是－－接口與實現的分離。我可以讓類ClxExp定義接口，而把實現放在另外一個類里面。下面是具體的方法：

　　首先，添加一個實現類ClxImplement來實現ClxExp的所有功能。注意：類ClxImplement有著跟類ClxExp一樣的公有成員函數，因為他們的接口要完全一致。

　　lxImplement.h文件內容：

#include "lxTest.h"

class ClxImplement 
{
public:
    ClxImplement();
    ~ClxImplement();

    void DoSomething();

private:
    ClxTest m_lxTest;

    void lxTest();
};

　　lxImplement.cpp文件內容：

#include "lxImplement.h"

ClxImplement::ClxImplement()
{
}

ClxImplement::~ClxImplement()

{
}

void ClxImplement::lxTest()
{
    m_lxTest.DoSomething();
}

void ClxImplement::DoSomething()
{
    lxTest();
}

　　然后，修改類ClxExp。

　　修改后的lxExp.h文件內容：

//  前置聲明
class ClxImplement;

class ClxExp 
{
public:
    ClxExp();
    virtual ~ClxExp();

 void DoSomething();

private:
    //  聲明一個類ClxImplement的指針，不需要知道類ClxImplement的定義
    ClxImplement *m_pImpl;
};

        修改后的lxExp.cpp文件內容：

//  在這里包含類ClxImplement的定義頭文件
#include "lxImplement.h"

ClxExp::ClxExp()
{
    m_pImpl = new ClxImplement;
}

ClxExp::~ClxExp()
{
    if (m_pImpl)
        delete m_pImpl;
}

void ClxExp::DoSomething()
{
    m_pImpl->DoSomething();
}

　　通過上面的方法就實現了類ClxExp的接口與實現的分離。請注意兩個文件中的注釋。類ClxExp里面聲明的只是接口而已，而真正的實現細節被隱藏到了類ClxImplement里面。為了能在類ClxExp中使用類ClxImplement而不include頭文件lxImplement.h，就必須有前置聲明class ClxImplement，而且只能使用指向類ClxImplement對象的指針，否則就不能通過編譯。在發布庫文件的時候，我們只需給用戶提供一個頭文件lxExp.h就行了，不會暴露類ClxExp的任何實現細節。而且我們對類ClxTest的任何改動，都不需要再給用戶更新頭文件（當然，庫文件是要更新的，但是這種情況下用戶也不用重新編譯！）。這樣做還有一個好處就是，可以在分析階段由系統分析員或者高級程序員來先把類的接口定義好，甚至可以把接口代碼寫好（例如上面修改后的lxExp.h文件和lxExp.cpp文件），而把類的具體實現交給其他程序員開發。

　　上文還沒有考慮到類與類之間的繼承關系。下面我們就來具體的談談這個方面。

　　還是以上面提到的那篇文章中的例子來說明。

　　執行類：

　　lxImplement.h文件內容：

#include "lxTest.h"

class ClxImplement 
{
public:
    ClxImplement();
    ~ClxImplement();

    void DoSomething();

private:
    ClxTest m_lxTest;

    void lxTest();
};

　　lxImplement.cpp文件內容：

#include "lxImplement.h"

ClxImplement::ClxImplement()
{
}

ClxImplement::~ClxImplement()
{
}

void ClxImplement::lxTest()
{
    m_lxTest.DoSomething();
}

void ClxImplement::DoSomething()
{
    lxTest();
}

　　接口類：

　　lxExp.h文件內容：

//  前置聲明
class ClxImplement;

class ClxExp 
{
public:
    ClxExp();
    virtual ~ClxExp();

 void DoSomething();

private:
    //  聲明一個類ClxImplement的指針，不需要知道類ClxImplement的定義
    ClxImplement *m_pImpl;
};

　　lxExp.cpp文件內容：

//  在這里包含類ClxImplement的定義頭文件
#include "lxImplement.h"

ClxExp::ClxExp()
{
    m_pImpl = new ClxImplement;
}

ClxExp::~ClxExp()
{
    if (m_pImpl)
        delete m_pImpl;
}

void ClxExp::DoSomething()
{
    m_pImpl->DoSomething();
}

　　但是，如果類ClxExp是另一個類的子類，而在類ClxExp中要調用基類的方法，那上面的方案就不行了。比如說，類ClxExp的基類是下面的樣子：

class ClxInF
{
public:
    ClxInF();
    virtual ~ClxInF();

    bool InitSet();

    virtual void DoSomething();
};

　　相應的類ClxExp的聲明變成了如下的形式：

class ClxExp : public ClxInF
{
public:
    ClxExp();
    virtual ~ClxExp();

    void DoSomething();

private:
    ClxImplement *m_pImpl;
};

　　現在，假設我們必須在類ClxExp的DoSomething()方法中根據InitSet()的返回值來確定是否執行操作。最簡單的實現方法是把類ClxExp的DoSomething()方法改成下面的樣子：

void ClxExp::DoSomething()
{
    if (InitSet())
        m_pImpl->DoSomething();
}

　　可是如果這樣的話，接口與實現就沒有徹底的分離，因為實現細節被暴露到了接口類中。為了避免這種情況發生，我們就必須把對基類ClxInF的方法InitSet()調用放到執行類ClxImplement當中。可是怎么在執行類ClxImplement當中調用接口類ClxExp的基類ClxInF的方法呢？其實很簡單，因為類ClxExp是類ClxInF的子類，那么它也就繼承了類ClxInF的方法，只要把類ClxExp的this指針傳給類ClxImplement，就可以通過這個指針來調用類ClxExp的方法，當然也可以調用類ClxExp從基類ClxInF繼承來的方法。下面是修改后的代碼：

　　lxImplement.h文件內容:

#include "lxTest.h"
// 包含聲明類ClxExp的頭文件
#include "lxExp.h"

class ClxImplement 
{
public:
    //  構造函數，傳入類的ClxExp的指針
    ClxImplement(ClxExp *plxExp);
    ~ClxImplement();

    void DoSomething();

private:
    ClxTest m_lxTest;
    //  定義一個類ClxExp的指針，可以通過該指針調用類ClxExp從基類繼承下來的方法
    ClxExp *m_plxExp;

    void lxTest();
};

　　lxImplement.cpp文件內容：

#include "lxImplement.h"

ClxImplement::ClxImplement(ClxExp *plxExp)
{
    m_plxExp = plxExp;
}

ClxImplement::~ClxImplement()
{
}

void ClxImplement::lxTest()
{
    m_lxTest.DoSomething();
}

void ClxImplement::DoSomething()
{
    if (m_plxExp->InitSet())
        lxTest();
}

　　對于類ClxExp來說，只要修改一下它的構造函數就行了，其他都不用修改。

ClxExp::ClxExp()
{
    m_pImpl = new ClxImplement(this);
}

　　這樣，我們就解決了前面所提到的問題。

　　當然，也許有人會說，讓類ClxImplement也從類ClxInF繼承不是更簡單嗎？那樣就可以在類ClxImplement中直接調用類ClxInF的方法，也不用添加什么代碼。可是我們知道公有繼承是的子類與基類是IS-A的關系。也就是說子類是一種基類，就像說轎車是一種汽車一樣。可是，在我們例子中，類ClxImplement只是類ClxExp的一個執行類而已，跟類ClxExp的基類ClxInF沒有一點兒關系，更不要說是一種ClxInF了。所以不能讓類ClxImplement從類ClxInF繼承。