iOS面试题(一)

记录一些自己遇到的iOS面试题

1.OC中的引用计数是什么？

在C语言中，只存在内存地址的分配和释放。同一个内存地址可以被多个指针指向。

int number = 4; // 定义一个数字
int *a = malloc(8); // 从堆区分配空间
*a = number; // 是指针a指向number
int *b = a; // 将指针a的值赋给指针b
free(b); // 释放指针b

在上述代码中，指针a和b指向的是一个同一个内存地址，由指针a来开辟内存空间，最后通过b来释放内存空间。实际上这两个指针是完全一模一样的，即a ＝ b。对a和b做操作，相当于是对他们指向的内存空间做操作。

但是这样会产生一个问题，在指针b被释放之后，如同上面说的，指针b被释放，实际上是指针b指向的内存空间被释放掉了，也就是说，指针a指向的内存空间也不存在了。如果我们使用指针a这个变量，就会报野指针错误。

为了改善这一方面，OC就有了引用计数机制：

NSObject *a = [[NSObject alloc] init]; // 在堆区分配内存空间，引用计数为1

NSObject *b = [a retain]; // 对象b通过retain持有对象a，引用计数+1，当前引用计数为2

[a release]; // 释放对象a，引用计数-1，当前引用计数为1

NSLog(@"a: %@, b: %@", a, b); // a和b都可以使用

[b release]; // 释放对象b // 引用计数-1，引用计数变为0

NSLog(@"a: %@, b: %@", a, b); // a和b被真正释放了

在上述代码中，效果是和C语言是一样的，对象a和对象b是完全相等的，他们也是指向相同的内存地址。但OC代码中使用alloc来分配空间，retain用来持有对象，通过release来释放对象（在OC中，是不允许直接将对象释放的，当引用计数为0的时候，dealloc方法系统会自动调用）。这里的release实际上的效果是对这片内存地址上的引用计数-1，代表的意思虽然是释放该对象，但其实在该内存地址的引用计数不为o的时候，我们还可以继续使用它，这种做法只是在编译上告知我们该对象已经被释放，当引用计数变为0的时候该片内存地址就会被彻底释放。就是一个对象创建了就一定会被释放，当所有持有该内存地址的对象被释放了，该内存地址才会被真正的释放。

OC内存管理上要注意的就是引用计数实际上是对内存地址的持有者的一个计数，而不是对象本身。创建对象的时候一定要使用alloc，retain，new，copy等关键词来创建，而不能直接赋值（其实直接赋值也是可以的，但该对象不能被释放，只要以后不再使用这个对象就好了。为了更加的安全，还是规范的写更好一些）。释放对象的方式有两种：release和autorelease。它们的含义是释放了这个对象，实际作用都是给引用计数-1，而不是去释放内存地址。所以当释放了这个对象之后，如果还有其他对象持有该内存地址，就可以继续使用该对象，但是为了安全起见，当对象不在使用的时候将其释放，释放之后不要再去使用释放后的对象。如果该对象是唯一的持有者，就会引起野指针。

PS:不要过分的相信用retainCount来获取引用计数
例如：

定义一个Pet类
**Pet.h**
@interface Pet : NSObject
@property NSString *name;
@end

**Pet.m**
#import "Pet.h"
@implementation Pet
- (void)dealloc {
    NSLog(@"被释放了");
}

**main.m**
int main(int argc, const char * argv[]) {
    Pet *pet = [[Pet alloc] init];
    pet.name = @"小狗";
    NSLog(@"%lu", pet.retainCount);
    Pet *ppet = [pet retain];
    ppet.name = @"dog";
    NSLog(@"%lu", pet.retainCount);
    NSLog(@"%@", pet.name);
    NSLog(@"%@", ppet.name);
    [pet release];
    [ppet release];
    NSLog(@"%lu", pet.retainCount);
}
@end

输出：
2017-05-10 14:54:39.126428+0800 Demo[1573:227285] 1 2017-05-10 14:54:39.126625+0800 Demo[1573:227285] 2 2017-05-10 14:54:39.126671+0800 Demo[1573:227285] dog 2017-05-10 14:54:39.126714+0800 Demo[1573:227285] dog 2017-05-10 14:54:39.126759+0800 Demo[1573:227285] 被释放了 2017-05-10 14:54:39.126768+0800 Demo[1573:227285] 1
我们重写了dealloc方法，但是被释放后，我们输出的retainCount仍然为1，而不是0。这就与我们常规的认识有所不同，不是都说当retainCount == 0 时，才会被释放，而实验结果又与结论相悖。
stackoverflow上也有关于这个的讨论。

2.ViewController的生命周期

主要有以下几个方法，并按顺序执行

单个viewController的情况下：

*initWithCoder:(NSCoder )aDecoder如果使用storyboard或者xib
loadView 此方法之前没有view
viewDidLoad 此时已经有view了
viewWillAppear view即将显示，此时superView一般为nil，即view还没被加到任何一个view上去
viewWillLayoutSubviews 控制器的view将要布局子控件
viewDidLayoutSubviews 控制器的view布局子控件完成
这期间系统可能会多次调用viewWillLayoutSubviews ，viewDidLayoutSubviews 两个方法
viewDidAppear view已经显示了，即view已经被加到一个view上了
这期间系统可能会多次调用viewWillLayoutSubviews ， viewDidLayoutSubviews 两个方法
viewWillDisAppear view即将消失，此时一般还没有调用removeFromSuperView
viewDidAppear view从superView上移除
viewDidUnload 内存不足等情况
dealloc 引用计数为0

说明：当你alloc并init一个viewControlller时，这个viewController还没有创建view，viewController的view是通过懒加载的方式加载的。
如果需要用到但没有被创建时如self.view，才会调用loadView这个方法来创建view。loadView方法结束后，会执行viewDidLoad方法

多个viewController之间跳转：

当我们点击push加载下一个viewController,上一个viewController消失，新的viewController显示时

*initWithCoder:(NSCoder )aDecoder viewController2 (如果用xib创建的情况下）
loadView viewController2
viewDidLoad ViewController2
viewWillDisappear viewController1 将要消失
viewWillAppear viewController2 将要出现
viewWillLayoutSubviews viewController2
viewDidLayoutSubviews viewController2
viewWillLayoutSubviews viewController1
viewDidLayoutSubviews viewController1
viewDidDisappear viewController1完全消失
viewDidAppear viewController2完全显示

3.循环引用是什么？

循环引用简单的说就是，有A类，和B类，A中有了对B的引用，B中有对A的引用，构成了环路，造成无法从内存中释放，或是多个类之间互相引用，形成环路。
举个例子🌰

**Teacher.h**
#import <Foundation/Foundation.h>
@class Student;
@interface Teacher : NSObject
@property (nonatomic, weak)Student *student;
@property (nonatomic, copy)NSString *teacherName;
@end

**Teacher.m**
#import "Teacher.h"
@implementation Teacher
- (void)dealloc {
    NSLog(@"叫%@的Teacher对象被销毁了",_teacherName);
}
@end

**Student.h**
#import <Foundation/Foundation.h>
#import "Teacher.h"
@interface Student : NSObject
@property (nonatomic, stong) Teacher *teacher;
@property (nonatomic, copy) NSString *studentName;
@end

**Student.m**
#import "Student.h"
@implementation Student
- (void)dealloc {
    NSLog(@"叫%@的Student对象被销毁了", _studentName);
}
@end

**main.m**
#import <Foundation/Foundation.h>
#import "Teacher.h"
#import "Student.h"

int main(int argc, const char * argv[]) {
    
    Teacher *teacher = [[Teacher alloc] init];
    teacher.teacherName = @"张老师";
    Student *student = [[Student alloc] init];
    student.studentName = @"王同学";
    
    teacher.student = student;
    student.teacher = teacher;
    return 0;
}

输出： 2017-05-09 20:28:13.711174+0800 Demo[1432:272469] 叫王同学的Student对象被销毁了 2017-05-09 20:28:13.711819+0800 Demo[1432:272469] 叫张老师的Teacher对象被销毁了
其中Teacher对Student为弱引用，用weak关键词表示
Student对Teacher为强引用，可以用retain或者strong表示
如果两边都是强引用，将不会有任何输出信息，因为这就造成了循环引用,两者都无法从内存中释放。

其他几种产生循环引用的情况：

delegate
Delegate是ios中开发中最常遇到的循环引用，一般在声明delegate的时候都要使用弱引用weak或者assign
当然怎么选择使用assign还是weak，MRC的话只能用assign，在ARC的情况下最好使用weak，因为weak修饰的变量在释放后自动指向nil，防止野指针存在
@property (nonatomic, weak, nullable) id <UITableViewDelegate> delegate;
** block**
最普遍的情况：

[self.teacher requestData:^(NSData *data) {
    self.name = @"case";
}];

self -> teacher -> block -> self
这里的self强引用了teacher，teacher又强引用了block，而block中有调用了self.name，这造成了block又强引用了self，这就形成了环路，发生了循环引用，造成内存泄漏。
一般性的解决方案:

__weak typeof(self) weakSelf = self;
    [self.teacher requestData:^(NSData *data) {
        typeof(weakSelf) strongSelf = weakSelf;
       strongSelf.name = @"case";
    }];

通过_weak的修饰，先把self弱引用（默认是强引用，实际上self是有个隐藏的_strong修饰的），然后在block回调里用weakSelf，这样就会打破保留环，从而避免了循环引用，如下：
self -> teacher -> block -> weakSelf

计时器NSTimer
即：NSTImer常常会被作为某个类的成员变量，而NSTimer初始化时需要制定target，一般为self。这就容易造成循环引用，一方面该类对NSTimer有一个强引用，另一方面设定target后，NSTimer也会对该类形成一个强引用。
该类需要释放，必须释放它所有的成员变量，包括NSTimer。而需要释放NSTimer，则必须要释放它所有的target，但是这个类就是它的target。这就形成了循环引用
解决方法:
将NSTimer设为弱连接，即weak