寫久了的 C++ 工程師,會累積出一整套幾乎變成第二天性的習慣與手法。問題在於,學新語言時這些習慣太舒服,反而讓人看不見新語言裡更直接的等價寫法。以下整理十個常見的 C++ 任務,以及它們在 D 語言中的對應做法。
C++ 的建構子與類別同名:
class Foo { Foo(int x); };
D 用 this 關鍵字:
class Foo { this(int x) { } }
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; }
}
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) ...
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 可以直接指定初始值作為新型別的預設值。
兩個類別關係緊密、需要互取私有成員,又不是繼承關係時,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 的作用是禁止其他模組存取成員。
假設有一個結構代表新的算術型別,想讓它與整數比較,C++ 得把四個比較運算子都寫一遍,而且連反向形式也要補上,一共八個函式,缺一不可。
D 意識到比較運算子之間本質相關,只需要一個函式:
struct A {
int opCmp(int i);
}
編譯器會依 opCmp 自動推導 <、<=、>、>=,並處理左運算元不是物件參考的情況。這類明智的規則也適用於其他運算子重載,讓 D 的重載比 C++ 少寫很多程式碼,也少很多出錯機會。
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;
別名靈活得多:可以用來重新命名符號、引用範本成員、引用巢狀型別。
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() 仍會執行
}
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。這也是定義介面類的一種方式:類別沒有資料欄位,語法上卻像做了實際工作。
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 過來最難的往往不是語法,而是放下那些已經變成肌肉記憶的繞道。