iOS 面试题--转自唐巧

iOS-2025进阶面试题加答案 文章摘要:本文系统梳理了iOS开发核心技术要点,包括:1) Objective-C内存管理机制,重点解析copy与strong的原理差异;2) 多线程方案比较,涵盖GCD与NSOperation的适用场景;3) Runtime消息转发机制及动态方法实现;4) UITableView性能优化策略;5) Block循环引用解决方案。深入探讨Swift特性,包括:1) Swift Concurrency与GCD的线程管理对比;2) Actor模型线程安全机制;3) 混编环境下的内存管理陷阱;4) 协议扩展方法派发 阅读详情
AI摘要

本文精选了多道iOS面试题,涵盖Objective-C语法、内存管理、数据结构与算法等内容,旨在帮助开发者深入理解iOS开发的核心技术和面试技巧。

iOS 面试题(一)寻找最近公共 View

题目:找出两个 UIView 的最近的公共 View,如果不存在,则输出 nil 。
分析:这其实是数据结构里面的找最近公共祖先的问题。

一个UIViewController中的所有view之间的关系其实可以看成一颗树,UIViewController的view变量是这颗树的根节点,其它的view都是根节点的直接或间接子节点。

所以我们可以通过 view 的 superview 属性,一直找到根节点。需要注意的是,在代码中,我们还需要考虑各种非法输入,如果输入了 nil,则也需要处理,避免异常。以下是找到指定 view 到根 view 的路径代码:

+ (NSArray *)superViews:(UIView *)view {
    if (view == nil) {
        return @[];
    }
    NSMutableArray *result = [NSMutableArray array];
    while (view != nil) {
        [result addObject:view];
        view = view.superview;
    }
    return [result copy];
}

然后对于两个 view A 和 view B,我们可以得到两个路径,而本题中我们要找的是这里面最近的一个公共节点。

一个简单直接的办法:拿第一个路径中的所有节点,去第二个节点中查找。假设路径的平均长度是 N,因为每个节点都要找 N 次,一共有 N 个节点,所以这个办法的时间复杂度是 O(N^2)。

+ (UIView *)commonView_1:(UIView *)viewA andView:(UIView *)viewB {
    NSArray *arr1 = [self superViews:viewA];
    NSArray *arr2 = [self superViews:viewB];
    for (NSUInteger i = 0; i < arr1.count; ++i) {
        UIView *targetView = arr1[i];
        for (NSUInteger j = 0; j < arr2.count; ++j) {
            if (targetView == arr2[j]) {
                return targetView;
            }
        }
    }
    return nil;
}

一个改进的办法:我们将一个路径中的所有点先放进 NSSet 中。因为 NSSet 的内部实现是一个 hash 表,所以查找元素的时间复杂度变成了 O(1),我们一共有 N 个节点,所以总时间复杂度优化到了 O(N)。

+ (UIView *)commonView_2:(UIView *)viewA andView:(UIView *)viewB {
    NSArray *arr1 = [self superViews:viewA];
    NSArray *arr2 = [self superViews:viewB];
    NSSet *set = [NSSet setWithArray:arr2];
    for (NSUInteger i = 0; i < arr1.count; ++i) {
        UIView *targetView = arr1[i];
        if ([set containsObject:targetView]) {
            return targetView;
        }
    }
    return nil;
}

除了使用 NSSet 外,我们还可以使用类似归并排序的思想,用两个「指针」,分别指向两个路径的根节点,然后从根节点开始,找第一个不同的节点,第一个不同节点的上一个公共节点,就是我们的答案。代码如下:

/* O(N) Solution */
+ (UIView *)commonView_3:(UIView *)viewA andView:(UIView *)viewB {
    NSArray *arr1 = [self superViews:viewA];
    NSArray *arr2 = [self superViews:viewB];
    NSInteger p1 = arr1.count - 1;
    NSInteger p2 = arr2.count - 1;
    UIView *answer = nil;
    while (p1 >= 0 && p2 >= 0) {
        if (arr1[p1] == arr2[p2]) {
            answer = arr1[p1];
        }
        p1--;
        p2--;
    }
    return answer;
}

我们还可以使用 UIView 的 isDescendant 方法来简化我们的代码,不过这样写的话,时间复杂度应该也是 O(N^2) 的。lexrus 提供了如下的 Swift 版本的代码:

/// without flatMap
extension UIView {    
func commonSuperview(of view: UIView) -> UIView? {        
    if let s = superview {            
       if view.isDescendant(of: s) {                
                 return s
            } else {                
                 return s.commonSuperview(of: view)
            }
        }        
       return nil
    }
}

特别地,如果我们利用 Optinal 的 flatMap 方法,可以将上面的代码简化得更短,基本上算是一行代码搞定。怎么样,你学会了吗?

extension UIView {
    func commonSuperview(of view: UIView) -> UIView? {
        return superview.flatMap { 
           view.isDescendant(of: $0) ? 
             $0 : $0.commonSuperview(of: view) 
        }
    }
}

iOS 面试题(二)什么时候在 block 中不需要使用 weakSelf

问题:我们知道,在使用 block 的时候,为了避免产生循环引用,通常需要使用 weakSelf 与 strongSelf,写下面这样的代码:

__weak typeof(self) weakSelf = self;
[self doSomeBlockJob:^{
    __strong typeof(weakSelf) strongSelf = weakSelf;
    if (strongSelf) {
        ...
    }
}];

那么请问:什么时候在 block里面用self,不需要使用weakself?

当block本身不被self 持有,而被别的对象持有,同时不产生循环引用的时候,就不需要使用weakself了。最常见的代码就是UIView的动画代码,我们在使用UIView animateWithDuration:animations方法 做动画的时候,并不需要使用weakself,因为引用持有关系是:

UIView 的某个负责动画的对象持有block,block 持有了self因为 self 并不持有 block,所以就没有循环引用产生,因为就不需要使用 weak self 了。

[UIView animateWithDuration:0.2 animations:^{
    self.alpha = 1;
}];

当动画结束时,UIView会结束持有这个 block,如果没有别的对象持有block的话,block 对象就会释放掉,从而 block会释放掉对于 self 的持有。整个内存引用关系被解除。

iOS 面试题(三)什么时候在 block 中不需要使用 weakSelf

我们知道,在使用 block 的时候,为了避免产生循环引用,通常需要使用 weakSelf 与 strongSelf,写下面这样的代码:

__weak typeof(self) weakSelf = self;
[self doSomeBackgroundJob:^{
    __strong typeof(weakSelf) strongSelf = weakSelf;
    if (strongSelf) {
        ...
    }
}];

那么请问:为什么 block 里面还需要写一个 strong self,如果不写会怎么样?

在 block 中先写一个 strong self,其实是为了避免在 block 的执行过程中,突然出现 self 被释放的尴尬情况。通常情况下,如果不这么做的话,还是很容易出现一些奇怪的逻辑,甚至闪退。

我们以AFNetworking中的AFNetworkReachabilityManager.m的一段代码举例:

__weak __typeof(self)weakSelf = self;
AFNetworkReachabilityStatusBlock callback = ^(AFNetworkReachabilityStatus status) {
    __strong __typeof(weakSelf)strongSelf = weakSelf;
    strongSelf.networkReachabilityStatus = status;
    if (strongSelf.networkReachabilityStatusBlock) {strongSelf.networkReachabilityStatusBlock(status);
    }
};

如果没有strongSelf的那行代码,那么后面的每一行代码执行时,self都可能被释放掉了,这样很可能造成逻辑异常。

特别是当我们正在执行 strongSelf.networkReachabilityStatusBlock(status); 这个 block闭包时,如果这个 block 执行到一半时 self 释放,那么多半情况下会 Crash。

这里有一篇文章详细解释了这个问题:点击查看文章
昨天的读者中,拓荒者 和 陈祥龙 同学在评论中也正确回答出了本题。

拓荒者:
1.在block里使用strongSelf是防止在block执行过程中self被释放。 2.可以通过在执行完block代码后手动把block置为nil来打破引用循环,AFNetworking就是这样处理的,避免使用者不了解引用循环造成内存泄露。实际业务中暂时没遇到这种需求,请巧哥指点什么情况下会有这种需求。

陈祥龙:
strongSelf 一般是在为了避免 block 回调时 weak Self变成了nil ,异步执行一些操作时可能会出现这种情况,不知道我说得对不对。因业务需要不能使用weakSelf 这种情况还真没遇到过

另外,还有读者提了两个有意思的问题,大家可以思考一下:
Yuen 提问:“数组” 和 “字典” 的 enumeratXXXUsingBlock: 是否要使用 weakSelf 和 strongSelf 呢?
潇湘雨同学提问:block 里 strong self 后,block 不是也会持有 self 吗?而 self 又持有 block ,那不是又循环引用了?

iOS 面试题(四):block 什么时候需要构造循环引用

问题:有没有这样一个需求场景,block 会产生循环引用,但是业务又需要你不能使用 weak self? 如果有,请举一个例子并且解释这种情况下如何解决循环引用问题。

答案:需要不使用 weak self 的场景是:你需要构造一个循环引用,以便保证引用双方都存在。比如你有一个后台的任务,希望任务执行完后,通知另外一个实例。在我们开源的 YTKNetwork 网络库的源码中,就有这样的场景。

在 YTKNetwork 库中,我们的每一个网络请求 API 会持有回调的 block,回调的 block 会持有 self,而如果 self 也持有网络请求 API 的话,我们就构造了一个循环引用。虽然我们构造出了循环引用,但是因为在网络请求结束时,网络请求 API 会主动释放对 block 的持有,因此,整个循环链条被解开,循环引用就被打破了,所以不会有内存泄漏问题。代码其实很简单,如下所示:

//  YTKBaseRequest.m
- (void)clearCompletionBlock {
    // nil out to break the retain cycle.
    self.successCompletionBlock = nil;
    self.failureCompletionBlock = nil;
}

总结来说,解决循环引用问题主要有两个办法:

第一个办法是「事前避免」,我们在会产生循环引用的地方使用 weak 弱引用,以避免产生循环引用。
第二个办法是「事后补救」,我们明确知道会存在循环引用,但是我们在合理的位置主动断开环中的一个引用,使得对象得以回收。

iOS 面试题(五):weak 的内部实现原理

问题:weak 变量在引用计数为0时,会被自动设置成 nil,这个特性是如何实现的?
答案:在 Friday QA 上,有一期专门介绍 weak的实现原理。

《Objective-C高级编程》一书中也介绍了相关的内容。
简单来说,系统有一个全局的 CFMutableDictionary 实例,来保存每个对象的 weak 指针列表,因为每个对象可能有多个 weak 指针,所以这个实例的值是 CFMutableSet 类型。

剩下我们要做的,就是在引用计数变成 0 的时候,去这个全局的字典里面,找到所有的 weak 指针,将其值设置成 nil。如何做到这一点呢?Friday QA 上介绍了一种类似 KVO 实现的方式。当对象存在 weak 指针时,我们可以将这个实例指向一个新创建的子类,然后修改这个子类的 release 方法,在 release 方法中,去从全局的 CFMutableDictionary 字典中找到所有的 weak 对象,并且设置成 nil。我摘抄了 Friday QA 上的实现的核心代码,如下:

Class subclass = objc_allocateClassPair(class, newNameC, 0);
Method release = class_getInstanceMethod(class, @selector(release));
Method dealloc = class_getInstanceMethod(class, @selector(dealloc));
class_addMethod(subclass, @selector(release), (IMP)CustomSubclassRelease, method_getTypeEncoding(release));
class_addMethod(subclass, @selector(dealloc), (IMP)CustomSubclassDealloc, method_getTypeEncoding(dealloc));
objc_registerClassPair(subclass);

当然,这并不代表苹果官方是这么实现的,因为苹果的这部分代码并没有开源。《Objective-C高级编程》一书中介绍了 GNUStep 项目中的开源代码,思想也是类似的。所以我认为虽然实现细节会有差异,但是大致的实现思路应该差别不大。

iOS 面试题(六):自己写的 view 成员,应该用 weak 还是 strong?

问题:我们知道,从 Storyboard 往编译器拖出来的 UI 控件的属性是 weak 的,如下所示

@property (weak, nonatomic) IBOutlet UIButton *myButton;

那么,如果有一些 UI 控件我们要用代码的方式来创建,那么它应该用 weak 还是 strong 呢?为什么?

答案:这是一道有意思的问题,这个问题是我当时和 Lancy 一起写猿题库 App 时产生的一次小争论。简单来说,这道题并没有标准答案,但是答案背后的解释却非常有价值,能够看出一个人对于引用计数,对于 view 的生命周期的理解是否到位。
从昨天的评论上,我们就能看到一些理解非常不到位的解释,例如:

@spume 说:Storyboard 拖线使用 weak 是为了规避出现循环引用的问题。

这个理解是错误的,Storyboard 拖出来的控件即使是 strong 的,也不会有循环引用问题。
我认为 UI 控件用默认用 weak,根源还是苹果希望只有这些 UI 控件的父 View 来强引用它们,而 ViewController 只需要强引用 ViewController.view 成员,则可以间接持有所有的 UI 控件。这样有一个好处是:在以前,当系统收到 Memory Warning 时,会触发 ViewController 的 viewDidUnload 方法,这样的弱引用方式,可以让整个 view 整体都得到释放,也更方便重建时整体重新构造。
但是首先 viewDidUnload 方法在 iOS 6 开始就被废弃掉了,苹果用了更简单有效地方式来解决内存警告时的视图资源释放,具体如何做的呢?嗯,这个可以当作某一期的面试题展开介绍。总之就是,除非你特殊地操作 view 成员,ViewController.view 的生命期和 ViewController 是一样的了。
所以在这种情况下,其实 UI 控件是不是 weak 其实关系并不大。当 UI 控件是 weak 时,它的引用计数是 1,持有它的是它的 superview,当 UI 控件是 strong 时,它的引用计数是 2,持有它的有两个地方,一个是它的 superview,另一个是这个 strong 的指针。UI 控件并不会持有别的对象,所以,不管是手写代码还是 Storyboard,UI 控件是 strong 都不会有循环引用的。
那么回到我们的最初的问题,自己写的 view 成员,应该用 weak 还是 strong?我个人觉得应该用 strong,因为用 weak 并没有什么特别的优势,加上上一篇面试题文章中,我们还看到,其实 weak 变量会有额外的系统维护开销的,如果你没有使用它的特别的理由,那么用 strong 的话应该更好。
另外有读者也提到,如果你要做 Lazy 加载,那么你也只能选择用 strong。
当然,如果你非要用 weak,其实也没什么问题,只需要注意在赋值前,先把这个对象用 addSubView 加到父 view 上,否则可能刚刚创建完,它就被释放了。
在我心目中,这才是我喜欢的面试题,没有标准答案,每种方案各有各的特点,面试者能够足够分清楚每种方案的优缺点,结合具体的场景做选择,这才是优秀的面试者。

1.懒加载的对象必须用strong的原因在于,如果使用weak,对象没有被没有被强引用,过了懒加载对象就会被释放掉。

iOS 面试题(七):为什么 Objective-C 的方法调用要用方括号?

问题:为什么 Objective-C 的方法调用要用方括号 [obj foo],而不是别的语言常常使用的点 obj.foo ?

答案:
首先要说的是,Objective-C 的历史相当久远,如果你查 wiki 的话,你会发现:Objective-C 和 C++ 这两种语言的发行年份都是 1983 年。在设计之初,二者都是作为 C 语言的面向对象的接班人,希望成为事实上的标准。最后结果大家都知道了,C++ 最终胜利了,而 Objective-C 在之后的几十年中,基本上变成了苹果自己家玩的玩具。不过最终,由于 iPhone 的出现,Objective-C 迎来了第二春,在 TOBIE 语言排行榜上,从 20 名开外一路上升,排名曾经超越过 C++,达到了第三名(下图),但是随着 Swift 的出现,Objective-C 的排名则一路下滑。


TOBIE排行版

Objective-C 在设计之初参考了不少 Smalltalk 的设计,而消息发送则是向 Smalltalk 学来的。Objective-C 当时采用了方括号的形式来表示发送消息,为什么没有选择用点呢?我个人觉得是,当时市面上并没有别的面向对象语言的设计参考,而 Objective-C 「发明」了方括号的形式来给对象发消息,而 C++ 则「发明」了用点的方式来 “发消息”。有人可能会争论说 C++ 的「点」并不是真正的发消息,但是其实二者都是表示「调用对象所属的成员函数」。
另外,有读者评论说使用方括号的形式是为了向下兼容 C 语言,我并不觉得中括号是唯一选择,C++ 不也兼容了 C 语言么?Swift 不也可以调用 C 函数么?
最终,其实是 C++ 的「发明」显得更舒服一些,所以后来的各种语言都借鉴了 C++ 的这种设计,也包括 Objective-C 在内。Objective-C 2.0 版本中,引入了 dot syntax,即:
a = obj.foo 等价于 a = [obj foo]
obj.foo = 1 则等价于 [obj setFoo:1]
Objective-C 其实在设计之中确实是比较特立独行的,除了方括号的函数调用方式外,还包括比较长的,可读性很强的函数命名风格。
我个人并不讨厌 Objective-C 的这种设计,但是从 Swift 语言的设计来看,苹果也开始放弃一些 Objective-C 的特点了,比如就去掉了方括号这种函数调用方式。

所以,回到我们的问题,我个人认为,答案就是:Objective-C 在 1983 年设计的时候,并没有什么有效的效仿对象,于是就发明了一种有特点的函数调用方式,现在看起来,这种方式比点操作符还是略逊一筹。

大多数语言一旦被设计好,就很难被再次修改,应该说 Objective-C 发明在 30 年前,还是非常优秀的,它的面向对象化设计得非常纯粹,比 C++ 要全面得多,也比 C++ 要简单得多。

iOS 面试题(八):实现一个嵌套数组的迭代器

问题:
给你一个嵌套的 NSArray 数据,实现一个迭代器类,该类提供一个 next() 方法,可以依次的取出这个 NSArray 中的数据。
比如 NSArray 如果是 [1,[4,3],6,[5,[1,0]]], 则最终应该输出:1, 4, 3, 6, 5, 1, 0 。
另外,实现一个 allObjects 方法,可以一次性取出所有元素。
给你一个嵌套的 NSArray 数据,实现一个迭代器类,该类提供一个 next() 方法,可以依次的取出这个 NSArray 中的数据。

解答:
本题的代码稍长,完整的代码我放在git上了,以下是讲解。

先说第二问吧,第二问比较简单:实现一个 allObjects 方法,可以一次性取出所有元素。
对于此问,我们可以实现一个递归函数,在函数中判断数组中的元素是否又是数组,如果是的话,就递归调用自己,如果不是数组,则加入到一个 NSMutableArray 中即可。下面是示例代码:

- (NSArray *)allObjects {
    NSMutableArray *result = [NSMutableArray array];
    [self fillArray:_originArray into:result];
    return result;
}

- (void)fillArray:(NSArray *)array into:(NSMutableArray *)result {
    for (NSUInteger i = 0; i < array.count; ++i) {
        if ([array[i] isKindOfClass:[NSArray class]]) {
            [self fillArray:array[i] into:result];
        } else {
            [result addObject:array[i]];
        }
    }
}

如果你还在纠结掌握递归有什么意义的话,欢迎翻翻我半年前写的另一篇文章:递归的故事(上),递归的故事(下)。

接下来让我们来看第一问,在同学的回复中,我看到很多人用第二问的办法,把数组整个另外保存一份,然后再记录一个下标,每次返回其中一个。这个方法当然是可行的,但是大部分的迭代器通常都不会这么实现。因为这么实现的话,数组需要整个复制一遍,空间复杂度是 O(N)。

所以,我个人认为本题第一问更好的解法是:
记录下遍历的位置,然后每次遍历时更新位置。由于本题中元素是一个嵌套数组,所以我们为了记录下位置,就需要两个变量:一个是当前正在遍历的子数组,另一个是这个数组遍历到的位置。

我在实现的时候,定义了一个名为 NSArrayIteratorCursor 的类来记录这些内容,NSArrayIteratorCursor 的定义和实现如下:

@interface NSArrayIteratorCursor : NSObject

@property (nonatomic) NSArray *array;
@property (nonatomic) NSUInteger index;

@end

@implementation NSArrayIteratorCursor

- (id)initWithArray:(NSArray *)array {
    self = [super init];
    if (self) {
        _array = array;
        _index = 0;
    }
    return self;
}

@end

由于数组在遍历的时候可能产生递归,就像我们实现 allObjects 方法那样。所以我们需要处理递归时的 NSArrayIteratorCursor 的保存,我在实现的时候,拿数组当作栈,来实现保存遍历时的状态。

最终,我实现了一个迭代器类,名字叫 NSArrayIterator,用于最终提供 next 方法的实现。这个类有两个私有变量,一个是刚刚说的那个栈,另一个是原数组的引用。

@interface NSArrayIterator : NSObject

- (id)initWithArray:(NSArray *)array;
- (id)next;
- (NSArray *)allObjects;

@end

@implementation NSArrayIterator {
    NSMutableArray *_stack;
    NSArray *_originArray;
}

在初使化的时候,我们初始化遍历位置的代码如下:

- (id)initWithArray:(NSArray *)array {
    self = [super init];
    if (self) {
        _originArray = array;
        _stack = [NSMutableArray array];
        [self setupStack];
    }
    return self;
}

- (void)setupStack {
    NSArrayIteratorCursor *c = [[NSArrayIteratorCursor alloc] initWithArray:_originArray];
    [_stack addObject:c];
}

接下来就是最关键的代码了,即实现 next 方法,在 next 方法的实现逻辑中,我们需要:

判断栈是否为空,如果为空则返回 nil。
从栈中取出元素,看是否遍历到了结尾,如果是的话,则出栈。
判断第 2 步是否使栈为空,如果为空,则返回 nil。
终于拿到元素了,这一步判断拿到的元素是否是数组。
如果是数组,则重新生成一个遍历的 NSArrayIteratorCursor 对象,放到栈中。
重新从栈中拿出第一个元素,循环回到第 4 步的判断。
如果到了这一步,说明拿到了一个非数组的元素,这样就可以把元素返回,同时更新索引到下一个位置。
以下是相关的代码,对于没有算法基础的同学,可能读起来还是比较累,其实我写起来也不快,所以希望你能多理解一下,其实核心思想就是手工操作栈的入栈和出栈:

- (id)next {
    //  1. 判断栈是否为空,如果为空则返回 nil。
    if ([_stack count] == 0) {
        return nil;
    }
    // 2. 从栈中取出元素,看是否遍历到了结尾,如果是的话,则出栈。
    NSArrayIteratorCursor *c;
    c = [_stack lastObject];
    while (c.index == c.array.count && _stack.count > 0) {
        [_stack removeLastObject];
        c = [_stack lastObject];
    }
    // 3. 判断第 2 步是否使栈为空,如果为空,则返回 nil。
    if (_stack.count == 0) {
        return nil;
    }
    // 4. 终于拿到元素了,这一步判断拿到的元素是否是数组。
    id item = c.array[c.index];
    while ([item isKindOfClass:[NSArray class]]) {
        c.index++;
        // 5. 如果是数组,则重新生成一个遍历的 NSArrayIteratorCursor 对象,放到栈中。
        NSArrayIteratorCursor *nc = [[NSArrayIteratorCursor alloc] initWithArray:item];
        [_stack addObject:nc];
        // 6. 重新从栈中拿出第一个元素,循环回到第 4 步的判断。
        c = nc;
        item = c.array[c.index];
    }

    // 7. 如果到了这一步,说明拿到了一个非数组的元素,这样就可以把元素返回,同时更新索引到下一个位置。
    c.index++;
    return item;
}

在读者回复中,听榆大叔 和 yiplee 同学用了类似的做法,他们的代码在:
听榆大叔 、yiplee

最终,我想说这个只是我个人想出来的解法,很可能不是最优的,甚至可能也有很多问题,比如,这个代码有很多可以进一步 challenge 的地方:

这个代码是线程安全的吗?如果我们要实现一个线程安全的迭代器,应该怎么做?
如果在使用迭代器的时候,数组被修改了,会怎么样?
如何检测在遍历元素的时候,数组被修改了?
如何避免在遍历元素的时候,数组被修改?
如果大家有想出更好的解法,欢迎留言告诉我。

【续】iOS 面试题(八):实现一个嵌套数组的迭代器

昨天我的代码,有一个 Bug,就是我没有处理好嵌套的数组元素为空的情况,我写了一个简单的 TestCase,大家也可以试试自己的代码是否处理好了这种情况:

- (void)testEmptyArray {
    NSArray *arr = @[ @[ @[ ]], @[@[ @[ @[ ]]]]];
    NSArrayIterator *c = [[NSArrayIterator alloc] initWithArray:arr];
    XCTAssertEqualObjects(nil, [c next]);
    XCTAssertEqualObjects(nil, [c next]);
}

于是乎,我发现我的代码可以再优化一下,用递归的方式来处理空数组的逻辑似乎是写起来更简单的,于是我优化之后的逻辑如下:

判断栈是否为空,如果为空则返回 nil。
从栈中取出元素,看是否遍历到了结尾,如果是的话,则出栈。
判断第 2 步是否使栈为空,如果为空,则返回 nil。
终于拿到元素了,这一步判断拿到的元素是否是数组。
如果是数组,则重新生成一个遍历的 NSArrayIteratorCursor 对象,放到栈中,并且递归调用自己。
如果不是数组,就把元素返回,同时更新索引到下一个位置。
整个代码也变得更短更清楚了一些,如下所示:

next 方法的实现:

- (id)next {
    //  1. 判断栈是否为空,如果为空则返回 nil。
    if (_stack.count == 0) {
        return nil;
    }
    // 2. 从栈中取出元素,看是否遍历到了结尾,如果是的话,则出栈。
    NSArrayIteratorCursor *c;
    c = [_stack lastObject];
    while (c.index == c.array.count && _stack.count > 0) {
        [_stack removeLastObject];
        c = [_stack lastObject];
    }
    // 3. 判断第2步是否使栈为空,如果为空,则返回 nil。
    if (_stack.count == 0) {
        return nil;
    }
    // 4. 终于拿到元素了,这一步判断拿到的元素是否是数组。
    id item = c.array[c.index];
    if ([item isKindOfClass:[NSArray class]]) {
        c.index++;
        // 5. 如果是数组,则重新生成一个遍历的
        //    NSArrayIteratorCursor 对象,放到栈中, 然后递归调用 next 方法
        [self setupStackWithArray:item];
        return [self next];
    }

    // 6. 如果到了这一步,说明拿到了一个非数组的元素,这样就可以把元素返回,
    //    同时更新索引到下一个位置。
    c.index++;
    return item;
}

初使化部分:
- (id)initWithArray:(NSArray *)array {
    self = [super init];
    if (self) {
        _originArray = array;
        _stack = [NSMutableArray array];
        [self setupStackWithArray:array];
    }
    return self;
}

- (void)setupStackWithArray:(NSArray *)array {
    NSArrayIteratorCursor *c = [[NSArrayIteratorCursor alloc] initWithArray:array];
    [_stack addObject:c];
}

iOS 面试题(九):创建一个可以被取消执行的 block

问题:
我们知道 block 默认是不能被取消掉的,请你封装一个可以被取消执行的 block wrapper 类,它的定义如下:

typedef void (^Block)();
@interface CancelableObject : NSObject

- (id)initWithBlock:(Block)block;

- (void)start;

- (void)cancel;

@end

答案:这道题是从网上看到的,原题是创建一个可以取消执行的 block,我想到两种写法。

// 方法一:创建一个类,将要执行的 block 封装起来,然后类的内部有一个 _isCanceled 变量,在执行的时候,检查这个变量,如果 _isCanceled 被设置成 YES 了,则退出执行。
typedef void (^Block)();
@interface CancelableObject : NSObject
- (id)initWithBlock:(Block)block;
- (void)start;
- (void)cancel;
@end

@implementation CancelableObject {
    BOOL _isCanceled;
    Block _block;
}

- (id)initWithBlock:(Block)block {
    self = [super init];
    if (self != nil) {
        _isCanceled = NO;
        _block = block;
    }
    return self;
}

- (void)start {
    __weak typeof(self) weakSelf = self;
    dispatch_async(dispatch_get_global_queue(0, 0), 
       ^{
        if (weakSelf) {
           typeof(self) strongSelf = weakSelf;
           if (!strongSelf->_isCanceled) {
               (strongSelf->_block)();
           }
        }
    });
}

- (void)cancel {
    _isCanceled = YES;
}

@end
// 另外一种写法,将要执行的 block 直接放到执行队列中,但是让其在执行前检查另一个 isCanceled 的变量,然后把这个变量的修改实现在另一个 block 方法中,如下所示:
typedef void (^CancelableBlock)();
typedef void (^Block)();

+ (CancelableBlock)dispatch_async_with_cancelable:(Block)block {
    __block BOOL isCanceled = NO;
    CancelableBlock cb = ^() {
        isCanceled = YES;
    };

    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        if (!isCanceled) {
            block();
        }
    });

    return cb;
}

以上两种方法都只能在 block 执行前有效,如果要在 block 执行中有效,只能让 block 在执行中,有一个机制来定期检查外部的变量是否有变化,而要做到这一点,需要改 block 执行中的代码。在本例中,如果 block 执行中的代码是通过参数传递进来的话,似乎并没有什么办法可以修改它了。

iOS 面试题(十):一个 Objective-C 对象的内存结构是怎样的?

问题:一个 Objective-C 对象的内存结构是怎样的?

答案:这是一道老题,或许很多人都准备过,其实如果不是被每个公司都考查的话,这道题可以看看候选人对于 iOS 背后底层原理的感兴趣程度。真正对编程感兴趣的同学,都会对这个多少有一些好奇,进而在网上搜索并学习这方面的资料。

以下是本题的简单回答:
如果把类的实例看成一个C语言的结构体(struct),它首先包含的是一个 isa 指针,而类的其它成员变量依次排列在结构体中。排列顺序如下图所示:



为了验证该说法,我们在Xcode中新建一个工程,在main.m中运行如下代码:

#import <UIKit/UIKit.h>
@interface Father : NSObject {    
    int _father;
}

@end@implementation Father

@end

@interface Child : Father {    
int _child;
}
@end

@implementation Child

@end

int main(int argc, char * argv[])
{

  Child * child = [[Child alloc] init];  
  @autoreleasepool {      
       // ...
  }
}
// 我们将断点下在 @autoreleasepool 处,然后在Console中输入p *child,则可以看到Xcode输出如下内容,这与我们上面的说法一致。

(lldb) p *child
(Child) $0 = {
  (Father) Father = {
    (NSObject) NSObject = {
      (Class) isa = Child
    }
    (int) _father = 0
  }
  (int) _child = 0
}

因为对象在内存中的排布可以看成一个结构体,该结构体的大小并不能动态变化。所以无法在运行时动态给对象增加成员变量。

注:需要特别说明一下,通过 objc_setAssociatedObject 和 objc_getAssociatedObject方法可以变相地给对象增加成员变量,但由于实现机制不一样,所以并不是真正改变了对象的内存结构。

iOS 面试题(11):对象内存结构中的 isa 指针是用来做什么的?

问题:Objective-C 对象内存结构中的 isa 指针是用来做什么的,有什么用?
答案:Objective-C 是一门面向对象的编程语言。每一个对象都是一个类的实例。在 Objective-C 语言的内部,每一个对象都有一个名为 isa 的指针,指向该对象的类。每一个类描述了一系列它的实例的特点,包括成员变量的列表,成员函数的列表等。每一个对象都可以接受消息,而对象能够接收的消息列表是保存在它所对应的类中。

在 Xcode 中按Shift + Command + O, 然后输入 NSObject.h 和 objc.h,可以打开 NSObject 的定义头文件,通过头文件我们可以看到,NSObject 就是一个包含 isa 指针的结构体,如下图所示:


按照面向对象语言的设计原则,所有事物都应该是对象(严格来说 Objective-C 并没有完全做到这一点,因为它有象 int, double 这样的简单变量类型,而 Swift 语言,连 int 变量也是对象)。在 Objective-C 语言中,每一个类实际上也是一个对象。每一个类也有一个名为 isa 的指针。每一个类也可以接受消息,例如代码[NSObject alloc],就是向 NSObject 这个类发送名为alloc消息。

在 Xcode 中按Shift + Command + O, 然后输入 runtime.h,可以打开 Class 的定义头文件,通过头文件我们可以看到,Class 也是一个包含 isa 指针的结构体,如下图所示。(图中除了 isa 外还有其它成员变量,但那是为了兼容非 2.0 版的 Objective-C 的遗留逻辑,大家可以忽略它。)

因为类也是一个对象,那它也必须是另一个类的实列,这个类就是元类 (metaclass)。元类保存了类方法的列表。当一个类方法被调用时,元类会首先查找它本身是否有该类方法的实现,如果没有,则该元类会向它的父类查找该方法,直到一直找到继承链的头。

元类 (metaclass) 也是一个对象,那么元类的 isa 指针又指向哪里呢?为了设计上的完整,所有的元类的 isa 指针都会指向一个根元类 (root metaclass)。根元类 (root metaclass) 本身的 isa 指针指向自己,这样就行成了一个闭环。上面提到,一个对象能够接收的消息列表是保存在它所对应的类中的。在实际编程中,我们几乎不会遇到向元类发消息的情况,那它的 isa 指针在实际上很少用到。不过这么设计保证了面向对象概念在 Objective-C 语言中的完整,即语言中的所有事物都是对象,都有 isa 指针。

我们再来看看继承关系,由于类方法的定义是保存在元类 (metaclass) 中,而方法调用的规则是,如果该类没有一个方法的实现,则向它的父类继续查找。所以,为了保证父类的类方法可以在子类中可以被调用,所以子类的元类会继承父类的元类,换而言之,类对象和元类对象有着同样的继承关系。

我很想把关系说清楚一些,但是这块儿确实有点绕,我们还是来看图吧,很多时候图象比文字表达起来更为直观。下面这张图或许能够让大家对 isa 和继承的关系清楚一些:


我们可以从图中看出:

NSObject 的类中定义了实例方法,例如 -(id)init 方法 和 - (void)dealloc 方法。
NSObject 的元类中定义了类方法,例如 +(id)alloc 方法 和 + (void)load 、+ (void)initialize 方法。
NSObject 的元类继承自 NSObject 类,所以 NSObject 类是所有类的根,因此 NSObject 中定义的实例方法可以被所有对象调用,例如 - (id)init 方法 和 - (void)dealloc 方法。
NSObject 的元类的 isa 指向自己。
isa swizzling 的应用

系统提供的 KVO 的实现,就利用了动态地修改 isa 指针的值的技术。在 苹果的文档
中可以看到如下描述:

Key-Value Observing Implementation Details
Automatic key-value observing is implemented using a technique called isa-swizzling.
The isa pointer, as the name suggests, points to the object’s class which maintains a dispatch table. This dispatch table essentially contains pointers to the methods the class implements, among other data.
When an observer is registered for an attribute of an object the isa pointer of the observed object is modified, pointing to an intermediate class rather than at the true class. As a result the value of the isa pointer does not necessarily reflect the actual class of the instance.
You should never rely on the isa pointer to determine class membership. Instead, you should use the class method to determine the class of an object instance.

iOS 面试题(12):按层遍历二叉树的节点

解题代码都是使用 Swift 完成的,我也尽量在代码中使用了 Swift 语言的一些特性,大家可以顺便学学 Swift。

问题:给你一棵二叉树,请按层输出其的节点值,即:按从上到下,从左到右的顺序。
例如,如果给你如下一棵二叉树:

    3
   / \
  9  20
    /  \
   15   7

输出结果应该是:
[
  [3],
  [9,20],
  [15,7]
]

本题的 Swift 代码模版如下:

private class TreeNode {
    public var val: Int
    public var left: TreeNode?
    public var right: TreeNode?
    public init(_ val: Int) {
        self.val = val
        self.left = nil
        self.right = nil
    }
}

class Solution {
    func levelOrder(_ root: TreeNode?) -> [[Int]] {

    }
}

解答:本题出自 LeetCode 第 102 题,是一个典型的有关遍历的题目。为了按层遍历,我们需要使用「队列」,来将每一层的节点先保存下来,然后再依次处理。

因为我们不但需要按层来遍历,还需要按层来输出结果,所以我在代码中使用了两个队列,分别名为 level 和 nextLevel,用于保存不同层的节点。

最终,整个算法逻辑是:

判断输入参数是否是为空。
将根节点加入到队列 level 中。
如果 level 不为空,则:
3.1 将 level 加入到结果 ans 中。
3.2 遍历 level 的左子节点和右子节点,将其加入到 nextLevel 中。
3.3 将 nextLevel 赋值给 level,重复第 3 步的判断。
将 ans 中的节点换成节点的值,返回结果。
因为我们是用 Swift 来实现代码,所以我使用了一些 Swift 语言的特性。例如:队列中我们保存的是节点的数据结构,但是最终输出的时候,我们需要输出的是值,在代码中,我使用了 Swift 的函数式的链式调用,将嵌套数组中的元素类型做了一次变换,如下所示:

let ans = result.map { $0.map { $0.val }}
另外,我们也使用了 Swift 特有的 guard 关键字,来处理参数的特殊情况。

完整的参考代码如下:

//
//  Binary Tree Level Order Traversal.swift
//
//  Created by Tang Qiao.
//

import Foundation

private class TreeNode {
    public var val: Int
    public var left: TreeNode?
    public var right: TreeNode?
    public init(_ val: Int) {
        self.val = val
        self.left = nil
        self.right = nil
    }
}

private class Solution {
    func levelOrder(_ root: TreeNode?) -> [[Int]] {
        guard let root = root else {
            return []
        }
        var result = [[TreeNode]]()
        var level = [TreeNode]()

        level.append(root)
        while level.count != 0 {
            result.append(level)
            var nextLevel = [TreeNode]()
            for node in level {
                if let leftNode = node.left {
                    nextLevel.append(leftNode)
                }
                if let rightNode = node.right {
                    nextLevel.append(rightNode)
                }
            }
            level = nextLevel
        }

        let ans = result.map { $0.map { $0.val }}
        return ans
    }
}

微信中排版代码非常不便,所以上述代码也可以从我的 Gist 中找到:代码Gist地址

完成这道题的同学,可以试着练习一下 LeetCode的第 107 题,看看能不能只改动一行代码,就把 107 题也解决掉。

iOS 面试题(13):求两个链表表示的数的和

问题:给你两个链表,分别表示两个非负的整数。每个链表的节点表示一个整数位。
为了方便计算,整数的低位在链表头,例如:123 在链表中的表示方式是:

3 -> 2 -> 1

现在给你两个这样结构的链表,请输出它们求和之后的结果。例如:

输入: (2 -> 4 -> 1) + (5 -> 6 -> 1)
输出: 7 -> 0 -> 3

本题的 Swift 代码模版如下:

private class ListNode {
    public var val: Int
    public var next: ListNode?
    public init(_ val: Int) {
        self.val = val
        self.next = nil
    }
}

class Solution {
    func addTwoNumbers(_ l1: ListNode?, _ l2: ListNode?) 
         -> ListNode? {

    }
}

考查点:本题出自 LeetCode 上的第 2 题。

这是我高中学习编程时最早接触的一类题目,我们把这类题目叫做「高精度计算」,其实就是在计算机计算精度不够时,模拟我们在纸上演算的方式来计算答案,然后获得足够精度的解。

我还记得我 7 年前第一次去网易有道面试的时候,就考查的是一道类似的高精度计算题目,比这道题复杂得多,我当时用了一个比较笨的办法,加上当时还是用 C++ 写的,内存分配和释放写起来也比较麻烦,最后写了两页 A4 纸才写完。

这道题其实完全不考查什么「算法」,人人都知道怎么计算,但是它考察了「将想法转换成代码」的能力,新手通常犯的毛病就是:意思都明白,但是写不出来代码。所以,这类题目用来过滤菜鸟确实是挺有效的办法。

答案:本题的做法其实没什么特别,就是直接计算。计算的时候需要考虑到以下这些情况:

两个整数长度不一致的情况。
进位的情况。当进位产生时,我们需要保存一个标志位,以便在计算下一位的和的时候,加上进位。
当计算完后,如果还有进位,需要处理最后结果加一位的情况。
以下是完整的代码,我使用了一些 Swift 语言的特性,比如用 flatMap 来减少对于 Optional 类型值为 nil 的判断。

private class ListNode {
    public var val: Int
    public var next: ListNode?
    public init(_ val: Int) {
        self.val = val
        self.next = nil
    }
}

private class Solution {

    private func getNodeValue(_ node: ListNode?) -> Int {
        return node.flatMap { $0.val } ?? 0
    }

    func addTwoNumbers(_ l1: ListNode?, _ l2: ListNode?) 
             -> ListNode? {
        if l1 == nil || l2 == nil {
            return l1 ?? l2
        }
        var p1 = l1
        var p2 = l2
        let result: ListNode? = ListNode(0)
        var current = result
        var extra = 0
        while p1 != nil || p2 != nil || extra != 0 {
            var tot = getNodeValue(p1) +
                      getNodeValue(p2) + extra
            extra = tot / 10
            tot = tot % 10
            let sum:ListNode? = ListNode(tot)
            current!.next = sum
            current = sum
            p1 = p1.flatMap { $0.next }
            p2 = p2.flatMap { $0.next }
        }
        return result!.next
    }
}

以上代码也可以从我的 Gist 中找到:Gist

偷偷告诉你一个小秘密,Gist 里面的代码我稍微修改了两行,最终性能就从打败 LeetCode 10% 的提交变成了打败 LeetCode 50% 的提交,如果你感兴趣,可以自己仔细对比一下。

iOS 面试题(14):计算有多少个岛屿

问题:在一个地图中,找出一共有多少个岛屿。
我们用一个二维数组表示这个地图,地图中的 1 表示陆地,0 表示水域。一个岛屿是指由上下左右相连的陆地,并且被水域包围的区域。

你可以假设地图的四周都是水域。

例一:一共有 1 个岛屿。
11110
11010
11000
00000
例二:一共有 3 个岛屿。
11000
11000
00100
00011

答案:这是 LeetCode 上的 第 200 题,我们可以用一种被称为「种子填充」(floodfill)的办法来解决此题。

具体的做法是:

遍历整个地图,找到一个未被标记过的,值为 1 的坐标。
从这个坐标开始,从上下左右四个方向,标记相邻的 1 。
把这些相邻的坐标,都标记下来,递归的进行标记,以便把相邻的相邻块也能标记上。
待标记全部完成之后,将岛屿的计数 +1。
回到第 1 步。如果第 1 步无法找到未标记的坐标,则结束。
虽然思路简单,但是实现起来代码量也不算小。这里有一些小技巧:

我们可以将上下左右四个方向的偏移量保存在数组中,这样在计算位置的时候,写起来更简单一些。
递归的标记过程可以用深度优先搜索(DFS)或者宽度优先搜索(BFS)。
以下是完整的参考代码:

private class Solution {
    private var flag: [[Int]]
    private var answer: Int
    private var movex : [Int] {
        return [-1, 1, 0, 0]
    }

    private var movey : [Int] {
        return [0, 0, -1, 1]
    }

    init() {
        flag = [[Int]]()
        answer = 0
    }

    func dfs(_ grid: [[Character]] ,_ x: Int,_ y: Int) {
        for i in 0..<4 {
            let tox = x + movex[i]
            let toy = y + movey[i]
            if tox >= 0 && tox < grid.count && toy >= 0 && toy < grid[0].count && grid[tox][toy] == "1" && flag[tox][toy] == 0 {
            flag[tox][toy] = 1
            dfs(grid, tox, toy)
            }
        }
    }

    func numIslands(_ grid: [[Character]]) -> Int {
        answer = 0
        flag = grid.map {
            $0.map {
                _ in return 0
            }}
            for i in 0..<grid.count {
            for j in 0..<grid[i].count {
                if grid[i][j] == "1" && flag[i][j] == 0 {
            flag[i][j] = 1
            // print("find in \(i), \(j)")
            dfs(grid, i, j)
            answer += 1
                }
            }
        }
        return answer
    }
}

Swift 的参数默认是不能修改值的,但是如果是 C++ 语言的话,我们可以直接在地图上做标记。因为地图只有 0 和 1 两种值,我们可以用 2 表示「标记过的陆地」,这样就省略了额外的标记数组。以下是我写的一个 C++ 的示例程序:

class Solution {
public:
    void fillLands(vector<vector<char>>& grid, int px, int py) {
        int movex[] = {0, 0, 1, -1};
        int movey[] = {-1, 1, 0, 0};
        queue<pair<int, int>> q;
        q.push(make_pair(px, py));
        grid[px][py] = '2';
        while (!q.empty()) {
            pair<int, int> item = q.front();
            q.pop();
            int tox, toy;
            for (int i = 0; i < 4; ++i) {
                tox = item.first + movex[i];
                toy = item.second + movey[i];
                if (tox >= 0 && tox < grid.size()
                    && toy >=0 && toy < grid[0].size()
                    && grid[tox][toy] == '1') {
                    grid[tox][toy] = '2';
                    q.push(make_pair(tox, toy));
                }
            }
        }
    }
    int numIslands(vector<vector<char>>& grid) {
        int ans = 0;
        for (int i = 0; i < grid.size(); ++i) {
            for (int j = 0; j < grid[0].size(); ++j) {
                if (grid[i][j] == '1') {
                    fillLands(grid, i, j);
                    ans++;
                }
            }
        }
        return ans;
    }
};

 

iOS 面试题(16):解释垃圾回收的原理

摘要: 问题 我们知道,Android 手机通常使用 Java 来开发,而 Java 是使用垃圾回收这种内存管理方式。 那么,ARC 和垃圾回收对比,有什么优点和缺点? 考查点 此题其实是考查大家的知识面,虽然做 iOS 开发并不需要用到垃圾回收这种内存管理…

问题

我们知道,Android 手机通常使用 Java 来开发,而 Java 是使用垃圾回收这种内存管理方式。 那么,ARC 和垃圾回收对比,有什么优点和缺点?

考查点

此题其实是考查大家的知识面,虽然做 iOS 开发并不需要用到垃圾回收这种内存管理机制。但是垃圾回收被使用得非常普遍,不但有 Java,还包括 JavaScript, C#,Go 等语言。

如果两个候选人,一个人只会 iOS 开发,另一个人不但会 iOS 开发,对别的语言或技术也有兴趣了解,那我通常更倾向于后者。而且事实常常是,由于后者对计算机兴趣更浓,他在 iOS 上也通常专研得比前者更多。

垃圾回收简介

作为 iOS 开发者,了解一下这个世界上除了 ARC 之外最流行的内存管理方式,还是挺有价值的。所以我尽量简单给大家介绍一下。

垃圾回收(Garbage Collection,简称 GC)这种内存管理机制最早由图灵奖获得者 John McCarthy 在 1959 年提出,垃圾回收的理论主要基于一个事实:大部分的对象的生命期都很短。

所以,GC 将内存中的对象主要分成两个区域:Young 区和 Old 区。对象先在 Young 区被创建,然后如果经过一段时间还存活着,则被移动到 Old 区。(其实还有一个 Perm 区,但是内存回收算法通常不涉及这个区域)

Young 区和 Old 区因为对象的特点不一样,所以采用了两种完全不同的内存回收算法。

Young 区的对象因为大部分生命期都很短,每次回收之后只有少部分能够存活,所以采用的算法叫 Copying 算法,简单说来就是直接把活着的对象复制到另一个地方。Young 区内部又分成了三块区域:Eden 区 , From 区 , To 区。每次执行 Copying 算法时,即将存活的对象从 Eden 区和 From 区复制到 To 区,然后交换 From 区和 To 区的名字(即 From 区变成 To 区,To 区变成 From 区)。

Old 区的对象因为都是存活下来的老司机了,所以如果用 Copying 算法的话,很可能 90% 的对象都得复制一遍了,不划算啊!所以 Old 区的回收算法叫 Mark-Sweep 算法。简单来说,就是只是把不用的对象先标记(Mark)出来,然后回收(Sweep),活着的对象就不动它了。因为大部分对象都活着,所以回收下来的对象并不多。但是这个算法会有一个问题:它会产生内存碎片,所以它一般还会带有整理内存碎片的逻辑,在算法中叫做 Compact。如何整理呢?早年用过 Windows 的硬盘碎片整理程序的朋友可能能理解,其实就是把对象插到这些空的位置里。这里面还涉及很多优化的细节,我就不一一展开了。

讲完主要的算法,接下来 GC 需要解决的问题就只剩下如何找出需要回收的垃圾对象了。为了避免 ARC 解决不了的循环引用问题,GC 引入了一个叫做「可达性」的概念,应用这个概念,即使是有循环引用的垃圾对象,也可以被回收掉。下面就给大家介绍一下这个概念。

当 GC 工作时,GC 认为当前的一些对象是有效的,这些对象包括:全局变量,栈里面的变量等,然后 GC 从这些变量出发,去标记这些变量「可达」的其它变量,这个标记是一个递归的过程,最后就像从树根的内存对象开始,把所有的树枝和树叶都记成可达的了。那除了这些「可达」的变量,别的变量就都需要被回收了。

听起来很牛逼对不对?那为什么苹果不用呢?实际上苹果在 OS X 10.5 的时候还真用了,不过在 10.7 的时候把 GC 换成了 ARC。那么,GC 有什么问题让苹果不能忍,这就是:垃圾回收的时候,整个程序需要暂停,英文把这个过程叫做:Stop the World。所以说,你知道 Android 手机有时候为什么会卡吧,GC 就相当于春运的最后一天返城高峰。当所有的对象都需要一起回收时,那种体验肯定是当时还在世的乔布斯忍受不了的。

看看下面这幅漫画,真实地展现出 GC 最尴尬的情况(漫画中提到的 Full GC,就是指执行 Old 区的内存回收):

当然,事实上经过多年的发展,GC 的回收算法一直在被优化,人们想了各种办法来优化暂停的时间,所以情况并没有那么糟糕。

答案

ARC 相对于 GC 的优点:

ARC 工作在编译期,在运行时没有额外开销。

ARC 的内存回收是平稳进行的,对象不被使用时会立即被回收。而 GC 的内存回收是一阵一阵的,回收时需要暂停程序,会有一定的卡顿。

ARC 相对于 GC 的缺点:

GC 真的是太简单了,基本上完全不用处理内存管理问题,而 ARC 还是需要处理类似循环引用这种内存管理问题。

GC 一类的语言相对来说学习起来更简单。

iOS面试题大全(附带答案) C语言相关面试题 1.static有什么用途? 答案:在C语言中,static主要定义全局静态变量,定义局部静态变量,定义静态函数。 static 属于静态变量,使用它修饰的变量生命周期是整个源程序。 @1.在函数体内的 static 变量的作用范围为该函数体,该变量的内存只被分配一次,因此其值在下次调用时仍维持上次的值; @2.在模块内的 static 全局变量可以被模块内所有函数访问,但不能被模块外其它函数访问; @3.在模块内的 static 函数只被这一模块内的其它函数调用,这个函数的使用范围被限 阅读详情

相关推荐

2021 iOS面试题大全---全方面剖析面试(一)

(答案不唯一,仅供参考,文章最后有福利) 一. iOS面试题—UI相关:事件传递,图像显示,性能优化,离屏渲染 UIView与CALayer 事件传递与视图响应链 图像显示原理 UI卡顿掉帧原因 滑动优化方案 UI绘制原理 离屏渲染 一、UIView与CALayer [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-g0SmOTbu-1627041880722)(//upload-images.jianshu.io/upload_images/1782258-e729ed.

IOSNF的博客 3702

(2026年)iOS Swift面试题,Flutter面试,OC面试题及答案。

第一大类OC面试题 一.设计模式是什么? 你知道哪些设计模式,并简要叙述? 设计模式是一种编码经验,就是用比较成熟的逻辑去处理某一种类型的事情。 1). MVC模式:Model View Control,把模型 视图 控制器 层进行解耦合编写。 2). MVVM模式:Model View ViewModel 把模型 视图 业务逻辑 层进行解耦和编写。 3). 单例模式:通过static...

田风有的博客 6万+

2020,300道高级iOS开发面试题(最新整理)

这个栏目将持续更新–请iOS的小伙伴关注! 一:知名大厂iOS开发面试题篇 1、腾讯—最新iOS面试题总结 2、百度—最新iOS面试题总结 3、头条—最新iOS面试题总结 4、阿里—最新iOS面试题总结 5、美团—最新iOS面试题总结 6、某大厂—最新iOS面试题总结 7、抖音–最新iOS面试题总结 8、拼多多–最新iOS面试题总结 9、快手–最新iOS面试题总结 10、虎牙–最新iOS面试题总结 11、iOS面试–最新快手iOS面试题 12、iOS面试–字节跳动最新iOS开发面试题 13、(最新)iO.

D_猿员的博客 7034

iOS 面试题总结(可能是最全的!!!)

不设置监听,就可以关闭了。实现思想:当设置监听一个对象时,动态创建一个新的继承被监听对象原本类的类,并重写setter方法,最后把这个对象的isa指针(即这个对象的类的内存地址)更改为这个新创建的类,这时,这个对象就变成了这个新类的实例重写addobserver方法:(1)检查该对象的类有没有对应的setter方法,如果没有就抛出异常(2)检查对象的类是不是一个kvo类,如果不是,就新建一个继承这个类的新类,并把对象的isa指向这个新类。

sgliquangang的专栏 1万+

新iOS面试题:iOS开发-组件化

MGJRouter 蘑菇街组件实现原理 方案一 url-block 这是蘑菇街中应用的一种页面间调用的方式,通过在启动时注册组件提供的服务,把调用组件使用的url和组件提供的服务block对应起来,保存到内存中。在使用组件的服务时,通过url找到对应的block,然后获取服务。 注册 [MGJRouter registerURLPattern:@"mgj://detail?id=:id" toHandler:^(NSDictionary *routerParameters) { NSNumber *

iOSvv的博客 2401

面试滴滴+美团+阿里之后,总结了62道最新iOS面试题

前言: 每年三四月份都是招聘高峰期,也就是我们说的金三银四,很多想换工作的职场人士都会选择在此时换一份工作,毕竟一年之计在于春,对于公司和个人而言都是一个新的开始。 2021年,各行各业都举步维艰,然而做为iOS面试官的我也在精心准备的为公司招进优秀的iOS开发,期间收到了很多简历,也笔试了不少开发者,上一周我们已经发了3个offer,所以先下手为强,我们已经招满了人的职位,依旧陆陆续续也还有很多的简历投向我们。 前面一段时间给公司面试了10个iOS开发,自己总结了62道面试题,在此,我分享给大家,希望大

原来是泽镜的博客 2061

iOS 面试题(一):寻找最近公共 View --转自唐巧

题目:找出两个 UIView 的最近的公共 View,如果不存在,则输出 nil 。 分析:这其实是数据结构里面的找最近公共祖先的问题。 一个 UIViewController 中的所有 view 之间的关系其实可以看成一颗树,UIViewController 的 view 变量是这颗树的根节点,其它的 view 都是根节点的直接或间接子节点。 所以我们可以通过 view 的 superv...

weixin_30316097的博客 259

《招聘一个靠谱的iOS》面试题参考答案

说明:面试题来源是微博@我就叫Sunny怎么了的这篇博文:《招聘一个靠谱的 iOS》 本人iOS github:https://github.com/netyouli?tab=repositories 欢迎mark star。1.[※]@property中有哪些属性关键字?(nonatomic, atomic , strong , retain , copy , week , assign

whc专栏 (github开源地址:https://github.com/netyouli?tab=) 3393

iOS 面试题(五):weak 的内部实现原理 --转自唐巧

问题 weak 变量在引用计数为0时,会被自动设置成 nil,这个特性是如何实现的? 答案 在 Friday QA 上,有一期专门介绍 weak 的实现原理。https://mikeash.com/pyblog/friday-qa-2010-07-16-zeroing-weak-references-in-objective-c.html 《Objective-C高级编程》一书中也介绍了相...

weixin_30469895的博客 206

iOS开发之高级面试题

一千个读者眼中有一千个哈姆雷特,一千名 iOS 程序员心目中就有一千套 iOS 高级面试题。本文就是笔者认为可以用来面试高级 iOS 程序员的面试题。 这套题的题目跟公司和业务都没有关系,而且也并不代表笔者本人可以把这些题回答得非常好,笔者只是将一部分觉得比较好的题从收集的面试题里面抽出来了而已。 收集的面试题有以下三个来源: 笔者在准备面试的过程中搜集并整理过的面试题。 笔者在准备面试的过程中自己思考过的新题。 笔者在面试过程中遇到的觉得比较好的题。 本文分为三个部分展开: 面试题 喜欢考察的和不喜欢考察

weixin_54803466的博客 1085

2018 一份"有点难"的iOS面试题(7年iOS开发)

序言:之前一时兴致在本站上出过一份iOS的中级面试题,引起一些关注,不少同学表示对”隐藏关卡“感兴趣。升级版iOS面试题来了,目测难倒90%iOS程序员,目测一大波程序员撸着袖子在靠近。每道题都不难,对知识广度有要求,请摸着良心回答,不要百度。声明:这份面试题和iOS程序员本身技术水平没任何关联,无论你能否全部答出,都不要对自己产生任何正面或消极的评价,权当做闲暇之余的消遣。其实做为一个开发者,有...

iOSzhuoyuan的博客 3273

iOS 面试题(二):什么时候在 block 中不需要使用 weakSelf --转自唐巧

问题 我们知道,在使用 block 的时候,为了避免产生循环引用,通常需要使用 weakSelf 与 strongSelf,写下面这样的代码: __weak typeof(self) weakSelf = self; [self doSomeBlockJob:^{ __strong typeof(weakSelf) strongSelf = weakSelf; if ...

weixin_30498921的博客 128

离线路径规划服务Graphhopper

离线路径规划服务Graphhopper 本文主要探索使用Graphhopper搭建离线路径规划服务,需要掌握一定的JAVA基础环境配置的知识 文章目录离线路径规划服务Graphhopper前言一、Graphhopper是什么?二、使用步骤1.下载Graphhopper2.从OpenStreetMap下载路图数据3.安装Graphhopper所需环境4.修改配置5.启动Graphhopper总结 前言 在外网环境中可以使用百度、高德等第三方的sdk用以实现路径规划的功能,由于项目的需要,在离线环境中需要使

Sysdark的博客 7566

iOS 面试题(三):为什么 weakSelf 需要配合 strong self 使用 --转自唐巧

问题 继续回答昨天的问题第二问。 我们知道,在使用 block 的时候,为了避免产生循环引用,通常需要使用 weakSelf 与 strongSelf,写下面这样的代码: __weak typeof(self) weakSelf = self; [self doSomeBackgroundJob:^{ __strong typeof(weakSelf) strongSelf ...

weixin_30559481的博客 107

Ubuntu 22.04源码编译安装ROS Noetic

Ubuntu 22.04源码编译安装ROS Noetic

Drknown的博客 2万+

扩散模型在工业缺陷检测中的应用与优化

扩散模型作为生成式AI的重要分支,通过逐步去噪的逆向过程实现高质量数据生成。其核心U-Net架构结合残差连接和时间步嵌入,特别适合处理工业场景中的细微缺陷检测。在计算机视觉领域,这种技术突破了传统深度学习模型对小样本数据的限制,通过域自适应预训练和小样本微调两阶段框架,显著提升金属表面、纺织品等复杂场景的检测准确率。关键技术实现涉及噪声调度优化、多任务损失设计等工程实践,最终在MVTec AD等工业数据集上达到90%以上的检测精度,为智能制造提供可靠的自动化质检方案。

weixin_30512043的博客 497

iOS 高级面试题

一千个读者眼中有一千个哈姆雷特,一千名 iOS 程序员心目中就有一千套 iOS 高级面试题。本文就是笔者认为可以用来面试高级 iOS 程序员的面试题。 这套题的题目跟公司和业务都没有关系,而且也并不代表笔者本人可以把这些题回答得非常好,笔者只是将一部分觉得比较好的题从收集的面试题里面抽出来了而已。 收集的面试题有以下三个来源: ...

iOSpipi的博客 1900

Geant4 案例分析(一): B1

本文是对Geant4 B1的案例分析,其中特定的功能不做介绍,而注重于各个文件的主要功能,以及它们组织的方式。

m0_51809467的博客 1583

史上最全的iOS面试题及答案

史上最全的iOS面试题及答案 博客分类:  iOS iOSios面试题ios面试题和答案ios面试题及答案    史上最全的iOS面试题及答案     iOS面试小贴士 ———————————————回答好下面的足够了------------------------------------- 多线程、特别是NSOperation

Lu_Ca的博客 2226

FPGA时序约束--实战篇(读懂Vivado时序报告)

本文将详细介绍如何读懂Vivado时序报告,包括报告的基本结构和如何分析报告。

mengzaishenqiu的博客 1万+

变焦跟踪理论基础(如何在变焦过程中保持清晰)

如何在整个变焦过程中一直保持图像的清晰度或焦点是变焦跟踪的主要挑战。 当用户在缩放跟踪的情况下改变缩放时,设备保持对焦。 然而,在没有变焦跟踪的情况下,图像变得失焦,图像在变焦跟踪后由于自动对焦(AF)算法才最终对焦。...................................................

ChenYX的博客 20万+

iOS面试题汇总

我在这里总结了一些关于iOS的面试题,以及分析,同时还有视频解析,有兴趣的可以看看。有什么面试资料需要也可以找我。 iOS面试题汇总内含面试题讲解,分析,以及视频讲解 后续还会不定时更新请关注点赞,谢谢!谢谢!谢谢! ...

henry_lei的博客 619

从零搭建一个虚拟ECU:手把手用Autosar CP模块模拟汽车灯控系统(基于Vector工具链)

本文详细介绍了如何使用Vector工具链从零搭建一个基于Autosar CP架构的虚拟ECU系统,模拟汽车灯光控制功能。通过环境搭建、模块配置、通信栈设置到灯光控制逻辑实现的全流程指导,帮助开发者掌握Autosar CP模块术语的实际应用,并提供了系统集成与测试的实用方案。

weixin_42628688的博客 317

优秀的iOS博客

收集一批优秀的iOS博客,不断更新 招聘一个靠谱的 iOS百度大佬出的一些面试题 唐巧的博客 做iOS的没几个不知道他的 杨萧玉 哈工大毕业,腾讯大佬 招聘一个靠谱的 iOS百度大佬出的一些面试题 《招聘一个靠谱的iOS》面试题参考答案 有问就有答 ...

IOSSHAN的博客 734

Monorepo与pnpm:前端项目管理的完美搭档

pnpm又称 performant npm,翻译过来就是高性能的npm。Monorepo是一种项目开发与管理的策略模式,它代表"单一代码仓库"(Monolithic Repository)。在Monorepo模式中,所有相关的项目和组件都被存储在一个统一的代码仓库中,而不是分散在多个独立的代码仓库中,这些项目之间还可能会有依赖关系。

m0_68271787的博客 2562

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

2018 iOS 面试题大全(补充完整版)

原文地址:2018 iOS 面试题大全 由于原作者并没有继续更新,这里我转过来继续更新下 整理的一些iOS面试相关问题,持续更新,敬请关注 2018 iOS面试题大全---全方面剖析面试 1、2018 iOS面试题---UI相关:事件传递,图像显示,性能优化,离屏渲染 2、2018 iOS面试题---Objective_C语言特性相关问题 3、2018 iOS面试题---runtime相关 ...

努力,可能成功!放弃,注定失败! 1279

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

上一篇: IOS面经系列(五)多线程开发
预言之子IX
博客等级 码龄16年 5粉丝 14原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值