與臨時(shí)對象的斗爭（下）

作者：唐風(fēng)

原載：www.cnblos.com/liyiwen

在上篇里，我們看到了 (N)RVO 和右值引用，下面我們來看看表達(dá)式模板。

Expression Template（表達(dá)式模板,ET）

如果有“系統(tǒng)地”學(xué)習(xí)過 C++ 的模板編程，那么你應(yīng)該已經(jīng)知道 Expression Template 這個(gè)“東西”。在模板圣經(jīng)《C++ templates》的第 18 章專門用了一整章來講這個(gè)技巧，（是的，我認(rèn)為它是一種技巧）。足以見得它比較復(fù)雜，也很重要。

說起 Expression Template 產(chǎn)生，“臨時(shí)對象”也是“功臣”之一啊。還是來用例子來說明（你能很容易找到這樣類似的例子，呵，我就是參照著別人寫的）：

class MyVec
{
public:
    MyVec(){
        p = new int[SIZE];
    }
    MyVec(MyVec const& a_left) {
        p = new int[SIZE];
        memcpy(p, a_left.p, SIZE * sizeof(int));
    }
    ~MyVec(){delete [] p;}
    MyVec& operator=(MyVec const& a_left) {
        if (this != &a_left) {
            delete [] p;
            p = new int[SIZE];
            memcpy(p, a_left.p, SIZE * sizeof(int));
        }
        return *this;
    }
    int& operator [](size_t a_idx) { 
        return p[a_idx];
    }
    int operator [](size_t a_idx)const { 
        return p[a_idx];
    }
    MyVec const operator + (MyVec const& a_left) const {
        MyVec temp(*this);
        temp += a_left;
        return temp;
    }
    MyVec& operator += (MyVec const& a_left) { 
        for (size_t i = 0; i < SIZE; ++i) {
            p[i] += a_left.p[i];
        }
        return *this;
    }
private:
    static int const SIZE = 100;
    int* p;
};

int main(int argc, char* argv[])
{
    MyVec a, b, c;
    MyVec d = a + b + c;
    return 0;
}

看，我們寫下這么小段代碼：

MyVec d = a + b + c;

這是很常用的數(shù)學(xué)運(yùn)算吧，而且代碼很直觀。但這個(gè)表達(dá)式有一個(gè)問題，就是產(chǎn)生了“不必要”的臨時(shí)對象。因?yàn)?a + b 的結(jié)果會成為一個(gè)存在一個(gè)臨時(shí)對象上 temp 上，然后這個(gè) temp 再加上 c ，最后把結(jié)果傳給 d 進(jìn)行初始化。如果這些向量很長，或是表達(dá)式再加幾節(jié)，可以想像這些 temp 會多讓人不爽。

而且，如果我們寫成這樣：

MyVec d = a;
d += b;
d += c;

就可以避免產(chǎn)生多余的臨時(shí)對象。但這樣寫，如果是不了解“行情”的人看了MyVec d ＝ a + b + c;之后再看這段，是不是會覺得寫這代碼的人欠K？

好吧，你會問，上面不是說右值引用可以解決這樣問題？是的，但在沒有右值引用的“黑暗日子”里，我們就不用過活了？當(dāng)然要，小學(xué)開始數(shù)學(xué)老師就教我們要一題多解吧，換個(gè)思路也有辦法，這個(gè)辦法就是ET。

怎么做的呢？a + b + c 會產(chǎn)生臨時(shí)變量是因?yàn)?C++ 是即時(shí)求值的，在看到 a + b，就先算出一個(gè) temp 的Vector對象，然后再向下算。如果能進(jìn)行延遲求值，看完整個(gè)表達(dá)式再來計(jì)算，那么就可以避免這個(gè)temp的產(chǎn)生。

怎么做？

原來的做法中，operator + 直接進(jìn)行了計(jì)算，既然我們不想它“過早”的計(jì)算，那么我們就在重新重載一個(gè)operator + 運(yùn)算符，在這個(gè)運(yùn)算中不進(jìn)行真正的運(yùn)算，只是生成一個(gè)對象，在這個(gè)對象中把加法運(yùn)算符兩邊的操作數(shù)保留下來~然后讓它參與到下一步的計(jì)算中去。（好吧，這個(gè)對象也是臨時(shí)的，但它的代價(jià)非常非常小，我們先不理會它）。于是我們寫下面的代碼：

class MyVec;

template <typename L>
class ExpPlus {
    L const & lvec;
    MyVec const & rvec;
public:
    ExpPlus(L const& a_l, MyVec const& a_r):
      lvec(a_l), rvec(a_r)
      { }
      int operator [] (size_t a_idx) const;
};

// Point 1
template <typename L>
ExpPlus<L> operator + (L const& a_l, MyVec const & a_r) {
    return ExpPlus<L>(a_l, a_r);
}

class MyVec
{
public:
    MyVec(){
        p = new int[SIZE];
    }

    MyVec(MyVec const& a_r) {
        p = new int[SIZE];
        memcpy(p, a_r.p, SIZE * sizeof(int));
    }

    template <typename Exp>
    MyVec(Exp const& a_r) {
        p = new int[SIZE];
        for (size_t i = 0; i < SIZE; ++i) {
            p[i] += a_r[i];
        }
    }

    ~MyVec(){delete [] p;}

    MyVec& operator = (MyVec const& a_r) {
        if (this != &a_r) {
            delete [] p;
            p = new int[SIZE];
            memcpy(p, a_r.p, SIZE * sizeof(int));
        }
        return *this;
    }

    template <typename Exp>
    MyVec& operator = (Exp const & a_r) {
        delete [] p;
        p = new int[SIZE];
        for (size_t i = 0; i < SIZE; ++i) {
            p[i] += a_r[i];
        }
        return *this;
    }

    int& operator [](size_t a_idx) { 
        return p[a_idx];
    }

    int operator [](size_t a_idx)const { 
        return p[a_idx];
    }
private:
    static int const SIZE = 100;
    int* p;
};

template <typename L>
int ExpPlus<L>::operator [] (size_t a_idx) const {
    return lvec[a_idx] + rvec[a_idx];
}

int main(int argc, char* argv[])
{
    MyVec a, b, c;
    MyVec d = a + b + c;
    return 0;
}

比起之前的代碼來說，這段代碼有幾個(gè)重要的修改：首先，我們增加了一個(gè)模板類 ExpPlus，用它來代表加法計(jì)算的“表達(dá)式”，但在進(jìn)行加法時(shí)，它本身并不進(jìn)行真正的計(jì)算。對這個(gè)類，定義了下標(biāo)運(yùn)算符，這個(gè)運(yùn)算符中才進(jìn)行了真正的加法計(jì)算。然后，對于原來的 MyVec，我們重載它的賦值運(yùn)算符，讓它在賦值的時(shí)候通過ExpPlus的下標(biāo)運(yùn)算符來獲得計(jì)算結(jié)果（也就是，在賦值操作時(shí)才真正的進(jìn)行了計(jì)算！）。

上面這段話，對于不了解ET的人來說，也許一時(shí)間還不容易明白，我們一步一步來：

在 d = a + b + c 這個(gè)式子中，首先遇到 a + b，這時(shí)，模板函數(shù) operator + 會被調(diào)用（代碼中注釋了“Point 1 ”），這時(shí)只是生成一個(gè)臨時(shí)的ExpPlus<MyVec>對象（我們叫它 t1 吧），不做計(jì)算，只是保留計(jì)算的左右操作數(shù)（也就是a和b），接著，t1 + c ，再次調(diào)用同樣的 operator + ，而且也只是生成一個(gè)對象（我們叫它 t2 吧），這個(gè)對象的類型是 ExpPlus<ExpPlus<MyVec>>，同樣，t2 在這里只是保留了兩邊的操作數(shù)（也就是 t1 和 c）。直到整個(gè)表達(dá)式“做完”，沒有任何東西進(jìn)行了計(jì)算，所做的事情實(shí)際上只是用 ExpPlus 這個(gè)模板類把計(jì)算式的信息記錄下來了（當(dāng)然，這些信息就是參與計(jì)算的操作數(shù)）。

最后，當(dāng)進(jìn)行 d ＝ t2 的時(shí)候，MyVec 的賦值運(yùn)算符被調(diào)用（用 t2 作參數(shù)）。注意，這個(gè)調(diào)用中的語句 p[i] ＝ t2[i]，其中 t2[i] 通過重載的下標(biāo)運(yùn)算符，展開成 t1[i] + c[i]，同理 t1[i] 又再次展開，成為 a[i]+b[i]，最終，p[i] = t2[i] 就變成了：p[i] = a[i] + b[i] + c[i]）（當(dāng)然，里面參雜了內(nèi)聯(lián)的效果，這些函數(shù)都是非常容易被內(nèi)聯(lián)的）。就像變“魔術(shù)”一樣，我們通過ExpPlus完成了“延遲計(jì)算”，并避免了大型的 MyVec 臨時(shí)對象的產(chǎn)生。

這基本上就是 ET 的“原理”了吧。我們來“專門化”一下 ET 的好處：

• To create a domain-specific embedded language (DSEL) in C++
• To support lazy evaluation of C++ expressions (e.g., mathematical expressions), which can be executed much later in the program from the point of their definition.
• To pass an expression — not the result of the expression — as a parameter to a function.

這樣，用 ET 就能兼顧到“直觀”和“效率”了。

ET 中 C++ 中的類庫里已經(jīng)有非常多的應(yīng)用了（包括 boost 中的多個(gè)子庫，以及 Blitz++ 等高性能數(shù)學(xué)庫）