DIV CSS 佈局教程網

您现在的位置: DIV+CSS佈局教程網 >> 網頁腳本 >  >> JavaScript入門知識 >> AJAX入門 >> AJAX詳解
C++ 老手改用 D 語言:十個常見任務的對照寫法
編輯:AJAX詳解     

寫久了的 C++ 工程師,會累積出一整套幾乎變成第二天性的習慣與手法。問題在於,學新語言時這些習慣太舒服,反而讓人看不見新語言裡更直接的等價寫法。以下整理十個常見的 C++ 任務,以及它們在 D 語言中的對應做法。

1. 定義建構子

C++ 的建構子與類別同名:

class Foo { Foo(int x); };

D 用 this 關鍵字:

class Foo { this(int x) { } }

2. 基底類別初始化

C++ 透過初始化串列呼叫基底建構子:

class A { A() { ... } };
class B : A { B(int x) : A() { ... } };

D 用 super:

class A { this() { ... } }
class B : A {
    this(int x) { ... super(); ... }
}

D 的優勢是 super() 可以放在衍生類別建構子中的任何位置,彈性更大。D 還允許一個建構子呼叫另一個建構子:

class A {
    int a;
    int b;
    this() { a = 7; b = foo(); }
    this(int x) { this(); a = x; }
}

由於成員可以在建構子之前初始化,上面這段等價於:

class A {
    int a = 7;
    int b;
    this() { b = foo(); }
    this(int x) { this(); a = x; }
}

3. 比較結構

C++ 允許結構直接賦值,卻不允許直接比較,因此得自己重載運算子:

inline bool operator==(const A& x, const A& y) {
    return (memcmp(&x, &y, sizeof(struct A)) == 0);
}

這個做法問題不少:每個要比較的結構都得重寫一次,而且重載等於放棄了語言本身提供的型別檢查;更麻煩的是,你無法從呼叫端看出 x == y 究竟做了什麼,必須逐一翻出每個 operator==() 才敢確定。

用 memcmp() 還藏著一個更醜的陷阱:基於對齊需求,結構在記憶體中的分布未必連續,成員之間可能有「洞」,而語言並不保證這些洞裡的填補值一致。結果是兩個成員完全相同的實例,可能因為洞裡的垃圾資料不同而判定不相等。

替代方案是逐成員比較,但這也不可靠:一是日後往結構裡加了新成員,工程師可能忘了同步更新比較函式;二是浮點數的 NaN,即使逐位元相同,比較結果仍是不等。C++ 在這裡沒有真正穩健的解法。

D 的寫法直接得多:

A x, y;
if (x == y) ...

4. 建立真正的新 typedef 型別

C++ 的 typedef 是弱的,編譯器不區分它與底層型別,因此下面這種錯誤不會被抓到:

typedef void *Handle;
void foo(void *);
void bar(Handle);
Handle h = HANDLE_INIT;
foo(h);  // 型別錯誤,卻沒被攔下
bar(h);  // ok

常見繞法是做一個傀儡結構,唯一目的就是取得真正的型別檢查與重載能力:

struct Handle {
    void *ptr;
    Handle() { ptr = HANDLE_INIT; }
    Handle(int i) { ptr = (void *)i; }
    operator void*() { return ptr; }
};

D 不需要這套儀式:

typedef void *Handle = cast(void *)-1;
void bar(Handle);
Handle h;
bar(h);
h = func();
if (h != Handle.init) ...

值得注意的是,typedef 可以直接指定初始值作為新型別的預設值。

5. 友元

兩個類別關係緊密、需要互取私有成員,又不是繼承關係時,C++ 得寫 friend:

class A {
private:
    int a;
public:
    int foo(B *j);
    friend class B;
    friend int abc(A *);
};

D 的做法是:同一個模組內的類別隱式擁有友元權限。這其實很合理——關係緊密的類別本來就該放在同一個模組裡,隱式開放顯得優雅:

module X;
class A {
private:
    static int a;
public:
    int foo(B j) { return j.b; }
}
class B {
private:
    static int b;
public:
    int bar(A j) { return j.a; }
}
int abc(A p) { return p.a; }

private 的作用是禁止其他模組存取成員。

6. 運算子重載

假設有一個結構代表新的算術型別,想讓它與整數比較,C++ 得把四個比較運算子都寫一遍,而且連反向形式也要補上,一共八個函式,缺一不可。

D 意識到比較運算子之間本質相關,只需要一個函式:

struct A {
    int opCmp(int i);
}

編譯器會依 opCmp 自動推導 <、<=、>、>=,並處理左運算元不是物件參考的情況。這類明智的規則也適用於其他運算子重載,讓 D 的重載比 C++ 少寫很多程式碼,也少很多出錯機會。

7. 命名空間的 using 宣告

C++ 用 using 把名稱從命名空間帶進當前作用域:

namespace Foo { int x; }
using Foo::x;

D 以模組取代命名空間與 include 檔,並以別名宣告取代 using:

---- Module Foo.d ----
module Foo;
int x;

---- 另一個模組 ----
import Foo;
alias Foo.x x;

別名靈活得多:可以用來重新命名符號、引用範本成員、引用巢狀型別。

8. RAII(資源取得即初始化)

C++ 中,記憶體等資源需要明確處理,靠的是離開作用域時自動呼叫解構子:

class File { Handle *h; ~File() { h->release(); } };

D 裡大多數資源釋放其實就是追蹤並回收記憶體,這件事交給垃圾回收即可。除了記憶體,最常見的資源是號誌與鎖,D 提供 synchronized 宣告與語句自動管理。剩下少見的情況用 auto 類處理——auto 類在離開作用域時會呼叫解構子:

auto class File {
    Handle h;
    ~this() { h.release(); }
}
void test() {
    if (...) {
        auto File f = new File();
        ...
    }   // 即使因例外離開作用域,f.~this() 仍會執行
}

9. 屬性

C++ 常見的寫法是:定義一個欄位,同時為它配上 get 與 set:

class Abc {
public:
    void setProperty(int v) { property = v; }
    int getProperty() { return property; }
private:
    int property;
};
a.setProperty(3);
int x = a.getProperty();

這只是增加了敲鍵盤的次數,還讓程式碼被 getProperty()、setProperty() 塞滿而難讀。

D 的屬性可以用一般欄位語法讀寫,編譯器再把它換成方法呼叫:

class Abc {
    void property(int v) { myprop = v; }   // set
    int property() { return myprop; }      // get
private:
    int myprop;
}

使用起來:

Abc a;
a.property = 3;    // 等價於 a.property(3)
int x = a.property; // 等價於 int x = a.property()

換句話說,屬性一開始可以只是個簡單欄位;哪天需要改成函式行為,只改類別定義就夠了,不必為了「以防萬一將來要重載」而提前寫一堆 get/set。這也是定義介面類的一種方式:類別沒有資料欄位,語法上卻像做了實際工作。

10. 遞迴範本

C++ 用範本遞迴搭配特化終止,例如計算階乘:

template<int n> class factorial {
public:
    enum { result = n * factorial<n - 1>::result };
};
template<> class factorial<1> {
public:
    enum { result = 1 };
};
printf("%d\n", factorial<4>::result);   // 24

D 的版本更簡短,靠的是能把單一範本成員提升到外層命名空間:

template factorial(int n) {
    enum { factorial = n * .factorial!(n-1) }
}
template factorial(int n : 1) {
    enum { factorial = 1 }
}
printf("%d\n", factorial!(4));   // 24

小結

把這十個對照放在一起看,會發現 D 的設計取向相當一致:凡是編譯器能替你推導的(比較運算子、屬性存取、資源回收),就不要求工程師手寫;凡是 C++ 需要靠慣用手法繞過的語言限制(弱 typedef、缺乏屬性、友元宣告),D 多半直接在語言層面給了答案。對 C++ 老手而言, chuyển 過來最難的往往不是語法,而是放下那些已經變成肌肉記憶的繞道。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved