天天看點
傳回

C++接口工程實踐：有哪些實作方法？

C++接口工程實踐：有哪些實作方法？

一 接口的分類

接口按照功能劃分可以分為調用接口與回調接口：

調用接口

一段代碼、一個子產品、一個程式庫、一個服務等（後面都稱為系統），對外提供什麼功能，以接口的形式暴露出來，使用者隻需要關心接口怎麼調用，不用關心具體的實作，即可使用這些功能。這類被使用者調用的接口，稱為調用接口。

調用接口的主要作用是解耦，對使用者隐藏實作，使用者隻需要關心接口的形式，不用關心具體的實作，隻要保持接口的相容性，實作上的修改或者更新對使用者無感覺。解耦之後也友善多人合作開發，設計好接口之後，各子產品隻通過接口進行互動，各自完成各自的子產品即可。

回調接口

系統定義接口，由使用者實作，注冊到系統中，系統有異步事件需要通知使用者時，回調使用者注冊的接口實作。系統定義接口的形式，但無需關心接口的實作，而是接受使用者的注冊，并在适當的時機調用。這類由系統定義，使用者實作，被系統調用的接口，稱為回調接口。

回調接口的主要作用是異步通知，系統定義好通知的接口，并在适當的時機發出通知，使用者接收通知，并執行相應的動作，使用者動作執行完後控制權交還給系統，使用者動作可以給系統傳回一些資料，以決定系統後續的行為。

二 調用接口

我們以一個Network接口為例，說明C++中的調用接口的定義及實作，示例如下：

class Network
{
public:
    bool send(const char* host, 
              uint16_t port, 
              const std::string& message);
}

Network接口現在隻需要一個send接口，可以向指定位址發送消息。下面我們用不同的方法來定義Network接口。

虛函數

虛函數是定義C++接口最直接的方式，使用虛函數定義Network接口類如下：

class Network
{
public:
    virtual bool send(const char* host, 
                      uint16_t port, 
                      const std::string& message) = 0;

    static Network* New();

    static void Delete(Network* network);
}

将send定義為純虛函數，讓子類去實作，子類不對外暴露，提供靜态方法New來建立子類對象，并以父類Network的指針形式傳回。接口的設計一般遵循對象在哪建立就在哪銷毀的原則，是以提供靜态的Delete方法來銷毀對象。因為對象的銷毀封裝在接口内部，是以Network接口類可以不用虛析構函數。

使用虛函數定義接口簡單直接，但是有很多弊端：

  • 虛函數開銷：虛函數調用需要使用虛函數表指針間接調用，運作時才能決定調用哪個函數，無法在編譯連結期間内聯優化。實際上調用接口在編譯期間就能确定調用哪個函數，無需虛函數的動态特性。
  • 二進制相容：由于虛函數是按照索引查詢虛函數表來調用，增加虛函數會造成索引變化，新接口不能在二進制層面相容老接口，而且由于使用者可能繼承了Network接口類，在末尾增加虛函數也有風險，是以虛函數接口一經釋出，難以修改。

指向實作的指針

指向實作的指針是C++比較推薦的定義接口的方式，使用指向實作的指針定義Network接口類如下：

class NetworkImpl;
class Network
{
public:
    bool send(const char* host, 
              uint16_t port, 
              const std::string& message);

    Network();

    ~Network();

private:
    NetworkImpl* impl;
}

Network的實作通過impl指針轉發給NetworkImpl，NetworkImpl使用前置聲明，實作對使用者隐藏。使用指向實作的指針的方式定義接口，接口類對象的建立和銷毀可以由使用者負責，是以使用者可以選擇将Network類的對象建立在棧上，生命周期自動管理。

使用指向實作的指針定義接口具有良好的通用性，使用者能夠直接建立和銷毀接口對象，并且增加新的接口函數不影響二進制相容性，便于系統的演進。

指向實作的指針增加了一層調用，盡管對性能的影響幾乎可以忽略不計，但不太符合C++的零開銷原則，那麼問題來了，C++能否實作零開銷的接口呢？當然可以，即下面要介紹的隐藏的子類。

隐藏的子類

隐藏的子類可以實作零開銷的接口，思想非常簡單。調用接口要實作的目标是解耦，主要就是隐藏實作，也即隐藏接口類的成員變量，如果能将接口類的成員變量都移到另一個隐藏的實作類中，接口類就不需要任何成員變量，也就實作了隐藏實作的目的。隐藏的子類就是這個隐藏的實作類，使用隐藏的子類定義Network接口類如下：

class Network
{
public:
    bool send(const char* host, 
              uint16_t port, 
              const std::string& message);

    static Network* New();

    static void Delete(Network* network);

protected:
    Network();

    ~Network();
}

Network接口類隻有成員函數（非虛函數），沒有成員變量，并且構造函數和析構函數都申明為protected。提供靜态方法New建立對象，靜态方法Delete銷毀對象。New方法的實作中建立隐藏的子類NetworkImpl的對象，并以父類Network指針的形式傳回。NetworkImpl類中存放Network類的成員變量，并将Network類聲明為friend：

class NetworkImpl : public Network
{
    friend class Network;

private:
    //Network類的成員變量
}

Network的實作中，建立隐藏的子類NetworkImpl的對象，并以父類Network指針的形式傳回，通過将this強制轉換為NetworkImpl的指針，通路成員變量：

bool Network::send(const char* host, 
                   uint16_t port, 
                   const std::string& message)
{
    NetworkImpl* impl = (NetworkImpl*)this;
    //通過impl通路成員變量，實作Network
}

static Network* New()
{
    return new NetworkImpl();
}

static void Delete(Network* network)
{
    delete (NetworkImpl*)network;
}

使用隐藏的子類定義接口同樣具有良好的通用性和二進制相容性，同時沒有增加任何開銷，符合C++的零開銷原則。

三 回調接口

同樣以Network接口為例，說明C++中的回調接口的定義及實作，示例如下：

class Network
{
public:
    class Listener
    {
    public:
        void onReceive(const std::string& message);
    }

    bool send(const char* host, 
              uint16_t port, 
              const std::string& message);

    void registerListener(Listener* listener);
}

現在Network需要增加接收消息的功能，增加Listener接口類，由使用者實作，并注冊其對象到Network中後，當有消息到達時，回調Listener的onReceive方法。

使用虛函數定義Network接口類如下：

class Network
{
public:
    class Listener
    {
    public:
        virtual void onReceive(const std::string& message) = 0;
    }

    bool send(const char* host, 
              uint16_t port, 
              const std::string& message);

    void registerListener(Listener* listener);
}

将onReceive定義為純虛函數，由使用者繼承實作，由于多态的存在，回調的是實作類的方法。

使用虛函數定義回調接口簡單直接，但同樣存在和調用接口中使用虛函數同樣的弊端：虛函數調用開銷，二進制相容性差。

函數指針

函數指針是C語言的方式，使用函數指針定義Network接口類如下：

class Network
{
public:
    typedef void (*OnReceive)(const std::string& message, void* arg);

    bool send(const char* host, 
              uint16_t port, 
              const std::string& message);

    void registerListener(OnReceive listener, void* arg);
}

使用函數指針定義C++回調接口簡單高效，但隻适用于回調接口中隻有一個回調函數的情形，如果Listener接口類中要增加onConnect，onDisconnect等回調方法，單個函數指針無法實作。另外函數指針不太符合面向對象的思想，可以換成下面要介紹的std::function。

std::function

std::function提供對可調用對象的抽象，可封裝簽名相符的任意的可調用對象。使用std::function定義Network接口類如下：

class Network
{
public:
    typedef std::function<void(const std::string& message)> OnReceive;

    bool send(const char* host, 
              uint16_t port, 
              const std::string& message);

    void registerListener(const OnReceive& listener);
}

std::function可以很好的取代函數指針，配合std::bind，具有很好的通用性，因而被廣受推崇。但std::function同樣隻适用于回調接口中隻有一個回調方法的情形。另外，std::function比較重量級，使用上面的便利卻會帶來了性能上的損失，有人做過性能對比測試，std::function大概比普通函數慢6倍以上，比虛函數還慢。

類成員函數指針

類成員函數指針的使用比較靈活，使用類成員函數指針定義Network接口類如下：

class Network
{
public:
    class Listener
    {
    public:
        void onReceive(const std::string& message);
    }

    typedef void (Listener::* OnReceive)(const std::string& message);

    bool send(const char* host, 
              uint16_t port, 
              const std::string& message);

    void registerListener(Listener* listener, OnReceive method);

    template<typename Class>
    void registerListener(Class* listener, 
         void (Class::* method)(const std::string& message)
    {
        registerListener((Listener*)listener, (OnReceive)method);
    }
}

因為類成員函數指針必須和類對象一起使用，是以Network的注冊接口需要同時提供對象指針和成員函數指針，registerListener模闆函數可注冊任意類的對象和相應符合簽名的方法，無需繼承Listener，與接口類解耦。

使用類成員函數指針定義C++回調接口靈活高效，可實作與接口類解耦，并且不破壞面向對象特性，可很好的取代傳統的函數指針的方式。

類成員函數指針同樣隻适用于回調接口中隻有一個回調方法的情形，如果有多個回調方法，需要針對每一個回調方法提供一個類成員函數指針。那麼有沒有方法既能實作與接口類解耦，又能适用于多個回調方法的場景呢？參考下面介紹的非侵入式接口。

四 非侵入式接口

Rust中的Trait功能非常強大，可以在類外面，不修改類代碼，實作一個Trait，那麼C++能否實作Rust的Trait的功能呢？還是以Network接口為例，假設現在Network發送需要考慮序列化，重新設計Network接口，示例如下：

定義Serializable接口：

class Serializable
{
public:
    virtual void serialize(std::string& buffer) const = 0;
};

Network接口示例：

class Network
{
public:
    bool send(const char* host, 
              uint16_t port, 
              const Serializable& s);
}

Serializable接口相當于Rust中的Trait，現在一切實作了Serializable接口的類的對象均可以通過Network接口發送。那麼問題來了，能否在不修改類的定義的同時，實作Serializable接口呢？假如我們要通過Network發送int類型的資料，能否做到呢？答案是肯定的：

1. class IntSerializable : public Serializable
{
public:
    IntSerializable(const int* i) :
        intThis(i)
    {

    }

    IntSerializable(const int& i) :
        intThis(&i)
    {

    }

    virtual void serialize(std::string& buffer) const override 
    {
        buffer += std::to_string(*intThis);
    }

private:
    const int* const intThis;
};

有了實作了Serializable接口的IntSerializable，就可以實作通過Network發送int類型的資料了：

Network* network = Network::New();
int i = 1;
network->send(ip, port, IntSerializable(i));

Rust編譯器通過impl關鍵字記錄了每個類實作了哪些Trait，是以在指派時編譯器可以自動實作将對象轉換為相應的Trait類型，但C++編譯器并沒有記錄這些轉換資訊，需要手動轉換類型。

非侵入式接口讓類和接口區分開來，類中的資料隻有成員變量，不包含虛函數表指針，類不會因為實作了N個接口而引入N個虛函數表指針；而接口中隻有虛函數表指針，不包含資料成員，類和接口之間通過實作類進行類型轉換，實作類充當了類與接口之間的橋梁。類隻有在充當接口用的時候才會引入虛函數表指針，不充當接口用的時候沒有虛函數表指針，更符合C++的零開銷原則。

rust 編譯器 c語言 c++ 索引 r語言索引 編譯器彙編語言 編譯器程式設計語言 effective c++使用編譯器 c++語言基礎指針const
上一篇: 用 NetworkX + Gephi + Nebula Graph 分析&lt;權力的遊戲&gt;人物關系（下篇）
下一篇: DDH叢集運維管理最佳實踐

繼續閱讀