一種高效的 vector 四則運算處理方法

---

實現 vector 的四則運算

這裏假設 vector 的運算定義爲對操做數 vector 中相同位置的元素進行運算，最後獲得一個新的 vector。具體來講就是，假如 vector<int> d1{1, 2, 3}, d2{4, 5, 6};則， v1 + v2 等於 {5, 7, 9}。實現這樣的運算看起來並非很難，一個很是直觀的作法以下所示：

vector<int> operator+(const vector<int>& v1, const vector<int>& v2) {
    // 假設 v1.size() == v2.size()
    vector<int> r;

    r.reserve(v1.size());
    for (auto i = 0; i < v1.size(); ++i) {
        r.push_back(v1[i] + v2[i]);
    }
    return r;
}

// 同理，須要重載其它運算符

咱們針對 vector 重載了每種運算符，這樣一來，vector 的運算就與通常簡單類型無異，實現也很直白明瞭，但顯然這個直白的作法有一個嚴重的問題：效率不高。效率不高的緣由在於整個運算過程當中，每一步的運算都產生了中間結果，而中間結果是個 vector，所以每次都要分配內存，若是參與運算的 vector 比較大，而後運算又比較長的話，效率會比較低，有沒有更好的作法？

既然每次運算產生中間結果會致使效率問題，那能不能優化掉中間結果？回過頭來看，這種 vector 的加減乘除與普通四則運算並沒有太大差別，在編譯原理中，對這類表達式進行求值一般能夠經過先把表達式轉爲一棵樹，而後經過遍歷這棵樹來獲得最後的結果，結果的計算是一次性完成的，並不須要保存中間狀態，好比對於表達式：v1 + v2 * v3，咱們一般能夠先將其轉化爲以下樣子的樹：

所以求值就變成一次簡單的中序遍歷，那麼咱們的 vector 運算是否也能夠這樣作呢？

表達式模板

要把中間結果去掉，關鍵是要推遲對錶達式的求值，但 c++ 語言成面上不支持 lazy evaluation，所以須要想辦法把表達式的這些中間步驟以及狀態，用一個輕量的對象保存起來，具體來講，就是須要可以將表達式的中間步驟的操做數以及操做類型封裝起來，以便在須要時能動態的執行這些運算獲得結果，爲此須要定義相似以下這樣一個類：

enum OpType {
    OT_ADD,
    OT_SUB,
    OT_MUL,
    OT_DIV,
};

class VecTmp {
    int type_;
    const vector<int>& op1_;
    const vector<int>& op2_;

public:
    VecTmp(int type, const vector<int>& op1, const vector<int>& op2)
        : type_(type), op1_(op1), op2_(op2) {}

    int operator[](const int i) const {
        switch(type_) {
            case OT_ADD: return op1_[i] + op2_[i];
            case OT_SUB: return op1_[i] - op2_[i];
            case OT_MUL: return op1_[i] * op2_[i];
            case OT_DIV: return op1_[i] / op2_[i];
            default: throw "bad type";
        }
    }
};

有了這個類，咱們就能夠把一個簡單的運算表達式的結果封裝到一個對象裏面去了，固然，咱們得先將加法操做符(以及其它操做符)重載一下：

VecTmp operator+(const vector<int>& op1, const vector<int>& op2) {
    return VecTmp(OT_ADD, op1, op2);
}

這樣一來，對於 v1 + v2，咱們就獲得了一個很是輕量的 VecTmp 對象，而該對象能夠很輕鬆地轉化爲 v1 + v2 的結果(遍歷一遍 VecTmp 中保存的操做數)。但上面的作法還不能處理 v1 + v2 * v3 這樣的套嵌的複雜表達式：v2 * v3 獲得一個 VecTmp，那 v1 + VecTmp 怎麼搞呢？

同理，咱們仍是得把 v1 + VecTmp 放到一個輕量的對象裏，所以最好咱們的 VecTmp 中保存的操做數也能是 VecTmp 類型的，有點遞歸的味道。。。用模板就能夠了，因而獲得以下代碼：

#include <vector>
#include <iostream>

using namespace std;

enum OpType {
    OT_ADD,
    OT_SUB,
    OT_MUL,
    OT_DIV,
};

template<class T1, class T2>
class VecSum {
    OpType type_;
    const T1& op1_;
    const T2& op2_;
  public:
    VecSum(int type, const T1& op1, const T2& op2): type_(type), op1_(op1), op2_(op2) {}

    int operator[](const int i) const {
        switch(type_) {
            case OT_ADD: return op1_[i] + op2_[i];
            case OT_SUB: return op1_[i] - op2_[i];
            case OT_MUL: return op1_[i] * op2_[i];
            case OT_DIV: return op1_[i] / op2_[i];
            default: throw "bad type";
        }
    }
};

template<class T1, class T2>
VecSum<T1, T2> operator+(const T1& t1, const T2& t2) {
    return VecSum<T1, T2>(OT_ADD, t1, t2);
}

template<class T1, class T2>
VecSum<T1, T2> operator*(const T1& t1, const T2& t2) {
    return VecSum<T1, T2>(OT_MUL, t1, t2);
}

int main() {
    std::vector<int> v1{1, 2, 3}, v2{4, 5, 6}, v3{7, 8, 9};
    auto r = v1 + v2 * v3;
    for (auto i = 0; i < r.size(); ++i) {
        std::cout << r[i] << " ";
    }
}

上面的代碼漂亮地解決了前面提到的效率問題，擴展性也很好(可以方便地增長對其它運算類型的支持)，並且對 vector 來講仍是非侵入性的，固然了，實現上乍看起來可能就不是很直觀了，除此也還有些小問題能夠更完善：

1. 操做符重載那裏極可能會影響別的類型，所以最好限制一下，只針對 vector<int> 和 VecTmp<> 進行重載，這裏能夠用 SFINAE 來處理。
2. VecTmp<> 的 operator[] 函數中的 switch 能夠優化掉，VecTmp<> 模板只需增長一個參數，而後對各類運算類型進行偏特化就能夠了。
3. VecTmp<> 對操做數的類型是有隱性要求的，只能是 vector<int> 或者是 VecTmp<>，這裏也應該用 SFINAE 強化一下限制，使得用錯時出錯信息能夠好看些。

如今咱們來重頭再看看這一小段奇怪的代碼，顯然關鍵在於 VecTmp<> 這個模板，咱們能夠發現，它的接口其實很簡單直白，但它的類型卻能夠是那麼地複雜，好比說對於 v1 + v2 * v3 這個表達式，它的結果的類型是這樣的： VecTmp<vector<int>, VecTmp<vector<int>, vector<int>>>，能夠想象若是表達式再複雜些，它的類型也會跟着更復雜，若是你看仔細點，是否是還發現這東西和哪裏很像？像一棵樹，一棵類型的樹：

這棵樹看起來是否是還很眼熟，每一個葉子結點都是 vector<int>，而每一個內部結點則是由 VecTmp<> 實例化的：這是一棵類型的樹，在編譯時就肯定了。這種經過表達式在編譯時獲得的複雜類型有一個學名叫： Expression template。在 c++ 中每個表達式必產生一個結果，而結果必然有類型，類型是編譯時的東西，結果倒是運行時的。像這種運算表達式，它的最終類型是由表達式中每一步運算所產生的結果所對應的類型組合起來所決定的，類型肯定的過程其實和表達式的識別是一致的。

而 VecTmp 對象在邏輯上其實也是一棵樹，它的成員變量 op1_, op2_ 分別是左右兒子結點，樹的內部結點表明一個運算，一個動做，左右兒子爲其操做數，葉子結點則表明直接數(或 terminal)，一遍中序遍歷下來，獲得的就是整個表達式的值。

神奇的 boost::proto

expression template 是個好東西(就正如 expression SFINAE 同樣)，它能幫助你根據給定的表達式，在編譯時創建很是複雜好玩的類型（從而實現不少高級玩意，主要是函數式，EDSL 等)。但顯然若是什麼東西都須要本身從頭開始寫，這個技術用起來仍是很麻煩痛苦的，好在模板元編程實在是個太好玩的東西，已經有不少人作了不少先驅性的工做，看看 boost proto 吧，在 c++ 的世界裏再打開一扇通往奇怪世界的大門。