从 C++ 到 Objective-C（1）：前言
作者:
Objective-C 可以算作 Apple 平台上“唯一的”开发语言。很多 Objective-C 的教程往往直接从 Objective-C 开始讲起。不过，在我看来，这样做有时候是不合适的。很多程序员往往已经掌握了另外一种开发语言，如果对一门新语言的理解建立在他们已有的知识之上，更能 起到事半功倍的效果。既然名为 Objective-C，它与 C 语言的联系更加密切，然而它又是 Objective 的。与 C 语言联系密切，并且是 Objective 的，我们能够想到的另外一门语言就是 C++。C++ 的开发人员也更普遍，受众也会更多。于是就有了本系列，从 C++ 的角度来讲述 Objective-C 的相关知识。不过，相比 C++，C# 似乎更近一些。不过，我们还是还用 C++ 作为对比。这个系列不会作为一个完整的手册，仅仅是入门。本系列文章不会告诉你 Objective-C 里面的循环怎么写，而是通过与 C++ 的对比来学习 Objective-C 一些更为高级的内容，例如类的实现等等。如果要更好的使用 Objective-C，你需要阅读更多资料。但是，相信在本系列基础之上，你在阅读其他资料时应该会理解的更加透彻一些。
说明：本系列大致翻译来自《From C++ to Objective-C》，你可以在这里找到它的英文 pdf 版本。
下面来简单介绍一下 Objective-C。
要说 Objective-C，首先要从 Smalltalk 说起。Smalltalk 是第一个真正意义上的面向对象语言。Smalltalk 出现之后，很多人都希望能在 C 语言的基础之上增加面向对象的特性。于是就出现了两种新语言：C++ 和 Objective-C。C++ 不必多说，很多人都比较熟悉。Objective-C 则比较冷门。它完全借鉴了 Smalltalk 的思想，有着类似的语法和动态机制；相比来说，C++ 则更加静态一些，目的在于提供能好的性能。Objective-C 最新版本是 2.0.我们的这个系列就是以 Objective-C 2.0 为基础讲解。
Objective-C 是一门语言，而 Cocoa 是这门语言用于 MacOS X 开发的一个类库。它们的关系类似于 C++ 和 Qt，Java 和 Spring 一样。所以，我们完全可以不使用 Cocoa，只去用 Objective-C。例如 gcc 就是一个不使用 Cocoa 的编译器。不过在 MacOS X 平台，几乎所有的功能都要依赖 Cocoa 完成。我们这里只是做一个区别，应该分清 Objective-C 和 Cocoa 的关系。
关键字
Objective-C 是 C 语言的超集。类似于 C++，良好的 C 源代码能够直接被 Objective-C 编译器编译。不同于 C++ 直接改变 C 语言的设计思路，Objective-C 仅仅是在 C 语言的基础上增加了一些概念。例如，对于类的概念，C++ 是增加了一个全新的关键字 class，把它作为语言内置的特性，而 Objective-C 则是将类转换成一个 struct 去处理。所以，为了避免冲突，Objective-C的关键字都是以 @ 开头。一个简单的关键字列表是：@class, @interface, @implementation, @public,@private, @protected, @try, @catch, @throw, @finally, @end, @protocol,@selector, @synchronized, @encode, @defs。Objective-C 2.0 又增加了 @optional, @required, @property, @dynamic, @synthesize 这几个。
另外的一些值同样也类似于关键字，有 nil 和 Nil, 类型 id, SEL 和 BOOL, 布尔变量 YES 和 NO。最后，特定上下文中会有一些关键字，分别是：in, out, inout, bycopy, byref, oneway 和 getter, setter, readwrite, readonly, assign,retain, copy, nonatomic 等。
很多继承自 NSObject 的函数很容易与关键字混淆。比如 alloc, release 和 autorelease 等。这些实际都是 NSObject 的函数。另外一个需要注意的是self 和 super。self 实际上是每一个函数的隐藏参数，而 super 是告知编译器使用 self 的另外语义。
注释
Objective-C 使用 // 和 两种注释风格。
变量声明的位置
Objective-C 允许在代码块的中部声明变量，而不仅仅在块的最开始处。
新增的值和变量
BOOL, YES, NO
C++ 中使用 bool 表示布尔类型。Objective-C 中则是使用 BOOL，其值为 YES 和 NO。
nil, Nil 和 id
简单来说：
·
·
·
SEL
SEL 用于存储选择器 selector 的值。所谓选择器，就是不属于任何类实例对象的函数标识符。这些值可以由 @selector 获取。选择器可以当做函数指针，但实际上它并不是一个真正的指向函数的指针。
@encode
为了更好的互操作性，Objective-C 的数据类型，甚至自定义类型、函数或方法的元类型，都可以使用 ASCII 编码。@encode(aType) 可以返回该类型的 C 字符串（char *）的表示。
源文件
与 C++ 类似，Objective-C同样建议将声明和实现区分开。Objective-C 的头文件后缀名是 .h，源代码后缀名是 .m。Objective-C 使用 #import 引入其它头文件。与 #include 不同的是，#import 保证头文件只被引入一次。另外，#import 不仅仅针对 Objective-C 的头文件，即便是标准 C 的头文件，比如 stdlib.h，同样可以使用 #import 引入。
| C++ | |
| 头文件 | 源文件 |
//In file Foo.h #ifndef __FOO_H__ //compilation guard #define __FOO_H__ // class Foo {
... }; #endif | //In file Foo.cpp #include "Foo.h" ... |
| Objective-C | |
| 头文件 | 源文件 |
//In file Foo.h //class declaration, different from //the "interface" Java keyword @interface Foo : NSObject {
... } @end | //In file Foo.m #import "Foo.h" @implementation Foo ... @end |
NS 前缀
我们前面看到的类 NSObject，NSString 都有一个前缀 NS。这是 Cocoa 框架的前缀（Cocoa 开发公司是 NeXTStep）。
函数和方法的区别
Objective-C 并不是“使用方括号表示函数调用”的语言。一开始很容易把
[object doSomething];
理解成
object.doSomething();
但实际上并不是这么简单。Objective-C 是 C 语言的超集，因此，函数和 C 语言的声明、定义、调用是一致的。C 语言并没有方法这一概念，因此方法是使用特殊语法，也就是方括号。不仅仅是语法上的，语义上也是不同的：这并不是方法调用，而是发送一条消息。看上去并没有什么区别，实际上，这是 Objective-C 的强大之处。例如，这种语法允许你在运行时动态添加方法。
既然是面向对象语言，类和对象显然是应该优先考虑的内容。鉴于本系列已经假定你已经熟悉 C++ 语言，自然就不会去解释类和对象的含义。我们直接从 Objecti-C 和 C++ 的区别开始说起。
Objetive-C 使用的是严格的对象模型，相比之下，C++ 的对象模型则更为松散。例如，在 Objective-C 中，所有的类都是对象，并且可以被动态管理：也就是说，你可以在运行时增加新的类，根据类的名字实例化一个类，以及调用类的方法。这比 C++ 的 RTTI 更加强大，而后者只不过是为一个“static”的语言增加的一点点功能而已。C++ 的 RTTI 在很多情况下是不被推荐使用的，因为它过于依赖编译器的实现，牺牲了跨平台的能力。
根类，id 类型，nil 和 Nil 的值
任何一个面向对象的语言都要管理很多类。同 Java 类似，Objective-C 有一个根类，所有的类都应该继承自这个根类（值得注意的是，在 Java 中，你声明一个类而不去显式指定它继承的父类，那么这个类就是 Object 类的直接子类；然而，在 Objective-C 中，单根类的子类必须被显式地说明）；而 C++ 并没有这么一个类。Cocoa 中，这个根类就是 NSObject，它提供了很多运行时所必须的能力，例如内存分配等等。另外需要说明一点，单根类并不是 Objective-C 语言规范要求的，它只不过是根据面向对象理论实现的。因此，所有 Java 虚拟机的实现，这个单根类都是 Object，但是在Objective-C 中，这就是与类库相关的了：在Cocoa 中，这个单根类是 NSObject，而在 gcc 的实现里则是 Object。
严格说来，每一个类都应该是 NSObject 的子类（相比之下，Java 应该说，每一个类都必须是 Object 的子类），因此使用 NSObject * 类型应该可以指到所有类对象的指针。但是，实际上我们使用的是 id 类型。这个类型更加简短，更重要的是，id 类型是动态类型检查的，相比来说，NSObject * 则是静态类型检查。Objective-C 里面没有泛型，那么，我们就可以使用 id 很方便的实现类似泛型的机制了。在 Objective-C 里面，指向空的指针应该声明为 nil，不能是 NULL。这两者虽然很相似但并不可以互换。一个普通的 C 指针可以指向 NULL，但是Objective-C 的类指针必须指向 nil。正如前文所说，Objective-C 里面，类也是对象（元类 Meta-Class 的对象）。nil 所对应的类就是 Nil。
类声明
属性和方法
在 Objective-C 里面，属性 attributes 被称为实例数据 instance data，成员函数 member functions 被称为方法 methods。如果没有特殊说明，在后续文章中，这两组术语都会被混用，大家见谅。
| C++ | Objective-C |
class Foo {
}; int Foo::f(int x) {...}
float Foo::g(int x, int y) {...}
| @interface Foo : NSObject {
} -(int) -(float) g:(int)x :(int)y; @end @implementation Foo -(int) -(float) g:(int)x :(int)y {...}
@end |
在 C++ 中，属性和成员函数都在类的花括号块中被声明。方法的实现类似于 C 语言，只不过需要有作用于指示符（Foo::）来说明这个函数属于哪个类。
Objective-C 中，属性和方法必须分开声明。属性在花括号中声明，方法要跟在下面。它们的实现要在 @implementation 块中。
这是与 C++ 的主要不同。在Objective-C 中，有些方法可以不被暴露在接口中，例如 private 的。而 C++ 中，即便是 private 函数，也能够在头文件中被看到。简单来说，这种分开式的声明可以避免 private 函数污染头文件。
实例方法以减号 – 开头，而 static 方法以 + 开头。注意，这并不是 UML 中的 private 和 public 的区别！参数的类型要在小括号中，参数之间使用冒号 : 分隔。
Objective-C 中，类声明的末尾不需要使用分号 ;。同时注意，Objective-C 的类声明关键字是 @interface，而不是 @class。@class 关键字只用于前向声明。最后，如果类里面没有任何数据，那么花括号可以被省略。
前向声明
为避免循环引用，C 语言有一个前向声明的机制，即仅仅告诉存在性，而不理会具体实现。C++ 使用 class 关键字实现前向声明。在 Objective-C 中则是使用 @class 关键字；另外，还可以使用 @protocol 关键字来声明一个协议（我们会在后面说到这个概念，类似于 Java 里面的 interface）。
| C++ | |
//In file Foo.h #ifndef __FOO_H__ #define __FOO_H__ class Bar; //forward declaration class Foo {
public:
}; #endif | //In file Foo.cpp #include "Foo.h" #include "Bar.h" void Foo::useBar(void) {
} |
| Objective-C | |
//In file Foo.h @class Bar; //forward declaration @interface Foo : NSObject {
} -(void) useBar; @end | //In file Foo.m #import "Foo.h" #import "Bar.h" @implementation Foo -(void) useBar {
} @end |
private，protected 和 public
访问可见性是面向对象语言的一个很重要的概念。它规定了在源代码级别哪些是可见的。可见性保证了类的封装性。
| C++ | Objective-C |
class Foo {
public:
protected:
private:
}; | @interface Foo : NSObject {
@public:
@protected:
@private:
} -(int) apple; -(int) pear; -(int) banana; @end |
在 C++ 中，属性和方法可以是 private，protected 和 public 的。默认是 private。
在 Objective-C 中，只有成员数据可以是 private，protected 和 public 的，默认是 protected 。方法只能是 public 的。然而，我们可以在 @implementation 块中实现一些方法，而不在 @interface 中声明；或者是使用分类机制（class categories）。这样做虽然不能阻止方法被调用，但是减少了暴露。不经过声明实现一些方法是 Objective-C 的一种特殊属性，有着特殊的目的。我们会在后面进行说明。
Objective-C 中的继承只能是 public 的，不可以是 private 和 protected 继承。这一点，Objective-C 更像 Java 而不是 C++。
static 属性
Objective-C 中不允许声明 static 属性。但是，我们有一些变通的方法：在实现文件中使用全局变量（也可以添加 static 关键字来控制可见性，类似 C 语言）。这样，类就可以通过方法访问到，而这样的全局变量的初始化可以在类的 initialize 方法中完成。
方法
Objective-C 中的方法与 C++ 的函数在语法方面风格迥异。下面，我们就来讲述 Objective-C 的方法。
原型、调用、实例方法和类方法
·
·
·
·
·
C++
// 原型
void Array::insertObject(void *anObject, unsigned int atIndex);
// shelf 是 Array 类的一个实例，book 是一个对象
shelf.insertObject(book, 2);
Objective-C（不带 label，即直接从 C++ 翻译来）
// 方法原型
// 方法名字是“insertObject::”
// 这里的冒号:用来分隔参数，成为方法名的一部分（注意，这不同于 C++ 的域指示符::）
-(void) insertObject:(id)anObject:(unsigned int)index
// shelf 是 Array 类的一个实例，book 是一个对象
[shelf insertObject:book:2];
Objective-C（带有 label）
// 方法原型。“index” 有一个标签“atIndex”
// 方法名为“insertObject:atIndex:”
// 这样的话，调用语句就很容易阅读了
-(void) insertObject:(id)anObject atIndex:(unsigned int)index
// shelf 是 Array 类的一个实例，book 是一个对象
[shelf insertObject:book:2];// 错误！
[shelf insertObject:book atIndex:2]; // 正确
注意，方括号语法不应该读作“调用 shelf 对象的 insertObject 方法”，而应该是“向 shelf 对象发送一个 insertObject 消息”。这是Objective-C 的实现方式。你可以向任何对象发送任何消息。如果目标对象不能处理这个消息，它就会将消息忽略（这会引发一个异常，但不会终止程序）。如果接收到一个消息，目标对象能够处理，那么，目标对象就会调用相应的方法。如果编译器能够知道目标对象没有匹配的方法，那么编译器就会发出一个警告。鉴于 Objective-C 的前向机制，这并不会作为一个错误。如果目标对象是 id 类型，那么在编译期就不会有警告，但是运行期可能会有潜在的错误。
this，self 和 super
一个消息有两个特殊的目标对象：self 和 super。self 指当前对象（类似 C++ 的 this），super 指父对象。Objective-C 里面没有 this 指针，取而代之的是 self。
注意，self 不是一个关键字。实际上，它是每个消息接收时的隐藏参数，其值就是当前对象。它的值可以被改变，这一点不同于 C++ 的 this 指针。然而，这一点仅仅在构造函数中有用。
在方法中访问实例变量
同 C++ 一样，Objective-C在方法中也可以访问当前对象的实例变量。不同之处在于，C++ 需要使用 this->，而Objective-C 使用的是 self->。
| C++ | Objective-C |
class Foo {
}; void Foo::f(void) {
} | @interface Foo : NSObject {
} -(void) f; @end @implementation Foo -(void) f {
} @end |
原型的 id、签名和重载
函数就是一段能够被引用的代码，例如使用函数指针。一般的，方法名会作为引用方法的唯一 id，但是，这就需要小心有重载的情况。C++ 和 Objective-C 使用截然不同的两种方式去区分：前者使用参数类型，后者使用参数标签。
在 C++ 中，只要函数具有不同的参数类型，它们就可以具有相同的名字。const 也可以作为一种重载依据。
C++
int f(int);
int f(float); // 允许，float 和 int 是不同类型
class Foo
{
public:
int g(int);
int g(float); // 允许，float 和 int 是不同类型
int g(float) const; // 允许，const 可以作为重载依据
};
class Bar
{
public:
int g(int); // 允许，我们使用的是 Bar::，而不是 Foo::
}
在 Objective-C 中，所有的函数都是普通的 C 函数，不能被重载（除非指定使用 C99标准）。方法则具有不同的语法，重载的依据是 label。
Objective-C
int f(int);
int f(float); // 错误！C 函数不允许重载
@interface Foo : NSObject
{
}
-(int) g:(int) x;
-(int) g:(float) x; // 错误！类型不同不作为重载依据，同上一个没有区别
-(int) g:(int) x :(int) y;// 正确：两个匿名 label
-(int) g:(int) x :(float) y; // 错误：同上一个没有区别
-(int) g:(int) x andY:(int) y;// 正确：第二个 label 是 “andY”
-(int) g:(int) x andY:(float) y; // 错误：同上一个没有区别
-(int) g:(int) x andAlsoY:(int) y; // 正确：第二个 label 是 “andAlsoY”
@end
基于 label 的重载可以很明白地解释方法的名字，例如：
@interface Foo : NSObject {}
// 方法名是“g”
-(int) g;
// 方法名是“g:”
-(int) g:(float) x;
// 方法名是“g::”
-(int) g:(float) x :(float) y;
// 方法名是“g:andY:”
-(int) g:(float) x andY:(float) y;
// 方法名是“g:andZ:”
-(int) g:(float) x andZ:(float) z;
@end
显然，Objective-C 的方法使用 label 区分，而不是类型。利用这种机制，我们就可以使用选择器 selector 来指定一个方法，而不是“成员函数指针”。
成员函数的指针：选择器
在 Objective-C 中，方法具有包含了括号和标签的特殊语法。普通的函数不能使用这种语法。在 Objective-C 和 C 语言中，函数指针具有相同的概念，但是对于成员函数指针则有所不同。
在 C++ 中，尽管语法很怪异，但确实兼容 C 语言的：成员函数指针也是基于类型的。
C++
class Foo
{
public:
};
Foo bar
int (Foo::*p_f)(float) = &Foo::f; // Foo::f 函数指针
(bar.*p_f)(1.2345); // 等价于 bar.f(1.2345);
在 Objective-C 中，引入了一个新的类型：指向成员函数的指针被称为选择器 selector。它的类型是 SEL，值通过 @selector 获得。@selector 接受方法名（包括 label）。使用类 NSInvocation 则可以通过选择器调用方法。大多时候，工具方法族 performSelector: （继承自 NSObject）更方便，约束也更大一些。其中最简单的三个是：
-(id) performSelector:(SEL)aSelector;
-(id) performSelector:(SEL)aSelector withObject:(id)anObjectAsParameter;
-(id) performSelector:(SEL)aSelector withObject:(id)anObjectAsParameter
这些方法的返回值同被调用的函数的返回值是一样的。对于那些参数不是对象的方法，应该使用该类型的包装类，如 NSNumber 等。NSInvocation 也有类似的功能，并且更为强大。
按照前面的说法，我们没有任何办法阻止在一个对象上面调用方法，即便该对象并没有实现这个方法。事实上，当消息被接收到之后，方法会被立即触发。但是，如果对象并不知道这个方法，一个可被捕获的异常将被抛除，应用程序并不会被终止。我们可以使用 respondsToSelector: 方法来检查对象是否可被触发方法。
最后，@selector 的值是在编译器决定的，因此它并不会减慢程序的运行效率。
Objective-C
@interface Slave : NSObject {}
-(void) readDocumentation:(Document*)document;
@end
// 假设 array[] 是包含 10 个 Slave 对象的数组，
// document 是一个 Document 指针
// 正常的方法调用是
for(i=0 ; i<10 ; ++i)
// 下面使用 performSelector: 示例：
for(i=0 ; i<10 ; ++i)
// 选择器的类型是 SEL
// 下面代码并不比前面的高效，因为 @selector() 是在编译器计算的
SEL methodSelector = @selector(readDocumentation:);
for(i=0 ; i<10 ; ++i)
// 对于一个对象“foo”，它的类型是未知的（id）
// 这种测试并不是强制的，但是可以避免没有 readDocumentation: 方法时出现异常
if ([foo respondsToSelector:@selector(readDocumentation:)])
因此，选择器可被用作函数参数。通用算法，例如排序，就可以使用这种技术实现。
严格说来，选择器并不是一个函数指针。它的底层实现是一个 C 字符串，在运行时被注册为方法的标识符。当类被加载之后，它的方法会被自动注册到一个表中，所以 @selector 可以很好的工作。根据这种实现，我们就可以使用 == 来判断内存地址是否相同，从而得出选择器是否相同，而无需使用字符串函数。
方法的真实地址，也就是看做 C 字符串的地址，其实可以看作是 IMP 类型（我们以后会有更详细的说明）。这种类型很少使用，除了在做优化的时候。例如虚调用实际使用选择器处理，而不是 IMP。等价于 C++ 函数指针的 Objective-C 的概念是选择器，也不是 IMP。
最后，你应该记得我们曾经说过 Objective-C 里面的 self 指针，类似于 C++ 的 this 指针，是作为每一个方法的隐藏参数传递的。其实这里还有第二个隐藏参数，就是 _cmd。_cmd 指的是当前方法。
@implementation Foo
-(void) f:(id)parameter
{
}
@end
参数的默认值
Objective-C 不允许参数带有默认值。所以，如果某些参数是可选的，那么就应当创建多个方法的副本。在构造函数中，这一现象成为指定构造函数（designated initializer）。
可变参数
Objective-C 允许可变参数，语法同 C 语言一样，使用 … 作为最后一个参数。这实际很少用到，即是 Cocoa 里面很多方法都这么使用。
匿名参数
C++ 允许匿名参数，它可以将不使用的参数类型作为一种占位符。Objective-C 不允许匿名参数。
原型修饰符（const，static，virtual，”= 0″，friend，throw）
在 C++ 中，还有一些可以作为函数原型的修饰符，但在 Objective-C 中，这都是不允许的。以下是这个的列表：
·
·
·
·
·
消息和消息传输
给 nil 发送消息
默认情况下，给 nil 发送消息也是合法的，只不过这个消息被忽略掉了。这种机制可以避免很多检查指针是否为空的情况。不过，有些编译器，比如 GCC，也允许你通过编译参数的设置关闭这一特性。
将消息代理给未知对象
代理 delegation 是 Cocoa 框架中 UI 元素的一个很常见的部分。代理可以将消息转发给一个未知的对象。通过代理，一个对象可以将一些任务交给另外的对象。
// 设置一个辅助对象 assistant
-(void) setAssistant:(id)slave
{
[assistant autorelease];
assistant = [slave retain];
}
// 方法 performHardWork 使用代理
-(void) performHardWork:(id)task
{
// assistant 在编译期是未知的
// 我们首先要检查它是否能够响应消息
if ([assistant respondsToSelector:@selector(performHardWork:)])
[assistant performHardWork:task];
else
[self findAnotherAssistant];
}
转发：处理未知消息
在 C++ 中，如果对象函数没有实现，是不能通过编译的。Objective-C 则不同，你可以向对象发送任何消息。如果在运行时无法处理，这个消息就被忽略了（同时会抛出一个异常）。除了忽略它，另外的处理办法是将消息转发给另外的对象。
当编译器被告知对象类型时，它可以知道对象可以处理哪些消息，因此就可以知道消息发出后是否会失败，也就可以抛出异常。这也就是为什么消息在运行时被执行，但是编译时就可以发出警告。这并不会引发错误，同时还有另外的选择：调用 forwardInvocation: 方法。这个方法可以将消息进行转发。这个方法是 NSObject 的，默认不做任何操作。下面代码就是一种实现：
-(void) forwardInvocation:(NSInvocation*)anInvocation
{
// 如果该方法被调用，意味着我们无法处理这个消息
// 错误的选择器（也就是调用失败的那个方法名）可以通过
// 向 anInvocation 对象发送“selector” 获得
if ([anotherObject respondsToSelector:[anInvocation selector]])
[anInvocation invokeWithTarget:anotherObject];
else // 不要忘记调用父类的实现
[super forwardInvocation:anInvocation];
}
即是在最后，这个消息在 forwardInvocation: 中被处理，respondsToSelector: 还是会返回 NO。事实上，respondsToSelector:并不是用来检查 forwardInvocation: 是否被调用的。
使用这种转发机制有时候被认为是一种不好的习惯，因为它会隐藏掉本应引发错误的代码。事实上，一些很好的设计同样可以使用这种机制实现，例如 Cocoa 的 NSUndoManager。它允许一种对异常友好的语法：undo manager 可以记录方法调用历史，虽然它并不是那些调用的接收者。
向下转型
C++ 中，父类指针调用子类的函数时，需要有一个向下转型的操作（downcasting），使用dynamic_cast 关键字。在Objective-C 中，这是不必要的。因为你可以将任何消息发送给任何对象。但是，为了避免编译器的警告，我们也可以使用简单的转型操作。Objective-C 中没有类似 C++ 的专门的向下转型的操作符，使用 C 风格的转型语法就可以了。
// NSMutableString 是 NSString 的子类
// 允许字符串修改的操作
// "appendString:" 仅在 NSMutableString 中实现
NSMutableString* mutableString = ... 初始化可变字符串 ...
NSString* string = mutableString;// 传给 NSString 指针
// 这些调用都是合法的
[string appendString:@"foo"]; // 有编译器警告
[(NSMutableString*)string appendString:@"foo"]; // 无警告
[(id)string appendString:@"; // 无警告
541
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
