C#语言中很早就开始有了属性这个概念了，而且很方便使用，也很符合面向对象的特性，OC2.0的时候也加入了对属性的支持，属性用起来确实方便顺手，甚至现在有开发者可能从来就没定义过成员变量。本篇文章通过一种对成员变量很不常见的访问方式来引申出指针变量的本质和用法；
内容提要
- 1.我们熟知的访问形式
- 2.通过指针解引用访问
- 3.一切起源于C语言指针变量解引用
- 4.iOS开发中指针变量解引用的使用场景
示例代码
@interface Girl : NSObject {
@public
NSString *_name;
}
@property (nonatomic, copy) NSString *name;
@end
@implementation Girl
@end
1. 我们熟知的访问形式
属性访问式 :
这是我们最容易掌握的一种使用方式，所以甚至有的开发者在开发中只会定义属性
girl.name = @"Lucy";指针访问式 :
作为一个有洁癖的程序员，更多时候还是定义成员变量而不是属性，因为至少减少了一次方法调用，减少了内存占用
girl->_name = @"Lily";KVC访问式 :
如果一个类的成员变量是私有的，然后我想访问它，可以使用KVC的方式
[girl setValue:@"Poly" forKey:@"name"];
2. 通过指针解引用访问(有些脑洞的访问方式)
- 指针解引用法：
大家应该只用到上面介绍的用法，但OC作为C语言的超集，下面这个用法虽然奇葩但确实正确无疑的
(*girl)._name = @"Tom";
为什么我要介绍这种奇葩用法
3. 一切起源于C语言指针变量解引用
C语言中指针变量的值存储的是一个地址，这个地址指向一个其他变量的(可以是基本类型，结构体，甚至其他指针变量)，而当我们想要操作这个地址指向的变量时我们需要对指针变量解引用，可以认为取地址&和解引用*是一组相对的操作，可以相互转化；
- 基本类型的指针操作：
int a = 1;
int *p1 = &a; // 指针变量p1指向了int变量a的地址（用&符号取地址）
int b = *p1; // 效果等同于b = a; *p1取得的是p1指针指向的变量
- 结构体的指针操作：
// 定义一个结构体
typedef struct DemoStruct{
int age;
} DemoStruct;
DemoStruct st;
DemoStruct *p1 = &st; // 指向结构体st的指针
p1->age = 100; // p1指向的结构体变量的age
(*p1).age = 101; // 结构体(*p1)的age
DemoStruct st1 = (*p1); // 效果等同于st1 = st;
我们知道OC中的类最终都会转化成一个结构体而存在，而类的实例对象其实是一个指向该结构体的指针，比如id类型就是一个结构体指针，所以对于实例对象我们可以像C语言(指针)一样操作，所以我们可以使用obj->语法和(*obj)语法，这两种使用起来是等效的，至于为什么会有两种用法可以去百度一下这个历史问题；
所谓的OC对象其实是个指针变量
4. iOS开发中变量取地址和指针解引用的使用场景
-
值类型的引用传参
如果想在方法内部改变外部传递进来的基本数据类型变量我们可以像下面一样通过地址引用传参，其实传递的是一个指针参数，使用的时候通过指针解引用可以获取外面定义的变量：
- (BOOL)takeMoney:(NSUInteger *)money {
*money = 100; // 解引用后进行赋值
return YES;
}
- (void)viewDidLoad {
[super viewDidLoad];
NSUInteger money;
NSUInteger *pMoney = &money;
// 传参的时候，使用&取得变量的地址
if ([self takeMoney:&money]) {
// if ([self takeMoney:pMoney) { // 这里使用这行代码可达到同样的效果
NSLog(@"取钱成功，本次取出%lu", money);
}
// 系统数组遍历方法中也包含一个BOOL类型的引用传参，因为block的调用者想知道block执行后的这个stop值，所以使用引用传参
[@[] enumerateObjectsUsingBlock:^(id _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
*stop = YES;
}];
-
对象类型的引用传参
OC的对象是一个结构体指针对象，所以如果从C语言的用法来说我们可以传递这个指针对象，然后在方法内部通过指针解引用，改变这个结构体的值，但是实际上是不可行的，我们需要遵循OC对象的生成方式，经过alloc init等方法才能创建一个正确的对象：
结构体引用穿参(传地址)
typedef struct MyStruct {
int a;
int b;
} MyStruct;
- (void)method1:(MyStruct *)myStruct {
*myStruct = ({
MyStruct st;
st.a = 1;
st.b = 2;
st;
});
}
- (void)viewDidLoad {
[super viewDidLoad];
MyStruct s;
[self method1:&s]; // 这行代码运行后s变量的值会被改变
尝试把OC类当做普通结构体来用(当然报错)
MyStruct *st1;
MyStruct *st2;
*st1 = *st2; // 没问题，结构体可以这样赋值
UIView *v = [UIView new];
UIView *v1 = [UIView new];
*v = *v1; // 编译报错 can not assign class object ('UIView' invalid)
OC方法内部改变外部OC对象只能使用指针的指针方式了
@interface MyObject : NSObject {
@public
NSInteger _age;
NSInteger _score;
}
@end
@implementation MyObject
- (NSString *)description {
return [NSString stringWithFormat:@"age:%ld, score:%ld", _age, _score];
}
@end
- (void)method2:(MyObject **)obj {
// obj是一个指针变量(指向另一个指针变量 = MyObject的实例对象)
// *obj将obj解引用后将得到这个指针指向的一个指针变量 = 外部的MyObject的实例对象
*obj = ({
MyObject *o = [MyObject new];
o->_age = 22;
o->_score = 59;
o;
});
// 这里的ob改变后只是将指针指向了另外一个对象并不能改变外部的MyObject的实例对象
__autoreleasing MyObject *o1 = ({
MyObject *o1 = [MyObject new];
o1->_age = 25;
o1->_score = 60;
o1;
});;
obj = &o1;
}
- (void)viewDidLoad {
[super viewDidLoad];
NSObject *o;
[self method2:&o];
NSLog(@"调用方法后的变量o:%@", o); // 输出：调用方法后变量O:age:22, score:59
Foundation框架中有不少的API方法都使用了对象地址传参的方式
比如：
- (BOOL)removeItemAtPath:(NSString *)path error:(NSError **)error NS_AVAILABLE(10_5, 2_0);
现在回到上面那个奇葩的用法
// girl可以看做是一个结构体指针，我们需要访问这个结构体成员变量时，只需要对这个指针解引用
// (*girl)可以看做是一个结构体，可以访问它的成员，但不能对它进行赋值
(*girl)._name = @"Tom";
总结总结：
因为OC方法的形参变量都是对实参变量进行了拷贝（拷贝基本类型变量的值，或者拷贝指针变量存储的地址），如果方法内部想改变外部的变量那么只要传递外部变量的地址即可；
.
不过(*girl)._name这个用法与girl->_name相比确实没有什么好处，敲起来也不顺手，不值的模仿
--------- 重要更新 -----------
着重提一下：文中method2中关于形参，实参，传值方式的注释本身是没有问题的，但是有细心的朋友运行后发现原本方法中的*obj和方法外的形参&o理论上应该是相等，然而运行后并不相等，这个问题的原因归结为编译器的优化。这个优化是基于下面2个事实
事实一：OC的内存管理的三大原则其中一条是“谁生成的对象谁负责释放”，那么method2内部生成的对象就应该method2负责释放，但是这个对象生成本来就是给方法外部使用的，所以不能在方法作用域结束的时候直接释放该对象，而是要延迟释放，没错，将这个对象加入到自动释放池中即可；这点系统编译器已经给我们做了。编译器会将方法转换成如下
// 方法内部给obj指向的对象赋值以后会添加到自动释放池中
- (void)method2:(MyObject * __autoreleasing *)obj {
事实二：__strong修饰的局部变量，编译器会在方法结束之前调用release方法释放该局部变量，这种前提下method2内部生成的对象(引用计数1)已经由自动释放池来管理了，如果o在出作用域之前调用了release(引用计数变为0), 那么在自动释放池清理调用该对象的release方法导致过度释放出现崩溃； 所以系统编译器自动为我们做了转换，由于编译器是不会改变我们声明的对象o的内存管理方式，所以会再生成了一个临时对象，最后在方法调用完以后又将临时对象temp赋给o，这样就给我们造成一直使用的都是o的假象，真是完美的伪装。
NSObject *o;
[self method2:&o];
上面代码在编译器会将它变成下面的样子
__strong NSObject *o; // nil
__autoreleasing NSObject *temp = o; // nil，这句话会将temp指向的对象加入到自动释放池，因为此时指向对象为nil，系统不会将这个nil添加到自动释放池
[self method2:&temp]; // 调用后temp指向对象引用计数为1
o = temp; // 因为o是__strong修饰的，所以此时o指向对象引用计数变为2 ， 最后当o出作用域时会调用一次release, 然后自动释放池会调用一次release
引申思考：
- 如果我们声明的对象NSObject *o前面加上__autoreleasing会怎样？
__autoreleasing NSObject *o;
- 如果我们method2方法参数强制使用__strong修饰会怎样？
- (void)method2:(MyObject * __strong *)obj {
|
|
|
|
|
引
|
申
|
分
|
析
|
|
|
|
- 结果就是编译器不会再为我们添加temp的临时变量了，这样我们方法调用前的&o和方法内部的obj是相等的；这种就避免了编译器的优化，但编译器优化同时会带来额外的代价(至少多了2行代码)，所以如果你想更好的话，就在变量声明的时候显示指定用__autoreleasing来修饰。【推荐做法】
- 因为参数obj是__strong修饰的所以方法内部赋值的时候
*obj = xxx就会使指向的对象的引用计数+1，因为*obj指针(外面的o)并不是在方法内部声明的，所以方法结束之前编译器并不会插入[*obj release]所以该对象在出了方法作用域以后也不会释放, 等外层调用方法viewDidLoad执行之前，编译器会添加[o release]方法从而释放该对象；这种方式虽然是可行的但是却要求我们每次都指定__strong修饰符，并且这种方式的内存管理其实不符合内存管理的“谁申请谁释放”的原则，所以系统默认缺省修饰符就是__autoreleasing；【不推荐使用】
