Castie!

iOS 如何「无中生有」资源搜索神器

Mon, 29 Jul 2019 14:26:00 +0000

GitHub Repo：coderZsq.project.ios
Follow: coderZsq · GitHub
Resume: https://coderzsq.github.io/coderZsq.practice.web/

日常扯淡

首先申明, 这绝对不是标题党, 看完全文你一定也能够自行的写出一个资源搜索App, 其实这个App, 本来是想在App Store卖钱的, 毕竟感觉需求量还是很大, 虽然知道有可能涉及版权的问题, 但本想只做一个搜索功能, 让用户自行下载应该也能打打擦边球蒙混过关吧, 谁知现在苹果审核5.2.3, 直接搬出了法律神器, 让我不敢逾越雷池一步, 经过内心的挣扎, 还是决定不铤而走险, 开源以回报社会.

其实这个App, 并不是特别复杂, 说实话也没有什么技术含量, iOS端的代码是在2天闲暇时间内写完的, 有一定经验的开发者估计也不会差很多, 核心在于对数据的爬取, 这里我是用Python写的爬虫, 其实爬虫并不复杂, 应该说是简单至极, 我整个服务端加上爬虫也就区区300行不到的代码, 可见难易程度, 所以本文, 并不会教你如何进行实现贴代码, 而是会在产品的思路上进行探讨, 如果你有看过我之前一篇 iOS 开发者该认真思考的「三个问题」就应该了解技术并不是很重要, 重要的是对人性的把握.

技术选型

由于这是一个全栈的项目, 这可是真全栈, 从产品, 设计, 运营, 客户端, 服务端, 数据端, 运维都有所涉及, 所以不能片面的看待问题, 我们需要一个系统的视角, 如何能够让这款产品受到用户的喜爱, (的确有很多的朋友想要这款软件, 但是… 苹果爸爸不允许呀…), 回到正题, 所以我们需要一个最小可用的APP, 什么是最小可用? 就是实现最少的功能, 让功能产生闭环, 并能够提供价值.

所以以这个为出发点, 设计了最简单的交互逻辑, 即点击可得和搜索可得, 减少用户交互的逻辑, 让用户直接达到爽感. 所以, 为了完成这个目标, 我们需要一些开发工具, 我这里用的很简单, Xcode, Photoshop, Sublime Test, 即可, 对, 我并没有使用产品原型设计工具, 因为这种东西本来就是给开发看的, 然而当你自己成为开发者后, 就等于你有了上帝之手, 直接就可以进行实现, 有逻辑设计不合理之处也能够自行修正.

前端, 我就不多介绍了, 因为本想以盈利为目的, 所以选择了iOS端的App Store, 然而… 后端我选用的是Python的Flask, 非常适合开发小型App, 代码少易控制, 简单易用.

获取数据

如何获取数据, 这里我们使用的是豆瓣的数据, 如何爬取豆瓣, 网上有大把大把的教程, 可以自行查阅, 而链接的地址呢, 你可以自行网上查找可用的免费资源分享网站进行爬虫, 虽然有些会有反爬机制, 但你可以反反爬呀, 就像逆向一样, 别人可以反调试, 你可以反反调试呀, 网络安全, 一点都不安全… 这里我就选在了, 种子猫, 磁力搜, 飘花, 讯播, 被窝进行了爬虫, 使用豆瓣爬到的数据进行其他网站的爬虫即可.

构建服务

之前有说, 我选用的是Flask框架, 所以只需要用装饰器就可以立竿见影的写接口, 具体业务逻辑可以自行阅读源码, 只要你有一点点开发经验就可以看懂的, 这里的难点… 也不是难点, 就是如何部署服务器, 这就是有关运维的操作了, 我这里使用的是Nginx + gunicorn搭建的服务器, 具体操作也可以看下教程, 具体就是端口映射和负载均衡, 记得如果是阿里云的话, 需要开启端口的访问权限.

产品设计

有了数据, 接下来就该进行产品设计了, 对于设计方面, 其实作者并没有什么设计的经验, 所以直接参考了Apple原生应用的设计语言, 然后用最少的逻辑达到想要的效果, 真可谓是极简主义了哈哈哈, 当然设计的时候也有一些小细节需要注意, 比如iOS13的暗黑模式的切换, 还有modal的时候iOS13和之前默认的效果不同都需要进行兼容, 还有的就是, 颜色方面不要用纯黑和纯白, 这样看起来的效果会比较的好. icon设计的话, 可以使用阿里开源的icon库, 这不是给阿里打广告, 也不需要我这种菜鸡来打广告hhh.

有关运营

说到这里就要贴出App Store 审核指南, 如果你需要自己开发一个App, 建议你通读此文, 我就是踩到了这个坑… 被5.2.3给拒之门外了,

你需要了解ASO, 这里推荐给你七麦数据这个网站. 可以了解一些搜索指数, 什么样的关键词是用户会经常搜索的, 这样可以极大的曝光你的App.

最后需要做的就是收集用户反馈以及建立社群, 但我并没有走到这一步… 有机会再分享吧.

效果展示

接下来只需要进行iOS端的开发了, 我这里就简单的使用了OC + StoryBoard的传统开发模式, 等SwiftUI成熟了之后再切换成Swift开发吧, 如果想要学习Swift 可以关注我的另一个仓库.

开源分享

iOS 项目相关仓库

Native 技术练习仓库

Data 技术练习仓库

本文所述代码已用红框所示.

写在最后

有了这次的经验, 下次开发会效率快的多, 有想法就去实现, 而不是写那种没有用的Demo, 期待作者下次优秀的作品吧!

iOS 有效「阅读源码」的一些思考

Wed, 27 Feb 2019 23:13:00 +0000

GitHub Repo：coderZsq.project.ios
Follow: coderZsq · GitHub
Resume: https://coderzsq.github.io/coderZsq.practice.web/

日常扯淡

上一篇是第一次写纯阅读类文章, 没有贴出的任何的代码块, 也没有写任何关于技术实现, 但反响出乎意料的好, 不仅获得了掘金的年度征文人气奖, 也得到了iOS大神南峰子的肯定并转载到了知识小集, 对此只有感恩和加倍的努力.

是的, 上一篇所提出的三个问题, 的确是每个开发者都该认真思考的, 但光有价值观, 没有方法论可不行, 有好多读者私信我想要知道前方的路在哪, 想必这也是困扰你许久的症结.

所以这一篇, 我们来谈谈如何进行快速的学习并使知识为我所用, 想要学习真正的技术, 光看技术博客可不行, 这一点在上一篇文章也有所涉及, 如何有效的学习技术, 必然的途径就是看官方文档和阅读优秀的三方源码.

源码区别

首先我们要了解官方源码和三方源码的区别, 到底看官方源码还是优秀的三方源码对成长的效率高, 这里要理解一个概念, 官方源码, 顾名思义对于iOS来说, 就是系统级别的代码, 就是官方会一直维护支持的, 而三方源码就是优秀的开发者开源出来的代码, 可能很优秀, 但并不能保证长时间的有效更新, 打个比方当你的iPhoneXs屏幕破碎了, 你可以到苹果天才吧进行维修, 或者到一些小作坊进行维修, 这里可以类比优秀的三方源码就是手艺高超的手艺人.

知道了区别, 我的建议是先看官方的源码, 这里不仅仅是iOS, 因为所有的三方源码都是大部分都是参照官方源码进行设计的, 也不乏优秀的三方源码被苹果爸爸相中集成到官方源码中, 但这毕竟是少数, 而且我对于三方源码一直是持有保留意见的.

难易程度

怎么选源码对学习的效率也有讲究么? 是的, 而且大有关系, 如果你是iOS开发, 想必你肯定用过AFNetWorking, SDWebImage, 这种牛逼哄哄的框架, 但如果你基础不是很扎实, 就算官方给出了架构文档, 你是不是感觉也无从下手? 就算看了个大概, 也不知道为什么要这样设计, 当然这两个框架网上有太多的文章来进行源码解读, 我也不会作出狂贴代码这种那么Low的事情, 因为所有的选择都是在特定的上下文之下才能观其端倪, 这也就是场景的重要性, 简单来说, 就是要输出倒逼输入, 在场景中想问题, 逆向思考, 你会得出不一样的结论.

还有很重要的一点是, 那你所看的源码需要和那你的能力所匹配, 比如说, 你并不懂C++, 而要看runtime源码你就会感觉很蛋疼, 如果你不懂汇编, 看消息发送那段就算有注释都自觉天书.

所以我的建议是可以看一些比你能力强一点点的, 稍微努努力能够够着的源码, 如果你感觉什么源码都入手困难的话, 可能你的语言基础太过薄弱, 还是乘早转行吧, 因为现在的环境下, 看不了源码几乎没有什么生存空间了.

一些趣事

入手之前, 我们先要了解一个概念, 并不是只有1000star以上的源码才有阅读的必要, 阅读和使用是两个不同的概念, 使用在项目中我们需要的是稳定性, 所以没有大量验证的代码是不能集成到项目中去的, 而阅读就不一样, 阅读是用来学习思想的, 理解了别人写的代码, 自己写一个, 就会觉得所谓的三方库也就不过尔尔.

这里挑选一个库ZIKViper, 可能大家并不了解这个库, 也跟别提用过这个库了, 在github上也就不到200个star, 作者也好像不怎么维护这个库了, 但这都不是重点, 重点是这我们能够从这个源码中学习到一些关于Viper架构优秀的设计思路, 以及将这些经验运用到自己的项目中去, 这才是我们看源码应该有的角度.

为什么选这个源码, 首先最近拟定要进行架构升级, 我之前也写过一篇关于架构的文章, 但现在回看还是非常幼稚和脆弱的, 但是这也证明了我的成长, 当你感觉过去的代码你看不下去了, 恭喜你, 你进步了.

有缘的是, 在我写之前的架构的时候还和ZIKViper的作者有一次交流, 我将交流整理成文章放在了网上可以点击查阅: iOS 关于组件化Router设计的争辩, 希望对你有所帮助.

了解概念

既然选择了一个源码, 在入手之前, 我们需要了解这个库到底是用来做什么的, 即场景的重要性. 可以看下相关库的README.md.

VIPER简介

VIPER的全称是View-Interactor-Presenter-Entity-Router。示意图如下：

相比MVX架构，VIPER多出了两个东西：Interactor（交互器）和Router（路由）。

各部分职责如下：

View 提供完整的视图，负责视图的组合、布局、更新向Presenter提供更新视图的接口将View相关的事件发送给Presenter Presenter 接收并处理来自View的事件向Interactor请求调用业务逻辑向Interactor提供View中的数据接收并处理来自Interactor的数据回调事件通知View进行更新操作通过Router跳转到其他View Router 提供View之间的跳转功能，减少了模块间的耦合初始化VIPER的各个模块 Interactor 维护主要的业务逻辑功能，向Presenter提供现有的业务用例维护、获取、更新Entity 当有业务相关的事件发生时，处理事件，并通知Presenter Entity 和Model一样的数据模型和MVX的区别 VIPER把MVC中的Controller进一步拆分成了Presenter、Router和Interactor。和MVP中负责业务逻辑的Presenter不同，VIPER的Presenter的主要工作是在View和Interactor之间传递事件，并管理一些View的展示逻辑，主要的业务逻辑实现代码都放在了Interactor里。Interactor的设计里提出了”用例”的概念，也就是把每一个会出现的业务流程封装好，这样可测试性会大大提高。而Router则进一步解决了不同模块之间的耦合。所以，VIPER和上面几个MVX相比，多总结出了几个需要维护的东西：

View事件管理数据事件管理事件和业务的转化总结每个业务用例模块内分层隔离模块间通信而这里面，还可以进一步细分一些职责。VIPER实际上已经把Controller的概念淡化了，这拆分出来的几个部分，都有很明确的单一职责，有些部分之间是完全隔绝的，在开发时就应该清晰地区分它们各自的职责，而不是将它们视为一个Controller。

优点 VIPER的特色就是职责明确，粒度细，隔离关系明确，这样能带来很多优点：

可测试性好。UI测试和业务逻辑测试可以各自单独进行。易于迭代。各部分遵循单一职责，可以很明确地知道新的代码应该放在哪里。隔离程度高，耦合程度低。一个模块的代码不容易影响到另一个模块。易于团队合作。各部分分工明确，团队合作时易于统一代码风格，可以快速接手别人的代码。

好了, 以上都是抄的, 都是Zuikyo的文字, 我仅仅是粘贴使用, 想必他也不会介意的吧hhh

准备入手

了解了源码的概念, 我们就该开始着手阅读了, 首先将库克隆岛本地, pod install什么的常规操作我就不说了.

首先我们要看的是主文件

#import <UIKit/UIKit.h>
#import "SQViperView.h"
#import "SQViperViewEventHandler.h"
#import "SQViperPresenter.h"
#import "SQViperInteractor.h"
#import "SQViperWireframe.h"
#import "SQViperRouter.h"
#import "SQViperViewPrivate.h"
#import "SQViperPresenterPrivate.h"
#import "SQViperInteractorPrivate.h"
#import "SQViperWireframePrivate.h"
#import "NSObject+SQViperAssembly.h"
#import "UIViewController+SQViperRouter.h"

FOUNDATION_EXPORT double SQViperVersionNumber;

FOUNDATION_EXPORT const unsigned char SQViperVersionString[];

这里你会发现和ZIK的前缀不同, 没关系, 我就是抄的, 在学习别人源码的过程中, 最有效的方法就是把别人的代码从新敲上一遍, 你会有不同的感悟, 在此声明我一直都是原创的簇拥者, 此篇文章所表达的意思是如何学习源码, 这里仅仅是代码举例.

你是不是也发现了优秀的代码都是极为的相似, 优秀是有范式, 有迹可循的.

重点分析

我这里不会长篇的贴代码进行解读, 想必看到这里, 你一定是有一定经验阅读源码的人, 所以文末放出地址, 自己去看就是了.

这里我们重点关注的是为什么要这样设计, 这样设计的好处在哪里.

看了主头文件, 我们可以发现所有协议后有加上Private字样. 以SQViperView举例.

#import <UIKit/UIKit.h>

NS_ASSUME_NONNULL_BEGIN

@protocol SQViperViewEventHandler;

@protocol SQViperView <NSObject>

- (nullable UIViewController *)routeSource;

@property (nonatomic, readonly, strong) id<SQViperViewEventHandler> eventHandler;

@optional
@property (nonatomic, readonly, strong) id viewDataSource;

@end

NS_ASSUME_NONNULL_END

#import "SQViperView.h"

NS_ASSUME_NONNULL_BEGIN

@protocol SQViperViewEventHandler;

@protocol SQViperViewPrivate <SQViperView>

- (id<SQViperViewEventHandler>)eventHandler;

- (void)setEventHandler:(id<SQViperViewEventHandler>)eventHandler;

@optional
- (id)viewDataSource;

- (void)setViewDataSource:(id)viewDataSource;

- (void)setRouteSource:(UIViewController *)routeSource;

@end

NS_ASSUME_NONNULL_END

这里很清楚的就能够看到, 这是表示权限问题, 也就是只读和读写的问题, 这个在架构设计上尤为重要, 也是工作经验的体现.

#import "NSObject+SQViperAssembly.h"

@implementation NSObject (SQViperAssembly)

+ (void)assembleViperForView:(id<SQViperViewPrivate>)view presenter:(id<SQViperPresenterPrivate>)presenter interactor:(id<SQViperInteractorPrivate>)interactor wireframe:(id<SQViperWireframePrivate>)wireframe router:(id<SQViperRouter>)router {
    
    NSParameterAssert([view conformsToProtocol:@protocol(SQViperView)]);
    NSParameterAssert([presenter conformsToProtocol:@protocol(SQViperPresenter)]);
    NSParameterAssert([interactor conformsToProtocol:@protocol(SQViperInteractor)]);
    NSParameterAssert([wireframe conformsToProtocol:@protocol(SQViperWireframe)]);
    NSParameterAssert([router conformsToProtocol:@protocol(SQViperRouter)]);
    
    NSAssert3(interactor.eventHandler == nil, @"Interactor (%@)'s eventHandler (%@) already exists when assemble viper for new eventHandler", interactor, interactor.eventHandler, presenter);
    NSAssert3(interactor.dataSource == nil, @"Interactor (%@)'s dataSource (%@) already exists when assemble viper for new dataSource", interactor, interactor.dataSource, presenter);
    
    interactor.eventHandler = presenter;
    interactor.dataSource = presenter;
    
    NSAssert3(wireframe.view == nil, @"Wireframe (%@)'s view (%@) already exists when assemble viper for new view", wireframe, wireframe.view, view);
    
    wireframe.view = view;
    wireframe.router = router;
    
    NSAssert3(presenter.interactor == nil, @"Presenter (%@)'s interactor already exists when assemble viper for new interactor", presenter, presenter.interactor, interactor);
    NSAssert3(presenter.view == nil, @"Presenter (%@)'s view already exists when assemble viper for new view", presenter, presenter.view, view);
    NSAssert3(presenter.wireframe == nil, @"Presenter (%@)'s wireframe (%@) already exists assemble viper for new router", presenter, presenter.wireframe, self);
    
    presenter.interactor = interactor;
    presenter.view = view;
    presenter.wireframe = wireframe;
    
    if ([view respondsToSelector:@selector(viewDataSource)] &&
        [view respondsToSelector:@selector(setViewDataSource:)]) {
        NSAssert3(view.viewDataSource == nil, @"View (%@)'s viewDataSource (%@) already exists when assemble viper for new viewDataSource", view, view.viewDataSource, presenter);
        view.viewDataSource = presenter;
    }
    
    NSAssert3(view.eventHandler == nil, @"View (%@)'s eventHandler (%@) already exists when assemble viper for new eventHandler", view, view.eventHandler, presenter);
    
    view.eventHandler = presenter;
}

@end

这个分类很好的将架构的所有逻辑结构进行了组装, 堪称是这个源码的精髓所在.

其他的就没有什么值得称道的东西了, 毕竟这是一份简单的源码. 我们的关注点在思想上.

这里要说的是, 根据不同的源码了解分析出其关键点, 并了解设计思路.

动手实践

所谓实践才是检验真理的唯一标准, 所以一般优秀的三方源码都会有demo作为参考, 所以想要学习的同学, 可以自行查阅.

我这里对比之前我写的容量增肌项目, 对比写了一个Viper版本的作为对照, 也会把碰到的问题分享给大家.

#import "SQTrainingCapacityViewController.h"
#import "SQTrainingCapacityCell.h"
#import "SQTrainingCapacityHeaderView.h"
#import "SQTrainingCapacityFooterView.h"
#import "SQTrainingCapacityCellPresenter.h"
#import "SQTrainingCapacityDataSource.h"
#import "SQTrainingCapacityViewEventHandler.h"

@interface SQTrainingCapacityViewController ()

@property (nonatomic, strong) NSMutableArray *dataSource;
@property (nonatomic, weak) SQTrainingCapacityFooterView * footerView;

@end

@implementation SQTrainingCapacityViewController

- (void)setupData {
    _dataSource = [NSMutableArray array];
}

- (void)fetchDataSource {
    NSArray *dataSource = [(id<SQTrainingCapacityDataSource>)self.viewDataSource fetchDataSourceFromDB];
    [self.dataSource removeAllObjects];
    [self.dataSource addObjectsFromArray:dataSource];
}

- (void)setupUI {
    [self setupRightBarButtonItem];
    [self setupTableView];
}

- (void)setupRightBarButtonItem {
    [self setRightBarButtonItem:(UIBarButtonSystemItemAdd) target:self action:@selector(addTraningAction)];
}

- (void)setRightBarButtonItem:(UIBarButtonSystemItem)item target:(nullable id)target action:(nullable SEL)action {
    self.navigationItem.rightBarButtonItem = [[UIBarButtonItem alloc]initWithBarButtonSystemItem:item target:target action:action];
}

- (void)setupTableView {
    self.tableView.tableHeaderView = [SQTrainingCapacityHeaderView headerView];
    SQTrainingCapacityFooterView * footerView = [SQTrainingCapacityFooterView footerView];
    footerView.totalCapacityLabel.text = [(id<SQTrainingCapacityDataSource>)self.viewDataSource totalCapacity];
    self.tableView.tableFooterView = footerView;
    self.footerView = footerView;
    [self.tableView registerNib:[UINib nibWithNibName:@"SQTrainingCapacityCell" bundle:[NSBundle bundleForClass:self.class]] forCellReuseIdentifier:@"TrainingCapacity"];
    [self setupDataSource:self.dataSource loadCell:^UITableViewCell *(UITableView * _Nonnull tableView, NSIndexPath * _Nonnull indexPath) {
        return [tableView dequeueReusableCellWithIdentifier:@"TrainingCapacity" forIndexPath:indexPath];
    } loadCellHeight:^CGFloat(id  _Nonnull model) {
        return 160;
    } bind:^(UITableViewCell * _Nonnull cell, id  _Nonnull model) {
        SQTrainingCapacityCell * c = (SQTrainingCapacityCell *)cell;
        SQTrainingCapacityCellPresenter * p = (SQTrainingCapacityCellPresenter * )model;
        [p bindToCell:c];
    }];
}

- (void)addTraningAction {
    [(id<SQTrainingCapacityViewEventHandler>)self.eventHandler didTouchNavigationBarAddButton];
}

- (void)tableView:(UITableView *)tableView commitEditingStyle:(UITableViewCellEditingStyle)editingStyle forRowAtIndexPath:(NSIndexPath *)indexPath {
    [(id<SQTrainingCapacityViewEventHandler>)self.eventHandler handleCommitEditingAtIndexPath:indexPath];
}

@end

这里仅仅贴出控制器的代码, 我们可以看到, 在Viper架构下, 获取数据和操作逻辑都通过协议进行传递, 没有任何冗余的代码, 分层清晰明了.

#import "SQTrainingCapacityPresenter.h"
#import "SQTrainingCapacityViewProtocol.h"
#import "SQTrainingCapacityInteractorInput.h"
#import "SQTrainingCapacityWireframeInput.h"
#import "SQTrainingCapacityNotification.h"

@interface SQTrainingCapacityPresenter ()

@property (nonatomic, weak) id<SQTrainingCapacityViewProtocol> view;
@property (nonatomic, strong) id<SQTrainingCapacityInteractorInput> interactor;
@property (nonatomic, strong) id<SQTrainingCapacityWireframeInput> wireframe;

@end

@implementation SQTrainingCapacityPresenter

- (void)handleViewReady {
    NSAssert(self.wireframe, @"Router should be initlized when view is ready.");
    NSAssert([self.view conformsToProtocol:@protocol(SQViperView)], @"Presenter should be attach to a view");
    NSAssert([self.interactor conformsToProtocol:@protocol(SQViperInteractor)], @"Interactor should be initlized when view is ready.");
    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(keyboardWillShow:) name:UIKeyboardWillShowNotification object:nil];
    [[NSNotificationCenter defaultCenter]addObserver:self selector:@selector(keyboardWillHide:) name:UIKeyboardWillHideNotification object:nil];
    [self.interactor loadDataSourceWithTitle:self.view.title type:self.view.type];
    [self.view fetchDataSource];
}

- (void)handleViewWillAppear:(BOOL)animated {
    NSLog(@"%s", __func__);
}

- (void)handleViewDidAppear:(BOOL)animated {
    NSLog(@"%s", __func__);
}

- (void)handleViewWillDisappear:(BOOL)animated {
    NSLog(@"%s", __func__);
}

- (void)handleViewDidDisappear:(BOOL)animated {
    NSLog(@"%s", __func__);
}

- (void)handleViewRemoved {
    NSLog(@"%s", __func__);
    [self.interactor storeDataSourceWithTitle:self.view.title type:self.view.type dataSource:self.fetchDataSourceFromDB];
    [[NSNotificationCenter defaultCenter] removeObserver:self];
}

- (void)handleCommitEditingAtIndexPath:(NSIndexPath *)indexPath {
    NSMutableArray *tempDataSource = self.fetchDataSourceFromDB.mutableCopy;
    [tempDataSource removeObjectAtIndex:indexPath.row];
    [self.interactor storeDataSourceWithTitle:self.view.title type:self.view.type dataSource:tempDataSource];
    [self.view fetchDataSource];
    [self.view.tableView deleteRowsAtIndexPaths:@[indexPath] withRowAnimation:UITableViewRowAnimationFade];
    self.view.footerView.totalCapacityLabel.text = self.totalCapacity;
}

- (void)didTouchNavigationBarAddButton {
    [self.interactor addTrainingAction];
    [self.view fetchDataSource];
    [self.view.tableView insertRowsAtIndexPaths:@[[NSIndexPath indexPathForRow:self.fetchDataSourceFromDB.count - 1 inSection:0]] withRowAnimation:(UITableViewRowAnimationLeft)];
}

- (void)didTouchNavigationBarDoneButton {
    [self.view.tableView endEditing:YES];
    [[NSNotificationCenter defaultCenter]postNotificationName:SQTrainingCapacityBindToModelNotification object:nil];
    self.view.footerView.totalCapacityLabel.text = self.totalCapacity;
    [self.view.tableView reloadData];
}

- (void)keyboardWillShow:(NSNotification *)sender {
    [self.view setRightBarButtonItem:(UIBarButtonSystemItemDone) target:self action:@selector(didTouchNavigationBarDoneButton)];
}

- (void)keyboardWillHide:(NSNotification *)sender {
    [self.view setRightBarButtonItem:(UIBarButtonSystemItemAdd) target:self action:@selector(didTouchNavigationBarAddButton)];
}

- (NSString *)totalCapacity {
    return self.interactor.totalCapacity;
}

- (NSArray *)fetchDataSourceFromDB {
    return self.interactor.fetchDataSource;
}

@end

协调整个架构的presenter, 逻辑一下子也清晰了很多, 和之前的进行对比, 你会更好的了解这个架构.

如何实践, 文档是讲不清楚的, 需要大家阅读源码和动手实践

GitHub: https://github.com/coderZsq

项目地址: https://github.com/coderZsq/coderZsq.project.ios

笔记地址: https://github.com/coderZsq/coderZsq.practice.native

写在最后

这篇分析了如何阅读源码的全过程, 简单来说就是, 确定场景, 了解概念, 重点分析, 动手实践, 这些东西说说简单, 实际操作中还是有很多的精妙之处的

以上.

iOS 开发者该认真思考的「三个问题」

Thu, 10 Jan 2019 17:00:00 +0000

GitHub Repo：coderZsq.project.ios
Follow: coderZsq · GitHub
Resume: https://coderzsq.github.io/coderZsq.practice.web/

日常扯淡

大半年没有更新文章了, 可能是对自己写的内容有要求吧, 不想写一些如OC底层, 逆向入门这些像内容洗稿,东拼西凑的伪原创, 修修改改换换顺序就又是一篇完全没有意义的文章. 如果你获取技术大部分的手段是看技术博客的话, 是的, 是时候调整你的视角, 扩展你的视野, 对自己有更具体的要求了.

如果你是一个iOS开发的新手, 是的, 这个职业的红利期早已过去, 随着APPL的股价大跌, 以及内忧外患不断, iOS这个职业的恐慌指数在不断的增高, 已经对新手不太友好了, 如果你是一个2-3年的iOS从业人员, 每天的工作内容就是画画界面, 写写业务, 调调接口, 那你是时候改变一下自己的视角从新审视下未来的职业规划, 如果你是一个3-5年的老鸟, 掌握了一定的技术及资源, 可能这篇文章的内容已经早已在你脑海中有段时日, 只是缺乏良好的契机, 如果你是6-10年的大佬, 呵呵, 这个等级的大佬是不会耗费时间在看技术博客上了, 自然也不会看到这篇文章.

由于iOS开发, 国内并没有相关对口的专业, 所以基本上大多数开发者都是通过自学进入市场的, 有的由于是科班出身, 重点大学, 幸运的进入大厂深造, 一路顺风顺水, 使得其他的开发者只能望其项背, 多数普通的开发者都是通过培训机构进入市场的, 并没有很深的技术基础, 没有系统的学习过计算机原理的课程, 只是从培训机构快速学习了API的调用, 对其本质不是很了解, 也造成了进阶的困难, 所以现在市面上出现了很多在线技术教育, 不坏, 学习是很好的行为, 我们这里谈的是如何精准的学习.

自我接纳

如何进行精准的学习, 首先我们需要学会自我接纳, 做产品的对目标用户都会有用户画像, 用户画像存在的意义是无论你做是什么东西说什么话, 都无法取悦所有人, 这就是定位的意义, 而对自身也是一样, 你需要了解自己的定位才能进行进一步的规划.

相同的环境造就相同的价值观, 真是由于每个人的价值观不同, 造就了这个五彩缤纷的世界, 当我们作为iOS开发刚进入市场的时候, 那时候只需要会画一个TableView就能赚取可观薪水的日子早已离我们而且, 市场成熟后门槛也逐渐的提升, 所以如果你只会用Objective-C, 画界面, 写业务, 调接口, 那真的需要加把劲了, 因为这个时代正在淘汰这些低级工作.

有了改变自己认知的契机, 我们就来问问自己三个问题:

你所拥有的技术储备真的是市场上需要的吗?
面对层出不穷的新兴技术, 如何才能做好技术选型?
你真的有把握能够在技术这条路上走到底吗?

市场数据

先不急着回答上述的问题, 在做所有决定之前我们需要看一下市场所呈现的数据, 而不是人云亦云, 不然就很容易被现在的某些知识付费收智商税, 鼓吹碎片化学习, 记住, 没有数据支撑纯靠思辨的产物不是知识, 你仅仅获得的是获取知识的感觉. 知识是需要全面系统的学习并进行场景验证的, 所以在如何规划之前先看看数据.

上图是艾瑞指数的数据, 不用去管媒体如何煽动, 数据表明iOS的占有量还是比较稳定的, 所以iOS没有人要了可能真的只是一句玩笑, 因为有市场就会有需求.

我们再来看iOS设备的分布图, 可以发现目前主要群体还是使用的iPhone6/6s的设备, 可以看到iPhone8/8P,XR, 并没有卖的很好, 换机频率下降是不争的事实. 但整个行业都是如此, 所以也不用太悲观. 所以还是以提升自身技术为先.

技术储备

技术储备是很能说明一个开发者具体的能力体现的, 所以不断的学习是每一个做技术每天需要完成的课题, 以iOS举例, iOS基本技术无外乎, UI, 网络, 业务, 三个方面, 也就是上述的, 画界面, 写业务, 调接口, 是的, 这是基础能力, 但你纵览整个大前端技术栈, 本质都是这三个方面, 所以就算你在这些地方花费再多的精力, 收益是很有限的, 所以很多的开发者会想要深入学习, 会看一些官方或者是三方的一些源码, 并写一些分析放在博客上, 自以为是的以为理解了作者的想法, 沾沾自喜. 挺好, 幻象会使人快乐, 就如有些人会看runtime, 但很少人知道Facebook的fishhook, 毕竟掌握后者的技术储备和runtime不是一个量级的.

这里假设你已经熟悉了runtime源码中的底层实现, 了解了OC的实现机制, 但你并不知道这些东西的使用场景在哪里, 为什么大厂可以用这些做一些APM的东西, 而你并不知道如何入手, 首先是你的技术储备不足, 再有就是你的视角产生了偏差.

技术储备不足, 这是先天缺陷, 只能后天弥补, C/C++/Linux/ASM, 如果你想深入理解, 这些逃不过去, 你有这些基础的话, 再看runtime源码, 就会感觉非常轻松, 没有任何的困难.

视角的问题在于, 你只有技术的视角, 只会用技术来解决问题, 自以为是的以为技术能够解决任何问题, 而事实是, 技术只是一个工具, 工具就是可替换的, 而工具只会变得越来越简单, 越来越顺手. 你的如果只被技术限制住, 你的竞争力会逐年降低.

聊聊面试

面试是一个非常热的话题, 只要发随便发一篇面经, 就会有很多人关注, 笔者有幸面试过很多大厂, 如饿了么, 京东, 美团, 携程, 头条, 招行等, 面试题无外乎就是, OC原理, UIKit, 网络, 线程, 组件化, 算法, 架构, 全部都在射程范围之内, 目前对Swift和跨平台插件化也会有一些涉及, 这个部分取决于你所面试的业务线, 但是, 算法必考, 架构必谈.

其实如果你是一个有技术储备的合格的开发者, 通过面试对你来说并不是一个非常困难的事情, 因为这些东西真的并不难, 都是一些日常涉及的东西, 常规操作而已.

谈谈全栈

对于技术提升会分为两条线, 就是深度和广度, 如果你涉及过算法, 你就会知道深度优先和广度优先, 这两条线并没有孰优孰劣, 看你所在的场景, 在知识付费领域的概念就是, T字型人才, 80%人才, 100%人才, 具体选择那条线没有什么实际的意义,

在先进互联网技术栈被笼统的分为, 前端, 后端, 移动端, 数据端, 我的观点是, 全栈很有必要, 首先你需要了解一个观点, 你的价值不取决于你的能力, 而是市场的稀缺性, 成为100%的专才, 的确可以拿到头部市场, 但成本大风险高, 而做一个80%的通才, 是一个对普通人比较友好的选择, 而如果你已经是一个有技术储备合格的开发者, T字型发展也是一个合理的选择.

如何选型

现在新兴技术层出不穷, 光iOS方向就有ReactiveCocoa, ReactNative,Flutter等, 还有人工智能, 区块链等新兴技术, H5, Andriod都没学过来了, 怎么有时间研究那么多的技术, 是的, 吾生也有涯，而知也无涯, 以有涯随无涯，殆已！所以这并不是最好的学习方式.

这里你要理解一个观念,技术不能够脱离产品而独立实现, 产品不能脱离运营而独立存活, 运营脱离了用户也没有了意义, 你要理解互联网的本质其实是人的连接, 理解了这层逻辑, 反推来看你的视野就会清晰很多, 由用户产生了需求, 运营用户而产生了群体, 分析群体而打造产品, 实现产品才需要技术, 所以在没有很大基数的用户的前提下, 对技术的追求是没有任何意义的. 而当你有了用户, 你就会知道你该如何技术选型, 最经济的方法就是选择那些稳定且成效快的, 这也是为什么三方库存在的本质.

技术之外

是的, 现在你已经理解了, 技术本质只是工具, 而互联网是人与人的连接, 是思想的碰撞, 这也是为什么一些大V仅仅是运营粉丝就能够赚的可观的收益, 而那些明星级别的顶级流量自不必说.

所以一个优秀的开发者也需要学习运营和产品方面的相关知识, 需要了解用户画像, 需要了解人性, 这样在你怼产品的时候就会更有底气.

幸运的是, 你成为产品简, 产品成为你难, 所以有极强学习能力的你已经理解了, 掌握系统的重要之处. 可以试着做一些新媒体及产品, 并用技术实现, 你会发现实现自我的同时, 收获了更多的快乐.

你会理解为什么现在内容创业洗稿, 知识付费拆书的本质逻辑, 独立开发者可以站在更高的维度来看世界. 当然对于不熟悉的东西, 每走一步都异常艰难. 但我们需要被讨厌的勇气, 不是吗.

动手实践

看到这里, 你会感觉你需要学习的东西实在是太多, 终身学习是非常有必要的, 但学以致用才是本文推崇的价值观, 笔者经常挂在嘴边的一句话就是, 没有用的都是垃圾.

这个是一个非常简单的产品, 是笔者在Youtube上看到的容量增肌计划随手实现的, 在技术角度没有任何的技术含量, 仅仅是一个ORM的数据库就可以实现, 但在产品的角度, 这其实已经是一个完整的App了, 虽然只有三个界面, 但内部逻辑已经产生了闭环, 并能够提供价值.

所以以后请不要写一些没有用的Demo, 而是转变视角想想新学的技术能够用在什么场景, 能够为什么人提供便利.

提升视野

现今世界最厉害的两个武器, 一个是技术, 一个是传播, 其实每个时代都一样, 一边是王权, 一边是宗教, 所以作为开发者, 技术是赖以生存的本能, 所以你需要提升的是你的传播的能力, 你可以想一下为什么会有人发公众号, 发微博, 发抖音, 发技术博客, 他们都是做慈善的吗? 当然不是, 其本质就是为了传播, 我写这篇文章很大一部分原因就是希望你能够在我GitHub上点上Star, 其实是为了锻炼我的文笔, 更好的运营我的新媒体, 创造属于自己品牌的价值.

但是你想要传播但是没有内容的输出是不可能的, 我能够洋洋洒洒写出那么多字, 也是我思考积累的过程, 现在写文字对我来说已经是思绪的流动, 写作技巧已经是非常次要的东西了.

和技术储备一样, 你也需要提升你的知识储备, 你需要了解这个世界正在发生的事情, 你就需要科学上网, 为了实现这个场景的需求, 你就会进行这方面的技术学习, 看, 技术选型是自然形成的, 并不需要你纠结, 有了场景, 一切看起来都是那么的简单, 当你的知识储备到了一定的阶段, 你就会感觉输出倒逼输入, 你就会有发表自己观点的欲求, 你可能也会从看博客到写博客的阶段, 而我想告诉你的是, 其实你可以靠技术轻松的进行变现.

当然变现并没有说的那么简单, 你需要学习的东西很多, 首先你需要了解经济, 市场的波动, 股票对公司的影响, 了解技术, 各种前沿技术和未来的趋势, 了解这些我到时推荐你看一些知识付费的东西, 比如得到里的万维钢和王煜全的专栏, 对提升你的视野很有帮助, 但如果你想要从中学习到知识, 还是别天真了, 老老实实的系统学习, 动手去做, `记住, 没有数据支撑, 纯靠思辨的产物不是知识.

干货分享

笔者将一些iOS学习的注意点整理成项目, 包括但不限于组件化, 跨平台, 响应式, 算法, 架构, 逆向, Swift等内容.

GitHub: https://github.com/coderZsq

项目地址: https://github.com/coderZsq/coderZsq.project.ios

笔记地址: https://github.com/coderZsq/coderZsq.practice.native

写在最后

文章开头所说的精准学习, 其实你已经大概的了解了, 其实道理很简单, 就是输出倒逼输入, 只有你真正知道自己要做什么了, 你学习的方向就会变的异常的明确, 愿你突破视野的限制, 成为更好的自己.

以上。

iOS 网络性能优化浅析

Thu, 23 Aug 2018 17:30:00 +0000

GitHub Repo：coderZsq.project.ios
Follow: coderZsq · GitHub
Resume: https://coderzsq.github.io/coderZsq.practice.web/

日常扯淡

emm~~ 最近有好多大厂疯狂招人, 也有很多朋友抛出了橄榄枝要来内推我, 在此我表示万分感谢, 但以小弟的简历… 真的连简历都过不了… 最近在学习Python, 真的学了Python才感受到了编程的乐趣啊, 爬虫, 自动化, 数据分析, 机器学习, 区块链 真的是感觉掌控了先进科技了… 我把所有学习Python的代码放在了这里–> 仓库, 会逐步更新的, 希望能够共同学习和进步!

诶… 一直在自学Python, iOS都不太会敲了, 想想之前看了函数式编程的书, 又想学着写写如何设计一个网络框架, 就有了今天这篇文章, 虽然也没啥技术含量….

对于iOS, Apple市值破万亿, 说明当初选择这个方向还是不错的, 但是现在的趋势真的是好多在职的iOS都在往大数据和人工智能方向上转, 真的, 我感觉iOS各个都是全栈, 什么都会真的牛逼, 我也要跟随大佬的步伐, 继续我的学习之旅了~~

网络优化

说实话, 网络优化基本是根据你的项目来的, 不同的需求会有不同的方案, 但思想上是想通的, 大体就是, 缓存, 缓存, 缓存… 总结为如下几点:

减少, 压缩网络数据
如果多次请求结果是相同的, 经量使用缓存
使用断点续传, 否则网络不稳定的时候可能多次传输相同的内容
网络不可用的时候, 不要尝试执行网络请求
让用户可以取消长时间运行或者速度很慢的网络操作, 设置合适的超时时间
批量传输，比如，下载视频流时，不要传输很小的数据包，直接下载整个文件或者一大块一大块地下载。如果下载广告，一次性多下载一些，然后再慢慢展示。如果下载电子邮件，一次下载多封，不要一封一封地下载.

HTTP

说起网络, 肯定要说到HTTP了, 这个真的绕不过去, 对于HTTP可以看看我学习实践的代码–> 仓库

当然这个是用JS写的, 而且这个需要服务端的支持, 简单来说就是设置一些头信息, cache-control 这个字段就非常虫咬了, 是做一些缓存处理的, 设置max-age就可以设定超时时间. accept设置为gzip之类的就可以进行网络数据的压缩..

这种都是常规操作, 就不过多赘述了…

准备工作

这个在上一篇iOS 界面性能优化浅析的基础上进行, 在我们server.js中添加代码.

    if (decodeURI(req.url).indexOf("/get") != -1) {
        console.log(req.url);
        res.writeHead(200, {
            'Content-Type': 'application/json'
        });
        res.end(JSON.stringify({
            data: "GET Method",
            status: 'Success'
        }));
    }

    if (decodeURI(req.url).indexOf("/post") != -1) {
        console.log(req.url);
        let body = "";
        req.on('data', function (chunk) {
            body += chunk;  
        });
        req.on('end', function () {
            body = querystring.parse(body);
            console.log(body);
        });
        res.writeHead(200, {
            'Content-Type': 'application/json'
        });
        res.end(JSON.stringify({
            data: "POST Method",
            status: 'Success'
        }));
    }

    if (decodeURI(req.url).indexOf("/image") != -1) {
        let path = __dirname + '/contents/Castie!.jpg';
        fs.readFile(path, 'binary', (err, file) => {
            if (err) {
                console.log(err);
                return;
            } else {
                res.writeHead(200, {
                    'Content-Type': 'image/jpeg'
                });
                res.write(file, 'binary');
                res.end();
                return;
            }
        })
    }

我们就简单的开了三个接口来模拟get请求, post请求和图片请求 这些基本上覆盖了我们80%的需求了吧.

如何设计

一个网络框架如何设计? 说实话, 我也不知道, 看了AFNetworking和SDWebImage的源码, 就会发现侧重点都是不同的. 做为开发者, 当然不能生搬硬套别人的思想, 所以我就按自己的理解来进行设计了.

我在写代码的时候, 有自顶向下设计的习惯, 首先把接口写出来, 关键是要让别人用的爽, 然后再进行具体的实现.

所以我们先看下之前AFN我们是怎么用的.

#import "Service.h"
#import <AFNetworking.h>

@implementation Service

- (void)fetchMockDataWithParam:(NSDictionary *)parameter completion:(RequestCompletionBlock)completion {
    
    AFHTTPSessionManager * manager = [AFHTTPSessionManager manager];
    [manager GET:@"http://localhost:8080/fetchMockData" parameters:parameter progress:nil success:^(NSURLSessionDataTask * _Nonnull task, id  _Nullable responseObject) {
        if ([responseObject[@"status"] isEqualToString: @"success"]) {
            completion(responseObject[@"data"], nil);
        }
    } failure:^(NSURLSessionDataTask * _Nullable task, NSError * _Nonnull error) {
        completion(nil, error);
    }];
}

@end

这个是我之前使用AFN的时候的常规操作, 再看我想要达到的效果:

#import "Service.h"
#import "SQFetcher.h"
#import <UIKit/UIKit.h>

@implementation Service

- (void)fetchMockDataWithParam:(NSDictionary *)parameter completion:(RequestCompletionBlock)completion {
    
    [SQFetchManager managerWithState:SQFetchSerialState]
    
    .GET(@"http://localhost:8090/fetchMockData", nil, ^(NSDictionary *responseObject){
        if ([responseObject[@"status"] isEqualToString: @"success"]) {
            completion(responseObject[@"data"], nil);
        }
        NSLog(@"EXCUTE: http://localhost:8090/fetchMockData");
    }, nil)
    
    .GET(@"http://localhost:8090/get", @{@"username": @"Castie!",
                                         @"passwd" : @"01234",
                                         @"param0" : @"0.0",
                                         @"param1" : @"1.1",
                                         @"param2" : @"2.2",
                                         @"param3" : @"3.3",
                                         @"param4" : @"4.4",
                                         }, ^(NSDictionary *responseObject){
             NSLog(@"EXCUTE: http://localhost:8090/get %@", responseObject);
    }, nil)
    
    .POST(@"http://localhost:8090/post", @{@"username": @"Castie!",
                                           @"passwd" : @"56789",
                                           @"param5" : @"5.5",
                                           @"param6" : @"6.6",
                                           @"param7" : @"7.7",
                                           @"param8" : @"8.8",
                                           @"param9" : @"9.9",
                                           }, ^(NSDictionary *responseObject){
              NSLog(@"EXCUTE: http://localhost:8090/post %@", responseObject);
    },nil)
    
    .GET(@"http://localhost:8090/image", nil, ^(UIImage *responseObject){
        NSLog(@"EXCUTE: http://localhost:8090/image %@", responseObject);
    },nil);
}

@end

这里的#import <UIKit/UIKit.h>是不必要的, 只是想表达请求图片也可以的意思.

可以看到, 这种调用, 我们从视觉的角度就非常清晰舒爽了~

刚才的代码, 细心的同学可以看到有一个状态的判断, 这个值可以操作下面链式调用是串行还是并行, 是不是很神奇~ 妈妈再也不用担心回调地狱的问题了~

如何实现

那如何实现这个链式调用及控制呢, 来看看我是怎么实现的.

#import <Foundation/Foundation.h>

typedef NS_ENUM(NSInteger, SQFetchState) {
    SQFetchSerialState,
    SQFetchConcurrentState
};

@interface SQFetchManager : NSObject

@property (nonatomic,strong) SQFetchManager * (^GET)(NSString * url, NSDictionary * parameters, void(^success)(id), void(^failure)(NSError *));

@property (nonatomic,strong) SQFetchManager * (^POST)(NSString * url, NSDictionary * parameters, void(^success)(id), void(^failure)(NSError *));

+ (SQFetchManager *)managerWithState:(SQFetchState)state;

@end

看看头文件, 就能够发现, 我这个属性是不是和你们用的都不太一样, 这是一个Block, 不要和我说Block要用copy修饰, 想想现在ARC已经多少时间了…. 当然copy是通用的…

#import "SQFetchManager.h"
#import "SQFetchSerialization.h"
#import "SQFetchReachability.h"
#import "SQFetchCache.h"

typedef NS_ENUM(NSInteger, SQHTTPMethod) {
    SQGETMethod,
    SQPOSTMethod
};

@interface SQFetchManager()

@property (nonatomic,strong) NSOperation * preOperation;
@property (nonatomic,strong) NSOperationQueue * operationQueue;
@property (nonatomic,assign) SQFetchState state;

@end

@implementation SQFetchManager

- (NSOperationQueue *)operationQueue {
    
    if (!_operationQueue) {
        _operationQueue = [NSOperationQueue new];
        _operationQueue.maxConcurrentOperationCount = 6;
    }
    return _operationQueue;
}

- (SQFetchManager *(^)(NSString *, NSDictionary *, void(^)(id), void(^)(NSError *)))GET {
    return ^(NSString * URLString, NSDictionary * parameters, void(^success)(NSDictionary *), void(^failure)(NSError *)){
        NSBlockOperation * operation = [NSBlockOperation blockOperationWithBlock:^{
            dispatch_semaphore_t semaphore = NULL;
            if (self.state == SQFetchSerialState)
                semaphore = dispatch_semaphore_create(0);
            [[self __dataTaskWithHTTPMethod:SQGETMethod
                                  URLString:URLString
                                 parameters:parameters
                                    success:success
                                    failure:failure
                                  semaphore:semaphore] resume];
            if (self.state == SQFetchSerialState)
                dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        }];
        if (self.preOperation) {
            [operation addDependency:self.preOperation];
        }
        [self.operationQueue addOperation:operation];
        self.preOperation = operation;
        
        return self;
    };
}

- (SQFetchManager *(^)(NSString *, NSDictionary *, void (^)(id), void (^)(NSError *)))POST {
    return ^(NSString * URLString, NSDictionary * parameters, void(^success)(NSDictionary *), void(^failure)(NSError *)){
        NSBlockOperation * operation = [NSBlockOperation blockOperationWithBlock:^{
            dispatch_semaphore_t semaphore = NULL;
            if (self.state == SQFetchSerialState)
                semaphore = dispatch_semaphore_create(0);
            [[self __dataTaskWithHTTPMethod:SQPOSTMethod
                                URLString:URLString
                               parameters:parameters
                                  success:success
                                  failure:failure
                                semaphore:semaphore] resume];
            if (self.state == SQFetchSerialState)
                dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        }];
        if (self.preOperation)
            [operation addDependency:self.preOperation];
        [self.operationQueue addOperation:operation];
        self.preOperation = operation;
        
        return self;
    };
}

- (NSURLSessionDataTask *)__dataTaskWithHTTPMethod:(SQHTTPMethod)method
                                       URLString:(NSString *)URLString
                                      parameters:(NSDictionary *)parameters
                                         success:(void (^)(id))success
                                         failure:(void (^)(NSError *))failure
                                       semaphore:(dispatch_semaphore_t)semaphore {
    SQFetchReachability * reachability = [SQFetchReachability sharedInstance];
    if (reachability.status == NotReachable) {
        return nil;
    }
    id cache = [SQFetchCache getCacheFromKey:URLString];
    if (cache) {
        success(cache);
        return nil;
    }

    if (method == SQGETMethod) {
        URLString = [URLString stringByAppendingString:
                     [SQFetchSerialization getMethodSerializationWithParameters:parameters]];
    }

    NSURL * url = [NSURL URLWithString:URLString];
    NSURLSession * session = [NSURLSession sessionWithConfiguration:[NSURLSessionConfiguration defaultSessionConfiguration]];
    NSMutableURLRequest * request = [NSMutableURLRequest requestWithURL:url];
    
    if (method == SQPOSTMethod) {
        request.HTTPMethod = @"POST";
        request.HTTPBody = [SQFetchSerialization postMethodSerializationWithParameters:parameters];
    }
    
    NSURLSessionDataTask * task = [session dataTaskWithRequest:request completionHandler:^(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error) {
        NSError * err;
        id responseObject = [SQFetchSerialization serializationWithContentType:response.MIMEType
                                                                          data:data error:err];
        [SQFetchCache setCache:responseObject key:URLString];
        if(err) {
            failure(err);
            if (self.state == SQFetchSerialState)
                dispatch_semaphore_signal(semaphore);
        } else {
            success(responseObject);
            if (self.state == SQFetchSerialState)
                dispatch_semaphore_signal(semaphore);
        }
        
    }];
    return task;
}

+ (SQFetchManager *)managerWithState:(SQFetchState)state {
    SQFetchManager * manager = [SQFetchManager new];
    manager.state = state;
    return manager;
}

@end

这个是整个实现文件, 可以看到, 这是如何使用函数式编程了, 用起来真是神清气爽, 但不知道如果别人用了会是什么感受…

如何实现同步依赖, 主要是使用了信号量, 配合队列依赖就可以实现啦~

序列化

序列化就是对不同的请求和响应做不同的解析.

#import <Foundation/Foundation.h>

@interface SQFetchSerialization : NSObject

+ (NSString *)getMethodSerializationWithParameters:(NSDictionary *)parameters;

+ (NSData *)postMethodSerializationWithParameters:(NSDictionary *)parameters;

+ (id)serializationWithContentType:(NSString *)contentType data:(NSData *)data error:(NSError *)error;

@end

看头文件也是简洁明了吧…

#import "SQFetchSerialization.h"
#import <UIKit/UIKit.h>

@implementation SQFetchSerialization

+ (NSString *)getMethodSerializationWithParameters:(NSDictionary *)parameters {
    
    NSMutableString * parameterString = [NSMutableString string];
    [parameters enumerateKeysAndObjectsUsingBlock:^(NSString * key, id  _Nonnull obj, BOOL * _Nonnull stop) {
        NSString * value = (NSString *)obj;
        [parameterString appendFormat:@"%@=%@&", key, value];
    }];
    if (parameterString.length) {
        [parameterString insertString:@"?" atIndex:0];
        [parameterString deleteCharactersInRange:NSMakeRange(parameterString.length - 1, 1)];
    }
    return parameterString;
}

+ (NSData *)postMethodSerializationWithParameters:(NSDictionary *)parameters {
    
    NSMutableString * parameterString = [NSMutableString string];
    [parameters enumerateKeysAndObjectsUsingBlock:^(NSString * key, id  _Nonnull obj, BOOL * _Nonnull stop) {
        NSString * value = (NSString *)obj;
        [parameterString appendFormat:@"%@=%@&", key, value];
    }];
    if (parameterString.length) {
        [parameterString deleteCharactersInRange:NSMakeRange(parameterString.length - 1, 1)];
    }
    return [parameterString dataUsingEncoding:NSUTF8StringEncoding];
}

+ (id)serializationWithContentType:(NSString *)contentType data:(NSData *)data error:(NSError *)error {
    
    id responseObject;
    if ([contentType isEqualToString:@"application/json"]) {
        responseObject = [NSJSONSerialization JSONObjectWithData:data
                                                         options:NSJSONReadingMutableContainers error:&error];
    } else if ([contentType isEqualToString:@"image/jpeg"]) {
        CGImageRef cgImage = [UIImage imageWithData:data].CGImage;
        CGImageAlphaInfo alphaInfo = CGImageGetAlphaInfo(cgImage) & kCGBitmapAlphaInfoMask;
        
        BOOL hasAlpha = NO;
        if (alphaInfo == kCGImageAlphaPremultipliedLast ||
            alphaInfo == kCGImageAlphaPremultipliedFirst ||
            alphaInfo == kCGImageAlphaLast ||
            alphaInfo == kCGImageAlphaFirst) {
            hasAlpha = YES;
        }
        
        CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
        CGBitmapInfo bitmapInfo = kCGBitmapByteOrder32Host;
        bitmapInfo |= hasAlpha ? kCGImageAlphaPremultipliedFirst : kCGImageAlphaNoneSkipFirst;
        
        size_t width = CGImageGetWidth(cgImage);
        size_t height = CGImageGetHeight(cgImage);
        
        CGContextRef context = CGBitmapContextCreate(NULL, width, height, 8, 0, colorSpace, bitmapInfo);
        CGContextDrawImage(context, CGRectMake(0, 0, width, height), cgImage);
        cgImage = CGBitmapContextCreateImage(context);
        
        UIImage * image = [UIImage imageWithCGImage:cgImage];
        CGColorSpaceRelease(colorSpace);
        CGContextRelease(context);
        CGImageRelease(cgImage);
        responseObject = image;
    }
    return responseObject;
}

@end

相关实现也是对请求参数进行拼接, 以及对响应的数据进行分类处理…

网络监测

这个依赖了Apple的Reachability就是作用网络不可用的时候, 不要尝试执行网络请求.

#import "SQFetchReachability.h"

@interface SQFetchReachability()
@property (nonatomic, strong) Reachability * hostReachability;
@property (nonatomic, strong) Reachability * routerReachability;
@end

@implementation SQFetchReachability

+ (void)load {
    [SQFetchReachability sharedInstance];
}

+ (instancetype)sharedInstance {
    static SQFetchReachability * instance = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        instance = [[super allocWithZone:NULL] init];
    });
    return instance;
}

+ (instancetype)allocWithZone:(struct _NSZone *)zone {
    return [self sharedInstance];
}

- (instancetype)init {
    self = [super init];
    if (self) {
        [[NSNotificationCenter defaultCenter] addObserver:self
                                                 selector:@selector(appReachabilityChanged:)
                                                     name:kReachabilityChangedNotification
                                                   object:nil];
        NSString * remoteHostName = @"www.baidu.com";
        self.hostReachability = [Reachability reachabilityWithHostName:remoteHostName];
        [self.hostReachability startNotifier];
        self.routerReachability = [Reachability reachabilityForInternetConnection];
        [self.routerReachability startNotifier];
    }
    return self;
}

- (void)appReachabilityChanged:(NSNotification *)notification{
    Reachability * reach = [notification object];
    if([reach isKindOfClass:[Reachability class]]){
        NetworkStatus status = [reach currentReachabilityStatus];
        self.status = status;
        if (reach == self.routerReachability) {
            if (status == NotReachable) {
                NSLog(@"routerReachability NotReachable");
            } else if (status == ReachableViaWiFi) {
                NSLog(@"routerReachability ReachableViaWiFi");
            } else if (status == ReachableViaWWAN) {
                NSLog(@"routerReachability ReachableViaWWAN");
            }
        }
        if (reach == self.hostReachability) {
            NSLog(@"hostReachability");
            if ([reach currentReachabilityStatus] == NotReachable) {
                NSLog(@"hostReachability failed");
            } else if (status == ReachableViaWiFi) {
                NSLog(@"hostReachability ReachableViaWiFi");
            } else if (status == ReachableViaWWAN) {
                NSLog(@"hostReachability ReachableViaWWAN");
            }
        }
        
    }
}

@end

二级缓存

对于这块, 看过SD的同学肯定非常了解, 内存缓存和磁盘缓存.

#import "SQFetchCache.h"
#import <CommonCrypto/CommonDigest.h>
#import <UIKit/UIKit.h>

@interface SQFetchCache()
@property (nonatomic, strong) NSMutableDictionary * memoryCache;
@end

@implementation SQFetchCache

- (NSMutableDictionary *)memoryCache {
    
    if (!_memoryCache) {
        _memoryCache = @{}.mutableCopy;
    }
    return _memoryCache;
}

+ (instancetype)sharedInstance {
    static SQFetchCache * instance = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        instance = [[super allocWithZone:NULL] init];
    });
    return instance;
}

+ (instancetype)allocWithZone:(struct _NSZone *)zone {
    return [self sharedInstance];
}

+ (void)setCache:(id)data key:(NSString *)key {
    if ([data isKindOfClass:[UIImage class]]) {
        [SQFetchCache sharedInstance].memoryCache[[self __sha1:key]] = data;
        [SQFetchCache __detectionDiskCache];
        NSString * homePath = NSHomeDirectory();
        NSString * path = [homePath stringByAppendingPathComponent:@"Library/Caches"];
        NSString * filePath = [path stringByAppendingPathComponent:[self __sha1:key]];
        [UIImagePNGRepresentation(data) writeToFile:filePath atomically:YES];
    }
}

+ (id)getCacheFromKey:(NSString *)key {
    id cache = [SQFetchCache sharedInstance].memoryCache[[self __sha1:key]];
    if (!cache) {
        NSString * cachePath = [NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES) lastObject];
        NSString * file = [NSString stringWithFormat:@"%@/%@", cachePath, [self __sha1:key]];
        cache = [[UIImage alloc]initWithContentsOfFile:file];
    }
    return cache;
}

+ (void)__detectionDiskCache {
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSFileManager * fileManager = [NSFileManager defaultManager];
        NSString * cachePath = [NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES) lastObject];
        NSDirectoryEnumerator * direnum = [fileManager enumeratorAtPath:cachePath];
        NSError * error = nil;
        NSString * filename;
        while (filename = [direnum nextObject]) {
            NSDictionary * fileAttributes = [fileManager attributesOfItemAtPath:[NSString stringWithFormat:@"%@/%@",cachePath, filename] error:&error];
            if (fileAttributes != nil) {
                NSNumber * fileSize = [fileAttributes objectForKey:NSFileSize];
                NSString * fileOwner = [fileAttributes objectForKey:NSFileOwnerAccountName];
                NSDate * fileModDate = [fileAttributes objectForKey:NSFileModificationDate];
                NSDate * fileCreateDate = [fileAttributes objectForKey:NSFileCreationDate];
                if (fileSize) {
                    NSLog(@"File size: %qi\n", [fileSize unsignedLongLongValue]);
                }
                if (fileOwner) {
                    NSLog(@"Owner: %@\n", fileOwner);
                }
                if (fileModDate) {
                    NSLog(@"Modification date: %@\n", fileModDate);
                }
                if (fileCreateDate) {
                    NSLog(@"create date:%@\n", fileModDate);
                }
            }
            else {
                NSLog(@"Path (%@) is invalid.", cachePath);
            }
        }
    });
}

+ (void)clearDiskCache {
    NSFileManager *fileManager = [NSFileManager defaultManager];
    NSString * cachePath = [NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES) lastObject];
    NSLog(@"%@",cachePath);
    NSDirectoryEnumerator * fileEnumerator = [fileManager enumeratorAtPath:cachePath];
    for (NSString * fileName in fileEnumerator) {
        NSString * filePath = [cachePath stringByAppendingPathComponent:fileName];
        [fileManager removeItemAtPath:filePath error:nil];
    }
}

+ (NSString *)__sha1:(NSString *)inputString {
    NSData * data = [inputString dataUsingEncoding:NSUTF8StringEncoding];
    uint8_t digest[CC_SHA1_DIGEST_LENGTH];
    CC_SHA1(data.bytes,(unsigned int)data.length,digest);
    NSMutableString *outputString = [NSMutableString stringWithCapacity:CC_SHA1_DIGEST_LENGTH];
    for (int i = 0; i < CC_SHA1_DIGEST_LENGTH; i++) {
        [outputString appendFormat:@"%02x",digest[i]];
    }
    return [outputString lowercaseString];
}

@end

如何优化就是对空间和时间两方面, 这里可以关注__detectionDiskCache这个方法中进行判断处理.. 可以策略性的进行删除..(内存缓存也是相同的思路)

#import "UIImageView+SQFetcher.h"
#import "SQFetcher.h"

@implementation UIImageView (SQFetcher)

- (void)sq_imageWithURLString:(NSString *)URLString {
    [SQFetchManager managerWithState:SQFetchConcurrentState]
    .GET(URLString, nil, ^(UIImage *responseObject){
        dispatch_async(dispatch_get_main_queue(), ^{
            self.image = responseObject;
        });
    },nil);
}

@end

分类使用的实现也是非常简单的, 我么使用起来也是非常方便.

最后

这个仅仅是一个最小可用的设计, 当然还有很多值得优化的点, 比如配置请求头, 请求复用, 哈希桶扩张, 管道, 对于需求, 还要安全验证等, 写这个东西其实就是了解下一个网络框架需要了解点什么, 平时使用的时候AFN和SD肯定是你首选的方案!! 但有了这些思路, 你也可以实现一个自己定制的网络框架!

最后本文中所有的源码都可以在github上找到 -> SQPerformance

GitHub Repo：coderZsq.project.ios
Follow: coderZsq · GitHub
Resume: https://coderzsq.github.io/coderZsq.practice.web/

iOS 界面性能优化浅析

Sun, 08 Jul 2018 14:30:00 +0000

GitHub Repo：coderZsq.project.ios
Follow: coderZsq · GitHub
Resume: https://coderzsq.github.io/coderZsq.practice.web/

日常扯淡

emm~~~ 前段时间又出去看了看iOS市场的行情, 除非是BAT, TMD, 这类一线的知名企业, 其他的只要努努力还是可以通过的, 这里分享一些小技巧, 比如当HR,或者别人内推你的时候, 不管要求写的多么的天花乱坠, 千万不要被这些东西给吓到了, 你可以先逆向一下对方的项目, 了解一下工程架构及代码规范, 以及使用了哪些三方库, 其实都是在面试前很好的对对方的初步了解, 知己知彼当然就增添了一份胜算. 当然现在对iOS的要求也是参差不齐, 面试官能力和视野的高低也会无形的给你入职造成一定的困扰, 就比如有一次, 面试官问, 能详细说说Swift么?, 这种如此宽泛的命题, 你让我用什么角度来回答呢… 编译器层面? 语言层面的写时复制? 还是语法层面的? 还是WWDC的新特性? 挑了一方面讲讲, 就被说只有这些么?, 能不能不要只说关键词? 然后就是伴随着的鄙视的眼神… 关键是个妹子面试官, 而且在我逆向其项目时发现代码质量其实也就一般, 算了不吐槽了, 免得又要被说影响不好, 面试不过就瞎bb~~

当然现在对于iOS的要求是比以前有了很大的提高, 只会用OC写个tableview现在是几乎很难找到工作了, 然而我除了公司的项目其他时间基本不会碰OC的代码, 所以当我要写这个OC版的性能优化的时候, 好多语法都不太记得都需要现查… 完全记不住API.

当然在做性能优化的时候, 你还是需要了解一些C系语言的底层知识, 这些虽然不一定能够在代码上能够体现, 但对于理解和设计是有非常大的帮助的, 而且现在网上的讲底层原理的博客实在是太多了, 都是你抄我我抄你的, 可能会有些许的水分, 建议还是从runtime-723, GNUStep, 这类源码来自己看会比较靠谱, 当然看这些代码的时候可能会看不太懂C++的语法, 可以去我的github-page上看看一些我整理的C++语法的总结, 应该会挺有帮助的.

准备工作

对于界面的性能优化, 简单的说就是保持界面流畅不掉帧, 当然原理这种网上一搜一大把, 有空的话看看YYKit也就能够知晓个大概. 硬是要说原理的话, 就是当Vsync信号来临的16.67ms内CPU做完排版, 绘制, 解码, GPU避免离屏渲染之类的, 就会在Runloop下一次来临的时候渲染到屏幕上.

不说那么多原理了, 理论永远不如实践来的有意义, 这也是所谓的贝叶斯算法随时修正的策略. 我们先写一个测试数据来以备后面优化的需要.

const http = require('http');

http.createServer((req, res) => {

    if (decodeURI(req.url) == "/fetchMockData") {
        console.log(req.url);

        let randomNumber = function (n) {
            var randomNumber = "";
            for (var i = 0; i < n; i++)
                randomNumber += Math.floor(Math.random() * 10);
            return randomNumber;
        }

        let randomString = function(len) {　　
           len = len || 32;　　
            var $chars = 'ABCDEFGHJKMNPQRSTWXYZabcdefhijkmnprstwxyz2345678';　　
            var maxPos = $chars.length;　　
            var randomString = '';　　
            for (i = 0; i < len; i++) {　　　　
                randomString += $chars.charAt(Math.floor(Math.random() * maxPos));　　
            }　　
            return randomString;
        }

        let json = [];
        for (let i = 0; i < 100; i++) {
            let obj = {};
            let texts = [];
            let images = [];
            for (let i = 0; i < randomNumber(4); i++) {
                texts.push(randomString(randomNumber(1)));
            }
            for (let i = 0; i < 16; i++) {
                images.push("https://avatars3.githubusercontent.com/u/19483268?s=40&v=4");
            }
            obj.texts = texts;
            obj.images = images;
            json.push(obj);
        }
        res.writeHead(200, {
            'Content-Type': 'application/json'
        });

        res.end(JSON.stringify({
            data: json,
            status: 'success'
        }));
    } 

}).listen(8080);
console.log('listen port = 8080');

我就偷个懒用javascript起了个node服务器, 就是用来模拟测试数据用的, 当然如果你的机器没有node环境的话, 建议你去自行安装.

完成之后, 我们通过浏览器访问就能够得到测试数据, 测试数据分为两块, 一块是文字, 一块是图片的url, 由于嫌麻烦, 直接就使用了我github的头像.

预排版

对于界面流畅, 第一个想到的就是预排版了, 而且预排版的作用显著, 原理也很简单, 就是异步预先计算, 避免每次在layoutSubviews中, cell重用的时候进行重复计算. 诶… 又要被说只讲关键词了… 但原理就是那么简单, 还能讲出个啥? 再说的细了代码就写出来了…

#import "Service.h"
#import <AFNetworking.h>

@implementation Service

- (void)fetchMockDataWithParam:(NSDictionary *)parameter completion:(RequestCompletionBlock)completion {
    
    AFHTTPSessionManager * manager = [AFHTTPSessionManager manager];
    [manager GET:@"http://localhost:8080/fetchMockData" parameters:parameter progress:nil success:^(NSURLSessionDataTask * _Nonnull task, id  _Nullable responseObject) {
        if ([responseObject[@"status"] isEqualToString: @"success"]) {
            completion(responseObject[@"data"], nil);
        }
    } failure:^(NSURLSessionDataTask * _Nullable task, NSError * _Nonnull error) {
        completion(nil, error);
    }];
}

@end

当然你需要请求一下刚才的模拟数据, 注意localhost是http的需要强制越权.

#import "ViewModel.h"
#import "ComponentModel.h"
#import "ComponentLayout.h"
#import "Element.h"
#import <UIKit/UIKit.h>

@implementation ViewModel

- (Service *)service {
    
    if (!_service) {
        _service = [Service new];
    }
    return _service;
}

- (void)reloadData:(LayoutCompeltionBlock)completion error:(void(^)(void))errorCompletion {
    
    [self.service fetchMockDataWithParam:nil completion:^(NSArray<ComponentModel *> *models, NSError *error) {
        if (models.count > 0 && error == nil) {
            dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_SERIAL);
            dispatch_async(queue, ^{
                NSMutableArray * array = [NSMutableArray new];
                for (ComponentModel * model in models) {
                    ComponentLayout * layout = [self preLayoutFrom:model];
                    [array addObject:layout];
                }
                dispatch_async(dispatch_get_main_queue(), ^{
                    if (completion) {
                        completion(array);
                    }
                });
            });
        } else {
            errorCompletion();
        }
    }];
}

- (void)loadMoreData:(LayoutCompeltionBlock)completion {
    [self reloadData:completion error:nil];
}

- (ComponentLayout *)preLayoutFrom:(ComponentModel *)model {
    
    ComponentLayout * layout = [ComponentLayout new];
    layout.cellWidth = [UIScreen mainScreen].bounds.size.width;
    
    CGFloat cursor = 0;
    
    CGFloat x = 5.;
    CGFloat y = 0.;
    CGFloat height = 0.;
    
    NSMutableArray * textElements = [NSMutableArray array];
    NSArray * texts = model[@"texts"];
    for (NSUInteger i = 0; i < texts.count; i++) {
        NSString * text = texts[i];
        CGSize size = [text boundingRectWithSize:CGSizeMake(MAXFLOAT, MAXFLOAT) options:NSStringDrawingUsesLineFragmentOrigin | NSStringDrawingUsesFontLeading  attributes:@{NSFontAttributeName : [UIFont systemFontOfSize:7]} context:nil].size;
        if ((x + size.width) > layout.cellWidth) {
            x = 5;
            y += (size.height + 10);
            height = y + size.height + 5;
        }
        CGRect frame = CGRectMake(x, y, size.width + 5, size.height + 5);
        x += (size.width + 10);

        Element * element = [Element new];
        element.value = text;
        element.frame = frame;
        [textElements addObject:element];
    }
    cursor += height + 5;
    
    x = 5.; y = cursor; height = 0.;
    
    NSMutableArray * imageElements = [NSMutableArray array];
    NSArray * images = model[@"images"];
    for (NSUInteger i = 0; i < images.count; i++) {
        NSString * url = images[i];
        CGSize size = CGSizeMake(40, 40);
        if ((x + size.width) > layout.cellWidth) {
            x = 5;
            y += (size.height + 5);
            height = (y - cursor) + size.height + 5;
        }
        CGRect frame = CGRectMake(x, y, size.width, size.height);
        x += (size.width + 5);
        
        Element * element = [Element new];
        element.value = url;
        element.frame = frame;
        [imageElements addObject:element];
    }
    cursor += height + 5;
    
    layout.cellHeight = cursor;
    layout.textElements = textElements;
    layout.imageElements = imageElements;
    return layout;
}

@end

- (void)setupData:(ComponentLayout *)layout asynchronously:(BOOL)asynchronously {
    _layout = layout; _asynchronously = asynchronously;
    
    [self displayImageView];
    if (!asynchronously) {
        for (Element * element in layout.textElements) {
            UILabel * label = (UILabel *)[_labelReusePool dequeueReusableObject];
            if (!label) {
                label = [UILabel new];
                [_labelReusePool addUsingObject:label];
            }
            label.text = element.value;
            label.frame = element.frame;
            label.font = [UIFont systemFontOfSize:7];
            [self.contentView addSubview:label];
        }
        [_labelReusePool reset];
    }
}

代码也是非常的简单, 即是根据获取的的数据进行排版而已, 然后cell直接获取排版后的frame进行一步赋值操作而已. 有兴趣也可以看看sunnyxx的FDTemplateLayoutCell.

重用池

眼尖的同学肯定就看到上面代码由类似于cell的重用机制, 这个其实就是下面要讲到的重用池的概念, 原理也是非常简单的, 就是维护了两个队列, 一个是当前队列, 一个是可重用队列.

#import "ReusePool.h"

@interface ReusePool ()
@property (nonatomic, strong) NSMutableSet * waitUsedQueue;
@property (nonatomic, strong) NSMutableSet * usingQueue;
@property (nonatomic, strong) NSLock * lock;
@end

@implementation ReusePool

- (instancetype)init
{
    self = [super init];
    if (self) {
        _waitUsedQueue = [NSMutableSet set];
        _usingQueue = [NSMutableSet set];
        _lock = [NSLock new];
    }
    return self;
}

- (NSObject *)dequeueReusableObject {
    
    NSObject * object = [_waitUsedQueue anyObject];
    if (object == nil) {
        return nil;
    } else {
        [_lock lock];
        [_waitUsedQueue removeObject:object];
        [_usingQueue addObject:object];
        [_lock unlock];
        return object;
    }
}

- (void)addUsingObject:(UIView *)object {
    if (object == nil) {
        return;
    }
    [_usingQueue addObject:object];
}

- (void)reset {
    NSObject * object = nil;
    while ((object = [_usingQueue anyObject])) {
        [_lock lock];
        [_usingQueue removeObject:object];
        [_waitUsedQueue addObject:object];
        [_lock unlock];
    }
}

@end

这里由于我这个重用队列, 并不仅仅针对于UI, 所以在多线程访问的情况下, 是需要加锁处理的, 这里就用最通用的pthread-mutex进行加锁.

预解码

这里做的就是通过url进行的异步解码的处理, 相关原理的文章其实很多, 自行查阅.

@implementation NSString (Extension)

- (void)preDecodeThroughQueue:(dispatch_queue_t)queue completion:(void(^)(UIImage *))completion {
    
    dispatch_async(queue, ^{
        CGImageRef cgImage = [UIImage imageWithData:[NSData dataWithContentsOfURL:[NSURL URLWithString:self]]].CGImage;
        CGImageAlphaInfo alphaInfo = CGImageGetAlphaInfo(cgImage) & kCGBitmapAlphaInfoMask;
        
        BOOL hasAlpha = NO;
        if (alphaInfo == kCGImageAlphaPremultipliedLast ||
            alphaInfo == kCGImageAlphaPremultipliedFirst ||
            alphaInfo == kCGImageAlphaLast ||
            alphaInfo == kCGImageAlphaFirst) {
            hasAlpha = YES;
        }
        
        CGBitmapInfo bitmapInfo = kCGBitmapByteOrder32Host;
        bitmapInfo |= hasAlpha ? kCGImageAlphaPremultipliedFirst : kCGImageAlphaNoneSkipFirst;
        
        size_t width = CGImageGetWidth(cgImage);
        size_t height = CGImageGetHeight(cgImage);
        
        CGContextRef context = CGBitmapContextCreate(NULL, width, height, 8, 0, CGColorSpaceCreateDeviceRGB(), bitmapInfo);
        CGContextDrawImage(context, CGRectMake(0, 0, width, height), cgImage);
        cgImage = CGBitmapContextCreateImage(context);
        
        UIImage * image = [[UIImage imageWithCGImage:cgImage] cornerRadius:width * 0.5];
        CGContextRelease(context);
        CGImageRelease(cgImage);
        completion(image);
    });
}

@end

预渲染

比如imageView.layer.cornerRadius及imageView.layer.masksToBounds = YES;这类操作会导致离屏渲染, GPU会导致新开缓冲区造成消耗. 为了避免离屏渲染，你应当尽量避免使用 layer 的 border、corner、shadow、mask 等技术，而尽量在后台线程预先绘制好对应内容。这种SDWebImage的缓存策略是有很大的参考意义的.

@implementation UIImage (Extension)

- (UIImage *)cornerRadius:(CGFloat)cornerRadius {
    
    CGRect rect = CGRectMake(0, 0, self.size.width, self.size.height);
    UIBezierPath * bezierPath = [UIBezierPath bezierPathWithRoundedRect:rect cornerRadius:cornerRadius];
    UIGraphicsBeginImageContextWithOptions(self.size, false, [UIScreen mainScreen].scale);
    CGContextAddPath(UIGraphicsGetCurrentContext(), bezierPath.CGPath);
    CGContextClip(UIGraphicsGetCurrentContext());
    
    [self drawInRect:rect];
    
    CGContextDrawPath(UIGraphicsGetCurrentContext(), kCGPathFillStroke);
    UIImage * image = UIGraphicsGetImageFromCurrentImageContext();
    UIGraphicsEndImageContext();
    return image;
}

@end

- (void)displayImageView {
    for (Element * element in _layout.imageElements) {
        UIImageView * imageView = (UIImageView *)[_imageReusePool dequeueReusableObject];
        if (!imageView) {
            imageView = [UIImageView new];
            [_imageReusePool addUsingObject:imageView];
        }
        UIImage * image = (UIImage *)[ComponentCell.asyncReusePool dequeueReusableObject];
        if (!image) {
            NSString * url = element.value;
            [url preDecodeThroughQueue:concurrentQueue completion:^(UIImage * image) {
                [ComponentCell.asyncReusePool addUsingObject:image];
                dispatch_async(dispatch_get_main_queue(), ^{
                    imageView.image = image;
                });
            }];
        } else {
            imageView.image = image;
        }
        imageView.frame = element.frame;
        [self.contentView addSubview:imageView];
    }
    [ComponentCell.asyncReusePool reset];
    [_imageReusePool reset];
}

这样通过和重用池的结合就可以达到很好的效果, 当然因为我这里是一张相同的图片, 正常情况下需要设计一整套的缓存策略, hash一下url什么的.

通过上述的方案结合, 我们已经能够比较流畅的显示那么多数据了而且帧数还是不错的, 但还有优化的空间.

异步绘制

进过了上面的优化, 我们其实已经做的不错了, 但是看下界面的层次, 是不是有点得了密集恐惧症… 接下来要讲的异步绘制就能够很好的解决这个问题. 并更加的优化流畅度. 异步绘制的原理么, 就是异步的drawInLayer, 异步的画在上下文上并统一绘制.

- (void)displayLayer:(CALayer *)layer {
    
    if (!layer) return;
    if (layer != self.layer) return;
    if (![layer isKindOfClass:[AsyncDrawLayer class]]) return;
    if (!self.isAsynchronously) return;
    
    AsyncDrawLayer *tempLayer = (AsyncDrawLayer *)layer;
    [tempLayer increaseCount];
    
    NSUInteger oldCount = tempLayer.drawsCount;
    CGRect bounds = self.bounds;
    UIColor * backgroundColor = self.backgroundColor;
    
    layer.contents = nil;
    dispatch_async(serialQueue, ^{
        void (^failedBlock)(void) = ^{
            NSLog(@"displayLayer failed");
        };
        if (tempLayer.drawsCount != oldCount) {
            failedBlock();
            return;
        }
        
        CGSize contextSize = layer.bounds.size;
        BOOL contextSizeValid = contextSize.width >= 1 && contextSize.height >= 1;
        CGContextRef context = NULL;
        
        if (contextSizeValid) {
            UIGraphicsBeginImageContextWithOptions(contextSize, layer.isOpaque, layer.contentsScale);
            context = UIGraphicsGetCurrentContext();
            CGContextSaveGState(context);
            if (bounds.origin.x || bounds.origin.y) {
                CGContextTranslateCTM(context, bounds.origin.x, -bounds.origin.y);
            }
            if (backgroundColor && backgroundColor != [UIColor clearColor]) {
                CGContextSetFillColorWithColor(context, backgroundColor.CGColor);
                CGContextFillRect(context, bounds);
            }
            [self asyncDraw:YES context:context completion:^(BOOL drawingFinished) {
                if (drawingFinished && oldCount == tempLayer.drawsCount) {
                    CGImageRef CGImage = context ? CGBitmapContextCreateImage(context) : NULL;
                    {
                        UIImage * image = CGImage ? [UIImage imageWithCGImage:CGImage] : nil;
                        dispatch_async(dispatch_get_main_queue(), ^{
                            if (oldCount != tempLayer.drawsCount) {
                                failedBlock();
                                return;
                            }
                            layer.contents = (id)image.CGImage;
                            layer.opacity = 0.0;
                            [UIView animateWithDuration:0.25 delay:0.0 options:UIViewAnimationOptionAllowUserInteraction animations:^{
                                layer.opacity = 1.0;
                            } completion:NULL];
                        });
                    }
                    if (CGImage) {
                        CGImageRelease(CGImage);
                    }
                } else {
                    failedBlock();
                }
            }];
            CGContextRestoreGState(context);
        }
        UIGraphicsEndImageContext();
    });
}

代码其实也没什么好讲的只要注意下多线程重绘时的问题也就可以了.

- (void)asyncDraw:(BOOL)asynchronously context:(CGContextRef)context completion:(void(^)(BOOL))completion {
    
    for (Element * element in _layout.textElements) {
        NSMutableParagraphStyle * paragraphStyle = [[NSParagraphStyle defaultParagraphStyle] mutableCopy];
        paragraphStyle.lineBreakMode = NSLineBreakByCharWrapping;
        paragraphStyle.alignment = NSTextAlignmentCenter;
        [element.value drawInRect:element.frame withAttributes:@{NSFontAttributeName:[UIFont systemFontOfSize:7],
                                                                 NSForegroundColorAttributeName:[UIColor blackColor],
                                                                 NSParagraphStyleAttributeName:paragraphStyle}];
    }
    completion(YES);
}

当在当前线程全部绘制完上下文后, 会统一的渲染到layer上, 很好理解的其实.

这样我们的图层就会被合成, 帧率也一直保持在60帧的样子.

语法技巧

OC现在也支持类属性了, 具体的使用可以看我swift的renderTree.

@property (class, nonatomic,strong) ReusePool * asyncReusePool;

static ReusePool * _asyncReusePool = nil;

+ (ReusePool *)asyncReusePool {
    if (_asyncReusePool == nil) {
        _asyncReusePool = [[ReusePool alloc] init];
    }
    return _asyncReusePool;
}

+ (void)setAsyncReusePool:(ReusePool *)asyncReusePool {
    if (_asyncReusePool != asyncReusePool) {
        _asyncReusePool = asyncReusePool;
    }
}

碰到的坑

其实理想的效果是如下图这样的. 所有的图片都被异步绘制到layer上.

- (void)asyncDraw:(BOOL)asynchronously context:(CGContextRef)context completion:(void(^)(BOOL))completion {
    
    for (Element * element in _layout.textElements) {
        NSMutableParagraphStyle * paragraphStyle = [[NSParagraphStyle defaultParagraphStyle] mutableCopy];
        paragraphStyle.lineBreakMode = NSLineBreakByCharWrapping;
        paragraphStyle.alignment = NSTextAlignmentCenter;
        [element.value drawInRect:element.frame withAttributes:@{NSFontAttributeName:[UIFont systemFontOfSize:7],
                                                                 NSForegroundColorAttributeName:[UIColor blackColor],
                                                                 NSParagraphStyleAttributeName:paragraphStyle}];
    }
    completion(YES);
    //TODO:
    //    for (Element * element in _layout.imageElements) {
    //        UIImage * image = (UIImage *)[ComponentCell.asyncReusePool dequeueReusableObject];
    //        if (!image) {
    //            NSString * url = element.value;
    //            [url preDecodeThroughQueue:concurrentQueue completion:^(UIImage * image) {
    //                [ComponentCell.asyncReusePool addUsingObject:image];
    //                [image drawInRect:element.frame]; //这里异步回调上下文获取不到报错
    //                completion(YES);
    //            }];
    //        } else {
    //            [image drawInRect:element.frame];
    //            completion(YES);
    //        }
    //    }
    //    [_asyncReusePool reset];
}

但这里碰到一个问题, CGContextRef, 也就是UIGraphicsGetCurrentContext()拿到的是当前线程的上下文, 而线程和Runloop是一一对应的, 只有当前线程的上下文才能进行绘制, 而网络图片又需要进行异步下载解码, 势必会进行并发下载, 从而上下文获取不到, 绘制不能.报错如下:

我尝试了一下将绘图上下文传入其他线程并渲染:

    for (Element * element in _layout.imageElements) {
        UIImage * image = (UIImage *)[ComponentCell.asyncReusePool dequeueReusableObject];
        if (!image) {
            NSString * url = element.value;
            [url preDecodeThroughQueue:concurrentQueue completion:^(UIImage * image) {
                [ComponentCell.asyncReusePool addUsingObject:image];
                CGContextDrawImage(context, element.frame, image.CGImage);
                completion(YES);
            }];
        } else {
            [image drawInRect:element.frame];
            completion(YES);
        }
    }
    [_asyncReusePool reset];

可惜的是, 使用CGContextDrawImage传入当前上下文也不能解决这个问题, 原因是上一个线程的上下文已经过期了…

常驻线程

碰到这个问题, 首先想到的就是可能是在上一条线程挂了之后, context失效导致的, 那我们可以使用runloop开启一条常驻线程来保住这个上下文.

#import "PermenantThread.h"

@interface Thread : NSThread
@end

@implementation Thread
- (void)dealloc {
    NSLog(@"%s", __func__);
}
@end

@interface PermenantThread()
@property (strong, nonatomic) Thread *innerThread;
@end

@implementation PermenantThread

- (instancetype)init
{
    if (self = [super init]) {
        self.innerThread = [[Thread alloc] initWithBlock:^{
            CFRunLoopSourceContext context = {0};
            CFRunLoopSourceRef source = CFRunLoopSourceCreate(kCFAllocatorDefault, 0, &context);
            CFRunLoopAddSource(CFRunLoopGetCurrent(), source, kCFRunLoopDefaultMode);
            CFRelease(source);
            CFRunLoopRunInMode(kCFRunLoopDefaultMode, 1.0e10, false);
        }];
        [self.innerThread start];
    }
    return self;
}


- (void)executeTask:(PermenantThreadTask)task {
    if (!self.innerThread || !task) return;
    [self performSelector:@selector(__executeTask:) onThread:self.innerThread withObject:task waitUntilDone:NO];
}

- (void)stop {
    if (!self.innerThread) return;
    [self performSelector:@selector(__stop) onThread:self.innerThread withObject:nil waitUntilDone:YES];
}

- (void)dealloc {
    NSLog(@"%s", __func__);
    [self stop];
}

- (void)__stop {
    CFRunLoopStop(CFRunLoopGetCurrent());
    self.innerThread = nil;
}

- (void)__executeTask:(PermenantThreadTask)task {
    task();
}

@end

然而在原以为是因为子线程销毁导致的上下文过期, 在我用Runloop做了一个常驻线程后, 一样没有效果… 真是醉了… 谁知道上下文过期会是什么造成的么?

解决方法

查了一些资料和问了一些大佬, 得到各种反馈的解决方案, dispath_async_f这个函数是没有用的, 传递的上下文和绘图上下文并没有关系, 所以这个是不对的, 最后尝试使用自建上下文解决了这个问题.

CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
CGContextRef context = CGBitmapContextCreate(NULL, contextSize.width, contextSize.height, 8, contextSize.width * 4, colorSpace, kCGImageAlphaPremultipliedFirst | kCGImageByteOrderDefault);
CGColorSpaceRelease(colorSpace);
CGAffineTransform normalState = CGContextGetCTM(context);
CGContextTranslateCTM(context, 0, bounds.size.height);
CGContextScaleCTM(context, 1, -1);
CGContextConcatCTM(context, normalState);
if (backgroundColor && backgroundColor != [UIColor clearColor]) {
    CGContextSetFillColorWithColor(context, backgroundColor.CGColor);
    CGContextFillRect(context, bounds);
}
UIGraphicsPushContext(context);

绘图的时候不使用drawInRect, 而使用CGContextDrawImage的API

    dispatch_group_t group = dispatch_group_create();
    dispatch_queue_t concurrentQueue = dispatch_queue_create("concurrent", DISPATCH_QUEUE_CONCURRENT);
    for (Element * element in _layout.imageElements) {
        UIImage * image = (UIImage *)[ComponentCell.asyncReusePool dequeueReusableObject];
        if (!image) {
            dispatch_group_enter(group);
            dispatch_group_async(group, concurrentQueue, ^{
                NSString * url = element.value;
                [url preDecodeWithCGCoordinateSystem:YES completion:^(UIImage * image) {
                    [ComponentCell.asyncReusePool addUsingObject:image];
                    CGContextDrawImage(context, element.frame, image.CGImage);
//                    completion(YES);
                }];
                dispatch_group_leave(group);
            });
        } else {
            CGContextDrawImage(context, element.frame, image.CGImage);
            completion(YES);
        }
    }
    dispatch_group_notify(group, concurrentQueue, ^{
        completion(YES);
    });
    [_asyncReusePool reset];

由于是异步绘制, 每下载一张图片就进行绘制, 会造成一直刷帧, 所以使用线程组来进行统一绘制.

这里还有一个坑就是 drawInRect和CGContextDrawImage 的绘制坐标系不一样, 所以需要加一下判断即可.

最后本文中所有的源码都可以在github上找到 -> SQPerformance

GitHub Repo：coderZsq.project.ios
Follow: coderZsq · GitHub
Resume: https://coderzsq.github.io/coderZsq.practice.web/

Swift 进阶 | 看得见的算法

Fri, 18 May 2018 22:46:00 +0000

GitHub Repo：coderZsq.target.swift
Follow: coderZsq · GitHub
Resume: https://coderzsq.github.io/coderZsq.webpack.js/#/

日常扯淡

前段日子写了篇面经, 得到了掘金的征文活动的三等奖还是非常开心, 但是被寒神说面试不过就泄题, 影响不好, 我想想也是, 马上就把大厂的名字给抹掉了, 但被转载的就无能为力了, 看到下面好多喷的, 真是背后一凉, 一首凉凉送给自己, 造成的伤害无法挽回, 再此郑重道歉, 再也不写面经了. 希望以后还能获得大厂面试的机会!

被大厂刷掉后, 我心情难以平复, 因为其实我是做了充足的准备来的, 但是还是实力上有差距, 诶… 还是想想改如何提升自己的水平吧!

其实对于自己, 我其实并不知道iOS该如何进行学习, 也不知道技术这条路我半道转的是不是正确, 更不知道在当今环境下我这种水平的iOS开发者是否还有存在的必要.

说起转行做iOS到现在, 从Objective-C基础语法学起, 认为OC是最好的语言, 学会做几个简单的UITableView页面, 能播放音频视频, 觉得自己真是转了个高大上的职业, 现在想想, 真是肤浅的让人忍不住发笑.

我把做iOS这段学习经历分为五个阶段:

第一个阶段: 是刚刚转行进入互联网企业, 那时候觉得学好CALayer掌握了一些酷炫的动画(贝塞尔曲线), 感觉就已经比大多数人都强了, 那时候还把常用的工具类封装起来, 就觉得, 嗯, 自己还不错.

第二个阶段: 就是瞎学些有的没的, 如Swift, JavaScript, Java什么的, 觉得自己全栈了, 什么都会了, 很牛逼, 你看还自己能够写一个前端简历, 还做过公司的前端项目, 服务器开发也会了, 自信心爆棚啊, 觉得自己真是无所不能.

第三个阶段: 写了一个架构生成器, 觉得自己所向披靡了, 公司项目都在用我写的架构, 用着我制定的规则, 尼玛不就是一个简单的字符串替换, 嘚瑟个啥… 而且对于架构的理解肤浅至极…

第四个阶段: 察觉到了自己的薄弱, 开始学习iOS的底层原理, 学习了C\C++的语法, 学习了Linux基础, 学习了8086, ARM64汇编, 了解了一些自认为还是比较深的知识点. 觉得自己前途还是有希望的.

第五个阶段: 也就是被刷掉之后的现在, 其实我现在也很迷茫, 也不知道现在学的东西到底有没有用, 也不知道大厂到底要什么样的人才(只知道牛逼就行…), 但我也通过把知识点进行分类进行进阶吧. 把最近的学习总结分享出来和大家一起讨论, 像我这种水平的玩家到底该怎么玩耍.

学习计划

我把最近学习的方面全部都整理在StudyNote这个里面了, 可以看得出, 这个阶段, 我明显的就是像要学习加强算法与数据结构方面的, 可能是因为被大厂刷的有阴影了吧.

除了数据结构与算法, 最近刚看完的CS193p的教程, 白胡子老头的这个视频的质量很高, 发现了很多我平时忽略的东西, 而且觉得很多我以为的写法从本质上都是有问题的.

还有就是objc.io的这几本书了, 质量挺高的, 函数式Swift的学习对我很有帮助. 感觉就像是打开了新世界.

还有就是排在后面的学习计划: python, 数据分析, 机器学习, 深度学习.可以看得出, 其实这些都学完, 其实也不知道能够干什么, 无所事事诶… 但至少这些都是我能够找到的比较高质量的资料了, 如果有其他高质量的资料, 欢迎进行资料共享hhhh~

算法学习

果然, 算法是挡在(复制黏贴)程序员和(正常)程序员之前的一条很难跨越的鸿沟, 我这里不是说, 你会写快速排序,二分查找, 深度广度优先这类大家都能够背出来的东西就叫做掌握算法了, 我在Coursera上看了加州大学的算法课, 才知道该如何设计算法, 但由于是英语的, 而且没有代码, 纯数学的看不太懂, 所以转向了北京大学的算法课, 以下就是我最新学到的算法和你分享.

这个只是算法基础的第二节课, 你能想象这是算法基础么? 光是这个题目, 我就看了老半天, 大意是点击一个灯, 上下左右的灯会自动点亮(熄灭), 当随机给出点亮熄灭数的时候, 需要算出点击哪几个灯可以将所有的灯点亮或熄灭.

这种算法题, 真是闻所未闻见所未见吧, 而且这是算法基础的开头的课… 我在想难道那些大厂的人做这种题跟玩的一样么, 想起了面试官的微笑, 那可真是有力量的微笑呢.

#include <stdio.h>

int puzzle[6][8], press[6][8];
/*
推测验证过程：
根据第一行猜测
*/
bool guess() {
    int c, r;
    //根据press第1行和puzzle数组，计算press其他行的值
    for(r=1; r<5; r++) {
        for(c=1; c<7; c++) {
            press[r+1][c]=(puzzle[r][c]+press[r][c]+press[r-1][c]+press[r][c-1]+press[r][c+1])%2;
        }
    }
    //判断所计算的press数组能否熄灭第5行的所有灯
    for(c=1; c<7; c++) {
        if ((press[5][c-1]+press[5][c]+press[5][c+1]+press[4][c])%2 != puzzle[5][c]) {
            return false;
        }
    }
    return true;
}

/*
枚举过程：
对press第1行的元素press[1][1]~press[1][6]的各种取值进行枚举
*/
void enumerate() {
    int c;
    bool success; //这个变量时当时定义了没排上用场吧，NodYoung注
    for(c=1; c<7; c++) {
        press[1][c]=0;
    }
    while(guess()==false) {
        press[1][1]++;
        c=1;
        while(press[1][c]>1) {  //累加进位
            press[1][c]=0;
            c++;
            press[1][c]++;
        }
    }
    return ;
}

int main() {
    int cases, i, r, c;
    scanf("%d", &cases);
    for(r=0; r<6; r++) {
        press[r][0]=press[r][7]=0;
    }
    for(c=0; c<7; c++) {
        press[0][c]=0;
    }
    for(i=0; i<cases; i++) {
        for(r=1; r<6; r++) {
            for(c=1; c<7; c++) {
                scanf("%d", &puzzle[r][c]); //读入输入数据
            }
        }
        enumerate();
        printf("PUZZLE#%d\n", i+1);
        for (r=1; r<6; r++) {
            for (c=1; c<7; c++) {
                printf("%d ", press[r][c]);
            }
            printf("\n");
        }
    }
    return 0;
}

这是北大老师视频里给出的算法的答案, 讲的很好, 但是说真的听的是一知半解, 原因在于不知道为什么, 这些网课都不是在线编译的, 而是直接对着代码分析, 上面的代码摘抄自-> 可以搜索熄灯问题.

var puzzle = [[Int]](repeating: [Int](repeating: 0, count: 8), count: 6)
var press = [[Int]](repeating: [Int](repeating: 0, count: 8), count: 6)

func guess() -> Bool {
    for r in 1..<5 {
        for c in 1..<7 {
            press[r + 1][c] = (puzzle[r][c] + press[r][c] + press[r - 1][c] + press[r][c - 1] + press[r][c + 1]) % 2
        }
    }
    for c in 1..<7 {
        if (press[5][c - 1] + press[5][c] + press[5][c + 1] + press[4][c]) % 2 != puzzle[5][c] {
            return false
        }
    }
    return true
}

func enumerate() {
    var c = 1
    for _ in 1..<7 {
        press[1][c] = 0
        while (guess() == false) {
            press[1][1] += 1
            c = 1
            while press[1][c] > 1 {
                press[1][c] = 0
                c += 1
                press[1][c] += 1
            }
        }
        c += 1
    }
}

class Enumerate {
    
    static func main() {
        let cases = 1
        for r in 0..<6 {
            press[r][0] = 0
            press[r][7] = 0
        }
        for c in 1..<7 {
            press[0][c] = 0
        }
        for i in 0..<cases {
            for r in 1..<6 {
                for c in 1..<7 {
                    puzzle[r][c] = 2.arc4random
                }
            }
            enumerate()
            print("PUZZLE #\(i + 1)")
            for r in 1..<6 {
                for c in 1..<7 {
                    print(puzzle[r][c], terminator: "")
                }
                print()
            }
            print("== press ==")
            for r in 1..<6 {
                for c in 1..<7 {
                    print(press[r][c], terminator: "")
                }
                print()
            }
            print()
        }
    }
}

以上是我学习的时候转换成swift表达的, 不为什么, 只是用来熟悉Swift语法罢了, 毕竟OC也不知道还能活个几年了.

PUZZLE #1
011010
001110
010011
000101
100000
== press ==
001001
000101
001010
001101
011110

但是光看代码, 很难看懂这个结果到底是正确还是不正确的… 因为跑出来是这样的一个东西, 但是有些地方还是可以讲一下, 比如是外面包了一圈0来避免冗余逻辑判断, 用2进制进位的方法进行运算, 还是有学到一些皮毛的.

看得见的算法

当然, 这种文字上的描述, 很难有深刻的印象的, 所以, 我就在想是否可以把这个熄灯游戏给做出来, 再自己测试一下呢? 想到就干吧!!

通过CS193p的学习, 对于画UI方面有了全新的认识, 该如何添加约束, MVC到底怎么写, 以至于我以前理解的感觉完全就是错的, 正好趁这个机会来练练手.

我们通过StoryBoard先把View画好, 不得不说UIStackView真是好用到爆!!

import Foundation

struct Matrix {
    var rows: Int
    var columns: Int
}

struct LightSwitch {
    
    private var puzzle: [[Int]]
    private var matrix: Matrix
    var lights = [Int]()
    
    mutating func lightUp(index: Array<Any>.Index?) {
        guard let index = index else { return }
        var m = Matrix(rows: 0, columns: 0)
        if index <= matrix.rows {
            m.columns = index + 1
        } else {
            m.columns += index % matrix.columns + 1
        }
        for i in 0...index {
            if i % matrix.columns == 0 {
                m.rows += 1
            }
        }
        puzzle[m.rows][m.columns] = puzzle[m.rows][m.columns] == 0 ? 1 : 0
        puzzle[m.rows + 1][m.columns] = puzzle[m.rows + 1][m.columns] == 0 ? 1 : 0
        puzzle[m.rows][m.columns + 1] = puzzle[m.rows][m.columns + 1] == 0 ? 1 : 0
        puzzle[m.rows - 1][m.columns] = puzzle[m.rows - 1][m.columns] == 0 ? 1 : 0
        puzzle[m.rows][m.columns - 1] = puzzle[m.rows][m.columns - 1] == 0 ? 1 : 0
        lights.removeAll()
        for r in 1..<matrix.rows + 1 {
            for c in 1..<matrix.columns + 1 {
                lights.append(puzzle[r][c])
            }
        }
    }
    
    init(matrix: Matrix) {
        self.matrix = matrix
        puzzle = [[Int]](repeating: [Int](repeating: 0, count: matrix.columns + 2), count: matrix.rows + 2)
        for r in 1..<matrix.rows + 1 {
            for c in 1..<matrix.columns + 1 {
                puzzle[r][c] = 2.arc4random
                lights.append(puzzle[r][c])
            }
        }
        print("========")
        for r in 0..<matrix.rows + 2 {
            for c in 0..<matrix.columns + 2 {
                print(puzzle[r][c], terminator: "")
            }
            print()
        }
        print("========")
    }
}

Model代码, 原来MVC的M需要这样写的, 以前都只是认为是简单的数据结构来的真是肤浅, 这种直接业务逻辑写在M里面的的写法真是好用到爆啊!

import UIKit

extension UIColor {
    var toImage: UIImage {
        let bounds = CGRect(origin: .zero, size: CGSize(width: 1.0, height: 1.0))
        let renderer = UIGraphicsImageRenderer(bounds: bounds)
        return renderer.image { context in
            self.setFill()
            context.fill(CGRect(x: 0.0, y: 0.0, width: 1.0, height: 1.0))
        }
    }
}

extension Int {
    var arc4random: Int {
        if self > 0 {
            return Int(arc4random_uniform(UInt32(self)))
        } else if self < 0 {
            return -Int(arc4random_uniform(UInt32(self)))
        } else {
            return 0
        }
    }
}

class ViewController: UIViewController {
    
    @IBOutlet var lights: [UIButton]! {
        didSet {
            for (index, light) in lights.enumerated() {
                light.setBackgroundImage(UIColor.yellow.toImage, for: .normal)
                light.setBackgroundImage(UIColor.darkGray.toImage, for: .selected)
                light.isSelected = switchs.lights[index] == 1 ? true : false
            }
        }
    }
    
    @IBAction func lightUp(_ sender: UIButton) {
        switchs.lightUp(index: lights.index(of: sender))
        for (index, light) in lights.enumerated() {
            light.isSelected = switchs.lights[index] == 1 ? true : false
        }
        if Set(switchs.lights).count == 1 {
            let alert = UIAlertController(title: "Congratulation", message: "You made all light up successfully", preferredStyle: .alert)
            alert.addAction(UIAlertAction(
                title: "again",
                style: .default,
                handler: { [weak self] _ in
                    self?.restart()
                }
            ))
            present(alert, animated: true)
        }
    }
    
    @IBAction func restart(_ sender: UIButton? = nil) {
        switchs = LightSwitch(matrix: Matrix(rows: 5, columns: 6))
        for (index, light) in (self.lights.enumerated()) {
            light.isSelected = self.switchs.lights[index] == 1 ? true : false
        }
    }
    
    var switchs: LightSwitch = LightSwitch(matrix: Matrix(rows: 5, columns: 6))
}

Controller的代码, 这才能够真正理解什么叫做控制器用来协调View和Model的交互, Model和View毫无关联, 这才是iOS的正确写法啊.

运行了一下, 果然白胡子大叔没有骗我, 跑的6到飞起~

可以看到的是, 终端打印的矩阵和界面上显示的是一一对应的, 从北大老师学到的外面包一圈的方法也是特别好用的.

算法测试

    init(matrix: Matrix) {
        self.matrix = matrix
        puzzle = [[Int]](repeating: [Int](repeating: 0, count: matrix.columns + 2), count: matrix.rows + 2)
        for r in 1..<matrix.rows + 1 {
            for c in 1..<matrix.columns + 1 {
//                puzzle[r][c] = 2.arc4random
                puzzle[1][1] = 1
                lights.append(puzzle[r][c])
            }
        }
        print("========")
        for r in 0..<matrix.rows + 2 {
            for c in 0..<matrix.columns + 2 {
                print(puzzle[r][c], terminator: "")
            }
            print()
        }
        print("========")
    }

我们将初始状态从随机数改成只暗一个灯, 位置是[1][1]

class Enumerate {
    
    static func main() {
        let cases = 1
        for r in 0..<6 {
            press[r][0] = 0
            press[r][7] = 0
        }
        for c in 1..<7 {
            press[0][c] = 0
        }
        for i in 0..<cases {
            for r in 1..<6 {
                for c in 1..<7 {
//                    puzzle[r][c] = 2.arc4random
                    puzzle[1][1] = 1
                }
            }
            enumerate()
            print("PUZZLE #\(i + 1)")
            for r in 1..<6 {
                for c in 1..<7 {
                    print(puzzle[r][c], terminator: "")
                }
                print()
            }
            print("== press ==")
            for r in 1..<6 {
                for c in 1..<7 {
                    print(press[r][c], terminator: "")
                }
                print()
            }
            print()
        }
    }
}

我们把北大算法也改成对应的[1][1]

PUZZLE #1
100000
000000
000000
000000
000000
== press ==
000111
101010
101100
001000
110000

可以看懂只要按下全部位置对应为1的按钮就可以将所有灯都打开了, 我们来试一下.

更新算法

为了不用每次都跑到另一个程序去运行算法, 我新增了Hint提示功能, 每盘游戏都可以点击提示, 看到提示显示的深色按钮点击对应位置的灯, 即可点亮所有的灯.

添加这个功能其实也很简单, 只需要新建一个Popver控制器即可, 使用对应算法, 映射到向量即可.

import UIKit

class HintViewController: UIViewController {

    override func viewDidLayoutSubviews() {
        super.viewDidLayoutSubviews()
        if let fittedSize = topLevelView?.sizeThatFits(UILayoutFittingCompressedSize) {
            preferredContentSize = CGSize(width: fittedSize.width + 30, height: fittedSize.height + 30)
        }
    }

    override func viewDidLoad() {
        super.viewDidLoad()
        if presentationController is UIPopoverPresentationController {
            view.backgroundColor = .clear
        }        
    }
    @IBOutlet var hints: [UIButton]! {
        didSet {
            for (index, hint) in hints.enumerated() {
                hint.setBackgroundImage(UIColor.yellow.toImage, for: .normal)
                hint.setBackgroundImage(UIColor.darkGray.toImage, for: .selected)
                hint.isSelected = switchs?.hints[index] == 1 ? true : false
            }
        }
    }
    @IBOutlet weak var topLevelView: UIStackView!
    var switchs: LightSwitch?
}

新增控制器, 就是显示提示的控制器

    @IBOutlet weak var hintButton: UIButton!
    
    override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
        if segue.identifier == "Show Hint", let destination = segue.destination.contents as? HintViewController,
            let ppc = destination.popoverPresentationController {
            ppc.delegate = self
            ppc.sourceRect = hintButton.bounds
            destination.switchs = switchs
        }
    }
    
    func adaptivePresentationStyle(for controller: UIPresentationController, traitCollection: UITraitCollection) -> UIModalPresentationStyle {
        return .none
    }

原先控制器的Segue设置, 让iphone默认不适配

    mutating func guess() -> Bool {
        for r in 1..<matrix.rows {
            for c in 1..<matrix.columns + 1 {
                press[r + 1][c] = (puzzle[r][c] + press[r][c] + press[r - 1][c] + press[r][c - 1] + press[r][c + 1]) % 2
            }
        }
        for c in 1..<matrix.columns + 1 {
            if (press[matrix.rows][c - 1] + press[matrix.rows][c] + press[matrix.rows][c + 1] + press[matrix.rows - 1][c]) % 2 != puzzle[matrix.rows][c] {
                return false
            }
        }
        return true
    }
    
    mutating func enumerate() {
        var c = 1
        for _ in 1..<matrix.columns + 1 {
            press[1][c] = 0
            while (guess() == false) {
                press[1][1] += 1
                c = 1
                while press[1][c] > 1 {
                    press[1][c] = 0
                    c += 1
                    press[1][c] += 1
                }
            }
            c += 1
        }
    }

在Model中加入核心算法即可

这个Demo可能是全网唯一的熄灯问题的UI版本吧, 给自己一个赞~

经过好几次测试, 可以看见, 算法是正确的, 我也学到了这个算法背后的思维, 更通过了写了一个Demo来证明了算法的正确性. 这个Demo的难点在于向量和矩阵之间的互相转换, 这里为什么不说一维数组和二维数组呢? , 原因在于吴恩达的机器学习课程中也教会了我一些比较厉害的算法, 比如梯度下降之类的.

好了, 现在写文章没有之前频繁了, 原因在于之前那些文章都太水, 太肤浅, 写了对自己也没有太大的意义, 被人看到也只会觉得是垃圾而已… 所以在我第五阶段的学习后, 希望能够有机会进入一家大厂继续深造吧!

最后本文中所有的源码都可以在github上找到 -> UIAlgorithm

GitHub Repo：coderZsq.target.swift
Follow: coderZsq · GitHub
Resume: https://coderzsq.github.io/coderZsq.webpack.js/#/

STL 一部数据结构的使用宝典

Wed, 02 May 2018 17:08:00 +0000

GitHub Repo：coderZsq.github.io
Follow: coderZsq · GitHub
Resume: https://coderzsq.github.io/coderZsq.webpack.js/#/

日常扯淡

一些STL的代码片段, 记录而已.

C++ 作者的建议

在C++中几乎不需要用宏, 用const和enum定义显式的常量, 用inline避免函数调用的额外开销, 用模板去刻画一组函数或类型, 用namespace去避免命名冲突.
不要在你需要变量之前去声明, 以保证你能立即对它进行初始化.
不要用malloc, new运算会做的更好.
避免使用void*, 指针算数, 联合和强制, 大多数情况下, 强制类型转换是设计错误的指示器.
尽量少用数组和C风格的字符串, 标准库中的string和vector可以简化程序.
更加重要的是, 试着将程序考虑为一组由类和对象表示的互相作用的概念年, 而不是一堆数据结构和一些可以拨弄的二进制.

STL

#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>

using namespace std;

class Compare {
public:
    bool operator()(int i, int j) {
        return i < j;
    }
};

class myCompare {
public:
    bool operator()(int & v) {
        return v > 5;
    }
};

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


    int arr[10] = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};
    vector<int, allocator<int>> vi;
    vi.assign(arr, arr+10);
    
    int *p;
    for (p = arr; p != arr+10; p++) {
        cout<<*p<<endl;
    }
    
    vector<int, allocator<int>>::iterator itr;
    for (itr = vi.begin(); itr != vi.end(); ++itr) {
        cout<<*itr<<endl;
    }
    
    sort(vi.begin(), vi.end(), Compare());
    for (auto & i: vi) {
        cout<<i<<endl;
    }
    
//    int count = count_if(vi.begin(), vi.end(),myCompare());
    
    int count = count_if(vi.begin(), vi.end(),bind(greater<int>(), std::placeholders::_1,5));
    cout<<"count = "<<count<<endl;
    
    return 0;
}
}

Container

class A {
public:
    A() {
        cout<<"无参构造函数 "<<this<<endl;
    }
    A(int d = 100):_data(d) {
        cout<<"有参构造函数 "<<this<<endl;
    }
    ~A() {
        cout<<"析构函数 "<<this<<endl;
    }
    A(const A & another) {
        cout<<this<<" 构造拷贝自 "<<&another<<endl;
    }
    A & operator=(const A & another) {
        cout<<this<<" 赋值拷贝自 "<<&another<<endl;
        return *this;
    }
    int getData() {
        return _data;
    }
    void setData(int d) {
        _data = d;
    }
private:
    int _data;
};

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

    A a(10);
    cout<<a.getData()<<endl;
    {
        vector<A> va;
        va.push_back(a);
        va[0].setData(20);
        cout<<va[0].getData()<<endl;
    }
    cout<<a.getData()<<endl;
    cout<<"++++++++++++++++++"<<endl;

    return 0;
}

Vector

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

    vector<int> vi = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
#if 0
    cout<<"front "<<vi.front()<<endl;
    cout<<"end   "<<vi.back()<<endl;
    vi.push_back(100);
    vi.pop_back();
    cout<<"front "<<vi.front()<<endl;
    cout<<"end   "<<vi.back()<<endl;

    vi.insert(vi.begin(), 10000);
    cout<<"front "<<vi.front()<<endl;
    cout<<"end   "<<vi.back()<<endl;
#endif
    vi.erase(vi.end() - 1);
    cout<<"front "<<vi.front()<<endl;
    cout<<"end   "<<vi.back()<<endl;
    
    vector<int>::iterator itr;
    for (itr = vi.begin(); itr != vi.end(); ++itr) {
        cout<<*itr<<endl;
    }
    return 0;
}

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

//    vector<int> vi(10, 2);
//    vector<int> vi {1, 2, 3, 4, 5, 6, 7};
    vector<int> vi = {1, 2, 3, 4, 5, 6, 7};
    vector<int> vi2(vi);
    cout<<vi2.size()<<endl;
    
    vector<int>::iterator itr;
    for (itr = vi2.begin(); itr != vi2.end(); ++itr) {
        cout<<*itr<<endl;
    }
    
    return 0;
}

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

    vector<int> vi;
    cout<<vi.size()<<endl;
    if (vi.empty()) {
        cout<<"is empty"<<endl;
    }
    vi.push_back(10);
    if (vi.empty()) {
        cout<<"is empty"<<endl;
    }
    cout<<vi.max_size()<<endl;

    return 0;
}

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

    vector<int> vi;
    vi.reserve(10);
    cout<<"size: "<<vi.size()<<endl;
    cout<<"capacity: "<<vi.capacity()<<endl;
    vi.push_back(1);
    cout<<"size: "<<vi.size()<<endl;
    cout<<"capacity: "<<vi.capacity()<<endl;
    vi.shrink_to_fit();
    cout<<"size: "<<vi.size()<<endl;
    cout<<"capacity: "<<vi.capacity()<<endl;
    
    return 0;
}

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

    vector<int> vi = {1, 2, 3, 4, 5};
    vector<int> vi2 = {1, 2, 3, 5, 4};
    if (vi == vi2) {
        cout<<"=="<<endl;
    } else {
        cout<<"!="<<endl;
    }
    if (vi > vi2) {
        cout<<">"<<endl;
    } else {
        cout<<"<"<<endl;
    }
    
    return 0;
}

//能用容器内部的算法, 不要用std::的算法

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

    vector<int> vi;
    vi = {1, 2, 3, 4, 5, 6};
    vector<int> vi2;
    vi2 = vi;
    
    vi2.assign(5, 1);
    for (auto & i: vi2) {
        cout<<i<<endl;
    }
    
    vi2.assign(vi.begin(), vi.end());
    for (auto & i: vi2) {
        cout<<i<<endl;
    }
    
    vi2.assign({1, 2, 3,4, 5, 6, 7, 8, 9});
    for (auto & i: vi2) {
        cout<<i<<endl;
    }
    
    vi.swap(vi2);
    swap(vi, vi2);
    
    return 0;
}
}

//random access 内存连续的容器

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

    vector<int> vi;
    vi = {1, 2, 3, 4, 5, 6};
    for (int i = 0; i < vi.size(); i++) {
        cout<<vi.at(i)<<endl;
    }
    
    return 0;
}

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

    vector<int> vi;
    vi = {1, 2, 3, 4, 5, 6};
    for (auto itr = vi.crbegin(); itr != vi.crend(); ++itr) {
        cout<<*itr<<endl;
    }
    
    return 0;
}

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

    vector<int> vi;
    vi = {1, 2, 3, 4, 5, 6};
    vi.push_back(100);
    for (auto & i: vi) {
        cout<<i<<endl;
    }
    while (!vi.empty()) {
        cout<<vi.back()<<endl;
        vi.pop_back();
    }
    cout<<vi.size()<<endl;
    
    return 0;
}

void printv(vector<int> & v) {
    for (auto & i: v) {
        cout<<i<<" ";
    }
    cout<<endl<<"================="<<endl;
}

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

    int arr[3] = {888, 888, 888};
    vector<int> vi;
    vi = {1, 2, 3, 4, 5, 6};
//    vi.insert(vi.begin() + 1, 1000);
//    vi.insert(vi.begin(), 5, 999);
//    vi.insert(vi.begin(), arr, arr+3);
    vi.insert(vi.begin(), {777, 777, 777});
//    vi.erase(vi.begin(), vi.begin()+3);
    vi.resize(19, 66666);
    
    printv(vi);
    
    return 0;
}

void printv(vector<int> & v) {
    for (auto & i: v) {
        cout<<i<<" ";
    }
    cout<<endl<<"================="<<endl;
}

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

    vector<int> vi;
    vi = {1, 2, 3, 4, 5, 6};
    auto itr = find(vi.begin(), vi.end(), 5);
    if (itr == vi.end()) {
        cout<<"find none"<<endl;
    } else {
        cout<<"find"<<endl;
        vi.erase(itr);
    }
    printv(vi);
    
    return 0;
}

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

    vector<int> vi;
    for (int i = 0; i < 10; i++) {
        vi.push_back(i);
        cout<<"size: "<<vi.size()<<endl;
        cout<<"capacity: "<<vi.capacity()<<endl;
    }
    vi.shrink_to_fit();
    cout<<"size: "<<vi.size()<<endl;
    cout<<"capacity: "<<vi.capacity()<<endl;
    
    return 0;
}

//capacity >= size;
//resize size的大小, capacity 中会变大不会变小
//capacity > size => capacity = size

//预留空间, 而不是申请空间

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

    vector<int> vi = {1, 2, 3, 4, 5};
    cout<<vi.capacity()<<endl;
    vi.resize(10);
    vi.resize(1);
    vi.shrink_to_fit();
    cout<<vi.capacity()<<endl;

    return 0;
}

//resize > cursize push_back
//resize < cursize pop_back

//预留空间, 而不是申请空间
//reserve 预留空间, 而不构造, resize 一定会发生构造和析构行为

class A {
public:
    A() {
        cout<<"无参构造函数 "<<this<<endl;
    }
    A(int d):_data(d) {
        cout<<"有参构造函数 "<<this<<endl;
    }
    ~A() {
        cout<<"析构函数 "<<this<<endl;
    }
    A(const A & another) {
        cout<<this<<" 构造拷贝自 "<<&another<<endl;
    }
    A & operator=(const A & another) {
        cout<<this<<" 赋值拷贝自 "<<&another<<endl;
        return *this;
    }
    int getData() {
        return _data;
    }
    void setData(int d) {
        _data = d;
    }
private:
    int _data;
};

int main(int argc, const char * argv[]) {
    
    vector<A> va;
    va.reserve(100);
    A a;
    va.push_back(a);
    va.push_back(a);
    va.push_back(a);
    {
        va.resize(2); //push_back() | pop_back()
    }
    
    return 0;
}

class A {
public:
    A() {
        cout<<"无参构造函数 "<<this<<endl;
    }
    A(int d):_data(d) {
        cout<<"有参构造函数 "<<this<<endl;
    }
    ~A() {
        cout<<"析构函数 "<<this<<endl;
    }
    A(const A & another) {
        cout<<this<<" 构造拷贝自 "<<&another<<endl;
    }
    A & operator=(const A & another) {
        cout<<this<<" 赋值拷贝自 "<<&another<<endl;
        return *this;
    }
    int getData() {
        return _data;
    }
    void setData(int d) {
        _data = d;
    }
private:
    int _data;
};

int main(int argc, const char * argv[]) {
    
    vector<A*> vap;
    vap.reserve(10);
    A *pa = new A;
    vap.push_back(pa);
    delete pa;
    
    return 0;
}

//怎么来看迭代器, 就是一个智能指针, 重载了 operator* operator->

int main(int argc, const char * argv[]) {
    
    vector<int> vi = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    vector<int>::iterator itr;
    for (itr = vi.begin(); itr != vi.end(); ) {
        if (!((*itr) % 2)) {
            vi.erase(itr);
        } else {
            cout<<*itr<<endl;
            ++itr;
        }
    }
    return 0;
}

int main(int argc, const char * argv[]) {
    
    vector<int> vi = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
//    auto itr = vi.insert(vi.begin(), 100);
//    cout<<*itr<<endl;
    
    vector<int>::iterator itr;
    for (itr = vi.begin(); itr != vi.end();) {
        if (*itr % 2) {
            itr = vi.insert(itr, 100);
            itr += 2;
        } else {
            ++itr;
        }
    }
    for (auto & i: vi) {
        cout<<i<<endl;
    }
    return 0;
}

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

    vector<int> t(5);
    vector<vector<int>> tt(5, t);
    
    cout<<tt.size()<<endl;
    cout<<tt[0].size()<<endl;
    cout<<tt[1].size()<<endl;
    cout<<tt[2].size()<<endl;
    cout<<tt[3].size()<<endl;
    cout<<tt[4].size()<<endl;

    for (int i = 0; i < 5; i++) {
        for (int j = 0; j < 5; j++) {
            cout<<(tt[i][j] = 100)<<" ";
        }
        cout<<endl;
    }
    
    return 0;
}

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

    srand(time(nullptr));
    
    vector<int> t;
    vector<vector<int>> tt(5, t);
 
    for (int i = 0; i < 5; i++) {
        for (int j = 0; j < rand()%20; j++) {
            tt[i].push_back(j);
        }
    }
    
    for (int i = 0; i < 5; i++) {
        for (int j = 0; j < tt[i].size(); j++) {
            cout<<tt[i][j]<<" ";
        }
        cout<<endl;
    }
    
    return 0;
}

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

    vector<int> vi = {1, 3, 5, 6, 7};
    
//    vector<int>::iterator itr;
//    vector<int>::reverse_iterator itr;
//    vector<int>::const_iterator itr;
    vector<int>::const_reverse_iterator itr;
    
    for (itr = vi.crbegin(); itr != vi.crend(); ++itr) {
        cout<<*itr<<endl;
    }
    
    return 0;
}

// .erase(std::remove) vector

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

    vector<int> vi = {1, 2, 3, 4, 5, 6, 7, 5 , 9, 10};
    auto itr = vi.begin();
//    for (; itr != vi.end();) {
//        if (*itr == 5) {
//            itr = vi.erase(itr);
//        } else {
//            ++itr;
//        }
//    }
    cout<<vi.size()<<endl;
    dump(vi);
    vi.erase(remove(vi.begin(), vi.end(), 5), vi.end());
    cout<<vi.size()<<endl;
    dump(vi);

    return 0;
}

List

void printl(list<int> & li) {
    for (auto & i : li) {
        cout<<i<<" ";
    }
    cout<<endl;
}

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

    list<int> li = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};
    cout<<li.front()<<endl;
    cout<<li.back()<<endl;
    
    printl(li);
//    li.push_back(999);
//    li.pop_back();
//    li.push_front(999);
//    li.pop_front();
//    li.insert(li.begin(), 999);
//    li.erase(li.begin());
    li.remove(2);
    printl(li);

    return 0;
}

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

    int arr[10] = {1, 2, 3, 4};
    list<int> li(arr, arr+4);
    printl(li);
    
//    list<int> li2(li);
    list<int> li2(li.begin(), li.end());
    printl(li);
    
    cout<<li2.size()<<endl;
    while (!li2.empty()) {
        cout<<li2.back()<<" ";
        li2.pop_back();
    }
    cout<<endl;
    cout<<li2.size()<<endl;

    return 0;
}

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

    list<int> li = {1, 2, 3, 4};
    list<int> li2 = {1, 3, 2, 4};
    
    if (li == li2) {
        cout<<"=="<<endl;
    } else {
        cout<<"!="<<endl;
    }
    
    return 0;
}

class A {
public:
    A() {
        cout<<"无参构造函数 "<<this<<endl;
    }
    A(int d):_data(d) {
        cout<<"有参构造函数 "<<this<<endl;
    }
    A(const A & another) {
        this->_data = another._data;
        cout<<this<<" 构造拷贝自 "<<&another<<endl;
    }
    A & operator=(const A & another) {
        if (this != &another) {
            this->_data = another._data;
        }
        cout<<this<<" 赋值拷贝自 "<<&another<<endl;
        return *this;
    }
    friend bool operator== (const A & one, const A & another) {
        if (one._data == another._data) {
            return true;
        } else {
            return false;
        }
    }
    ~A() {
        cout<<"析构函数 "<<this<<endl;
    }
private:
    int _data;
};

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

    list<A> li = {A(1), A(2), A(3), A(4)};
    list<A> li2 = {A(1), A(2), A(3), A(4)};
    
    if (li == li2) {
        cout<<"=="<<endl;
    } else {
        cout<<"!="<<endl;
    }
    
    return 0;
}

class A {
public:
    A() {
        cout<<"无参构造函数 "<<this<<endl;
    }
    A(int d):_data(d) {
        cout<<"有参构造函数 "<<this<<endl;
    }
    A(const A & another) {
        this->_data = another._data;
        cout<<this<<" 构造拷贝自 "<<&another<<endl;
    }
    A & operator=(const A & another) {
        if (this != &another) {
            this->_data = another._data;
        }
        cout<<this<<" 赋值拷贝自 "<<&another<<endl;
        return *this;
    }
    friend bool operator== (const A & one, const A & another) {
        if (one._data == another._data) {
            return true;
        } else {
            return false;
        }
    }
    void dump() {
        cout<<_data<<" ";
    }
    ~A() {
        cout<<"析构函数 "<<this<<endl;
    }
private:
    int _data;
};

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

    list<A> la;
    la.push_back(A(1));
    la.push_back(A(100));
    la.emplace(la.begin(), 200);
    la.emplace_back(300);
    la.emplace_front(400);
    
    for (auto & obj: la) {
        obj.dump();
    }
    cout<<endl;
    
    return 0;
}

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

    list<int> li = {1, 3, 5, 7, 9};
//    list<int>::iterator itr = li.begin();
//    advance(itr, 1);
//    li.erase(li.begin(), itr);
//    li.erase(li.begin(), ++li.begin());
    li.erase(li.begin(), li.end());
    dump(li);
    
    return 0;
}

int main(int argc, const char * argv[]) {
    
    list<int> li = {1, 3, 5, 7, 9};
//    li.remove(5);
    li.remove_if([](int x) {
        if(x >= 5)
            return true;
        else
            return false;
    });
    dump(li);
    
    return 0;
}

int main(int argc, const char * argv[]) {
    
    greater<int>()(1, 2);
    int arr[10] = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};
    sort(arr, arr+10, greater<int>());
    for (auto & i: arr) {
        cout<<i<<endl;
    }
    vector<int> vi(arr, arr + 10);
    sort(vi.begin(), vi.end(), less<int>());
    for (auto & i: vi) {
        cout<<i<<endl;
    }
    list<int> li(arr, arr + 10);
    li.sort();
    for (auto & i: li) {
        cout<<i<<endl;
    }
    
    return 0;
}

class A {
public:
    A() {
        cout<<"无参构造函数 "<<this<<endl;
    }
    A(int d):_data(d) {
        cout<<"有参构造函数 "<<this<<endl;
    }
    A(const A & another) {
        this->_data = another._data;
        cout<<this<<" 构造拷贝自 "<<&another<<endl;
    }
    A & operator=(const A & another) {
        if (this != &another) {
            this->_data = another._data;
        }
        cout<<this<<" 赋值拷贝自 "<<&another<<endl;
        return *this;
    }
    friend bool operator== (const A & one, const A & another) {
        if (one._data == another._data) {
            return true;
        } else {
            return false;
        }
    }
    void dump() {
        cout<<_data<<" ";
    }
    friend bool operator<(const A & one, const A & another) {
        if (one._data == another._data) {
            return true;
        } else {
            return false;
        }
    }
    ~A() {
        cout<<"析构函数 "<<this<<endl;
    }
private:
    int _data;
};

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

    srand(time(nullptr));
    list<A> la;
    for (int i = 0; i < 10; i++) {
        la.emplace_back(rand() % 100);
    }
    la.sort();
    for (auto & obj: la) {
        obj.dump();
    }
    cout<<endl;
    
    return 0;
}

class g {
public:
    bool operator()(int x) const {
        if (x > 5) {
            return true;
        } else {
            return false;
        }
    }
    typedef int argument_type;
};

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

    vector<int> vi = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int count = count_if(vi.begin(), vi.end(), not1(g()));
    cout<<count<<endl;
    
    return 0;
}

using namespace std;
using namespace placeholders;

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

    vector<int> vi = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int count = count_if(vi.begin(), vi.end(), bind(greater<int>(), _1, 5));
    cout<<count<<endl;
    
    return 0;
}

using namespace std;
using namespace std::placeholders;

struct mygreat {
    int operator()(int x, int y) {
        cout<<"x: "<<x<<endl;
        cout<<"y: "<<y<<endl;
        return x < y;
    }
};

//bind1st bind2nd

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

    vector<int> vi = {1, 2, 3, 11, 22, 33, 44, 55, 66, 77};
//    int count1 = count_if(vi.begin(), vi.end(), bind1st(greater<int>(), 10));
//    int count2 = count_if(vi.begin(), vi.end(), bind2nd(greater<int>(), 10));
//    cout<<count1<<"-"<<count2<<endl;
    
    int count1 = count_if(vi.begin(), vi.end(), bind(greater<int>(), 10, _1));
    int count2 = count_if(vi.begin(), vi.end(), bind(greater<int>(), _1, 10));
    int count3 = count_if(vi.begin(), vi.end(), bind(mygreat(), _1, 10));

    cout<<count1<<"-"<<count2<<"-"<<count3<<endl;

    return 0;
}

int main(int argc, const char * argv[]) {
    
    list<int> li = {1, 2, 1, 1, 1, 3, 4, 5, 5, 6, 6, 9, 7, 9};
//    li.sort();
    li.unique([](int x, int y) {
        if (x == y && y % 2) {
            return true;
        } else {
            return false;
        }
    });
    dump(li);
    
    return 0;
}

int main(int argc, const char * argv[]) {
    
    list<int> li1 = {1, 3, 5, 9, 7};
    list<int> li2 = {2, 4, 6, 8, 10};
//    li1.splice(li1.begin(), li2);
//    li1.splice(li1.end(), li2, li2.begin());
//    auto itr = li1.begin();
//    advance(itr, 2);
//    li1.splice(itr, li2, li2.begin(), li2.end());
//    li1.reverse();
    li1.sort();
    li2.sort();
    li1.merge(li2);
    dump(li1);
    dump(li2);
    return 0;
}

Deque

int main(int argc, const char * argv[]) {
    
    deque<char> dc;
    for (char ch = 'a'; ch <= 'z'; ch++) {
        dc.push_front(ch);
    }
    while (!dc.empty()) {
        cout<<dc.front()<<" ";
        dc.pop_front();
    }
    
    return 0;
}

int main(int argc, const char * argv[]) {
    
    deque<char> dc;
    for (char ch = 'a'; ch <= 'z'; ch++) {
        dc.push_front(ch);
    }
    while (!dc.empty()) {
        cout<<dc.back()<<" ";
        dc.pop_back();
    }
    
    return 0;
}

Stack

int main(int argc, const char * argv[]) {
    
    stack<char> si;
    for (char ch = 'a'; ch <= 'z'; ch++) {
        si.push(ch);
    }
    while (!si.empty()) {
        cout<<si.top()<<" ";
        si.pop();
    }
    
    return 0;
}

Queue

int main(int argc, const char * argv[]) {
    
    queue<char> qc;
    for (char ch = 'a'; ch <= 'z'; ch++) {
        qc.push(ch);
    }
    while (!qc.empty()) {
        cout<<qc.front()<<" ";
        qc.pop();
    }
    
    return 0;
}

int main(int argc, const char * argv[]) {
    
    priority_queue<int, vector<int>, greater<int>> pqi;
    pqi.push(1);
    pqi.push(3);
    pqi.push(5);
    pqi.push(7);
    pqi.push(9);
    pqi.push(2);
    pqi.push(4);
    pqi.push(6);
    pqi.push(8);

    while (!pqi.empty()) {
        cout<<pqi.top()<<" ";
        pqi.pop();
    }
    
    return 0;
}

Map

int main(int argc, const char * argv[]) {
    
    map<int, string, less<int>> mis = {
        pair<int, string>(1, "aaa"),
        pair<int, string>(2, "bbb"),
        pair<int, string>(3, "ccc"),
        pair<int, string>(4, "ddd")
    };
    
    mis.insert(pair<int, string>(5, "eee"));
    mis.insert(map<int, string>::value_type(6, "fff"));
    mis.insert(make_pair(7, "ggg"));
    
    mis[4] = "xxx";
    mis[100] = "yyy";
    
    map<int, string>::iterator itr;
    for (itr = mis.begin(); itr != mis.end(); ++itr) {
        //        cout<<itr->first<<" : "<<itr->second<<endl;
        cout<<(*itr).first<<" : "<<(*itr).second<<endl;
    }
    
    return 0;
}

int main(int argc, const char * argv[]) {
    
    multimap<int, string, less<int>> mis = {
        pair<int, string>(1, "aaa"),
        pair<int, string>(2, "bbb"),
        pair<int, string>(3, "ccc"),
        pair<int, string>(4, "ddd")
    };
    
    mis.insert(pair<int, string>(4, "eee"));
    mis.insert(map<int, string>::value_type(3, "fff"));
    mis.insert(make_pair(2, "ggg"));
    
    multimap<int, string>::iterator itr;
    for (itr = mis.begin(); itr != mis.end(); ++itr) {
        //        cout<<itr->first<<" : "<<itr->second<<endl;
        cout<<(*itr).first<<" : "<<(*itr).second<<endl;
    }
    
    return 0;
}

int main(int argc, const char * argv[]) {
    
    multimap<int, string, less<int>> mis = {
        pair<int, string>(1, "aaa"),
        pair<int, string>(2, "bbb"),
        pair<int, string>(3, "ccc"),
        pair<int, string>(4, "ddd")
    };
    
    mis.insert(mis.find(100), pair<int, string>(100, "ddd"));
    mis.insert(mis.find(100), pair<int, string>(100, "ddd"));
    mis.insert(mis.find(100), pair<int, string>(100, "ddd"));
//    mis.erase(100);
    auto it = mis.find(1);
    if (it != mis.end()) {
        mis.erase(it);
    }
//    mis.erase(mis.begin());
//    mis.clear();
    
    multimap<int, string>::iterator itr;
    for (itr = mis.begin(); itr != mis.end(); ++itr) {
        //        cout<<itr->first<<" : "<<itr->second<<endl;
        cout<<(*itr).first<<" : "<<(*itr).second<<endl;
    }
    cout<<mis.count(100)<<endl;
    
    return 0;
}

int main(int argc, const char * argv[]) {
    
    map<int, string, less<int>> mis = {
        pair<int, string>(1, "a"),
        pair<int, string>(2, "ab"),
        pair<int, string>(3, "abc"),
        pair<int, string>(4, "abcd"),
        pair<int, string>(5, "abcde"),
        pair<int, string>(6, "abcdef"),
        pair<int, string>(7, "abcdefg"),
        pair<int, string>(8, "abcdefgh"),
        pair<int, string>(9, "abcdefghi"),
        pair<int, string>(10, "abcdefghij")
    };
    
    auto lowitr = mis.lower_bound(5);
    auto upperitr = mis.upper_bound(7);
    
    cout<<"low: "<<lowitr->first<<" upper: "<<upperitr->first<<endl;
    //循环删除最好不要用遍历的方式.
//    for (auto itr = lowitr; itr != upperitr;) {
//        itr = mis.erase(itr);
//    }
    mis.erase(lowitr, upperitr);
    
    map<int, string>::iterator itr;
    for (itr = mis.begin(); itr != mis.end(); ++itr) {
        cout<<itr->first<<" : "<<itr->second<<endl;
    }
    
    return 0;
}

int main(int argc, const char * argv[]) {
    
    multimap<int, string, less<int>> mis = {
        pair<int, string>(1, "a"),
        pair<int, string>(2, "ab"),
        pair<int, string>(3, "abc"),
        pair<int, string>(4, "abcd"),
        pair<int, string>(5, "a"),
        pair<int, string>(5, "b"),
        pair<int, string>(5, "c"),
        pair<int, string>(5, "d"),
        pair<int, string>(6, "abcdef"),
        pair<int, string>(7, "abcdefg"),
        pair<int, string>(8, "abcdefgh"),
        pair<int, string>(9, "abcdefghi"),
        pair<int, string>(10, "abcdefghij")
    };
    
//    auto range = mis.equal_range(5);
    pair<map<int, string>::iterator, map<int, string>::iterator> range = mis.equal_range(5);
    cout<<"low: "<<range.first->first<<" uppper: "<<range.second->first<<endl;
    cout<<"low: "<<range.first->first<<" :"<<range.first->second<<endl;
    cout<<"low: "<<range.second->first<<" :"<<range.second->second<<endl;

    return 0;
}

Set

int main(int argc, const char * argv[]) {
    
    set<string, greater<string>> ss;
    ss.insert("a");
    ss.insert("b");
    ss.insert("c");
    ss.insert("d");
    ss.insert("e");
    ss.insert("f");

    for (auto & s: ss) {
        cout<<s<<endl;
    }
    
    return 0;
}

最后

更多新鲜文章可以关注并Star, 我们一起学习.

GitHub Repo：coderZsq.github.io
Follow: coderZsq · GitHub

C++ 一把卍解OC底层的斩魄刀

Tue, 24 Apr 2018 17:18:00 +0000

GitHub Repo：coderZsq.github.io
Follow: coderZsq · GitHub
Resume: https://coderzsq.github.io/coderZsq.webpack.js/#/

日常扯淡

本期没什么好扯淡的, 这篇文章留着自己看.

C++ 作者的建议

在C++中几乎不需要用宏, 用const和enum定义显式的常量, 用inline避免函数调用的额外开销, 用模板去刻画一组函数或类型, 用namespace去避免命名冲突.
不要在你需要变量之前去声明, 以保证你能立即对它进行初始化.
不要用malloc, new运算会做的更好.
避免使用void*, 指针算数, 联合和强制, 大多数情况下, 强制类型转换是设计错误的指示器.
尽量少用数组和C风格的字符串, 标准库中的string和vector可以简化程序.
更加重要的是, 试着将程序考虑为一组由类和对象表示的互相作用的概念年, 而不是一堆数据结构和一些可以拨弄的二进制.

inheritance

class A {
public:
    A(){}
    ~A(){}
    A(const A &){}
    A & operator=(const A &){ return *this; }
};

class Human {
public:
    void eat(string food) {
        cout<<food<<endl;
    }
};

class Teacher: public Human {
public:
    void teach(string course) {
        cout<<"i am a teacher i am teaching "<<course<<endl;
    }
};

class Student: public Human {
public:
    void study(string course) {
        cout<<"i am student i am learing "<<course<<endl;
    }
};

class Worker: public Human {};

int main(int argc, const char * argv[]) {
    
    Teacher t;
    t.teach("C++");
    t.eat("红烧牛肉面");
    
    Student s;
    s.study("C++");
    s.eat("老坛酸菜牛肉面");
    
    return 0;
}

#include <iostream>
#include <typeinfo>

using namespace std;

class A {
public:
    A() {
        cout<<"A()"<<endl;
        cout<<"&a: "<<&a<<endl;
        cout<<"A-this: "<<this<<endl;
        cout<<"type A this: "<<typeid(this).name()<<endl;
    }
    int a;
};

class B: public A {
public:
    B() {
        cout<<"B()"<<endl;
        cout<<"&b: "<<&b<<endl;
        cout<<"B-this: "<<this<<endl;
        cout<<"type B this: "<<typeid(this).name()<<endl;
    }
    int b;
};

class C: public B {
public:
    C() {
        cout<<"C()"<<endl;
        cout<<"&c: "<<&c<<endl;
        cout<<"C-this: "<<this<<endl;
        cout<<"type C this: "<<typeid(this).name()<<endl;
    }
    int c;
};

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

    C cc;
    cout<<"&cc: "<<&cc<<endl;
    return 0;
}

A()
&a: 0x7ffeefbff5f0
A-this: 0x7ffeefbff5f0
type A this: P1A
B()
&b: 0x7ffeefbff5f4
B-this: 0x7ffeefbff5f0
type B this: P1B
C()
&c: 0x7ffeefbff5f8
C-this: 0x7ffeefbff5f0
type C this: P1C
&cc: 0x7ffeefbff5f0
Program ended with exit code: 0

subclass constructor

class C {
public:
    C(int k) {
        cout<<"C()"<<endl;
        c = k;
    };
    int c;
};

class A {
public:
    A(int i): a(i) {
        cout<<"A()"<<endl;
    }
    int a;
};

class B: public A {
public:
    B(int i, int j, int k): A(i), b(j), c(k) {
        cout<<"B()"<<endl;
    }
    int b;
    C c;
};

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

    B b(3, 5, 10);
    cout<<b.a<<endl;
    cout<<b.b<<endl;
    cout<<b.c.c<<endl;
    return 0;
}

A()
C()
B()
3
5
10
Program ended with exit code: 0

//class Birthday {
//public:
//    Birthday(int y, int m, int d):_year(y), _month(m), _day(d) {}
//    void disBirth() {
//        cout<<"year: "<<_year<<endl;
//        cout<<"month: "<<_month<<endl;
//        cout<<"day: "<<_day<<endl;
//    }
//private:
//    int _year;
//    int _month;
//    int _day;
//};

class Student {
public:
    Student(string sn, char cs, float fs):_name(sn), _sex(cs),_score(fs) {}
    void dis() {
        cout<<"name: "<<_name<<endl;
        cout<<"sex: "<<_sex<<endl;
        cout<<"score: "<<_score<<endl;
    }
private:
    string _name;
    char _sex;
    float _score;
};

class Graduate: public Student {
public:
    Graduate(string sn, char cs, float fs, float fsa/*, int y, int m, int d*/)
    : Student(sn, cs, fs)/*, birth(y, m, d)*/ {
        _salary = fsa;
    }
    void dump() {
        dis();
//        birth.disBirth();
        cout<<"salary: "<<_salary<<endl;
    }
private:
    float _salary;
//    Birthday birth;
};

class Doctor: public Graduate {
public:
    Doctor(string sn, char cs, float fs, float fsa, string st):Graduate(sn, cs, fs, fsa) {
        _title = st;
    }
    void disDump() {
        dump();
        cout<<"title: "<<_title<<endl;
    }
private:
    string _title;
};

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

//    Graduate g("zhangsan", 's', 99, 1000, 1989, 9, 9);
//    g.dump();
    
    Doctor d("zhaosi", 's', 99, 3000, "doctor zhao");
    d.disDump();
    return 0;
}

subclass copy constructor

//当子类, 不自实现时, 默认调用父类的拷贝构造
//若自实现, 不作特殊处理, 此时只会调用父类的构造器, 此时失去了拷贝构造的意义
//特殊处理 显示的调用父类的拷贝构造, 子类对象赋给父类的引用, 赋值兼容.

class A {
public:
    A(int x = 99) {
        cout<<"A()"<<endl;
        a = x;
    }
    A(const A & another) {
        this->a = another.a;
        cout<<"const A & another"<<endl;
    }
    int a;
};

class B: public A {
public:
    B(int x = 0, int y = 0): A(x) {
        cout<<"B()"<<endl;
        b = y;
    }
    B(const B & another): A(another) {
        this->b = another.b;
        cout<<"const B & another"<<endl;
    }
    int b;
};

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

    B b(199, 200);
    B bb(b);
    
    cout<<bb.a<<endl;
    cout<<bb.b<<endl;
    
    return 0;
}

class Birthday {
public:
    Birthday(int y, int m, int d):_year(y), _month(m), _day(d) {}
    Birthday(const Birthday & another) {
        this->_year = another._year;
        this->_month = another._month;
        this->_day = another._day;
    }
    void disBirth() {
        cout<<"year: "<<_year<<endl;
        cout<<"month: "<<_month<<endl;
        cout<<"day: "<<_day<<endl;
    }
private:
    int _year;
    int _month;
    int _day;
};

class Student {
public:
    Student(string sn, char cs, float fs):_name(sn), _sex(cs),_score(fs) {}
    Student(const Student & another) {
        this->_name = another._name;
        this->_sex = another._sex;
        this->_score = another._score;
    }
    void dis() {
        cout<<"name: "<<_name<<endl;
        cout<<"sex: "<<_sex<<endl;
        cout<<"score: "<<_score<<endl;
    }
private:
    string _name;
    char _sex;
    float _score;
};

class Graduate: public Student {
public:
    Graduate(string sn, char cs, float fs, float fsa, int y, int m, int d)
    : Student(sn, cs, fs), birth(y, m, d) {
        _salary = fsa;
    }
    Graduate(const Graduate & another): Student(another), birth(another.birth) {
        this->_salary = another._salary;
    }
    void dump() {
        dis();
        birth.disBirth();
        cout<<"salary: "<<_salary<<endl;
    }
private:
    float _salary;
    Birthday birth;
};

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

    Graduate g("zhaosi", 's', 99, 1000, 1992, 06, 19);
    g.dump();
    Graduate gg(g);
    gg.dump();
    
    return 0;
}

subclass operator overload

class C {
public:
    C() {
        cout<<"C()"<<endl;
    }
    C & operator= (const C & another) {
        cout<<"C & operator= (const C & another)"<<endl;
        return *this;
    }
    int c;
};

class A {
public:
    A(int x): a(x) {
        cout<<"A()"<<endl;
    }
    A & operator= (const A & another) {
        if (this == &another) {
            return *this;
        }
        cout<<"A & operator= (const A & another)"<<endl;
        this->a = another.a;
        return *this;
    }
    int a;
};

class B: public A {
public:
    B(int x, int y): A(x) {
        b = y;
        cout<<"B()"<<endl;
    }
    B & operator= (const B & another) {
        if (this == &another) {
            return *this;
        }
        A::operator=(another);
        cout<<"B & operator= (const B & another)"<<endl;
        this->b = another.b;
        c = another.c;
        return *this;
    }
    int b;
    C c;
};

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

    B b(1, 2);
    B bb(3, 4);
    b = bb;
    cout<<b.a<<b.b<<endl;
    
    return 0;
}

class Birthday {
public:
    Birthday(int y, int m, int d):_year(y), _month(m), _day(d) {}
    Birthday(const Birthday & another) {
        this->_year = another._year;
        this->_month = another._month;
        this->_day = another._day;
    }
    void disBirth() {
        cout<<"year: "<<_year<<endl;
        cout<<"month: "<<_month<<endl;
        cout<<"day: "<<_day<<endl;
    }
private:
    int _year;
    int _month;
    int _day;
};

class Student {
public:
    Student(string sn, char cs, float fs):_name(sn), _sex(cs),_score(fs) {}
    Student(const Student & another) {
        this->_name = another._name;
        this->_sex = another._sex;
        this->_score = another._score;
    }
    void dis() {
        cout<<"name: "<<_name<<endl;
        cout<<"sex: "<<_sex<<endl;
        cout<<"score: "<<_score<<endl;
    }
private:
    string _name;
    char _sex;
    float _score;
};

class Graduate: public Student {
public:
    Graduate(string sn, char cs, float fs, float fsa, int y, int m, int d)
    : Student(sn, cs, fs), birth(y, m, d) {
        _salary = fsa;
    }
    Graduate(const Graduate & another): Student(another), birth(another.birth) {
        this->_salary = another._salary;
    }
    Graduate & operator=(const Graduate & another) {
        if (this == &another) {
            return *this;
        }
        Student::operator=(another);
        this->_salary = another._salary;
        birth = another.birth;
        return *this;
    }
    void dump() {
        dis();
        birth.disBirth();
        cout<<"salary: "<<_salary<<endl;
    }
private:
    float _salary;
    Birthday birth;
};

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

    Graduate g("zhaoqi", 's', 99, 1000, 1992, 06, 19);
    g.dump();
    Graduate gg("xxx", 'x', 9, 9999, 1111, 11, 11);
    g = gg;
    g.dump();
    return 0;
}

subclass friend

class Student {
    friend void operator<<(ostream & out, Student & stu);
public:
    Student(int i, int j): a(i), b(j) {}
private:
    int a;
    int b;
};

void operator<<(ostream & out, Student & stu) {
    out<<stu.a<<endl;
    out<<stu.b<<endl;
}

class Graduate: public Student {
    friend void operator<<(ostream & out, Graduate & gra) {
        out<<(Student&)gra;
        out<<gra.c<<endl;
    }
public:
    Graduate(int i, int j, int k):Student(i, j), c(k) {}
private:
    int c;
};

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

    Graduate g(1, 2, 3);
    cout<<g;
    return 0;
}

multiple inheritance

class Sofa {
public:
    void sit() {
        cout<<"take a sit have a rest"<<endl;
    }
};

class Bed {
public:
    void sleep() {
        cout<<"have a sleep ......"<<endl;
    }
};

class SofaBed: public Sofa, public Bed {
    
};

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

    Sofa sf;
    sf.sit();
    
    Bed bd;
    bd.sleep();
    
    SofaBed sb;
    sb.sit();
    sb.sleep();
    
    return 0;
}

//1. 数据冗余的问题, 2. 访问方便
//三角转四角的问题
//1. 提取各父类, 相同的成员, 构成祖父类
//2. 让各父类, 继承祖父类
//3. 虚继承是一种继承的扩展, virtual 继承祖父类
//4. 虚继承也是一种设计的结果

class A {

protected:
    int _data;
};

class X: virtual public A {
public:
    X(int d) {
        _data = d;
    }
    void setData(int d) {
        _data = d;
    }
};

class Y: virtual public A {
public:
    Y(int d) {
        _data = d;
    }
    int getData() {
        return _data;
    }
};

class Z: public X, public Y {
public:
    Z(int i, int j):X(i), Y(j) {}
    void dis() {
        cout<<_data<<endl;
    }
};

int main(int argc, const char * argv[]) {
    
    Z z(100, 200);
    z.dis();
    z.setData(100000);
    cout<<z.getData()<<endl;
    z.dis();
    return 0;
}

//虚基类, 被虚继承的类就叫虚基类;
//虚继承, 是一种对继承的扩展;

class A {
protected:
    int _data;
};

class B: virtual public A {
public:
    B(int i = 0) {
        cout<<"B(int i)"<<endl;
        _data = i;
    }
};

class C: virtual public A {
public:
    C(int i = 0) {
        cout<<"C(int i)"<<endl;
        _data = i;
    }
};

class D: public B, C {
public:
    D(int d) {
        cout<<"D(int i)"<<endl;
        _data = d;
    }
    void dis() {
        cout<<_data<<endl;
    }
};

int main(int argc, const char * argv[]) {
    
    D d(10);
    d.dis();
    return 0;
}

class Furniture {
public:
    void descript() {
        cout<<"_weight :"<<_weight<<endl;
        cout<<"_color :"<<_color<<endl;
    }
protected:
    float _weight;
    int _color;
};

class Sofa: virtual public Furniture {
public:
    Sofa(float w = 0, int c = 1) {
        _weight = w;
        _color = c;
    }
    void sit() {
        cout<<"take a sit have a rest"<<endl;
    }
};

class Bed: virtual public Furniture {
public:
    Bed(float w = 0, int c = 1) {
        _weight = w;
        _color = c;
    }
    void sleep() {
        cout<<"have a sleep ......"<<endl;
    }
};

class SofaBed: public Sofa, public Bed {
public:
    SofaBed(float w, int c) {
        _weight = w;
        _color = c;
    }
};

int main(int argc, const char * argv[]) {
    
    SofaBed sb(1000, 2);
    sb.sit();
    sb.sleep();
    sb.descript();
    return 0;
}

polymorphism

//1. 派生类的对象可以赋值给基类对象
//2. 派生类的对象可以初始化基类的引用
//3. 派生类对象的地址可以赋值给指向基类的指针

class Shape {
public:
    Shape(int x = 0, int y = 0):_x(x), _y(y) {
        cout<<"Shape: "<<this<<endl;
        cout<<typeid(this).name()<<endl;
    }
    void draw() {
        cout<<"draw shape from "<<"("<<_x<<", "<<_y<<")"<<endl;
    }
protected:
    int _x;
    int _y;
};

class Circle: public Shape {
public:
    Circle(int x = 0, int y = 0, int r = 0):Shape(x, y), _radius(r) {
        cout<<"Circle: "<<this<<endl;
        cout<<typeid(this).name()<<endl;
    }
    void draw() {
        cout<<"draw shape from "<<"("<<_x<<", "<<_y<<", "<<_radius<<")"<<endl;
    }
protected:
    int _radius;
};

class Rect: public Shape {
    
};

int main(int argc, const char * argv[]) {
    
//    Shape s(1, 2);
//    s.draw();
    
    Circle c(4, 5, 6);
//    s = c;
//    s.draw();
    
//    Shape & rs = c;
//    rs.draw();
    
    Shape * ps = &c;
    ps->draw();
    
    return 0;
}

//多态形成的条件有3个
//1. 父类中有虚函数, 加virtual 声明型关键字
//2. 子类override了父类的虚函数, 子类中同名, 同参, 同返回, 才能构成override
//3. 子类对象赋给父类的指针, 通过父类的指针, 调用虚函数, 形成多态


class Shape {
public:
    Shape(int x = 0, int y = 0):_x(x), _y(y) {
        cout<<"Shape: "<<this<<endl;
        cout<<typeid(this).name()<<endl;
    }
    virtual void draw() {
        cout<<"draw shape from "<<"("<<_x<<", "<<_y<<")"<<endl;
    }
protected:
    int _x;
    int _y;
};

class Circle: public Shape {
public:
    Circle(int x = 0, int y = 0, int r = 0):Shape(x, y), _radius(r) {
        cout<<"Circle: "<<this<<endl;
        cout<<typeid(this).name()<<endl;
    }
    virtual void draw() {
        cout<<"draw shape from "<<"("<<_x<<", "<<_y<<", "<<_radius<<")"<<endl;
    }
protected:
    int _radius;
};

class Rect: public Shape {
public:
    Rect(int x = 0, int y = 0, int w = 0, int l = 0): Shape(x, y), _width(w), _length(l) {}
    virtual void draw() {
        cout<<"draw rect from "<<"("<<_x<<", "<<_y<<", "<<_width<<", "<<_length<<")"<<endl;
    }
protected:
    int _width;
    int _length;
};

int main(int argc, const char * argv[]) {
    
    Circle c(3, 4, 5);
    Rect r(7, 8, 9, 10);
    Shape * ps;
    
    while (1) {
        int choice;
        cin>>choice;
        switch (choice) {
            case 1:
                ps = &c;
                break;
            case 2:
                ps = &r;
                break;
            default:
                break;
        }
        ps->draw();
    }
    
    return 0;
}

virtual function

//virtual 声明型关键字, 用于声明一个函数, 虚, 子类override的函数, 也是virtual
//override 同名, 同参, 同返回
//虚函数在子类中, 访问属性并不影响多态, 具体需求, 要看子类

class A {
public:
    virtual void foo() {
        cout<<"A: foo"<<endl;
    }
};

class B: public A {
private:
    virtual void foo() override {
        cout<<"B: foo"<<endl;
    }
};

int main(int argc, const char * argv[]) {
    
    B b;
    A * pa = &b;
    pa->foo();
    
    return 0;
}

pure virtual function

class A {
public:
    virtual void foo() {
        cout<<"A: foo"<<endl;
    }
};

class B: public A {

};

class C: public B {
public:
    virtual void foo() {
        cout<<"C: foo"<<endl;
    }
};

int main(int argc, const char * argv[]) {
    
    C c;
    B * bp = &c;
    bp->foo();
    A * ap = &c;
    ap->foo();
    
    return 0;
}

//纯虚函数, virtual 没有实现体, 被"初始化"为0
//纯接口类, 才配具备, 拥有纯虚函数, 含有纯虚函数的类, 称为抽象基类 Interface
//抽象基类不能实例化
//子类中若无override, 则依然为纯虚, 依然不能实例化

class A {
public:
    virtual void foo() = 0;
};

class B: public A {
    
};

class C: public B {
public:
    virtual void foo() override {
        cout<<"C: foo"<<endl;
    }
};

int main(int argc, const char * argv[]) {
    
    C c;
    B * bp = &c;
    bp->foo();
    A * ap = &c;
    ap->foo();
    
    return 0;
}

virtual destructor

class Animal {
public:
    Animal();
    ~Animal();
    virtual void voice() = 0;
};

class Dog: public Animal {
public:
    Dog();
    ~Dog();
    virtual void voice();
};

class Cat: public Animal {
public:
    Cat();
    ~Cat();
    virtual void voice();
};

Animal::Animal() {
    cout<<"Animal::Animal()"<<endl;
}

Animal::~Animal() {
    cout<<"Animal::~Animal()"<<endl;
}

Dog::Dog() {
    cout<<"Dog::Dog()"<<endl;
}

Dog::~Dog() {
    cout<<"Dog::~Dog()"<<endl;
}

void Dog::voice() {
    cout<<"wang wang wang"<<endl;
}

Cat::Cat() {
    cout<<"Cat::Cat()"<<endl;
}

Cat::~Cat() {
    cout<<"Cat::~Cat()"<<endl;
}

void Cat::voice() {
    cout<<"mew mew mew"<<endl;
}

int main(int argc, const char * argv[]) {
    
    Cat c;
    Dog d;
    Animal *pa = &c;
    pa->voice();
    return 0;
}

Animal::Animal()
Cat::Cat()
Animal::Animal()
Dog::Dog()
mew mew mew
Dog::~Dog()
Animal::~Animal()
Cat::~Cat()
Animal::~Animal()
Program ended with exit code: 0

dependency inversion

class IReader {
public:
    virtual string getContents() = 0;
};

class Book: public IReader {
public:
    string getContents() {
        return "从前有座山, 山里有座庙, 庙里有个小和尚"
               "听老和尚讲故事, 从前有座山";
    }
};

class EBook: public IReader {
public:
    string getContents() {
        return "郭文贵, 在美国瞎bb";
    }
};

class NewsPaper: public IReader {
public:
    string getContents() {
        return "Trump 要在墨西哥边境建一堵墙";
    }
};

class Mother {
public:
    void tellStory(IReader * pi) {
        cout<<pi->getContents()<<endl;
    }
};

int main(int argc, const char * argv[]) {
    
    Mother m;
    Book b;
    EBook eb;
    NewsPaper n;
    m.tellStory(&b);
    m.tellStory(&eb);
    m.tellStory(&n);
    return 0;
}

func template

class MyType {
public:
    MyType(int x, int y):_x(x), _y(y){}
    int _x;
    int _y;
};

//类型参数化, 设置默认类型

template<typename T>
void myswap(T & a, T & b) {
    T t = a;
    a = b;
    b = t;
}

//函数模板   实例化模板函数    模板函数的调用
//myswap -> myswap<int> -> myswap<int>(1, 2)

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

    int a = 3; int b = 4;
    myswap(a, b);
    cout<<"a: "<<a<<", b: "<<b<<endl;

    string s1 = "china"; string s2 = "america";
    myswap(s1, s2);
    cout<<"s1: "<<s1<<", s2: "<<s2<<endl;
    
    double d1 = 3.1; double d2 = 4.1;
    myswap(d1, d2);
    cout<<"d1: "<<d1<<", d2: "<<d2<<endl;
    
    MyType mt1(1, 2); MyType mt2(3, 4);
    myswap(mt1, mt2);
    cout<<mt1._x<<mt2._x<<endl;

    return 0;
}

template <typename T>
void quickSort(T * p, int low, int high) {
    
    if (low < high) {
        int l = low, h = high;
        T pivot = p[l];
        while (l < h) {
            while (p[h] >= pivot && l < h) {
                h--;
            }
            p[l] = p[h];
            while (p[l] <= pivot && l < h) {
                l++;
            }
            p[h] = p[l];
            p[l] = pivot;
            quickSort(p, low, l - 1);
            quickSort(p, l + 1, high);
        }
    }
}

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

    string arr[8] = {"1", "2", "3", "8", "7", "6", "4", "5"};
//    sort(arr, arr + 8, [](int x, int y) {return x < y;});
    quickSort(arr, 0, 7);
    for (auto i: arr) {
        cout<<i<<endl;
    }
    return 0;
}

template <typename T>
int compare(T a, T b) {
    if (a > b) {
        return 1;
    } else if (a < b) {
        return -1;
    } else {
        return 0;
    }
}

template <> int compare<const char *>(const char * a, const char * b) {
    cout<<"template <> int compare<const char *>"<<endl;
    if (strcmp(a, b)) {
        return 1;
    } else if (a < b) {
        return -1;
    } else {
        return 0;
    }
}

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

    int a = 10, b = 20;
    cout<<compare(a, b)<<endl;
    
    string sa = "abc", sb = "Abc";
    cout<<compare(sa, sb)<<endl;
    
    const char *ca = "abc", *cb = "Abc";
    cout<<compare(cb, ca)<<endl;
    
    return 0;
}

class template

template <typename T>
class Stack {
public:
    Stack(int size = 1024);
    ~Stack();
    bool isEmpty();
    bool isFull();
    void push(T data);
    T pop();
private:
    T * space;
    int top;
};

template <typename T>
Stack<T>::Stack(int size) {
    space = new T[size];
    top = 0;
}

template <typename T>
Stack<T>::~Stack() {
    delete []space;
}

template <typename T>
bool Stack<T>::isEmpty() {
    return top == 0;
}

template <typename T>
bool Stack<T>::isFull() {
    return top == 1024;
}

template <typename T>
void Stack<T>::push(T data) {
    space[top++] = data;
}

template <typename T>
T Stack<T>::pop() {
    return space[--top];
}

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

    Stack<string> s;
    s.push("aaa");
    s.push("bbb");
    s.push("ccc");

    while (!s.isEmpty()) {
        cout<<s.pop()<<endl;
    }
    
    return 0;
}

iostream

class A {
public:
    A() {}
    ~A() {}
    operator void* () const {
        cout<<"operator void* () cast to void*; ";
        return (void *)this;
    }
    bool operator!() const {
        cout<<"bool operator!() return bool; ";
        return true;
    }
};

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

    A a;
    while(a) {
        cout<<"first"<<endl;
        break;
    }
    if (!a) {
        cout<<"second"<<endl;
    }
    
    return 0;
}

operator void* () cast to void*; first
bool operator!() return bool; second
Program ended with exit code: 0

最后

更多新鲜文章可以关注并Star, 我们一起学习.

GitHub Repo：coderZsq.github.io
Follow: coderZsq · GitHub

Swift 第二梯队iOS面试败北感悟

Sat, 14 Apr 2018 01:16:00 +0000

GitHub Repo：coderZsq.target.swift
Follow: coderZsq · GitHub
Resume: https://coderzsq.github.io/coderZsq.webpack.js/#/

日常扯淡

从去年开始, 我就一直有尝试的面试些大公司, 因为对于一个半路出家(非计算机专业), 靠着MJ视频入门的iOS菜鸡玩家, 经过了3年的摸爬滚打, 终于也渐渐的可以做一些简单的前端, 后端, 移动端的交互, 但想要继续深入就感觉瓶颈越发的明显, 基础的薄弱导致很难上升, 所以能够进入一家大型成熟互联网公司就成为了我最近的目标, 原因很简单, 这是最为有效的学习成长的方式.

去年7月, 第一次面试大公司: 饿了么, 收到大公司的召唤非常的兴奋, 觉得自己翻身的机会终于要来了, 兴冲冲的跑去面试, 以为会和一般初级iOS面试的题目相同, 没有做任何的准备, 其实也不知道准备什么, 记得那时候聊的是:

UI方面: 如何避免卡顿掉帧, 异步渲染.
性能方面: 性能优化, Vsync, CPU / GPU
网络方面: 如何进行请求缓存策略.
安全方面: lild重签名, Mach-O.
前端方面: 如何避免DOM重绘.
后端方面: 如何进行负载均衡的处理.

还有一些极端的情况, 由于时间久远已经记不太清了, 反正这次面试给我的感觉就是, 靠… 我简直就是个垃圾啊~ 当时记得内推我的架构师建议我扎实一下iOS的基本功, 然后就推荐了基本书: 计算机网络, 操作系统原理, HTTP权威指南, TCP/IP权威指南, 深入解析Max OS X & iOS 操作系统… 这些书, 除了HTTP权威指南我咬着牙看完了, 其他的对于我来说简直就是天书, 根本消化不良啊.

去年12月, 第二次面试大公司: 京东, 由于有了上一次的经验, 我变得非常的淡定, 知道自己肯定会被大公司所淘汰, 和优等专业生有着不可逾越的天堑, 比较吃惊的是, 进入京东的大楼需要用身份证换取临时门禁… 那时候的面试题就比饿了么的柔和的多了, 虽然当时还是回答不出.

Runtime: isa, 消息转发, 弱引用表.
Runloop: mode, timer.
Block: __block, __forwording.
Property: assign, weak, copy.
Category: assoc, load

现在想想, 这TM才是面试iOS啊, 只可惜, 那时候并不具备这些知识, 可惜了了. 之后我就对C++, ASM, Linux, 这三方面进行了学习, 也学习了些MACH-O, 逆向的相关的知识, 以备后面的面试机会.

第三次就是这周三面试第二梯队了, 我准备了所有我能够准备的面试题内容, 底层原理, 逆向安全, 多线程与锁, 内存布局, UI性能优化等, 果不其然, 足足1个小时的电话面试, 我轻松通过, 问的就是些我准备好的底层知识, 让我觉得机会终于来了, 可是…. 当我现场面试后… 题目全部是上机题…

设计一个网络框架, 如何进行不同数据解析的设计(header, body), 并能够进行自定义, 重连机制如何处理, 状态码错误转发机制的处理, 如何避免回调地狱, 实现Promise的自实现.
根据UIControl实现UIButton….
找到两个排序数组的中位数…
pow(double, double)函数的自实现….

果然,网络, UI, 算法… 好吧, 第一次做上机题, 瞬间就蒙了… 然后就是面试官在旁边不停的笑… 不停的笑… 可能是他对我友好的一种方式吧… 最后的面试结论是, 我的知识面还是比较广的, 做过的东西也是挺多的, 但是在知识深度方面还是比较欠缺.

后来得知, 他们招聘的是技术专家的职级, 觉得我的技术水平达不到要求, 不能给与录取, 当然被拒我是当场就知道了, 也觉得美团和饿了么的两次面试经历都和我的水平相差甚远… 可是, 我只是想进入大公司学习, 就一定要成为专家才行么? 现在初中高级, 资深都不需要了, 直接专家么…, 我的猎头朋友和我说, 3-1的级别就是对标阿里P6/P7, 我选择去死啊…..

有了这次的面试经验后, 我的策略也发生了改变, 不再追求大公司的光环了, 做人开心一点不好么, 非要像机器一样思考? 活的像个算法一样是不是感觉缺少了些重要的东西? 和朋友们吹吹牛逼的日子不快活么, 偏要用功学习? 这里想到了最近听到的两句话, 最好的产品体验就是要让用户不用思考, 认知即痛苦, 无知即极乐, 人真是矛盾, 价值观的一念之差, 差之毫厘失之千里啊….

第二梯队面试题1 自实现pow(double, double)

这道题目上机的时候非常的蒙, 因为幂是double, 完全不知道如何下手, 面试官就降低难度使用整型.

解法1

func _pow_1(_ base: Int, _ exponent: Int) -> Int {

    if exponent < 0 {
        return 0
    }
    if exponent == 0 {
        return 0
    }
    if exponent == 1 {
        return base
    }
    
    var result = base
    for _ in 1..<exponent {
        result *= base
    }
    return result
}

然后, 第一次做算法题的我, 只能想到通过最为粗糙的办法解答, 就是一个循环, 我也知道这不是面试官所期许的答案, 但这有什么办法呢…

解法2

func _pow_2(_ base: Double, _ exponent: Int) -> Double {
    
    if exponent < 0 {
        return 0
    }
    if exponent == 0 {
        return 0
    }
    var ans:Double = 1, last_pow = base, exp = exponent
    
    while exp > 0 {
        if (exp & 1) != 0 {
            ans = ans * last_pow
        }
        exp = exp >> 1
        last_pow = last_pow * last_pow
    }
    return ans
}

这个是我在网上翻阅资料后的另一种看似比较好的解答方式.

解法3

func _pow_3(_ base: Double, _ exponent: Int) -> Double {

    var isNegative = false
    var exp = exponent
    if exp < 0 {
        isNegative = true
        exp = -exp
    }
    let result = _pow_2(base, exp)
    return isNegative ? 1 / result : result
}

这个仅仅是加了一个负值判断…. 但是幂是double的仍然是毫无头绪, 需要请大佬和大神不吝赐教.

第二梯队面试题2 findMedianSortedArrays

这是一道LeetCode的原题, 但是我至今还没有刷过算法题库… 也是平生第一次面试的时候遇到算法题. 题目的意思是找到两个排序数组的中位数.

解法1

func findMedianSortedArrays_1(_ array1: [Int], _ array2: [Int]) -> Double {
    
    var array = [Int]()
    array.append(contentsOf: array1)
    array.append(contentsOf: array2)
    
    quickSort(list: &array)
    
    let b = array.count % 2
    let c = array.count
    var result = 0.0;
    if  b == 1  {
        result = Double(array[c / 2])
    } else {
        let n1 = array[c / 2 - 1]
        let n2 = array[c / 2]
        result = Double((n1 + n2)) / 2.0
    }
    
    return result
}

第一次做算法题, 只能无视算法复杂度, 能够完成就算是不错了, 要什么自行车…

解法2

func findMedianSortedArrays_2(_ array1: [Int], _ array2: [Int]) -> Double {
    
    let c1 = array1.count, c2 = array2.count
    var a1 = array1, a2 = array2
    if c1 <= 0 && c2 <= 0 {
        return 0.0
    }
    
    func findKth(_ nums1: inout [Int], i: Int, _ nums2: inout [Int], j: Int, k: Int) -> Double {
        if nums1.count - i > nums2.count - j {
            return findKth(&nums2, i: j, &nums1, j: i, k: k)
        }
        if nums1.count == i {
            return Double(nums2[j + k - 1])
        }
        if k == 1 {
            return Double(min(nums1[i], nums2[j]))
        }
        let pa = min(i + k / 2, nums1.count), pb = j + k - pa + i
        if nums1[pa - 1] < nums2[pb - 1] {
            return findKth(&nums1, i: pa, &nums2, j: j, k: k - pa + i)
        } else if nums1[pa - 1] > nums2[pb - 1] {
            return findKth(&nums1, i: i, &nums2, j: pb, k: k - pb + j)
        } else {
            return Double(nums1[pa - 1])
        }
    }
    
    let total = c1 + c2
    if total % 2 == 1 {
        return findKth(&a1, i: 0, &a2, j: 0, k: total / 2 + 1)
    } else {
        return (findKth(&a1, i: 0, &a2, j: 0, k: total / 2) + findKth(&a1, i: 0, &a2, j: 0, k: total / 2 + 1)) / 2.0
    }
}

这个是我在网上查资料的时候的答案… 还没理清是个什么思路, 反正面试官提示分而治之, 掐头去尾… 也不知道是不是最优算法.

解法3

func findMedianSortedArrays_3(_ array1: [Int], _ array2: [Int]) -> Double {
    
    let total = array1.count + array2.count
    let index = total / 2
    let count = array1.count < array2.count ? array2.count : array1.count
    var array = [Int]()
    
    var i = 0, j = 0;
    for _ in 0...count {
        if array.count >= index + 1 {
            break
        }
        if array1[i] < array2[j] {
            array.append(array1[i])
            i += 1
        } else {
            array.append(array2[j])
            j += 1
        }
    }
    return total % 2 == 1 ? Double(array[index]) : Double(array[index] + array[index - 1]) * 0.5
}

这个是请教霜神(@halfrost-一缕殇流化隐半边冰霜)后给的思路, 的确很好实现. 但霜神谦虚的说不是最优解….

奇数测试

var array1 = randomList(1000001)
var array2 = randomList(1000000)
quickSort(list: &array1)
quickSort(list: &array2)
print(findMedianSortedArrays_1(array1, array2))
print(findMedianSortedArrays_2(array1, array2))
print(findMedianSortedArrays_3(array1, array2))

--- scope of: findMedianSortedArrays ---
500045.0
500045.0
500045.0

偶数测试

var array1 = randomList(1000000)
var array2 = randomList(1000000)
quickSort(list: &array1)
quickSort(list: &array2)
print(findMedianSortedArrays_1(array1, array2))
print(findMedianSortedArrays_2(array1, array2))
print(findMedianSortedArrays_3(array1, array2))

--- scope of: findMedianSortedArrays ---
499665.5
499665.5
499665.5

耗时比较

--- scope of: findMedianSortedArrays_1 ---
timing: 2.50845623016357
--- scope of: findMedianSortedArrays_2 ---
timing: 1.28746032714844e-05
--- scope of: findMedianSortedArrays_3 ---
timing: 0.0358490943908691

可以看出网上查资料的答案是三种解法里性能最高的算法, 霜神的思路和网上的答案差了三个数量级, 而我写的差了五个数量级…. 果然我写的果然是最为垃圾的算法….

解法4

@discardableResult func findMedianSortedArrays_4(_ array1: [Int], _ array2: [Int]) -> Double {
    
    if array1.count == 0 {
        if array2.count % 2 == 1 {
            return Double(array2[array2.count / 2])
        } else {
            return Double(array2[array2.count / 2] + array2[array2.count / 2 - 1]) * 0.5
        }
    } else if array2.count == 0 {
        if array1.count % 2 == 1 {
            return Double(array1[array1.count / 2])
        } else {
            return Double(array1[array1.count / 2] + array1[array1.count / 2 - 1]) * 0.5
        }
    }
    
    let total = array1.count + array2.count
    let count = array1.count < array2.count ? array1.count : array2.count
    let odd = total % 2 == 1
    
    var i = 0, j = 0, f = 1, m1 = 0.0, m2 = 0.0, result = 0.0;
    for _ in 0...count {
        if odd { array1[i] < array2[j] ? (i += 1) : (j += 1) }
        if f >= total / 2 {
            if odd {
                result = array1[i] < array2[j] ? Double(array1[i]) : Double(array2[j])
            } else {
                if array1[i] < array2[j] {
                    m1 = Double(array1[i])
                    if (i + 1) < array1.count && array1[i + 1] < array2[j] {
                        m2 = Double(array1[i + 1])
                    } else {
                        m2 = Double(array2[j])
                    }
                } else {
                    m1 = Double(array2[j])
                    if (j + 1) < array2.count && array2[j + 1] < array1[i] {
                        m2 = Double(array2[j + 1])
                    } else {
                        m2 = Double(array1[i])
                    }
                }
                result = (m1 + m2) * 0.5
            }
            break
        }
        if !odd { array1[i] < array2[j] ? (i += 1) : (j += 1) }
        f += 1
    }
    return result
}

--- scope of: findMedianSortedArrays_3 ---
timing: 0.0358932018280029
--- scope of: findMedianSortedArrays_4 ---
timing: 0.0241639614105225

沿着霜神的思路和面试官给的提示, 给出了上面的算法, 但是解法3的数量级是相同的

第二梯队面试题3 UIContorl -> UIButton

protocol ButtonInterface {
    func setTitle(_ title: String);
    func setTitleColor(_ titleColor: UIColor);
    func setTitleEdgeInsets(_ edgeInsets: UIEdgeInsets);
    func setImage(_ image: UIImage);
    func setBackgroundImage(_ image: UIImage);
    func setImageEdgeInsets(_ edgeInsets: UIEdgeInsets);
}

class Button: UIControl, ButtonInterface { 

}

以上就是面试时候的原题, 一开始根本不知道是要让我做些什么, 说是只要让我把上面的方法全部实现就好了, 就像实现一个自己的UIButton… 一开始, 我以为是要我用CALayer来实现, 吓的我瑟瑟发抖… 还好不是… 然后, 我就按照自己平时自定义控件的写法, 写了一个UIImageView, 一个UILabel, 然后布局赋值… 就看到面试官对着我笑着说, 你以为这道题这么简单么… 这么简单么…

然后说, 你知道UIButton setTitle的时候才会创建UILabel, setImage的时候才会创建UIImageView, 你为什么吧frame给写死… 不知道UIView有sizeToFit么, 你怎么不实现sizeThatFits, 你是完全不会用吧… 你知道UIButton用AutoLayout布局的时候只要设置origin坐标, 宽高就可以自适应了, 你自定义的时候怎么不实现呢? setBackgroundImage和setImageEdgeInsets你就不要做了吧, 反正你也不会…

我想说的是,谁没事放着UIButton不用, 用UIContorl这种东西… 就为了一个target-action的设计模式么… 我每次在想思路的时候一直打断我, 可能这是面试官的一种策略吧… 算了不吐槽了, 还是尽力实现吧.

import UIKit

protocol ButtonInterface {
    func setTitle(_ title: String);
    func setTitleColor(_ titleColor: UIColor);
    func setTitleEdgeInsets(_ edgeInsets: UIEdgeInsets);
    func setImage(_ image: UIImage);
    func setBackgroundImage(_ image: UIImage);
    func setImageEdgeInsets(_ edgeInsets: UIEdgeInsets);
}

class Button: UIControl, ButtonInterface {

    lazy var titleLabel: UILabel = UILabel()
    lazy var imageView: UIImageView = UIImageView()
    lazy var backgroundImageView: UIImageView = UIImageView()
    
    var titleLabelIsCreated = false
    var imageViewIsCreated = false
    var backgroundImageViewCreated = false
    
    internal func setTitle(_ text: String) {
        if !titleLabelIsCreated {
            addSubview(titleLabel)
            titleLabelIsCreated = true
        }
        titleLabel.text = text
    }

    internal func setTitleColor(_ textColor: UIColor) {
        if !titleLabelIsCreated {
            return
        }
        titleLabel.textColor = textColor
    }
    
    internal func setTitleEdgeInsets(_ edgeInsets: UIEdgeInsets) {
        if !titleLabelIsCreated {
            return
        }
    }
    
    internal func setImage(_ image: UIImage) {
        if !imageViewIsCreated {
            addSubview(imageView)
            imageViewIsCreated = true
        }
        imageView.image = image
    }
    
    internal func setBackgroundImage(_ image: UIImage) {
        if !backgroundImageViewCreated {
            addSubview(backgroundImageView)
            insertSubview(backgroundImageView, at: 0)
            backgroundImageViewCreated = true
        }
        backgroundImageView.image = image
    }
    
    internal func setImageEdgeInsets(_ edgeInsets: UIEdgeInsets) {
        if !imageViewIsCreated {
            return
        }
    }
    
    override func sizeThatFits(_ size: CGSize) -> CGSize {
        if titleLabelIsCreated && !imageViewIsCreated && !backgroundImageViewCreated {
            let text: NSString? = titleLabel.text as NSString?
            let titleLabelW: CGFloat = text?.boundingRect(with: CGSize(width: CGFloat(MAXFLOAT), height: bounds.height), options: NSStringDrawingOptions.usesLineFragmentOrigin, attributes: [NSAttributedStringKey.font : titleLabel.font], context: nil).size.width ?? 0.0
            let titleLabelH: CGFloat = text?.boundingRect(with: CGSize(width: titleLabelW, height: CGFloat(MAXFLOAT)), options: NSStringDrawingOptions.usesLineFragmentOrigin, attributes: [NSAttributedStringKey.font : titleLabel.font], context: nil).size.height ?? 0.0
            return CGSize(width: titleLabelW, height: titleLabelH + 10)
        } else if !titleLabelIsCreated && imageViewIsCreated {
            return imageView.image?.size ?? CGSize.zero
        } else if titleLabelIsCreated && imageViewIsCreated {
            let text: NSString? = titleLabel.text as NSString?
            let titleLabelW: CGFloat = text?.boundingRect(with: CGSize(width: CGFloat(MAXFLOAT), height: bounds.height), options: NSStringDrawingOptions.usesLineFragmentOrigin, attributes: [NSAttributedStringKey.font : titleLabel.font], context: nil).size.width ?? 0.0
            let titleLabelH: CGFloat = text?.boundingRect(with: CGSize(width: titleLabelW, height: CGFloat(MAXFLOAT)), options: NSStringDrawingOptions.usesLineFragmentOrigin, attributes: [NSAttributedStringKey.font : titleLabel.font], context: nil).size.height ?? 0.0
            let imageViewW: CGFloat = imageView.image?.size.width ?? 0.0
            let imageViewH: CGFloat = imageView.image?.size.height ?? 0.0
            return CGSize(width: titleLabelW + imageViewW, height: imageViewH > titleLabelH ? imageViewH : titleLabelH)
        } else {
            return backgroundImageView.image?.size ?? CGSize.zero
        }
    }
    
    override func layoutSubviews() {
        super.layoutSubviews()

        if titleLabelIsCreated && !imageViewIsCreated {
            titleLabel.frame = bounds
            titleLabel.textAlignment = .center
        } else if !titleLabelIsCreated && imageViewIsCreated {
            let y: CGFloat = 0;
            let width: CGFloat = imageView.image?.size.width ?? 0;
            let x: CGFloat = (bounds.width - width) * 0.5;
            let height: CGFloat = bounds.height;
            imageView.frame = CGRect(x: x, y: y, width: width, height: height)
        } else if titleLabelIsCreated && imageViewIsCreated {
            let imageViewY: CGFloat = 0;
            let imageViewW: CGFloat = imageView.image?.size.width ?? 0;
            let imageViewH: CGFloat = bounds.height;
            let text: NSString? = titleLabel.text as NSString?
            let titleLabelW: CGFloat = text?.boundingRect(with: CGSize(width: CGFloat(MAXFLOAT), height: bounds.height), options: NSStringDrawingOptions.usesLineFragmentOrigin, attributes: [NSAttributedStringKey.font : titleLabel.font], context: nil).size.width ?? 0.0
            let titleLabelH: CGFloat = text?.boundingRect(with: CGSize(width: titleLabelW, height: CGFloat(MAXFLOAT)), options: NSStringDrawingOptions.usesLineFragmentOrigin, attributes: [NSAttributedStringKey.font : titleLabel.font], context: nil).size.height ?? 0.0
            let imageViewX: CGFloat = (bounds.width - imageViewW - titleLabelW) * 0.5;
            let titleLabelX: CGFloat = imageViewX + imageViewW
            let titleLabelY = (bounds.height - titleLabelH) * 0.5
            titleLabel.frame = CGRect(x: titleLabelX, y: titleLabelY, width: titleLabelW, height: titleLabelH)
            imageView.frame = CGRect(x: imageViewX, y: imageViewY, width: imageViewW, height: imageViewH)
        }
        
        if backgroundImageViewCreated {
            backgroundImageView.frame = bounds
        }
    }
}

虽然实现了部分的功能, 但是AutoLayout和EdgeInsets的功能还是没有思路, 还请各位大佬解惑.

测试对比

我们用自己自实现的Button和UIButton进行对比.

class ViewController: UIViewController {

    override func loadView() {
        super.loadView();
        
        let uibutton = UIButton()
        uibutton.layer.borderWidth = 1
        uibutton.layer.borderColor = UIColor.black.cgColor
        
        uibutton.frame = CGRect(x: 0, y: 100, width: view.bounds.width, height: 40)
        uibutton.setTitle("github.com/coderZsq", for: .normal)
        uibutton.setTitleColor(.red, for: .normal)
        uibutton.titleEdgeInsets = UIEdgeInsetsMake(0, 0, 0, 0)
        uibutton.setImage(UIImage(named: "avatar"), for: .normal)
        uibutton.setBackgroundImage(UIImage(named: "avatar"), for: .normal)
        uibutton.imageEdgeInsets = UIEdgeInsetsMake(-10, -10, -10, -10)
        view.addSubview(uibutton)
        uibutton.sizeToFit()
        
        let button = Button()
        button.layer.borderWidth = 1
        button.layer.borderColor = UIColor.black.cgColor
        
        button.frame = CGRect(x: 0, y: 350, width: view.bounds.width, height: 40)
        button.setTitle("github.com/coderZsq")
        button.setTitleColor(.red)
        button.setTitleEdgeInsets(UIEdgeInsetsMake(0, 0, 0, 0))
        button.setImage(UIImage(named: "avatar") ?? UIImage());
        button.setBackgroundImage(UIImage(named: "avatar") ?? UIImage())
        button.setImageEdgeInsets(UIEdgeInsetsMake(0, 0, 0, 0))
        view.addSubview(button)
        button.sizeToFit()
    }
}

zero impl

        let uibutton = UIButton()
        uibutton.layer.borderWidth = 1
        uibutton.layer.borderColor = UIColor.black.cgColor
        
        uibutton.frame = CGRect(x: 0, y: 100, width: view.bounds.width, height: 40)
//        uibutton.setTitle("github.com/coderZsq", for: .normal)
//        uibutton.setTitleColor(.red, for: .normal)
//        uibutton.titleEdgeInsets = UIEdgeInsetsMake(0, 0, 0, 0)
//        uibutton.setImage(UIImage(named: "avatar"), for: .normal)
//        uibutton.setBackgroundImage(UIImage(named: "avatar"), for: .normal)
//        uibutton.imageEdgeInsets = UIEdgeInsetsMake(-10, -10, -10, -10)
        view.addSubview(uibutton)
//        uibutton.sizeToFit()
        
        let button = Button()
        button.layer.borderWidth = 1
        button.layer.borderColor = UIColor.black.cgColor
        
        button.frame = CGRect(x: 0, y: 350, width: view.bounds.width, height: 40)
//        button.setTitle("github.com/coderZsq")
//        button.setTitleColor(.red)
//        button.setTitleEdgeInsets(UIEdgeInsetsMake(0, 0, 0, 0))
//        button.setImage(UIImage(named: "avatar") ?? UIImage());
//        button.setBackgroundImage(UIImage(named: "avatar") ?? UIImage())
//        button.setImageEdgeInsets(UIEdgeInsetsMake(0, 0, 0, 0))
        view.addSubview(button)
//        button.sizeToFit()

setTitle && setTitleColor

        let uibutton = UIButton()
        uibutton.layer.borderWidth = 1
        uibutton.layer.borderColor = UIColor.black.cgColor
        
        uibutton.frame = CGRect(x: 0, y: 100, width: view.bounds.width, height: 40)
        uibutton.setTitle("github.com/coderZsq", for: .normal)
        uibutton.setTitleColor(.red, for: .normal)
//        uibutton.titleEdgeInsets = UIEdgeInsetsMake(0, 0, 0, 0)
//        uibutton.setImage(UIImage(named: "avatar"), for: .normal)
//        uibutton.setBackgroundImage(UIImage(named: "avatar"), for: .normal)
//        uibutton.imageEdgeInsets = UIEdgeInsetsMake(-10, -10, -10, -10)
        view.addSubview(uibutton)
//        uibutton.sizeToFit()
        
        let button = Button()
        button.layer.borderWidth = 1
        button.layer.borderColor = UIColor.black.cgColor
        
        button.frame = CGRect(x: 0, y: 350, width: view.bounds.width, height: 40)
        button.setTitle("github.com/coderZsq")
        button.setTitleColor(.red)
//        button.setTitleEdgeInsets(UIEdgeInsetsMake(0, 0, 0, 0))
//        button.setImage(UIImage(named: "avatar") ?? UIImage());
//        button.setBackgroundImage(UIImage(named: "avatar") ?? UIImage())
//        button.setImageEdgeInsets(UIEdgeInsetsMake(0, 0, 0, 0))
        view.addSubview(button)
//        button.sizeToFit()
    }

setTitle && setTitleColor && sizeToFit

        let uibutton = UIButton()
        uibutton.layer.borderWidth = 1
        uibutton.layer.borderColor = UIColor.black.cgColor
        
        uibutton.frame = CGRect(x: 0, y: 100, width: view.bounds.width, height: 40)
        uibutton.setTitle("github.com/coderZsq", for: .normal)
        uibutton.setTitleColor(.red, for: .normal)
//        uibutton.titleEdgeInsets = UIEdgeInsetsMake(0, 0, 0, 0)
//        uibutton.setImage(UIImage(named: "avatar"), for: .normal)
//        uibutton.setBackgroundImage(UIImage(named: "avatar"), for: .normal)
//        uibutton.imageEdgeInsets = UIEdgeInsetsMake(-10, -10, -10, -10)
        view.addSubview(uibutton)
        uibutton.sizeToFit()
        
        let button = Button()
        button.layer.borderWidth = 1
        button.layer.borderColor = UIColor.black.cgColor
        
        button.frame = CGRect(x: 0, y: 350, width: view.bounds.width, height: 40)
        button.setTitle("github.com/coderZsq")
        button.setTitleColor(.red)
//        button.setTitleEdgeInsets(UIEdgeInsetsMake(0, 0, 0, 0))
//        button.setImage(UIImage(named: "avatar") ?? UIImage());
//        button.setBackgroundImage(UIImage(named: "avatar") ?? UIImage())
//        button.setImageEdgeInsets(UIEdgeInsetsMake(0, 0, 0, 0))
        view.addSubview(button)
        button.sizeToFit()

setImage

        let uibutton = UIButton()
        uibutton.layer.borderWidth = 1
        uibutton.layer.borderColor = UIColor.black.cgColor
        
        uibutton.frame = CGRect(x: 0, y: 100, width: view.bounds.width, height: 40)
//        uibutton.setTitle("github.com/coderZsq", for: .normal)
//        uibutton.setTitleColor(.red, for: .normal)
//        uibutton.titleEdgeInsets = UIEdgeInsetsMake(0, 0, 0, 0)
        uibutton.setImage(UIImage(named: "avatar"), for: .normal)
//        uibutton.setBackgroundImage(UIImage(named: "avatar"), for: .normal)
//        uibutton.imageEdgeInsets = UIEdgeInsetsMake(-10, -10, -10, -10)
        view.addSubview(uibutton)
//        uibutton.sizeToFit()
        
        let button = Button()
        button.layer.borderWidth = 1
        button.layer.borderColor = UIColor.black.cgColor
        
        button.frame = CGRect(x: 0, y: 350, width: view.bounds.width, height: 40)
//        button.setTitle("github.com/coderZsq")
//        button.setTitleColor(.red)
//        button.setTitleEdgeInsets(UIEdgeInsetsMake(0, 0, 0, 0))
        button.setImage(UIImage(named: "avatar") ?? UIImage());
//        button.setBackgroundImage(UIImage(named: "avatar") ?? UIImage())
//        button.setImageEdgeInsets(UIEdgeInsetsMake(0, 0, 0, 0))
        view.addSubview(button)
//        button.sizeToFit()

setImage && sizeToFit

        let uibutton = UIButton()
        uibutton.layer.borderWidth = 1
        uibutton.layer.borderColor = UIColor.black.cgColor
        
        uibutton.frame = CGRect(x: 0, y: 100, width: view.bounds.width, height: 40)
//        uibutton.setTitle("github.com/coderZsq", for: .normal)
//        uibutton.setTitleColor(.red, for: .normal)
//        uibutton.titleEdgeInsets = UIEdgeInsetsMake(0, 0, 0, 0)
        uibutton.setImage(UIImage(named: "avatar"), for: .normal)
//        uibutton.setBackgroundImage(UIImage(named: "avatar"), for: .normal)
//        uibutton.imageEdgeInsets = UIEdgeInsetsMake(-10, -10, -10, -10)
        view.addSubview(uibutton)
        uibutton.sizeToFit()
        
        let button = Button()
        button.layer.borderWidth = 1
        button.layer.borderColor = UIColor.black.cgColor
        
        button.frame = CGRect(x: 0, y: 350, width: view.bounds.width, height: 40)
//        button.setTitle("github.com/coderZsq")
//        button.setTitleColor(.red)
//        button.setTitleEdgeInsets(UIEdgeInsetsMake(0, 0, 0, 0))
        button.setImage(UIImage(named: "avatar") ?? UIImage());
//        button.setBackgroundImage(UIImage(named: "avatar") ?? UIImage())
//        button.setImageEdgeInsets(UIEdgeInsetsMake(0, 0, 0, 0))
        view.addSubview(button)
        button.sizeToFit()

setBackgroundImage

        let uibutton = UIButton()
        uibutton.layer.borderWidth = 1
        uibutton.layer.borderColor = UIColor.black.cgColor
        
        uibutton.frame = CGRect(x: 0, y: 100, width: view.bounds.width, height: 40)
//        uibutton.setTitle("github.com/coderZsq", for: .normal)
//        uibutton.setTitleColor(.red, for: .normal)
//        uibutton.titleEdgeInsets = UIEdgeInsetsMake(0, 0, 0, 0)
//        uibutton.setImage(UIImage(named: "avatar"), for: .normal)
        uibutton.setBackgroundImage(UIImage(named: "avatar"), for: .normal)
//        uibutton.imageEdgeInsets = UIEdgeInsetsMake(-10, -10, -10, -10)
        view.addSubview(uibutton)
//        uibutton.sizeToFit()
        
        let button = Button()
        button.layer.borderWidth = 1
        button.layer.borderColor = UIColor.black.cgColor
        
        button.frame = CGRect(x: 0, y: 350, width: view.bounds.width, height: 40)
//        button.setTitle("github.com/coderZsq")
//        button.setTitleColor(.red)
//        button.setTitleEdgeInsets(UIEdgeInsetsMake(0, 0, 0, 0))
//        button.setImage(UIImage(named: "avatar") ?? UIImage());
        button.setBackgroundImage(UIImage(named: "avatar") ?? UIImage())
//        button.setImageEdgeInsets(UIEdgeInsetsMake(0, 0, 0, 0))
        view.addSubview(button)
//        button.sizeToFit()

这里, 我们看到和系统的实现不一样, 因为我直接在渲染(display)设置了bitmap, 而不是像系统添加了一个新的view. 这样的性能消耗会少些… (以修改为了下面的问题)

setBackgroundImage && sizeToFit

        let uibutton = UIButton()
        uibutton.layer.borderWidth = 1
        uibutton.layer.borderColor = UIColor.black.cgColor
        
        uibutton.frame = CGRect(x: 0, y: 100, width: view.bounds.width, height: 40)
//        uibutton.setTitle("github.com/coderZsq", for: .normal)
//        uibutton.setTitleColor(.red, for: .normal)
//        uibutton.titleEdgeInsets = UIEdgeInsetsMake(0, 0, 0, 0)
//        uibutton.setImage(UIImage(named: "avatar"), for: .normal)
        uibutton.setBackgroundImage(UIImage(named: "avatar"), for: .normal)
//        uibutton.imageEdgeInsets = UIEdgeInsetsMake(-10, -10, -10, -10)
        view.addSubview(uibutton)
        uibutton.sizeToFit()
        
        let button = Button()
        button.layer.borderWidth = 1
        button.layer.borderColor = UIColor.black.cgColor
        
        button.frame = CGRect(x: 0, y: 350, width: view.bounds.width, height: 40)
//        button.setTitle("github.com/coderZsq")
//        button.setTitleColor(.red)
//        button.setTitleEdgeInsets(UIEdgeInsetsMake(0, 0, 0, 0))
//        button.setImage(UIImage(named: "avatar") ?? UIImage());
        button.setBackgroundImage(UIImage(named: "avatar") ?? UIImage())
//        button.setImageEdgeInsets(UIEdgeInsetsMake(0, 0, 0, 0))
        view.addSubview(button)
        button.sizeToFit()

setTitle && setTitleColor && setImage

        let uibutton = UIButton()
        uibutton.layer.borderWidth = 1
        uibutton.layer.borderColor = UIColor.black.cgColor
        
        uibutton.frame = CGRect(x: 0, y: 100, width: view.bounds.width, height: 40)
        uibutton.setTitle("github.com/coderZsq", for: .normal)
        uibutton.setTitleColor(.red, for: .normal)
//        uibutton.titleEdgeInsets = UIEdgeInsetsMake(0, 0, 0, 0)
        uibutton.setImage(UIImage(named: "avatar"), for: .normal)
//        uibutton.setBackgroundImage(UIImage(named: "avatar"), for: .normal)
//        uibutton.imageEdgeInsets = UIEdgeInsetsMake(-10, -10, -10, -10)
        view.addSubview(uibutton)
//        uibutton.sizeToFit()
        
        let button = Button()
        button.layer.borderWidth = 1
        button.layer.borderColor = UIColor.black.cgColor
        
        button.frame = CGRect(x: 0, y: 350, width: view.bounds.width, height: 40)
        button.setTitle("github.com/coderZsq")
        button.setTitleColor(.red)
//        button.setTitleEdgeInsets(UIEdgeInsetsMake(0, 0, 0, 0))
        button.setImage(UIImage(named: "avatar") ?? UIImage());
//        button.setBackgroundImage(UIImage(named: "avatar") ?? UIImage())
//        button.setImageEdgeInsets(UIEdgeInsetsMake(0, 0, 0, 0))
        view.addSubview(button)
//        button.sizeToFit()

setTitle && setTitleColor && setImage && sizeToFit

        let uibutton = UIButton()
        uibutton.layer.borderWidth = 1
        uibutton.layer.borderColor = UIColor.black.cgColor
        
        uibutton.frame = CGRect(x: 0, y: 100, width: view.bounds.width, height: 40)
        uibutton.setTitle("github.com/coderZsq", for: .normal)
        uibutton.setTitleColor(.red, for: .normal)
//        uibutton.titleEdgeInsets = UIEdgeInsetsMake(0, 0, 0, 0)
        uibutton.setImage(UIImage(named: "avatar"), for: .normal)
//        uibutton.setBackgroundImage(UIImage(named: "avatar"), for: .normal)
//        uibutton.imageEdgeInsets = UIEdgeInsetsMake(-10, -10, -10, -10)
        view.addSubview(uibutton)
        uibutton.sizeToFit()
        
        let button = Button()
        button.layer.borderWidth = 1
        button.layer.borderColor = UIColor.black.cgColor
        
        button.frame = CGRect(x: 0, y: 350, width: view.bounds.width, height: 40)
        button.setTitle("github.com/coderZsq")
        button.setTitleColor(.red)
//        button.setTitleEdgeInsets(UIEdgeInsetsMake(0, 0, 0, 0))
        button.setImage(UIImage(named: "avatar") ?? UIImage());
//        button.setBackgroundImage(UIImage(named: "avatar") ?? UIImage())
//        button.setImageEdgeInsets(UIEdgeInsetsMake(0, 0, 0, 0))
        view.addSubview(button)
        button.sizeToFit()

setTitle && setTitleColor && setBackgroundImage

        let uibutton = UIButton()
        uibutton.layer.borderWidth = 1
        uibutton.layer.borderColor = UIColor.black.cgColor
        
        uibutton.frame = CGRect(x: 0, y: 100, width: view.bounds.width, height: 40)
        uibutton.setTitle("github.com/coderZsq", for: .normal)
        uibutton.setTitleColor(.red, for: .normal)
//        uibutton.titleEdgeInsets = UIEdgeInsetsMake(0, 0, 0, 0)
//        uibutton.setImage(UIImage(named: "avatar"), for: .normal)
        uibutton.setBackgroundImage(UIImage(named: "avatar"), for: .normal)
//        uibutton.imageEdgeInsets = UIEdgeInsetsMake(-10, -10, -10, -10)
        view.addSubview(uibutton)
//        uibutton.sizeToFit()
        
        let button = Button()
        button.layer.borderWidth = 1
        button.layer.borderColor = UIColor.black.cgColor
        
        button.frame = CGRect(x: 0, y: 350, width: view.bounds.width, height: 40)
        button.setTitle("github.com/coderZsq")
        button.setTitleColor(.red)
//        button.setTitleEdgeInsets(UIEdgeInsetsMake(0, 0, 0, 0))
//        button.setImage(UIImage(named: "avatar") ?? UIImage());
        button.setBackgroundImage(UIImage(named: "avatar") ?? UIImage())
//        button.setImageEdgeInsets(UIEdgeInsetsMake(0, 0, 0, 0))
        view.addSubview(button)
//        button.sizeToFit()

setTitle && setTitleColor && setBackgroundImage && sizeToFit

        let uibutton = UIButton()
        uibutton.layer.borderWidth = 1
        uibutton.layer.borderColor = UIColor.black.cgColor
        
        uibutton.frame = CGRect(x: 0, y: 100, width: view.bounds.width, height: 40)
        uibutton.setTitle("github.com/coderZsq", for: .normal)
        uibutton.setTitleColor(.red, for: .normal)
//        uibutton.titleEdgeInsets = UIEdgeInsetsMake(0, 0, 0, 0)
//        uibutton.setImage(UIImage(named: "avatar"), for: .normal)
        uibutton.setBackgroundImage(UIImage(named: "avatar"), for: .normal)
//        uibutton.imageEdgeInsets = UIEdgeInsetsMake(-10, -10, -10, -10)
        view.addSubview(uibutton)
        uibutton.sizeToFit()
        
        let button = Button()
        button.layer.borderWidth = 1
        button.layer.borderColor = UIColor.black.cgColor
        
        button.frame = CGRect(x: 0, y: 350, width: view.bounds.width, height: 40)
        button.setTitle("github.com/coderZsq")
        button.setTitleColor(.red)
//        button.setTitleEdgeInsets(UIEdgeInsetsMake(0, 0, 0, 0))
//        button.setImage(UIImage(named: "avatar") ?? UIImage());
        button.setBackgroundImage(UIImage(named: "avatar") ?? UIImage())
//        button.setImageEdgeInsets(UIEdgeInsetsMake(0, 0, 0, 0))
        view.addSubview(button)
        button.sizeToFit()

setTitle && setTitleColor && setImage && setBackgroundImage

        let uibutton = UIButton()
        uibutton.layer.borderWidth = 1
        uibutton.layer.borderColor = UIColor.black.cgColor
        
        uibutton.frame = CGRect(x: 0, y: 100, width: view.bounds.width, height: 40)
        uibutton.setTitle("github.com/coderZsq", for: .normal)
        uibutton.setTitleColor(.red, for: .normal)
//        uibutton.titleEdgeInsets = UIEdgeInsetsMake(0, 0, 0, 0)
        uibutton.setImage(UIImage(named: "avatar"), for: .normal)
        uibutton.setBackgroundImage(UIImage(named: "avatar"), for: .normal)
//        uibutton.imageEdgeInsets = UIEdgeInsetsMake(-10, -10, -10, -10)
        view.addSubview(uibutton)
//        uibutton.sizeToFit()
        
        let button = Button()
        button.layer.borderWidth = 1
        button.layer.borderColor = UIColor.black.cgColor
        
        button.frame = CGRect(x: 0, y: 350, width: view.bounds.width, height: 40)
        button.setTitle("github.com/coderZsq")
        button.setTitleColor(.red)
//        button.setTitleEdgeInsets(UIEdgeInsetsMake(0, 0, 0, 0))
        button.setImage(UIImage(named: "avatar") ?? UIImage());
        button.setBackgroundImage(UIImage(named: "avatar") ?? UIImage())
//        button.setImageEdgeInsets(UIEdgeInsetsMake(0, 0, 0, 0))
        view.addSubview(button)
//        button.sizeToFit()

setTitle && setTitleColor && setImage && setBackgroundImage && sizeToFit

        let uibutton = UIButton()
        uibutton.layer.borderWidth = 1
        uibutton.layer.borderColor = UIColor.black.cgColor
        
        uibutton.frame = CGRect(x: 0, y: 100, width: view.bounds.width, height: 40)
        uibutton.setTitle("github.com/coderZsq", for: .normal)
        uibutton.setTitleColor(.red, for: .normal)
//        uibutton.titleEdgeInsets = UIEdgeInsetsMake(0, 0, 0, 0)
        uibutton.setImage(UIImage(named: "avatar"), for: .normal)
        uibutton.setBackgroundImage(UIImage(named: "avatar"), for: .normal)
//        uibutton.imageEdgeInsets = UIEdgeInsetsMake(-10, -10, -10, -10)
        view.addSubview(uibutton)
        uibutton.sizeToFit()
        
        let button = Button()
        button.layer.borderWidth = 1
        button.layer.borderColor = UIColor.black.cgColor
        
        button.frame = CGRect(x: 0, y: 350, width: view.bounds.width, height: 40)
        button.setTitle("github.com/coderZsq")
        button.setTitleColor(.red)
//        button.setTitleEdgeInsets(UIEdgeInsetsMake(0, 0, 0, 0))
        button.setImage(UIImage(named: "avatar") ?? UIImage());
        button.setBackgroundImage(UIImage(named: "avatar") ?? UIImage())
//        button.setImageEdgeInsets(UIEdgeInsetsMake(0, 0, 0, 0))
        view.addSubview(button)
        button.sizeToFit()

这道题还没有实现的就是AutoLayout和EdgeInsets, 还有就是在sizeToFit算的最佳尺寸和系统的最佳尺寸有细微出入, 还有就是UIImageView和UILabel的先后加载的问题.

update

    lazy var titleLabel: UILabel =  {
        let titleLabel = UILabel()
        titleLabel.font = UIFont.systemFont(ofSize: 18)
        titleLabel.textAlignment = .center
        return titleLabel
    }()

对于在sizeToFit算的最佳尺寸和系统的最佳尺寸有细微出入 这个问题是UILabel的默认系统字体大小是17, 而UIButton中的titleLabel的字体大小是18.

    internal func setImage(_ image: UIImage) {
        if !imageViewIsCreated {
            addSubview(imageView)
            if titleLabelIsCreated {
                insertSubview(imageView, belowSubview: titleLabel)
            }
            imageViewIsCreated = true
        }
        imageView.image = image
    }

对于UIImageView和UILabel的先后加载的问题, 需要在setImage时判断titleLabel是否存在即可

现已达到完全相同, 接下来就是要解决AutoLayout和EdgeInsets的问题.

update2

通过 nib 进行创建..

实现方法:

1.判断是否是从nib中创建

    var createdFromNib = false
    
    override init(frame: CGRect) {
        super.init(frame: frame)
    }
    
    required init?(coder aDecoder: NSCoder) {
        super.init(coder: aDecoder)
        createdFromNib = true
    }

2.重写系统实现函数intrinsicContentSize并返回最佳尺寸

    override var intrinsicContentSize: CGSize {
        return bestSize()
    }
    
    func bestSize() -> CGSize {
        if titleLabelIsCreated && !imageViewIsCreated && !backgroundImageViewCreated {
            let text: NSString? = titleLabel.text as NSString?
            let titleLabelW: CGFloat = text?.boundingRect(with: CGSize(width: CGFloat(MAXFLOAT), height: bounds.height), options: NSStringDrawingOptions.usesLineFragmentOrigin, attributes: [NSAttributedStringKey.font : titleLabel.font], context: nil).size.width ?? 0.0
            let titleLabelH: CGFloat = text?.boundingRect(with: CGSize(width: titleLabelW, height: CGFloat(MAXFLOAT)), options: NSStringDrawingOptions.usesLineFragmentOrigin, attributes: [NSAttributedStringKey.font : titleLabel.font], context: nil).size.height ?? 0.0
            return CGSize(width: titleLabelW, height: titleLabelH + 10)
        } else if !titleLabelIsCreated && imageViewIsCreated {
            return imageView.image?.size ?? CGSize.zero
        } else if titleLabelIsCreated && imageViewIsCreated {
            let text: NSString? = titleLabel.text as NSString?
            let titleLabelW: CGFloat = text?.boundingRect(with: CGSize(width: CGFloat(MAXFLOAT), height: bounds.height), options: NSStringDrawingOptions.usesLineFragmentOrigin, attributes: [NSAttributedStringKey.font : titleLabel.font], context: nil).size.width ?? 0.0
            let titleLabelH: CGFloat = text?.boundingRect(with: CGSize(width: titleLabelW, height: CGFloat(MAXFLOAT)), options: NSStringDrawingOptions.usesLineFragmentOrigin, attributes: [NSAttributedStringKey.font : titleLabel.font], context: nil).size.height ?? 0.0
            let imageViewW: CGFloat = imageView.image?.size.width ?? 0.0
            let imageViewH: CGFloat = imageView.image?.size.height ?? 0.0
            return CGSize(width: titleLabelW + imageViewW, height: imageViewH > titleLabelH ? imageViewH : titleLabelH)
        } else {
            return backgroundImageView.image?.size ?? CGSize.zero
        }
    }

3.布局时判断即可

    override func layoutSubviews() {
        super.layoutSubviews()

        if createdFromNib {
            frame.size = intrinsicContentSize
        }
        ...
   }

4.测试一下, 不加sizetofit

        nib_button.layer.borderWidth = 1
        nib_button.layer.borderColor = UIColor.black.cgColor
        
        nib_button.setTitle("github.com/coderZsq")
        nib_button.setTitleColor(.red)
//        nib_button.setTitleEdgeInsets(.zero)
        nib_button.setImage(UIImage(named: "avatar") ?? UIImage())
//        nib_button.setBackgroundImage(UIImage(named: "avatar") ?? UIImage())
        nib_button.setImageEdgeInsets(.zero)

一样的完美, 攻克了AutoLayout, 接下来就是EdgeInsets啦~~~

update3

一直理解错了, intrinsicContentSize 这个方法是在添加约束后生效, 不管是nib还是手动约束, 都会生效.

所以update2中只需实现第二步即可, 并不需要其他的判断.

第二梯队面试题4 网络架构实现

这道题真是戳中我的软肋, 网络与多线程是我最为薄弱的地方, 现在对线程的理解应该已经不错了, 但是网络还是有所欠缺的, 所以, 我会在今后学习Linux和精读AFNetWorking && SDWebImage后, 自己写一个网络架构来进行自我提升.

第二梯队面试总结

对于两道算法题, 我没有什么太多想讲的, 技不如人吧, 可是算法题这种东西在iOS上用处其实不是很大, 我就不信那些没有刷过算法题的同学, 面对一道从没有见过的算法题能够一下子从容的写出最优解的. 还有就是UI的那道题目, 坑吧, 谁会去放着好好的现成的不用, 去恶心自己, 还一定要一样… 我都问过面试官好几遍, 到底想要做什么功能… 回答只有, 我不在乎你怎么写, 只要和系统的一样就好了…. 产品附体了么….

好吧… 技不如人, 被挂了也是理所当然… 不会找什么借口… 听美团的朋友说, 现在只招技术专家, 其他低职级的名额紧缩都不招了… 诶… 随缘吧…

最后本文中所有的源码都可以在github上找到:

GitHub Repo：coderZsq.target.swift
Follow: coderZsq · GitHub
Resume: https://coderzsq.github.io/coderZsq.webpack.js/#/

C++ 一把剖析OC底层的军刀

Sat, 17 Mar 2018 14:16:00 +0000

GitHub Repo：coderZsq.github.io
Follow: coderZsq · GitHub
Resume: https://coderzsq.github.io/coderZsq.webpack.js/#/

日常扯淡

明天就要出国了, 所以本来想将.md的旅行攻略放到网上共享的, 就使用了简书的.md编译器, 没想到的是, 用完之后我的账号就被冻结了….

尊敬的简书用户您好，由于您有可能违反了简书社区管理规定（包括但不仅限于违反法律法规，不友善行为，发布垃圾信息，恶意行为如简信滋扰），具体可查看《「简书」指导原则和管理细则》http://dwz.cn/3BcYrg 和《简书社区指导规则》http://dwz.cn/3BcZi1 ，现根据情节严重程度，给予您冻结账户的惩罚，冻结期间帐号无法发表和编辑任何内容，您的数据将会为您保留60天，在此期间您可以备份您的文章，钱包里如有余额可及时提现，如您对结果处理有异议，也可联系邮箱 help@jianshu.com ，60天后将会直接注销您的账号并删除所有数据

真是的… 现在简书给我的印象是越来越差了, 随随便便写一点水文都有上千的阅读量, 而现在那个事件之后, 许多大佬的出走, 简书也可能对程序员这个群体不再重视了吧, 所以以后的文章会陆续发在掘金上. 简书的账号可能会在60天之后被删除吧… 也无所谓了…反正我已经全部迁移到githubpages上去了. 有兴趣的同学可以star关注.

上周我们就简单了解了, C和C++之间的差异为切入点, 而有了上周的基础, 这次, 我们就能够更加深入的理解OC的底层实现原理了.

C++ 作者的建议

在C++中几乎不需要用宏, 用const和enum定义显式的常量, 用inline避免函数调用的额外开销, 用模板去刻画一组函数或类型, 用namespace去避免命名冲突.
不要在你需要变量之前去声明, 以保证你能立即对它进行初始化.
不要用malloc, new运算会做的更好.
避免使用void*, 指针算数, 联合和强制, 大多数情况下, 强制类型转换是设计错误的指示器.
尽量少用数组和C风格的字符串, 标准库中的string和vector可以简化程序.
更加重要的是, 试着将程序考虑为一组由类和对象表示的互相作用的概念年, 而不是一堆数据结构和一些可以拨弄的二进制.

自实现 string

string本质其实就是对char * 的包装, 而NSString也是如此.

int sq_strlen(const char * str) {
    int len = 0;
    while (*str++)
        len++;
    return len;
}

char * sq_strcpy(char * dst, const char * src) {
    char * d = dst;
    while ((*dst++ = *src++));
    return d;
}

int sq_strcmp(const char * str1, const char * str2) {
    for (; *str1 && *str2; str1++, str2++) {
        if (*str1 == *str2) {
            continue;
        } else {
            return *str1 - *str2;
        }
    }
    return *str1 - *str2;
}

char * sq_strcat(char * dst, const char * src) {
    char * d = dst;
    while (*dst)
        dst++;
    while ((*dst++ = *src++));
    return d;
}

我们先来自实现一下<string.h>中的常用方法, 代码公开了, 我就不细讲原理了, 自己多试试应该就能够有所领悟.

class SQString {
    
public:
    SQString(const char * str = nullptr);
    SQString(const SQString & another);
    SQString& operator=(const SQString & another);
    bool operator==(const SQString & another);
    bool operator>(const SQString & another);
    bool operator<(const SQString & another);
    bool operator>=(const SQString & another);
    bool operator<=(const SQString & another);
    SQString operator+(const SQString & another);
    SQString& operator+=(const SQString & another);
    ~SQString();
    char at(int n);
    char operator[](int n);
    char * c_str();
    void description();
private:
    char * _str;
};

猜测string内部实现原理, 其实就是构造器, 拷贝构造器, 运算符重载, 和一些常用函数的封装罢了, 并没有什么很神奇的东西.

SQString::SQString(const char * str) {
    if (str == nullptr) {
        _str = new char[1];
        *_str = '\0';
    } else {
        _str = new char[sq_strlen(str) + 1];
        sq_strcpy(_str, str);
    }
}

SQString::SQString(const SQString & another) {
    _str = new char[sq_strlen(another._str) + 1];
    sq_strcpy(_str, another._str);
}

SQString& SQString::operator=(const SQString & another) {
    if (this == &another) {
        return *this;
    }
    delete []this->_str;
    _str = new char[sq_strlen(another._str) + 1];
    sq_strcpy(_str, another._str);
    return *this;
}

bool SQString::operator==(const SQString & another) {
    return sq_strcmp(this->_str, another._str) == 0;
}
bool SQString::operator>(const SQString & another) {
    return sq_strcmp(this->_str, another._str) > 0;
}
bool SQString::operator<(const SQString & another) {
    return sq_strcmp(this->_str, another._str) < 0;
}
bool SQString::operator>=(const SQString & another) {
    return sq_strcmp(this->_str, another._str) >= 0;
}
bool SQString::operator<=(const SQString & another) {
    return sq_strcmp(this->_str, another._str) <= 0;
}

SQString SQString::operator+(const SQString & another) {
    int len = sq_strlen(this->_str) + sq_strlen(another._str);
    SQString str;
    delete []str._str;
    str._str = new char[len + 1]{0};
    sq_strcat(sq_strcat(str._str, this->_str), another._str);
    return str;
}
SQString& SQString::operator+=(const SQString & another) {
    int catLen = sq_strlen(this->_str);
    int srcLen = sq_strlen(another._str);
    int len = catLen + srcLen;
    this->_str = (char *)realloc(this->_str, len + 1);
    memset(this->_str + catLen, 0, srcLen + 1);
    sq_strcat(this->_str, another._str);
    return *this;
}

SQString::~SQString() {
    cout<<"delete: "<<this<<endl;
    delete []_str;
}

char SQString::at(int n) {
    return _str[n];
}

char SQString::operator[](int n) {
    return _str[n];
}

void SQString::description() {
    cout<<_str<<endl;
}

char * SQString::c_str() {
    return _str;
}

上面就是一些string的基础实现方式, 并没有超出上篇文章所涉及的范畴, 简单易理解, 对我们以后看runtime源码会有帮助.

int main(int argc, const char * argv[]) {
    
    SQString * s  = new SQString;
    SQString * s1 = new SQString("Castiel");
    SQString * s2 = new SQString(*s1);
    SQString   s3 = *s = *s1;
    SQString   s4 = *s1 + SQString(" is perpect!");
    SQString   s5 = SQString("Tell a joke: ") += s4;
    
    cout<<"s:  "; s->description();
    cout<<"s1: "; s1->description();
    cout<<"s2: "; s2->description();
    cout<<"s3: "; s3.description();
    cout<<"s4: "; s4.description();
    cout<<"s5: "; s5.description();

    if (*s == s3) {
        cout<<"*s == s3"<<endl;
    }
    if (*s2 >= s3) {
        cout<<"*s2 >= s3"<<endl;
    }
    if (*s < SQString("abc")) {
        cout<<"*s < SQString(\"abc\")"<<endl;
    }
    
    cout<<"s5.at(2): "<<s5.at(2)<<endl;
    cout<<"s5[5]: "<<s5[5]<<endl;
    cout<<"s5.c_str(): "<<s5.c_str()<<endl;

    cout<<"sizeof(SQString) : "<<sizeof(SQString)<<endl;
    
    delete s;
    delete s1;
    delete s2;
    
    return 0;
}

我们来用自实现的想系统的string一样使用, 会感觉并无差别.

delete: 0x7ffeefbff560
delete: 0x7ffeefbff550
s:  Castiel
s1: Castiel
s2: Castiel
s3: Castiel
s4: Castiel is perpect!
s5: Tell a joke: Castiel is perpect!
*s == s3
*s2 >= s3
delete: 0x7ffeefbff548
*s < SQString("abc")
s5.at(2): l
s5[5]: a
s5.c_str(): Tell a joke: Castiel is perpect!
sizeof(SQString) : 8
delete: 0x100419ad0
delete: 0x100404b60
delete: 0x100403f40
delete: 0x7ffeefbff558
delete: 0x7ffeefbff568
delete: 0x7ffeefbff570
Program ended with exit code: 0

使用起来还是如此的自然, 当然, 自实现只是让我们更好的了解本质, 并不是要使用自实现的东西, 而重复造轮子炫技.

const

接下来, 我们来说说const, const这个东西非常的厉害, 比如 int const * a, 和 int * const a就是完全两个概念, 这在上一篇文章里也有说到了, 这次我们来看下const在类中的表述.

struct A
{
public:
    A(int x, int y, int & z):_x(x), _y(y), _z(z) {
        cout<<"const x: "<<_x<<endl;
        cout<<"      y: "<<_y<<endl;
        cout<<"      z: "<<_z<<endl;
    }
private:
    const int _x;
    int _y;
    int & _z;
};

int main(int argc, const char * argv[]) {
    
    int z = 300;
    A a(100, 200, z);
    
    return 0;
}

const x: 100
      y: 200
      z: 300
Program ended with exit code: 0

在类中const与初始化列表的使用, 可以使用初始化列表为const变量初始化.

int add(int & a, int & b) {
    return a + b;
}

int add(const int & a, const int & b) {
    return a + b;
}

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

    int a = 3; int b = 5;
    cout<<add(a, b)<<endl;
    cout<<add(4, 6)<<endl;
    
    return 0;
}

8
10
Program ended with exit code: 0

使用const可以在传递参数的时候, 重载常量引用.

class A {
public:
    A(int x, int y):_x(x), _y(y) {}
    void foo();
    void foo() const;
private:
    int _x;
    int _y;
};

void A::foo() {
    _x = 300;
    cout<<"non-const : "<<_x<<_y<<endl;
}
void A::foo() const {
    cout<<"const: "<<_x<<_y<<endl;
}

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

    const A a(3, 4);
    a.foo();
    
    A a1(5, 6);
    a1.foo();

    return 0;
}

const: 34
non-const : 3006
Program ended with exit code: 0

总结一下:

const修饰函数以后, 承诺, 不改变, 在本函数不会发生改变数据成员的行为.

const构成的重载函数, 非const对象, 优先调用非const版本.

const 对象, 只能调用const版本的函数. 很多库常见提供两个版本.

const 修饰的对象, 其内可以有非const数据成员, 但不可修改. 只能调用const 成员函数.

static

接下来, 我们来说说static, static是全局的存储在代码段的rw段, 我们平时的场景比如在 cell的标识符的引用, static const代替宏, gcd单例 等等.

class A {
    
public:
    int _m = 0, _n = 0;
    static int _share;
};
int A::_share = 100;

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

    A a;
    cout<<a._n<<endl;
    cout<<a._m<<endl;
    cout<<a._share<<endl;
    cout<<A::_share<<endl;
    
    return 0;
}

0
0
100
100
Program ended with exit code: 0

static 修饰数据成员, 需要初始化, 不可以类内初始化.

类外初始化, 需要类名空间, 且不需要static.

static声明的数据成员, 不占用类的大小, 存储在data rw段.

class A {
    
public:
    ~A();
    void foo();
    int _m = 0, _n = 0;
    static int _fooCount;
};

int A::_fooCount = 0;

A::~A() {
    cout<<"dealloc"<<endl;
}

void A::foo() {
    cout<<"void foo()"<<endl;
    _fooCount++;
}

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

    {
        A a,b,c;
        a.foo();
        b.foo();
        c.foo();
    }
    cout<<A::_fooCount<<endl;
    
    return 0;
}

void foo()
void foo()
void foo()
dealloc
dealloc
dealloc
3
Program ended with exit code: 0

class A {
    
public:
    ~A();
    void foo();
    static int invokeFooCount();
private:
    int _m = 0, _n = 0;
    static int _fooCount;
};

int A::_fooCount = 0;

A::~A() {
    cout<<"dealloc"<<endl;
}

void A::foo() {
    cout<<"void foo()"<<endl;
    _fooCount++;
}

int A::invokeFooCount() {
    return _fooCount;
}

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

    {
        A a,b,c;
        a.foo();
        b.foo();
        c.foo();
        
        cout<<a.invokeFooCount()<<endl;
    }
    cout<<A::invokeFooCount()<<endl;
    
    return 0;
}

void foo()
void foo()
void foo()
3
dealloc
dealloc
dealloc
3
Program ended with exit code: 0

static修饰函数, 目的为管理静态变量.

class University {
public:
    University(string t, string l);
    static string & getLib();
    void display();
private:
    string _tower;
    string _lake;
    static string _lib;
};

string University::_lib = "";

University::University(string t, string l):_tower(t), _lake(l){}

string & University::getLib() {
    return _lib;
}
void University::display() {
    cout<<"tower: "<<_tower<<" lake: "<<_lake<<" lib: "<<_lib<<endl;
}

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

    University u1("tower1", "lake1");
    University u2("tower2", "lake2");
    University u3("tower3", "lake3");

    University::getLib() += "lib1";
    u1.display();

    u2.getLib() += "lib2";
    u2.display();

    u3.getLib() += "lib3";
    u3.display();
    
    return 0;
}

tower: tower1 lake: lake1 lib: lib1
tower: tower2 lake: lake2 lib: lib1lib2
tower: tower3 lake: lake3 lib: lib1lib2lib3
Program ended with exit code: 0

static 共享

静态成员函数, 只能访问静态的成员. (数据成员和函数成员), 不能访问非静态的成员. 是因为非静态函数没有隐式传入this指针.

非静态函数访问静态函数式可以的.

singleton

单例, 这个非常简单, 对于有经验的iOS开发者来说, 其实就会写一个单例的宏, 但我们还是要知道如何实现.

class Singleton {
public:
    static Singleton * shareInstance();
    static void releaseInstance();
private:
    Singleton(){};
    ~Singleton(){};
    Singleton(const Singleton & another){};
    Singleton & operator=(const Singleton & another){return *this;};
    static Singleton * _instance;
};

Singleton * Singleton::_instance = nullptr;

Singleton * Singleton::shareInstance() {
    if (_instance == nullptr) {
        _instance = new Singleton;
    }
    return _instance;
}

void Singleton::releaseInstance() {
    if (_instance != NULL) {
        delete _instance;
        _instance = nullptr;
    }
}

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

    Singleton * ps = Singleton::shareInstance();
    Singleton * ps2 = Singleton::shareInstance();
    Singleton * ps3 = Singleton::shareInstance();

    cout<<ps<<endl;
    cout<<ps2<<endl;
    cout<<ps3<<endl;
    
    Singleton::releaseInstance();
    
    return 0;
}

0x100412a60
0x100412a60
0x100412a60
Program ended with exit code: 0

总结就是静态读取, 私有构造.

自实现 autoreleasepool

自动释放池这个概念对于我们做iOS的并不会陌生吧, 接下来, 我们就来自实现一个简版的自动释放池, 当然这个版本并不会有引用计数的内容, 仅仅是内存托管的实现.

#include <iostream>
#include <stdlib.h>
#include <time.h>

using namespace std;

class SQObject {
public:
    SQObject(){}
    static SQObject * create() {
        SQObject * obj = new SQObject();
        if (obj && obj->init()) {
            obj->autoRealease();
            return obj;
        } else {
            delete obj;
            obj = nullptr;
            exit(-1);
        }
    }
    bool init() {
        cout<<"initial"<<endl;
        ch = rand()%(127-32) + 33;
        return true;
    }
    void autoRealease() {
//        if (head == nullptr) {
//            head = this;
//            this->next = nullptr;
//        } else {
//            this->next = head;
//            head = this;
//        }
        this->next = head;
        head = this;
    }
    
    static void autoRealeasePool() {
        SQObject * t = head;
        while (t) {
            cout<<"realease: "<<t->ch<<endl;
            t = t->next;
        }
    }
    
private:
    static SQObject * head;
    SQObject * next;
    char ch;
};

SQObject * SQObject::head = nullptr;

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

    srand(time(NULL));
    for (int i = 0; i < 5; i++) {
        SQObject * obj = SQObject::create();
    }
    SQObject::autoRealeasePool();
    return 0;
}

initial
initial
initial
initial
initial
realease: n
realease: .
realease: ^
realease: i
realease: k
Program ended with exit code: 0

其实就和我们感觉上一样, 自动释放池用一个链表就可以解决, 当出了作用域的时候后, 将自动释放池链表中引用计数为0的地址给赋值null就完成了, 真是easy~

static const

这个我就不多说了, 大家日常使用都会有心得的东西.

class A {
public:
    static const int a = 100;
};

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

    cout<<A::a<<endl;
    return 0;
}

static const 存储在数据段的 ro段;

pointer2class -> ivar & func

这一章会比较晦涩难懂些, 可以翻阅一下其他的文章, 其实就是如何通过指针来指向类内的成员变量及函数.

class Student {
public:
    Student(string n, int nu):name(n), num(nu){}
    void display(int idx) {
        cout<<"idx "<<idx<<" name "<<name<<" num "<<num<<endl;
    }
    //private:
    string name;
    int num;
};

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

    Student s("Castiel", 1024);
    Student * ps = &s;
    
    Student ss("Aquas", 3328);
    Student * pss = &ss;
    
    string Student::* psn = &Student::name;
    cout<<s.*psn<<endl;
    cout<<ps->*psn<<endl;

    cout<<ss.*psn<<endl;
    cout<<pss->*psn<<endl;
    
    void (Student::* pf)(int) = &Student::display;
    (s.*pf)(1);
    (ss.*pf)(2);
    (ps->*pf)(3);
    (pss->*pf)(4);

    return 0;
}

Castiel
Castiel
Aquas
Aquas
idx 1 name Castiel num 1024
idx 2 name Aquas num 3328
idx 3 name Castiel num 1024
idx 4 name Aquas num 3328
Program ended with exit code: 0

关注void (Student::* pf)(int) = &Student::display; 和 string Student::* psn = &Student::name;就可以了, 编译器固定格式.

科里化

通过上述的指针, 我们还可以实现科里化, 也就是喵神100tips中的第一章内容的本质.

struct Point {
    int add(int x, int y) {
        return x + y;
    }
    int minus(int x, int y) {
        return x - y;
    }
    int mul(int x, int y) {
        return x * y;
    }
    int div(int x, int y) {
        return x / y;
    }
};

int oper(Point & p, int (Point::*pf)(int x, int y), int x, int y) {
    return (p.*pf)(x, y);
}

typedef int (Point::*PF)(int, int);

int main(int argc, const char * argv[]) {
    
    Point p;
    PF pf = &Point::add;
    pf = &Point::mul;
    cout<<oper(p, pf, 5, 2)<<endl;
    
    return 0;
}

10
Program ended with exit code: 0

隐蔽接口

更高级点的做法, 我们可以使用这个方法来隐藏接口, 这样别人在用我们做好的功能的时候, 就能傻瓜式的操作, 而隐蔽内部逻辑了.

class Game {
public:
    Game() {
        pf[0] = &Game::a;
        pf[1] = &Game::b;
        pf[2] = &Game::c;
        pf[3] = &Game::d;
    }
    void select(int i) {
        if (i >= 0 && i <= 3) {
            (this->*pf[i])(i);
        }
    }
private:
    void a(int idx){cout<<"void a(int idx)"<<idx<<endl;}
    void b(int idx){cout<<"void b(int idx)"<<idx<<endl;}
    void c(int idx){cout<<"void c(int idx)"<<idx<<endl;}
    void d(int idx){cout<<"void d(int idx)"<<idx<<endl;}
    enum {
        nc = 4
    };
    void (Game::*pf[nc])(int idx);
};

int main(int argc, const char * argv[]) {
    
    Game g;
    g.select(1);
    g.select(2);
    g.select(3);
    
    return 0;
}

void b(int idx)1
void c(int idx)2
void d(int idx)3
Program ended with exit code: 0

friend

友元, 其实就是一种便捷访问非本类私有方法的. 是对封装的破坏.

class Sprite {
    friend void fight(Sprite & sp);
public:
    Sprite(int lb = 100): _lifeBlood(lb){}
    int getLifeBlood() {
        return _lifeBlood;
    }
    void setLifeBlood(int lb) {
        _lifeBlood = lb;
    }
private:
    int _lifeBlood;
};

void fight(Sprite & sp) {
//    sp.setLifeBlood(sp.getLifeBlood() - 20);
//    cout<<sp.getLifeBlood()<<endl;
    sp._lifeBlood = sp._lifeBlood - 20;
    cout<<sp._lifeBlood<<endl;
}

int main(int argc, const char * argv[]) {
    
    Sprite sp;
    fight(sp);
    
    return 0;
}

class Complex {
    friend Complex operator+(Complex & c1, Complex & c2);
public:
    Complex(double r = 0, double i = 0): real(r), image(i) {}
    void dumpFormat() {
        cout<<"("<<real<<","<<image<<")"<<endl;
    }
private:
    double real;
    double image;
};

Complex operator+(Complex & c1, Complex & c2) {
    Complex c;
    c.real = c1.real + c2.real;
    c.image = c1.image + c2.image;
    return c;
}

int main(int argc, const char * argv[]) {
    
    Complex c1(1, 2);
    Complex c2(3, 4);
    Complex sum;
    sum = c1 + c2;
    sum.dumpFormat();
    
    return 0;
}

声明为谁的友元, 就可以通过谁的对象, 访问谁的私有函数.

class Point {
    friend float getDistance(Point & p1, const Point & p2);
public:
    Point(int x = 0, int y = 0):_x(x), _y(y){}
    void dumpFormat() {
        cout<<"("<<_x<<","<<_y<<")"<<endl;
    }
private:
    float _x;
    float _y;
};

float getDistance(const Point & p1, const Point & p2) {
    float dx = p1._x - p2._x;
    float dy = p1._y - p2._y;
    return sqrt(dx * dx + dy * dy);
}

int main(int argc, const char * argv[]) {
    
    Point p1(3, 4);
    p1.dumpFormat();
    Point p2(7, 8);
    p2.dumpFormat();
    
    cout<<"dis:"<<getDistance(p1, p2)<<endl;
    
    return 0;
}

全局做friend 不受类的权限控制

class Point;

class ManagePoint {
public:
    float getDistance(Point & p1, const Point & p2);
};

class Point {
    friend float ManagePoint::getDistance(Point & p1, const Point & p2);
public:
    Point(int x = 0, int y = 0):_x(x), _y(y){}
    void dumpFormat() {
        cout<<"("<<_x<<","<<_y<<")"<<endl;
    }
private:
    float _x;
    float _y;
};

float ManagePoint::getDistance(const Point & p1, const Point & p2) {
    float dx = p1._x - p2._x;
    float dy = p1._y - p2._y;
    return sqrt(dx * dx + dy * dy);
}

int main(int argc, const char * argv[]) {
    
    Point p1(3, 4);
    p1.dumpFormat();
    Point p2(7, 8);
    p2.dumpFormat();
    
    ManagePoint mp;
    cout<<"dis:"<<mp.getDistance(p1, p2)<<endl;
    
    return 0;
}

前向声明的问题前向声明, 是一种不完全类型的声明, 不能定义对象.

可以定义指针和引用作参数和返回值, 仅用在函数声明中.

class Point {
    friend class ManagePoint;
public:
    Point(int x = 0, int y = 0):_x(x), _y(y){}
    void dumpFormat() {
        cout<<"("<<_x<<","<<_y<<")"<<endl;
    }
private:
    float _x;
    float _y;
};

class ManagePoint {
public:
    float getDistance(const Point & p1, const Point & p2) {
        float dx = p1._x - p2._x;
        float dy = p1._y - p2._y;
        return sqrt(dx * dx + dy * dy);
    }
};

int main(int argc, const char * argv[]) {
    
    Point p1(3, 4);
    p1.dumpFormat();
    Point p2(7, 8);
    p2.dumpFormat();
    
    ManagePoint mp;
    cout<<"dis:"<<mp.getDistance(p1, p2)<<endl;
    
    return 0;
}

class Point {
    friend class ManagePoint;
public:
    Point(int x = 0, int y = 0):_x(x), _y(y){}
    void dumpFormat() {
        cout<<"("<<_x<<","<<_y<<")"<<endl;
    }
private:
    float _x;
    float _y;
};

class ManagePoint {
public:
    float getDistance(const Point & p1, const Point & p2) {
        float dx = p1._x - p2._x;
        float dy = p1._y - p2._y;
        return sqrt(dx * dx + dy * dy);
    }
    float getArea(const Point & p1, const Point & p2, const Point & p3) {
        float da = getDistance(p1, p2);
        float db = getDistance(p2, p3);
        float dc = getDistance(p3, p1);
        float p = (da + db + dc) / 2;
        return sqrt(p * (p - da) * (p - db) * (p - dc));
    }
};

int main(int argc, const char * argv[]) {
    
    Point p1(3, 4);
    p1.dumpFormat();
    Point p2(7, 8);
    p2.dumpFormat();
    Point p3(-100, 900);

    ManagePoint mp;
    cout<<"dis:"<<mp.getDistance(p1, p2)<<endl;
    cout<<"area:"<<mp.getArea(p1, p2, p3)<<endl;
    
    return 0;
}

友元类的使用, 可以避免前向声明的麻烦, 仅仅是提供便捷.

operator

运算符重载的使用, 和上篇一样, 这里更加深入.

class Complex {
public:
    Complex(double r = 0, double i = 0):real(r), image(i){}
    void dumpFormat() {
        cout<<"("<<this->real<<","<<this->image<<")"<<endl;
    }
    Complex & operator= (const Complex & another) {
        this->real = another.real;
        this->image = another.image;
        return *this;
    }
    const Complex operator+(const Complex & another) {
        Complex sum;
        sum.real = this->real + another.real;
        sum.image = this->image + another.image;
        return sum;
    }
private:
    double real;
    double image;
};

int main(int argc, const char * argv[]) {
    
    Complex a(1, 2), b(4, 5);
    Complex s = a + b;
    b.dumpFormat();
    a.dumpFormat();
    s.dumpFormat();
    
    return 0;
}

class Complex {
public:
    Complex(double r = 0, double i = 0):real(r), image(i){}
    void dumpFormat() {
        cout<<"("<<this->real<<","<<this->image<<")"<<endl;
    }
    Complex & operator +=(const Complex & another) {
        this->real += another.real;
        this->image += another.image;
        return *this;
    }
private:
    double real;
    double image;
};

int main(int argc, const char * argv[]) {
    
    int a = 10, b = 20, c = 30;
    a += b;
    b += c;
    cout<<"a: "<<a<<endl;
    cout<<"b: "<<b<<endl;
    cout<<"c: "<<c<<endl;

    Complex ca(10, 0), cb(20, 0), cc(30, 0);
    ca += cb; // plus return *this
    cb += cc;
    ca.dumpFormat();
    cb.dumpFormat();
    cc.dumpFormat();
    
    int a1 = 10, b1 = 20, c1 = 30;
    a1 += b1 += c1;
    cout<<"a1: "<<a1<<endl;
    cout<<"b1: "<<b1<<endl;
    cout<<"c1: "<<c1<<endl;
    
    Complex ca1(10, 0), cb1(20, 0), cc1(30, 0);
    ca1 += cb1 += cc1; // plus const
    ca1.dumpFormat();
    cb1.dumpFormat();
    cc1.dumpFormat();
    
    int a2 = 10, b2 = 20, c2 = 30;
    (a2 += b2) += c2;
    cout<<"a2: "<<a2<<endl;
    cout<<"b2: "<<b2<<endl;
    cout<<"c2: "<<c2<<endl;
    
    Complex ca2(10, 0), cb2(20, 0), cc2(30, 0);
    (ca2 += cb2) += cc2; // plus &
    ca2.dumpFormat();
    cb2.dumpFormat();
    cc2.dumpFormat();
    return 0;
}

a: 30
b: 50
c: 30
(30,0)
(50,0)
(30,0)
a1: 60
b1: 50
c1: 30
(60,0)
(50,0)
(30,0)
a2: 60
b2: 20
c2: 30
(60,0)
(20,0)
(30,0)
Program ended with exit code: 0

class Complex {
public:
    Complex(double r = 0, double i = 0):real(r), image(i){}
    void dumpFormat() {
        cout<<"("<<this->real<<","<<this->image<<")"<<endl;
    }
    const Complex operator-() const {
        return Complex(-this->real, -this->image);
    }
    
private:
    double real;
    double image;
};

int main(int argc, const char * argv[]) {
    
    int n = 5;
//    -n = 10;
    cout<<-n<<endl;
    cout<<n<<endl;
    cout<<-(-n)<<endl;

    Complex c(5, 0);
    Complex c1 = -c;
//    -cc = Complex(10, 0); //plus const
    Complex c2 = -(-c); //plus func const
    c1.dumpFormat();
    c.dumpFormat();
    c2.dumpFormat();
    
    return 0;
}

-5
5
5
(-5,-0)
(5,0)
(5,0)
Program ended with exit code: 0

class Complex {
public:
    Complex(double r = 0, double i = 0):real(r), image(i){}
    void dumpFormat() const {
        cout<<"("<<this->real<<","<<this->image<<")"<<endl;
    }
    Complex & operator++() {
        this->real++;
        this->image++;
        return *this;
    }
    const Complex operator++(int) /*编译器的规则*/ {
        Complex r(*this);
        ++this->real;
        ++this->image;
        return r;
    }
    
private:
    double real;
    double image;
};

int main(int argc, const char * argv[]) {
    
    int a = 10;
    cout<<++a<<endl;
    cout<<a<<endl;
    cout<<++++a<<endl;
    cout<<a<<endl;
    cout<<a++<<endl;
    cout<<a<<endl;
//    cout<<a++++<<endl;

    Complex c(10, 0);
    (++c).dumpFormat();
    c.dumpFormat();
    (++++c).dumpFormat();
    c.dumpFormat();
    (c++).dumpFormat();
    c.dumpFormat();
    
    return 0;
}

11
11
13
13
13
14
(11,1)
(11,1)
(13,3)
(13,3)
(13,3)
(14,4)
Program ended with exit code: 0

class Mail {
    friend class Sender;
public:
    Mail(string title, string contents):_title(title), _contents(contents){}
private:
    string _title;
    string _contents;
};


class Sender {
public:
    Sender(string addr):_addr(addr){}
    Sender & operator<<(const Mail & mail) {
        cout<<mail._title<<endl;
        cout<<mail._contents<<endl;
        return *this;
    }
private:
    string _addr;
};


int main(int argc, const char * argv[]) {
    
    Sender sender("github.com/coderzsq");
    Mail mail("title1", "description1");
    Mail mail2("title2", "description2");
    sender<<mail<<mail2;
    
    return 0;
}

title1
description1
title2
description2
Program ended with exit code: 0

class Complex {
public:
    Complex(double r = 0, double i = 0):real(r), image(i){}
    friend istream & operator>>(istream & ci, Complex & c) {
        ci>>c.real;
        ci>>c.image;
        return ci;
    }
    friend ostream & operator<<(ostream & co, Complex & c) {
        co<<"("<<c.real<<","<<c.image<<")"<<endl;
        return co;
    }
    
private:
    double real;
    double image;
};

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

    Complex c, c1;
    cin>>c>>c1;
    cout<<c<<c1;
    return 0;
}

1 2
3 4
(1,2)
(3,4)
Program ended with exit code: 0

custom type conversion

自动类型转换, 其实就是一个单参数构造函数而已, 没有什么神奇的.

class Point3D;

class Point2D {
    friend class Point3D;
public:
    Point2D(int x = 0, int y = 0):_x(x), _y(y){}
    operator Point3D(void);
private:
    int _x;
    int _y;
};

class Point3D {
    friend class Point2D;
public:
    Point3D(int x = 0, int y = 0, int z = 0):_x(x), _y(y), _z(z){}
    explicit Point3D(const Point2D & d2) {
        this->_x = d2._x;
        this->_y = d2._y;
        this->_z = rand()%100;
    }
    void dumpFormat() {
        cout<<"("<<_x<<","<<_y<<","<<_z<<")"<<endl;
    }
private:
    int _x;
    int _y;
    int _z;
};

Point2D::operator Point3D(void) {
    return Point3D(this->_x, this->_y, rand()%100);
}

Point3D convert(Point2D d2) {
    return Point3D(d2);
}

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

    srand((unsigned)time(0));
    Point2D d2(10, 100);
    Point3D d3 = static_cast<Point3D>(d2);
//    Point3D d3 = (Point3D)d2;
//    d3 = convert(d2);
    d3.dumpFormat();
     
    return 0;
}

functor

仿函数, 看似比较高级的应用, 其本质只不过和运算符从冲裁的本质是调用函数一样.

class Pow {
public:
    double operator() (double x, int y) {
        int ret = 1;
        for (int i = 0; i < y; i++) {
            ret *= x;
        }
        return ret;
    }
};

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

    int a = 5;
    cout<<pow(a, 5)<<endl;
    Pow mypow;
    mypow(a, 2);
    cout<<mypow(a, 5)<<endl;

    return 0;
}

bool myCompare(int a, int b) {
    return a < b;
}

class Compare {
public:
    Compare(bool b = true):flag(b){}
    bool operator() (int a, int b) {
        if (flag == true) {
            return a > b;
        } else {
            return a < b;
        }
    }
private:
    bool flag;
};

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

    int arr[6] = {1, 3, 5, 8, 6, 4};
    vector<int> vi(arr, arr + 6);
#if 0
    //method1
    vector<int>::iterator itr;
    for (itr = vi.begin(); itr != vi.end(); ++itr) {
        cout<<*itr<<endl;
    }
    //method2
    for (auto itr = vi.begin(); itr != vi.end(); ++itr) {
        cout<<*itr<<endl;
    }
    //method3
    for (auto i:vi) {
        cout<<i<<endl;
    }
#endif
    
    sort(vi.begin(), vi.end(), myCompare);
    for (auto i:vi) {
        cout<<i<<endl;
    }
    
    sort(vi.begin(), vi.end(), Compare(false));
    for (auto i:vi) {
        cout<<i<<endl;
    }
    
    return 0;
}

smart pointer

智能指针, 类似于自动释放池? 出了作用域后自动释放堆内存.

class A {
public:
    A() {
        cout<<"A()"<<endl;
    }
    void xxxx() {
        cout<<"xxxx"<<endl;
    }
    ~A() {
        cout<<"~A()"<<endl;
    }
};

class SmartPtr {
public:
    SmartPtr(A * pa) {
        _pa = pa;
    }
    A & operator*() {
        return *_pa;
    }
    A * operator->() {
        return _pa;
    }
    ~SmartPtr() {
        delete _pa;
    }
private:
    A * _pa;
};

void foo() {
#if 0
    A a;
    A * p = new A;
    delete p;
    
    auto_ptr<A> p(new A);
    p->xxxx();
    (*p).xxxx();
#endif
    
    SmartPtr sp(new A);
    sp->xxxx();
    (*sp).xxxx();
}

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

    foo();
    return 0;
}

A()
xxxx
xxxx
~A()
Program ended with exit code: 0

memory customization

主要用于内存定制, 其实感觉没什么太大的意义, 封装的使用吧..

class A {
public:
    A() {
//        _x = 100;
//        _y = 200;
        cout<<"A()"<<endl;
    }
    void xxxx() {
        cout<<_x<<_y<<endl;
    }
    ~A() {
        cout<<"~A()"<<endl;
    }
    void *operator new(size_t size) {
        cout<<"operator new"<<endl;
        cout<<size<<endl;
        void * p = malloc(size);
        ((A*)p)->_x = 100;
        ((A*)p)->_y = 200;
        cout<<p<<endl;
        return p;
    }
    void operator delete(void * p) {
        cout<<"operator delete"<<endl;
        cout<<p<<endl;
    }
    void * operator new[](size_t size) {
        cout<<"operator new[]"<<endl;
        cout<<size<<endl;
        void *p = malloc(size);
        cout<<p<<endl;
        return p;
    }
    void operator delete[] (void * p) {
        cout<<"operator delete[]"<<endl;
        cout<<p<<endl;
        free(p);
    }
private:
    int _x;
    int _y;
};

int main(int argc, const char * argv[]) {
#if 0
    A * pa = new A;
    pa->xxxx();
    delete pa;
#endif
    A * pa = new A[10];
    delete[] pa;
    return 0;
}

operator new[]
88
0x10291f740
A()
A()
A()
A()
A()
A()
A()
A()
A()
A()
~A()
~A()
~A()
~A()
~A()
~A()
~A()
~A()
~A()
~A()
operator delete[]
0x10291f740
Program ended with exit code: 0

最后

更多新鲜文章可以关注并Star, 我们一起学习.

GitHub Repo：coderZsq.github.io
Follow: coderZsq · GitHub