C++ 接口

大家好.由於七七八八的原因給耽擱了,好久好久沒更新BLOG了.

現在繼續更新我的閱讀C++沉思錄的筆記.

本篇博文是我閱讀沉思錄第16章的筆記.在這篇博文中,主要講了C++中接口的技術.

問題的提出:

　　總所周知,JAVA和C#都有很簡單的接口機制.其實現是通過了關鍵字interface來實現,也即類似下列代碼

 

public interface Test {
    public String getStr();
}

　　這個方式是聲明了一個接口類.然后由代碼實現這個接口.

       不過本文說的接口和此接口不相同.JAVA的這種接口可以由C++的純虛函數來實現.本文說的是基於模板的接口函數的技術.

       一個簡單的問題:

               對一個數組進行求和.返回結果.

       自然而然,我們會編寫一個函數叫sum.由於我們已經知道數組長度,數組類型,我們寫出的代碼很可能就是這個樣子.

#include <iostream>
using namespace std;

//sum v1
int sum(int *array,int num)
{
   int result = 0;
   for(int i = 0; i != num;++i)
    result += array[i];
   return result;
}

int main()
{
   int *d = new int[10];
   for(int i = 0;i!=10;++i)
    d[i] = i + 1;
   cout << sum(d,10) << endl;
}

　　這個函數沒有任何錯誤,工作的也很好.不過,要是這時候要求對一個double型的數組累加呢?不可能再寫一遍一模一樣只是類型不同的函數吧?

　　顯然我們要做的就是進行模板化.利用模板來實現累加任何類型.

　　不過在此之前,還有一個問題,這里限定了其存儲方式必須是數組.而實際上,我們的sum的要求僅僅只有兩個.

　　1.可以進行遍歷,獲取值

　　2.知道何時結束.

　　而迭代器(Iterator)完全就可以符合這兩樣的要求.(Iterator之前沒講,我會盡快補上)

       這個迭代器的要就是訪問下一個,判斷何時結束.因此,我們的第二個版本sum,也就是比較通用的版本就出來了.

　

#include <iostream>

using namespace std;

template<class T>
class Iterator {
public:
    Iterator(T*,int);
    bool validate()const;
    T next();
private:
    T *data;
    int len;
};

template<class T>
Iterator<T>::Iterator(T *d,int l)
    :data(d),len(l)
{

}

template<class T>
bool Iterator<T>::validate() const
{
    return len > 0;
}

template<class T>
T Iterator<T>::next()
{
    --len;
    return *data++;
}

template<class T>
T sum(Iterator<T> ite)
{
    T t = 0;
    while(ite.validate())
        t += ite.next();
    return t;
}

int main()
{
    int *d = new int[10];
    for(int i = 0;i!=10;++i)
        d[i] = i;
    cout << sum(Iterator<int>(d,10)) << endl;
    return 0;
}

 　　不過問題又來了,我們的Iterator其實就是一個數組指針的變形.如果要為此再提供鏈表迭代器,那我們目前的就不符合了.因此,我們利用繼承的技術,對迭代器進行了抽象.

　　通過將Iterator設為純虛函數,然后繼承實現對於數組和鏈表的迭代器.代碼如下(只有數組,鏈表的同理可以實現)

#include <iostream>

using namespace std;

template<class T>
class Iterator
{
public:
    virtual bool validate()const = 0;
    virtual T next() = 0;
};

template<class T>
class Array_Iterator : public Iterator<T>
{
public:
    Array_Iterator(T *d,int);
    bool validate() const;
    T next();
private:
    T *data;
    int len;
};

template<class T>
Array_Iterator<T>::Array_Iterator(T *d,int l)
    :data(d),len(l)
{}

template<class T>
bool Array_Iterator<T>::validate()const{
    return len > 0;    
}

template<class T>
T Array_Iterator<T>::next()
{
    --len;
    return *data++;
}

template<class T>
T sum(Iterator<T> &it)
{
    T result = 0;
    while(it.validate())
        result += it.next();
    return result;
}

int main()
{
    int *d = new int[10];
    for(int i = 0;i!=10;++i)
        d[i] = i;
    Array_Iterator<int> ai(d,10);
    cout << sum(ai) << endl;
    delete d;
    return 0;
}

　　恩.看起來我們的迭代器和sum函數已經很通用了.也許我們到達這一步就可以了.

　　不過有一個很現實的問題擺在所有C++程序員的面前.這東西效率怎么樣??

　　我想大家應該都知道,C++的虛函數使用其實是需要很大的代價的.無論從空間效率上來看也好,從時間效率上來看也好,虛函數動態綁定都是一個很昂貴的操作.實際上,STL里面的iterator也沒有采用繼承的方式.(至於成什么樣,之后的文章會詳細述說)因此,我們不采用這種方式.
　　我們采用的方式是

template<class T,class Ite>
void sum2(T& result,Ite ir)
{
    result  = 0;
    while(ir.valid())
        result += ir.next();
}

　　在我們的模板中,有兩個模板參數,一個是返回的值,一個是我們迭代器的類型.

       只要對我們的main函數進行小小的修改,就可以運行了.

　　為了驗證我們設計的好處,這里,我們設計一個從istream里面獲取值進行累加的例子.sum2仍然不變,我們僅僅通過改變Ite即可實現此功能.

#include <iostream>

using namespace std;

template<class T>
class Reader{
public:
    Reader(istream &is): i(is) {advance();}
    int valid() const {return status;}
    T next()
    {
        T result = data;
        advance();
        return result;
    }
public:
    istream& i;
    bool status;
    T data;
    void advance()
    {
        i >> data;
        status = i != 0;
    }    
};

template<class T,class Ite>
void sum2(T& result,Ite ir)
{
    result  = 0;
    while(ir.valid())
        result += ir.next();
}

int main()
{
    cout << "Enter Number:" << endl;
    double r = 0;
    sum2(r,Reader<double>(cin));
    cout << r << endl;
    return 0;
}

　　顯然,我們不用對原來的代碼做大的修改,甚至完全不用修改sum2的代碼,只要Ite這個模板參數能進行valid和next操作,我們的函數就能正確的運行.而這正是sum2這個接口的要求.

總結:

　　本文章介紹了如用利用模板的參數來實現接口,減少各個模塊之間的耦合度,提高代碼的重用性,減少了代碼的冗余.我們可以看到,通過利用模板的技術,我們可以寫出一個很簡潔但是很通用的一個功能出來.