您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 使用技巧 >> iOS 技巧大全

從 C++ 到 Objective-C:給 C++ 工程師的快速對照指南

編輯:iOS 技巧大全

簡介

剛開始為 iOS 寫程式時,我發現身為一個 C++ 開發者,得花不少時間去理解 Objective-C 裡那些「古怪」的寫法。這篇文章就是一份給 C++ 工程師的速查表,幫助你快速掌握 Apple 的語言。

這当然不是完整指南,但它能讓你少讀一百頁手冊。

先備知識

本文會大量拿 C++ 來做對照,因此需要具備 C++ 基礎。此外,COM 編程經驗也會有幫助,因為 Objective-C 有類似 IUnknown 的東西(不需要但有用)。

Objective-C++ 就是 C++ 與 Objective-C 的結合體:你可以把任何 C++ 程式碼混進 Objective-C,只要記得把副檔名從 .m 改成 .mm。

成員函式

// Objective-C
- (int) foo : (int) a : (char) b {}
+ (int) foo : (int) a : (char) b {}

// C++
int foo(int a, char b) {}
static int foo(int a, char b) {}

// Objective-C —— 具名參數
- (void) foo2 val1:(int) a;
[obj foo2 val1:5];

// C++
void foo2(int val1);
obj->foo2(5);

- 表示一般成員函式(透過物件實體呼叫),+ 表示靜態成員函式,不需要實體即可呼叫;與 C++ 一樣,靜態成員無法存取實體變數。

此外,Objective-C 的函式可以為參數命名,一眼就知道哪個值給了哪個參數。理論上具名參數允許任意順序傳值,但 Objective-C 規定必須依宣告順序傳入。

呼叫成員

// Objective-C
NSObject* ptr = ...;
[ptr foo:5:3];            // 呼叫實體方法
[NSObject staticfoo:5:3]; // 呼叫靜態方法

// C++
CPPObject* ptr = ...;
ptr->foo(5,3);
CPPObject::staticfoo(5,3);

Objective-C 用 [ ] 呼叫方法,參數以冒號分隔。它對 nil 收件者非常友善:當 ptr 為 nil 時,呼叫會被安靜忽略,而 C++ 在這種情況下會拋出指標錯誤。這使得大量判空程式碼得以省下。

協定 vs 介面

// Objective-C
@protocol foo
- (void) somefunction;
@end

@interface c1 : NSObject <foo>
@end

@implementation c1
- (void) somefunction { ... }
@end

// C++
class foo {
    virtual void somefunction() = 0;
};

class c1 : public NSObject, public foo {
    void somefunction() { ... }
};

協定等同抽象類別。兩者的關鍵差異在於:Objective-C 中的方法不一定要被實作。你可以把某個方法宣告為 optional,那只是給編譯器的提示,並不強制。

檢查方法是否已實作

// Objective-C
NSObject* ptr = ...;
[ptr somefunction:5:3];
// NSObject 不保證實作了 somefunction,若未實作會引發異常。

// C++
CPPObject* ptr = ...;
ptr->somefunction(5,3);
// CPPObject 必須實作,否則根本無法編譯。

Objective-C 的成員函式其實就是 Smalltalk 意義下的「訊息」。我們會說收件者「回應」某個選擇器(selector),意思是它實作了對應的方法。C++ 中只要宣告了介面,物件就必須實作全部方法;Objective-C 不然,因此可能對一個不保證有實作的物件送訊息。安全的寫法是先確認:

NSObject* ptr = ...;
if ([ptr respondsToSelector:@selector(somefunction::)])
    [ptr somefunction:5:3];

這樣就能確保收件者會回應再呼叫。C++ 不需要這種檢查,因為不實作就編不過。注意選擇器要寫出參數個數,上面是兩個參數,所以是兩個冒號。

向下轉型

// Objective-C
NSObject* ptr = ...;
if ([ptr isKindOfClass:[foo class]])
    [(foo*)ptr somefunction:5:3];

// C++
CPPObject* ptr = ...;
foo* f = dynamic_cast<foo*>(ptr);
if (f) f->somefunction(5,3);

Objective-C 靠 NSObject 提供的 isKindOfClass: 完成類似 C++ dynamic_cast 的向下轉型。

是否符合協定

// Objective-C
NSObject* ptr = ...;
if ([ptr conformsToProtocol:@protocol(foo)])
    [ptr somefunction:5:3];

// C++
CPPObject* ptr = ...;   // 某個繼承自 foo 的指標
foo* f = ptr;           // 編譯器會警告 ptr 與 foo 不相容
f->somefunction(5,3);

要對物件送出某協定所定義的訊息前,先確認它符合該協定。這裡的邏輯很像 Java 的類別與介面;而在 C++ 中,「完全實作的類別」與「介面」之間並沒有技術上的區別。

void*、id 與 SEL

// Objective-C
id ptr = ...;
if ([ptr conformsToProtocol:@protocol(foo)])
    [ptr somefunction:5:3];
SEL s = @selector(foo:);   // 指向接受一個參數的 foo 方法

// C++
void* ptr = ...;
foo* f = dynamic_cast<foo*>(ptr);
if (f) f->somefunction(5,3);

id 是 Objective-C 類別的通用型別,概念上像 void*。之所以要用 id 而非 void*,是因為 id 可以參與 ARC 的記憶體管理,編譯器需要在「裸指標」與「Objective-C 物件指標」之間做出區分。SEL 則是選擇器(相當於 C++ 的函式指標)的通用型別,用 @selector 加上方法名與對應數量的冒號即可建立;選擇器本質上是字串,在執行期綁定到方法識別碼。

類別定義、資料與繼承

// Objective-C
@class f2;   // 前向宣告

@interface f1 : NSObject   // 只支援 public 與單一繼承
{
    int test;    // 預設 protected
@public
    int a;
    int b;
    f2* f;
}
- (void) foo;
@end

@implementation f1
- (void) foo
{
    a = 5;
    self->a = 5;
    [super foo];
}
@end

// C++
class f1 : public CPPObject
{
    int test;    // 預設 private
public:
    class f2* f; // 前向宣告
    int a;
    int b;
    void foo();
};

void f1::foo()
{
    a = 5;
    this->a = 5;
    CPPObject::foo();
}

Objective-C 的實作必須寫在 @implementation/@end 之間(C++ 則可在任何有 :: 作用域的地方實作),並用 @class 做前向宣告。它預設是 private,但這只對資料成員有效——方法一律是公開的。它用 self 代替 this,並用 super 呼叫父類實作。

建構子與解構子

// Objective-C
NSObject* s = [[NSObject alloc] init];  // 建構失敗時回傳 nil
[s retain];    // 參考計數 +1

// C++
CPPObject* ptr = new CPPObject();  // 可能拋出例外
ptr->AddRef();

// Objective-C
NSObject* s = [[NSObject alloc] initWithArg:4];
[s release];

// C++
CPPObject* ptr = new CPPObject(4);
ptr->Release();

Objective-C 的記憶體配置透過靜態方法 alloc 完成,所有 NSObject 的後裔都有這個方法。self 在 Objective-C 中是可以被重新賦值的,建構失敗時會被設為 nil(C++ 則是拋出例外)。配置之後,真正的建構由一個公開的成員函式負責,預設就是 init。

Objective-C 使用與 COM 相同的參考計數機制,對應的方法是 retain 與 release(等同 AddRef/Release)。當計數歸零,物件即從記憶體中移除。

多執行緒

// Objective-C
- (void) foo
{
    [self performSelectorInBackground:@selector(threadfunc:)
                           withObject:nil
                        waitUntilDone:NO];
}

- (void) threadfunc : (NSInteger*) param
{
    [self performSelectorOnMainThread:@selector(mt)
                           withObject:nil
                        waitUntilDone:NO];
}

- (void) mt {}

Objective-C 為 NSObject 內建了一些實用能力:把某個選擇器丟到另一條執行緒執行、在主執行緒上執行、以及等待呼叫完成等,細節可參考 Foundation 的文件。

記憶體與 ARC

// Objective-C
@interface f1 : NSObject
@end

-(void)foo
{
    NSObject* s = [[NSObject alloc] init];  // 建構失敗會回傳 nil
    // 使用 s
}   // 結束時,編譯器會自動幫你送出 [s release]

這裡你得先忘掉一些良好的 C++ 習慣。Objective-C 有垃圾回收式的機制,這正是 C++ 工程師最反感的那類東西,但 ARC(自動參考計數)是編譯期特性:你告訴編譯器「這是我的物件,請幫我算算何時該銷毀它」,之後就不必手動送 retain/release。

為了讓編譯器判斷物件該保留多久,你需要區分強引用與弱引用。預設所有變數都是強引用(只要有強引用存在,物件就不會被釋放);你也可以取得弱引用,它會在所有強引用消失時自動變成 nil。這在類別成員從 Xcode 的介面建構器中取得值時特別有用——當類別銷毀,這些成員也會一併失效。

字串

// Objective-C
NSString* s1 = @"hello";
NSString* s2 = [NSString stringWithUTF8String:"A C String"];
printf("%s hello to %@\n", "there", s2);
const char* s3 = [s2 UTF8String];

NSString 是 Objective-C 字串的不可變表示,可用靜態方法或加上 @ 前綴的字串字面值建立。輸出時以 %@ 代表 NSString。

陣列

// Objective-C
NSArray* a1 = [NSArray alloc] initWithObjects:@"hello", @"there", nil];
NSString* first = [a1 objectAtIndex:0];

NSArray 與 NSMutableArray 是 Objective-C 處理陣列的兩個類別,差別在於前者一經建立即不可變,後者可在之後修改。使用傳統建構子時,必須以 nil 作為「結束元素」。排序、搜尋、插入等操作對兩者相同,只是 NSArray 會回傳新物件,NSMutableArray 則直接修改自身。

分類(Categories)

// C++
class MyString : public string {
public:
    void printmystring() { printf("%s", c_str()); }
};

// Objective-C
@interface NSString (MyString)
- (void) printmystring;
@end

@implementation NSString (MyString)
- (void) printmystring { printf("%@", self); }
@end

// C++
MyString s1 = "hi";
s1.printmystring();   // ok
string s2 = "hello";
s2.printmystring();   // 錯誤,必須把 s2 從 string 改成 MyString

// Objective-C
NSString* s2 = @"hello";
[s2 printmystring];   // 合法,我們在不改變型別的前提下擴充了 NSString

C++ 得靠繼承來擴充既有類別,這很麻煩,因為所有自訂實作都必須換一個新的型別名稱(例如用 MyString 取代 string)。Objective-C 用分類(Categories)允許直接擴充已知類別,且維持同一型別。上面範例中,我們立刻就能呼叫新方法,不需要把 NSString 改寫成 MyString。

區塊(Block)與 Lambda

// Objective-C
// 成員函式
- (void) addButtonWithTitle:(NSString*)title
                      block:(void(^)(AlertView*, NSInteger))block;

// 呼叫
[object addButtonWithTitle:@"hello" block:^(AlertView* a, NSInteger i){
    /* 做些什麼 */
}];

Block 是 Objective-C 模擬 lambda 的方式。想深入了解,可以參考 Apple 官方文件中的 UIAlertView 範例。

給 C++ 開發者的 ARC 重要提醒

// C++ —— 危險寫法
class A {
public:
    NSObject* s;
    A();
};

A::A()
{
    s = 0;   // 在 Release 模式下可能崩潰!
}

這個 bug 的特性是:Release 版會崩,Debug 版永遠正常,而使用者不會體諒你。

問題出在 s = 0 這一行。這是「賦值」而非「初始化」,所以不管 s 原本的值是什麼,編譯器都會先送一次 [s release]。若 s 原本就是 nil(Debug 下常見),什麼事都不會發生;但在 Release 模式下,s 可能是野指標,包含任何垃圾值——在把 0 寫進去之前就被 release,後果難料。

C++ 沒有這個問題,因為其中不存在 ARC。而在 Objective-C 中,編譯器無從判斷這是「賦值」還是「初始化」(若是後者就不該送 release)。正確寫法是用初始化列表:

// C++ —— 正確寫法
class A {
public:
    NSObject* s;
    A();
};

A::A() : s(0) {}   // 編譯器知道這是初始化,不會送出 [s release]

請特別小心這一點。

Objective-C 物件與 C++ 型別之間的轉換

// Objective-C
NSObject* a = ...;
void* b = (__bridge void*)a;                 // 一般橋接
void* c = (__bridge_retained void*)a;        // 保留計數 +1,你必須稍後自行釋放
NSObject* d = (__bridge_transfer NSObject*)c; // ARC 取回 c 的擁有權,轉為受管的物件

我的建議很簡單:不要把 ARC 型別與非 ARC 型別混用。如果必須轉換 Objective-C 物件,用 id 而不是 void*,否則很容易遇到嚴重的記憶體問題。

Objective-C 有而 C++ 沒有的

  • 分類(Categories)
  • 以 NSObject 為基礎的執行期操作(如 respondsToSelector:)
  • YES/NO(等同 true/false)
  • NIL/nil(等同 NULL)
  • 具名參數
  • self(等同 this),且在建構子中可以被重新賦值

C++ 有而 Objective-C 沒有的

  • 靜態物件:Objective-C 的物件無法成為靜態或存在於堆疊上,只能是指標
  • 多重繼承
  • 命名空間
  • 樣板(template)
  • 運算子重載
  • STL 與演算法
  • protected/private 方法(Objective-C 的方法一律公開)
  • const/mutable 修飾
  • friend 方法
  • 參考(reference)
  • 匿名函式簽章(沒有參數名稱)
  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved