您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 程式開發 >> iOS 開發綜合

寫給 iOS 工程師的 C++(下):多型、模板與 Objective-C++

編輯:iOS 開發綜合

歡迎回到《寫給 iOS 工程師看的 C++ 系列》第二篇。上一篇談了類別與記憶體管理,這次要往更深的層次走:多型、虛擬函式、解構函式、運算子重載、模板與標準模板庫,最後再看 Objective-C++ 如何把兩種語言揉在一起。

多型

這裡的多型可不是那隻只會學舌的鸚鵡,雖然聽起來很像。簡單說,多型就是在子類中覆寫父類的函式。在 Objective-C 裡你其實用過无数次——繼承 UIViewController 並覆寫 viewDidLoad 就是最典型的例子。

但在 C++ 中,事情沒那麼理所當然。看這段程式碼:

class Foo {
public:
    int value() { return 5; }
};

class Bar : public Foo {
public:
    int value() { return 10; }
};

Bar *b = new Bar();
Foo *f = (Foo*)b;
printf("%i", f->value());   // 輸出 5

輸出 5,而不是你期待的 10。這是 C++ 與 Objective-C 之間一個很根本的差異。在 Objective-C 中,把子類指標轉成父類指標完全沒問題,當你送出訊息時,執行期會查找物件真正的類別,呼叫最後派生的那個實作。而在 C++ 中,編譯器看到 f 的靜態型別是 Foo,就直接把跳轉目標定為 Foo::value(),它無從得知 f 實際上指向一個 Bar。

靜態綁定與動態綁定

上面的例子正好說明了兩者的分野。C++ 預設走靜態綁定:由編譯器決定呼叫哪個函式,這個決定在編譯完成後就已寫死於二進位檔中,執行期無法更改。Objective-C 則是動態綁定,直到執行期才決定要呼叫哪個實作。

動態綁定讓 Objective-C 格外靈活,例如執行期為某個類別動態添加方法這種事,在純靜態綁定的語言裡是做不到的。但也別急著下結論——C++ 同樣具備動態綁定的機制,那就是所謂的虛擬函式。

虛擬函式與虛擬函式表

虛擬函式提供了動態綁定的能力:執行期透過查表決定要呼叫哪個實作,每個類別都有這麼一張表。代價是效能——除了呼叫函式本身,還多了一次查表。靜態綁定則是直接跳轉,沒有額外開銷。

使用方式很簡單,在函式前面加上 virtual 關鍵字即可:

class Foo {
public:
    virtual int value() { return 5; }
};

class Bar : public Foo {
public:
    virtual int value() { return 10; }
};

Bar *b = new Bar();
Foo *f = (Foo*)b;
printf("%i", f->value());   // 輸出 10

這次結果符合預期了。動態還是靜態,取決於你的實際情境;這種把選擇權交還給開發者的設計哲學,也正是 C++ 被視為多重典範語言的原因。相對於 Cocoa 框架那種約束性較強的風格,C++ 給的自由度明顯更高,相對地,也需要你更清楚自己做了什麼。

虛擬函式的運作機制

要理解虛擬函式,先看非虛擬函式的情況。假設有:

MyClass a;
a.foo();

若 foo() 不是虛擬函式,編譯器會直接產生一條跳轉到 MyClass::foo() 的指令。問題就在這裡:當類別具備多型性時,編譯器無從得知變數的完整型別,也就無法決定跳去哪裡,因此必須有某種執行期查找機制。

這個機制就是虛擬函式表(v-table)。它是一張把函式與其對應實作連起來的速查表,每個物件都會指向所屬類別的表。當編譯器發現某個虛擬函式被呼叫,就會透過物件的 v-table 定位到正確的實作。

回到前面的例子:建立 b 這個 Bar 物件時,它的 v-table 指向 Bar 的表;即使被轉型成 Foo 指標,物件本身的內容並未改變,v-table 依然是 Bar 的。所以呼叫 value() 時,走的是 Bar::value()。

建構函式與解構函式

每個物件生命週期中最重要的兩個階段就是建構與解構,而 C++ 讓你完全掌控這兩者。它們分別對應 Objective-C 的初始化方法與 dealloc。

C++ 的建構函式名稱與類別同名,而且可以有多個,就像你可以有多個初始化方法一樣:

class Foo {
private:
    int x;
public:
    Foo()      { x = 0; }
    Foo(int x) { this->x = x; }
};

如果只是單純設定成員變數,可以用初始化列表把程式碼寫得更精簡:

class Foo {
private:
    int x;
public:
    Foo()      : x(0) { }
    Foo(int x) : x(x) { }
};

這種寫法通常只用於設定成員。若需要執行邏輯或呼叫其他函式,就還是得寫出函式主體,當然兩者也可以並用。

在繼承的情況下,通常會呼叫父類的建構函式,對應 Objective-C 裡「第一行先呼叫父類指定初始化方法」的習慣:

class Bar : public Foo {
private:
    int y;
public:
    Bar()          : Foo(),   y(0) { }
    Bar(int x)     : Foo(x),  y(0) { }
    Bar(int x, int y) : Foo(x), y(y) { }
};

父類建構函式必須寫在初始化列表的第一個位置,而你可以繼承父類的任何一個建構函式。

C++ 長久以來沒有所謂「指定初始化方法」的概念,也就是說無法在這個類別的某個建構函式中呼叫同一個類別的另一個建構函式。在 Objective-C 中這是常見寫法:

@implementation Foo
- (id)init {
    if (self = [super init]) { /* 父類指定初始化 */ }
    return self;
}
- (id)initWithFoo:(id)foo {
    if (self = [self init]) { /* 呼叫自己的指定初始化 */ }
    return self;
}
@end

過去在 C++ 中,模擬這種模式得靠一個共用的私有方法:

class Bar : public Foo {
private:
    int y;
    void commonInit() { /* 共用初始化 */ }
public:
    Bar()      : Foo() { this->commonInit(); }
    Bar(int y) : Foo(), y(y) { this->commonInit(); }
};

直到 C++11 這個標準問世,才終於允許建構函式委派給同一個類別的另一個建構函式:

class Bar : public Foo {
private:
    int y;
public:
    Bar()      : Foo() { /* 共用初始化 */ }
    Bar(int y) : Bar()  { this->y = y; }
};

這裡有個小限制:委派時無法同時在初始化列表中設定其他成員,像上面的 y 就只能在函式主體中賦值。另外補充一個冷知識,C++11 在開發期間原本稱為 C++0x,因為最初預計在 2000 到 2009 年間完成,x 應該被年份最後一位取代,但進度落後,最後定名為 C++11。

至於解構,當一個堆上物件被 delete,或一個堆疊物件離開作用域時,物件就會被解構,此時你需要在解構函式中做必要的清理。解構函式沒有參數(這一點和 dealloc 同理),一個類別也只能有一個。名稱由 (~) 加上類別名稱構成:

class Foo {
public:
    ~Foo() { printf("Foo destructor\n"); }
};

接著來看一個繼承時常見的陷阱:

Bar *b = new Bar();
Foo *f = (Foo*)b;
delete f;      // 只印出 Foo destructor

明明刪除的是 Bar,卻只呼叫了 Foo 的解構函式。原因和前面多型的問題完全一樣:編譯器看到的是一個 Foo,而 Foo 的解構函式不是虛擬函式,於是只呼叫了 Foo 的版本。解法也一樣——加上 virtual:

class Foo {
public:
    virtual ~Foo() { printf("Foo destructor\n"); }
};
class Bar : public Foo {
public:
    virtual ~Bar() { printf("Bar destructor\n"); }
};

Bar *b = new Bar();
Foo *f = (Foo*)b;
delete f;      // Bar destructor,接著 Foo destructor

這次兩個解構函式都被呼叫了,順序是先子類後父類。這麼做是必要的,概念上和 ARC 出現之前你得手動呼叫 [super dealloc] 是一樣的道理。

你可能會想:編譯器難道不能自動幫我們處理嗎?技術上可以,但並非在所有情境下都合適。比方說,如果某個類別你確定永遠不會被繼承,那麼把解構函式設為虛擬,反而會讓每次 delete 都多繞一層 v-table,而這層間接性並不是你想要的。C++ 把決定權交給你,代價是你必須知道背後發生了什麼事。

所以給你一個實務建議:除非你確定某個類別不會被繼承,否則一律把解構函式宣告為虛擬函式。

運算子重載

接下來這個主題在 Objective-C 中完全不存在,所以先補一點概念。運算子就是那些你熟悉的符號,例如 +、-、*、/。

int x = 5;
int y = x + 5;        // y = 10
int y2 = add(x, 5);   // 等價寫法

C++ 允許你在自訂類別上使用這些運算子,這能力相當強大,但有時也會有點荒謬——把兩個 Person 相加是什麼意思?結婚嗎?玩笑歸玩笑,看個實際例子:

class DoubleInt {
private:
    int x;
    int y;
public:
    DoubleInt(int x, int y) : x(x), y(y) {}
};

DoubleInt a(1, 2);
DoubleInt b(3, 4);
DoubleInt c = a + b;   // 期望得到 DoubleInt(4, 6)

只要替 DoubleInt 補上一個方法即可:

DoubleInt operator+(const DoubleInt &rhs) {
    return DoubleInt(x + rhs.x, y + rhs.y);
}

函式名稱有點特別,叫做 operator+。當編譯器看到一個加號、兩側各有一個 DoubleInt,就會呼叫這個函式。函式會在加號左側的物件上被呼叫,右側物件則作為參數傳入——這也是我們習慣把參數命名為 rhs 的原因,因為它是 right hand side(右側)的意思。

參數使用參考型別而非複本,是因為沒有複製的必要;若用複本,語意上會暗示我們可能修改它。再加上 const 修飾,則明確表示執行加法期間不會改動 rhs。

如果你還想讓 DoubleInt 能和 int 相加,也完全可以:

DoubleInt operator+(const int &rhs) {
    return DoubleInt(x + rhs, y + rhs);
}

DoubleInt a(1, 2);
DoubleInt b = a + 10;   // DoubleInt(11, 12)

而且不只有加法。++, --, +=, -=, *, -> 等等幾乎所有運算子都能重載。若想把這塊學透,建議直接閱讀 learncpp.com 上專門討論運算子重載的章節。

模板

現在捲起袖子,C++ 最精彩的部分來了。你大概有過這種經驗:寫完一個函式後發現以前寫過幾乎一樣的東西,只是型別不同。以交換兩個數值為例:

void swap(int &a, int &b) {
    int temp = a;
    a = b;
    b = temp;
}

這裡參數刻意用參考型別,因為唯有如此才能真正交換到原變數本身;若傳值,只是交換了兩份複本,呼叫端毫無感覺。這個例子也順便說明了 C++ 參考特性帶來的便利。

問題是這個函式只能交換整數。想交換浮點數就得再寫一份幾乎相同的程式碼,很笨。C++ 提供了一種語法讓你暫時忽略型別,那就是模板:

template <typename T>
void swap(T &a, T &b) {
    T temp = a;
    a = b;
    b = temp;
}

int ix = 1, iy = 2;
swap(ix, iy);

float fx = 3.141, fy = 2.901;
swap(fx, fy);

Person px("Matt Galloway"), py("Ray Wenderlich");
swap(px, py);

使用模板時有一點必須注意:模板函式的實作只能放在標頭檔中。原因是編譯器必須在看到呼叫時一併看到實作,才能針對該型別產生出對應的版本。也因此,只要你修改了模板函式的實作,所有參考的檔案都得重新編譯,而不像一般函式那樣只需重編一個檔案。

這代表大量使用模板可能帶來編譯時間上的負擔。但它們實在太有用了,所以和 C++ 的許多設計一樣,你需要在威力與簡單之間自行拿捏平衡。

模板類別

模板不只能用於函式,也能用於整個類別。假設你需要一個能存三個值的類別,一開始想存整數:

class IntTriplet {
private:
    int a, b, c;
public:
    IntTriplet(int a, int b, int c) : a(a), b(b), c(c) {}
    int getA() { return a; }
    int getB() { return b; }
    int getC() { return c; }
};

後來發現還需要存三個浮點數,只好再複製一份改成 FloatTriplet。這種情況正是模板的用武之地,語法和函式模板一致:

template <typename T>
class Triplet {
private:
    T a, b, c;
public:
    Triplet(T a, T b, T c) : a(a), b(b), c(c) {}
    T getA() { return a; }
    T getB() { return b; }
    T getC() { return c; }
};

差別在於使用方式:函式模板的型別由編譯器推斷,而類別模板必須由你明確告知要用哪個型別:

Triplet<int>    intTriplet(1, 2, 3);
Triplet<float>  floatTriplet(3.141, 2.901, 10.5);
Triplet<Person> personTriplet(Person("Matt"), Person("Ray"), Person("Bob"));

而且模板參數不只一個。Triplet 可以擴充成支援三種不同的型別:

template <typename TA, typename TB, typename TC>
class Triplet {
private:
    TA a; TB b; TC c;
public:
    Triplet(TA a, TB b, TC c) : a(a), b(b), c(c) {}
    TA getA() { return a; }
    TB getB() { return b; }
    TC getC() { return c; }
};

Triplet<int, float, Person> mixedTriplet(1, 3.141, Person("Matt"));

標準模板庫 STL

幾乎每個語言都有標準庫。Objective-C 中是 Foundation,提供 NSArray、NSDictionary 等常用結構;C++ 中則是標準模板庫,簡稱 STL。之所以叫「模板」庫,是因為它大量使用了模板這個特性。

容器

STL 提供的容器種類比 Foundation 更多。最典型的例子是陣列:STL 裡有兩個「NSArray 的兄弟」——vector 與 list。兩者都表示一列物件,但各有優缺點,C++ 又一次把選擇權交給你。

#include <vector>

std::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(5);

注意 std:: 前綴,因為絕大部分 STL 內容都放在 std 命名空間下,目的是避免命名衝突。另外值得留意的是,C++ 的容器一律是可變的,不像 Objective-C 有可變與不可變之分。

取值有兩種方式:

int first        = v[1];      // C 風格陣列語法
int outOfBounds  = v.at(100); // 會檢查越界,超出範圍時丟出例外

vector 是一整塊連續記憶體,大小等於「元素型別大小 × 元素個數」。因此隨機存取非常快,但往尾端追加元素時若容量不足,就得重新配置記憶體,代價不低。

std::list 則是雙向連結串列:每個節點除了資料本身,還帶有指向前一與後一元素的指標。因為不是連續的,插入與刪除很快,但要存取第 n 個元素就必須從頭逐一走訪,無法用方括號取值。

#include <list>

std::list<int> l;
l.push_back(1);
l.push_back(2);
l.push_back(3);

for (std::list<int>::iterator i = l.begin(); i != l.end(); i++) {
    int thisInt = *i;
    // 在這裡處理 thisInt
}

這裡用到了迭代器。迭代器是一個能透過前進或後退來走訪集合的物件,i++ 讓指標前移一個元素,i-- 則後退;要取得目前位置的資料,則使用解參考運算子 *。

值得一提的是,上面這段程式碼其實示範了兩次運算子重載:i++ 重載了遞增運算子,*i 重載了解參考運算子。這類重載在 STL 中隨處可見,也正是它能寫得如此直覺的原因。

除了 vector 與 list,STL 還有許多特性各異的容器。Objective-C 中的 set 對應 std::set,字典對應 std::map,另外還有一個常用來存放成對值的 std::pair。

共享指標

複習一下記憶體管理:在 C++ 中使用堆上物件時,你得自己打理一切,語言本身並沒有引用計數。不過從 C++11 開始,STL 加入了一個支援引用計數的類別,也就是 shared_ptr(Shared Pointer,共享指標)。

它把一個普通指標與其底層的引用計數包裝在一起,使用方式非常類似 ARC 底下的 Objective-C 物件指標。

std::shared_ptr<int> p1(new int(1));
std::shared_ptr<int> p2 = p1;
std::shared_ptr<int> p3 = p1;
// 三個共享指標的引用計數皆為 3

每當一個共享指標被銷毀或呼叫 reset,計數就減一;當最後一個引用被釋放,底層指標才會真正被刪除。由於共享指標本身是堆疊物件,離開作用域時會自動被銷毀,因此整體行為等同於 ARC 之下的物件指標。

std::shared_ptr<int> p1(new int(1));   // count = 1
if (doSomething) {
    std::shared_ptr<int> p2 = p1;      // count = 2
    // 使用 p2
}                                      // p2 離開作用域,count = 1
p1.reset();                            // count = 0,底層 int 被刪除

把 p1 賦值給 p2 其實是複製了一份共享指標。還記得函式參數是傳值呼叫嗎?也就是說,當你把一個共享指標傳進函式,實際上傳入的是一份新的共享指標;函式結束、作用域結束,它就會被銷毀。因此在函式執行期間,計數會 +1——ARC 底下正是這樣運作的。

要存取共享指標裡包的指標,有兩種方式,兩者都被重載過,因此使用起來就像普通指標:

std::shared_ptr<Person> p1(new Person("Matt Galloway"));
Person *underlyingPointer = *p1;   // 取出底層指標
p1->doADance();                    // 透過箭頭運算子呼叫方法

共享指標讓 C++ 也具備了引用計數的能力。它確實有成本,但相對於帶來的便利,這個代價是值得的。

Objective-C++

你可能會問:有了 C++ 就夠了,為什麼還要用 Objective-C?答案是可以混用。Objective-C++ 並不是一種全新的語言,顧名思義,它就是兩種語言的結合體。透過混用,你能同時取用兩邊的特性:把 C++ 物件當成 Objective-C 類別的實例變數,反之亦然。當你想在 app 中呼叫某個以 C++ 撰寫的函式庫時,這招非常管用。

要讓編譯器把某個檔案當成 Objective-C++ 處理,只需把副檔名從 .m 改成 .mm 即可。

@class ObjcClass;
class CppClass;

// 帶有 Objective-C 成員的 C++ 類別
class CppClass {
public:
    ObjcClass *objcClass;
};

// 帶有 C++ 物件作為屬性的 Objective-C 類別
@interface ObjcClass : NSObject
@property (nonatomic, assign) std::shared_ptr<CppClass> cppClass;
@end

@implementation ObjcClass
@end

// 交互使用
std::shared_ptr<CppClass> cppClass(new CppClass());
ObjcClass *objcClass = [[ObjcClass alloc] init];
cppClass->objcClass = objcClass;
objcClass.cppClass = cppClass;

注意屬性宣告為 assign,而不是 strong 或 weak,因為它不是 Objective-C 物件,編譯器不會對它做 retain 或 release。即便如此,記憶體管理也不會出錯,因為你用的是共享指標。若改用裸指標,就得自行實作 setter,在釋放舊物件後再設定新值。

使用 Objective-C++ 時有幾個限制要留意:C++ 類別不能繼承 Objective-C 類別,反之亦然;例外處理也需要小心,目前的編譯器與執行期允許兩種例外並存,但仍建議詳閱文件。

另一個要注意的是 C++ 依賴外洩。看看這個例子:

// MyClass.h
#import <Foundation/Foundation.h>
#include <list>

@interface MyClass : NSObject
@property (nonatomic, assign) std::list<int> listOfIntegers;
@end

因為使用了 C++,實作檔必須是 .mm。但當別人 import 你的 MyClass.h 時,也就被迫跟著引入 C++,於是那些原本完全不想碰 C++ 的檔案也被當成 Objective-C++ 來編譯。可行的作法是盡量在公開標頭檔中避免使用 C++ 型別,改以私有屬性或實例變數在实现檔中處理。

最後談談記憶體管理上的細節。Objective-C 物件永遠位於堆上,而 C++ 物件既可能在堆上也可能在堆疊上。若把一個堆疊上的 C++ 物件放進 Objective-C 類別的成員,結果可能出乎意料——它實際上仍在堆內,因為整個 Objective-C 物件本來就在堆上。編譯器會自動產生名為 .cxx_construct 與 .cxx_destruct 的兩個方法,分別負責建構與解構時的 C++ 相關處理(ARC 其實也扮演了類似 .cxx_destruct 的角色)。

因此原则是:C++ 堆疊物件交給編譯器即可,但所有 C++ 堆上物件你仍須自行正確建立與銷毀——在指定初始化方法中建立,並在 dealloc 中 delete。

結語

C++ 是一門值得投資的語言。它和 Objective-C 同源,卻被用來解決不同類型的問題。學會 C++ 之後,你對物件導向的整體理解會更透徹,回頭看 Objective-C 的設計時,往往也能做出更好的取捨。

建議多讀別人的 C++ 程式碼,並親手動手驗證。若想 further 深入,learncpp.com 上有大量優質的教材。有任何問題或想法,歡迎留言討論。

  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved