macOS开机iterm2 + oh my zsh会显示xcodebuild

06/23/2022 08:12 上午 posted in  apple

解决2019款macbookpro -16寸 外接显示器风扇不停的转,温度特别高

终极方案: 禁止独显 & 使用 Turbo_Boost_Switcher_Pro_2.10.2 。

禁止独显使用集成显卡

发热很久了,最后找到一个解决方法。禁止独显,使用集显即可。但设置仅使用集显后还需要在关闭系统设置/电源/自动切换显卡 选项,不然外接显示器没有反应。步骤:打开终端,输入:sudo pmset -a GPUSwitch 0
// 0: 强制使用核显; 1: 强制使用独显 2: 自动切换显卡

pmset -g //查看是否成功,会看到下图

后关闭系统设置 / 电源 / 自动切换显卡 选项

特别操作: 关闭系统设置 / 电源 / 自动切换显卡 选项

参考: https://www.zhihu.com/question/290208585

使用Turbo_Boost_Switcher_Pro


外接显示器的风扇会在4000rpm 左右, 风扇噪音明显减轻。

机器型号

06/16/2022 07:59 上午 posted in  apple

iOS - CloudKit 基础

关于CloudKit开发的基础说明

Read more   04/29/2022 07:26 上午 posted in  apple

马蜂窝 iOS App 启动治理:回归用户体验

From:https://mp.weixin.qq.com/s?__biz=Mzg5MTA4Mzg5NA==&mid=2247483816&idx=1&sn=588981334dd8c797ce2e4395db6ca68d&utm_source=tuicool&utm_medium=referral

增长、活跃、留存是移动 App 的常见核心指标,直接反映一款 App 甚至一个互联网公司运行的健康程度和发展动能。启动流程的体验决定了用户的第一印象,在一定程度上影响了用户活跃度和留存率。因此,确保启动流程的良好体验至关重要。

Read more   05/16/2019 10:04 上午 posted in  apple

时间的格式

##NSDateFormatter的作用

//NSString * -> NSDate *
- (nullable NSDate *)dateFromString:(NSString *)string;
//NSDate * -> NSString *
- (NSString *)stringFromDate:(NSDate *)date;

##常见的日期格式

http://www.cnblogs.com/mailingfeng/archive/2011/07/28/2120422.html

###NSString * -> NSDate *

"2016-10-03 14:01:00"

// 时间字符串
NSString *string = "2016-10-03 14:01:00";

// 日期格式化类
NSDateFormatter *fmt = [[NSDateFormatter alloc] init];
// 设置日期格式(为了转换成功)
fmt.dateFormat = @"yyyy-MM-dd HH:mm:ss";

// NSString * -> NSDate *
NSDate *date = [fmt dateFromString:string];

NSLog(@"%@", date);

10月-03号/2016年 09-10:05秒

// 时间字符串
NSString *string = @"10月-03号/2016年 09-10:05秒";

// 日期格式化类
NSDateFormatter *fmt = [[NSDateFormatter alloc] init];
fmt.dateFormat = @"MM月-dd号/yyyy年 HH-mm:ss秒";

NSLog(@"%@", [fmt dateFromString:string]);

Tue May 31 17:46:55 +0800 2011

// 时间字符串
NSString *string = @"Tue May 31 17:46:55 +0800 2011";

// 日期格式化类
NSDateFormatter *fmt = [[NSDateFormatter alloc] init];
fmt.dateFormat = @"EEE MMM dd HH:mm:ss Z yyyy";
// fmt.dateFormat = @"EEE MMM dd HH:mm:ss ZZZZ yyyy";
// 设置语言区域(因为这种时间是欧美常用时间)
fmt.locale = [[NSLocale alloc] initWithLocaleIdentifier:@"en_US"];

NSLog(@"%@", [fmt dateFromString:string]);

1745645645645

// 时间戳 : 从1970年1月1号 00:00:00开始走过的毫秒数

// 时间字符串 - 时间戳
NSString *string = @"1745645645645";
NSTimeInterval second = string.longLongValue / 1000.0;

// 时间戳 -> NSDate *
NSDate *date = [NSDate dateWithTimeIntervalSince1970:second];
NSLog(@"%@", date);

##NSCalendar的注意点

#define iOS(version) ([UIDevice currentDevice].systemVersion.doubleValue >= (version))

NSCalendar *calendar = nil;
if ([UIDevice currentDevice].systemVersion.doubleValue >= 8.0) {
    calendar = [NSCalendar calendarWithIdentifier:NSCalendarIdentifierGregorian];
} else {
    calendar = [NSCalendar currentCalendar];
}

NSCalendar *calendar = nil;
if ([NSCalendar respondsToSelector:@selector(calendarWithIdentifier:)]) {
    calendar = [NSCalendar calendarWithIdentifier:NSCalendarIdentifierGregorian];
} else {
    calendar = [NSCalendar currentCalendar];
}

NSDate * -> NSString *

NSDate *date = [NSDate date];

NSDateFormatter *fmt = [[NSDateFormatter alloc] init];
fmt.dateFormat = @"yyyy年MM月dd号 HH:mm:ss";

NSString *string = [fmt stringFromDate:date];

获得日期元素

NSString *string = @"2016-10-03 14:01:00";

NSString *month = [string substringWithRange:NSMakeRange(5, 2)];

NSLog(@"%@", month);
// 时间字符串
NSString *string = @"2016-10-03 14:01:00";

// 日期格式化类
NSDateFormatter *fmt = [[NSDateFormatter alloc] init];
// 设置日期格式(为了转换成功)
fmt.dateFormat = @"yyyy-MM-dd HH:mm:ss";

// NSString * -> NSDate *
NSDate *date = [fmt dateFromString:string];

// 利用NSCalendar处理日期
NSCalendar *calendar = [NSCalendar currentCalendar];
NSInteger month = [calendar component:NSCalendarUnitMonth fromDate:date];
NSInteger hour = [calendar component:NSCalendarUnitHour fromDate:date];
NSInteger minute = [calendar component:NSCalendarUnitMinute fromDate:date];

NSLog(@"%zd %zd %zd", month, hour, minute);
// 时间字符串
NSString *string = @"2016-10-03 14:01:00";

// 日期格式化类
NSDateFormatter *fmt = [[NSDateFormatter alloc] init];
// 设置日期格式(为了转换成功)
fmt.dateFormat = @"yyyy-MM-dd HH:mm:ss";

// NSString * -> NSDate *
NSDate *date = [fmt dateFromString:string];

// 利用NSCalendar处理日期
NSCalendar *calendar = [NSCalendar currentCalendar];

NSCalendarUnit unit = NSCalendarUnitYear | NSCalendarUnitMonth | NSCalendarUnitDay | NSCalendarUnitHour | NSCalendarUnitMinute | NSCalendarUnitSecond;
NSDateComponents *cmps = [calendar components:unit fromDate:date];

// NSLog(@"%zd %zd %zd", cmps.year, cmps.month, cmps.day);
NSLog(@"%@", cmps);
日期比较

// 时间字符串
NSString *createdAtString = @"2016-10-03 14:01:00";
NSDateFormatter *fmt = [[NSDateFormatter alloc] init];
fmt.dateFormat = @"yyyy-MM-dd HH:mm:ss";
NSDate *createdAtDate = [fmt dateFromString:createdAtString];

// 手机当前时间
NSDate *nowDate = [NSDate date];

/**
NSComparisonResult的取值
NSOrderedAscending = -1L, // 升序, 越往右边越大
NSOrderedSame, // 相等
NSOrderedDescending // 降序, 越往右边越小
*/
// 获得比较结果(谁大谁小)
NSComparisonResult result = [nowDate compare:createdAtDate];
if (result == NSOrderedAscending) { // 升序, 越往右边越大
NSLog(@"createdAtDate > nowDate");
} else if (result == NSOrderedDescending) { // 降序, 越往右边越小
NSLog(@"createdAtDate < nowDate");
} else {
NSLog(@"createdAtDate == nowDate");
}
// 时间字符串
NSString *createdAtString = @"2016-10-03 14:01:00";
NSDateFormatter *fmt = [[NSDateFormatter alloc] init];
fmt.dateFormat = @"yyyy-MM-dd HH:mm:ss";
NSDate *createdAtDate = [fmt dateFromString:createdAtString];

// 手机当前时间
// NSDate *nowDate = [NSDate date];

// 获得createdAtDate和nowDate的时间间隔(间隔多少秒)
// NSTimeInterval interval = [nowDate timeIntervalSinceDate:createdAtDate];
NSTimeInterval interval = [createdAtDate timeIntervalSinceNow];
NSLog(@"%f", interval);
NSDateFormatter *fmt = [[NSDateFormatter alloc] init];
fmt.dateFormat = @"yyyy-MM-dd HH:mm:ss";

// 时间字符串
NSString *createdAtString = @"2016-10-03 14:01:00";
NSDate *createdAtDate = [fmt dateFromString:createdAtString];

// 其他时间
NSString *otherString = @"2016-10-03 14:01:00";
NSDate *otherDate = [fmt dateFromString:otherString];

// 获得NSCalendar
NSCalendar *calendar = nil;
if ([NSCalendar respondsToSelector:@selector(calendarWithIdentifier:)]) {
calendar = [NSCalendar calendarWithIdentifier:NSCalendarIdentifierGregorian];
} else {
calendar = [NSCalendar currentCalendar];
}

// 获得日期之间的间隔
NSCalendarUnit unit = NSCalendarUnitYear | NSCalendarUnitMonth | NSCalendarUnitDay | NSCalendarUnitHour | NSCalendarUnitMinute | NSCalendarUnitSecond;
NSDateComponents *cmps = [calendar components:unit fromDate:createdAtDate toDate:otherDate options:0];

NSLog(@"%@", cmps);
条件判断的一些注意点

1.判断一个数组中是否有具体内容
1> 正确
if (array.count) {

}

2> 错误
if (array) {

}

2.判断一个字符串是否有具体内容
1> 正确
if (string.length) {

}

2> 错误
if (string) {

}

07/23/2018 20:38 下午 posted in  apple

ios NSNumberFormatter 金额格式处理

##NSNumberFormatter
可以通过NSNumberFormatter,同样可以设置NSNumber输出的格式
比如123,456,789 或者 123 456 789

NSNumber *number = @(123456789.6789);
2017-10-27 17:20:59.064200+0800 NSNumberFormatter的使用[59895:2506616] No Style                  = 123456790
2017-10-27 17:20:59.064354+0800 NSNumberFormatter的使用[59895:2506616] Decimal Style             = 123,456,789.679
2017-10-27 17:20:59.064436+0800 NSNumberFormatter的使用[59895:2506616] Currency Style            = $123,456,789.68
2017-10-27 17:20:59.064537+0800 NSNumberFormatter的使用[59895:2506616] Percent Style             = 12,345,678,968%
2017-10-27 17:20:59.064626+0800 NSNumberFormatter的使用[59895:2506616] Scientific Style          = 1.234567896789E8
2017-10-27 17:20:59.064720+0800 NSNumberFormatter的使用[59895:2506616] Spell Out Style           = one hundred twenty-three million four hundred fifty-six thousand seven hundred eighty-nine point six seven eight nine
2017-10-27 17:20:59.064828+0800 NSNumberFormatter的使用[59895:2506616] Ordinal Style             = 123,456,790th
2017-10-27 17:20:59.064916+0800 NSNumberFormatter的使用[59895:2506616] Currency ISO Style        = USD123,456,789.68
2017-10-27 17:20:59.065019+0800 NSNumberFormatter的使用[59895:2506616] Currency plural Style     = 123,456,789.68 US dollars
2017-10-27 17:20:59.065107+0800 NSNumberFormatter的使用[59895:2506616] Currency accounting Style = $123,456,789.68

NSNumberFormatter类有个属性numberStyle,它是一个枚举型,设置不同的值可以输出不同的数字格式。该枚举包括

NSNumber *number = @(123456789.6789);
enum {
    NSNumberFormatterNoStyle = kCFNumberFormatterNoStyle, //无格式,四舍五入,输出123456790 
    NSNumberFormatterDecimalStyle = kCFNumberFormatterDecimalStyle, //小数型,保留小数输出123,456,789.679
    NSNumberFormatterCurrencyStyle = kCFNumberFormatterCurrencyStyle, //货币型,加上了人民币标志,原值输出$123,456,789.68
    NSNumberFormatter
    NSNumberFormatterPercentStyle = kCFNumberFormatterPercentStyle,  //百分比型,本身数值乘以100后用百分号表示,输出12,345,678,968%
    NSNumberFormatterScientificStyle = kCFNumberFormatterScientificStyle, //科学计数型,原值表示,输出1.234567896789E8
    NSNumberFormatterSpellOutStyle = kCFNumberFormatterSpellOutStyle  //全拼,原值的中文表示,
};

typedef NSUInteger NSNumberFormatterStyle;

以下是所有API的注释:

NSNumberFormatter *numberFormatter = [NSNumberFormatter new];
numberFormatter.numberStyle.rawValue // numberStyle 0
numberFormatter.locale.localeIdentifier // 语言环境 语言环境
numberFormatter.generatesDecimalNumbers // 是否生成小数 false
numberFormatter.formatterBehavior.rawValue // formatterBehavior 1,040
numberFormatter.negativeFormat // 负格式 "#"
numberFormatter.textAttributesForNegativeValues // textAttributesForNegativeValues nil
numberFormatter.positiveFormat // 正格式 "#"
numberFormatter.textAttributesForPositiveValues // textAttributesForPositiveValues nil
numberFormatter.allowsFloats // 是否允许浮点值 true
numberFormatter.decimalSeparator // 小数分隔符 "."
numberFormatter.alwaysShowsDecimalSeparator // 是否始终显示小数分隔符 false
numberFormatter.currencyDecimalSeparator // 货币小数分隔符 "."
numberFormatter.usesGroupingSeparator // 是否采用分组分隔符 false
numberFormatter.groupingSeparator // 分组分隔符 ","
numberFormatter.zeroSymbol // 零符号 nil
numberFormatter.textAttributesForZero // 文本属性 nil
numberFormatter.nilSymbol // nil符号 ""
numberFormatter.textAttributesForNil // 文本属性 nil
numberFormatter.notANumberSymbol // 非数字符号 "NaN"
numberFormatter.textAttributesForNotANumber // 文本属性 nil
numberFormatter.positiveInfinitySymbol // 正无穷大符号 "+∞"
numberFormatter.textAttributesForPositiveInfinity // 文本属性 nil
numberFormatter.negativeInfinitySymbol // 负无穷大符号 "+∞"
numberFormatter.textAttributesForNegativeInfinity // 文本属性 nil
numberFormatter.positivePrefix // 正前缀 ""
numberFormatter.positiveSuffix // 正后缀 ""
numberFormatter.negativePrefix // 负前缀 "-"
numberFormatter.negativeSuffix // 负后缀 ""
numberFormatter.currencyCode // 货币代码 "USD"
numberFormatter.currencySymbol // 货币符号 "$"
numberFormatter.internationalCurrencySymbol // 国际货币符号 "USD"
numberFormatter.percentSymbol // 百分号符号 "%"
numberFormatter.perMillSymbol // 千分号符号 "‰"
numberFormatter.minusSign // 减号 "-"
numberFormatter.plusSign //加号 "+"
numberFormatter.exponentSymbol // 指数符号 "E"
numberFormatter.groupingSize // 分组大小 0
numberFormatter.secondaryGroupingSize // 第二分组大小 0
numberFormatter.multiplier // 乘数 nil
numberFormatter.formatWidth // 格式宽度 0
numberFormatter.paddingCharacter // 填充字符 "*"
numberFormatter.paddingPosition.rawValue // 填充位置 0
numberFormatter.roundingIncrement // 舍入增量 0
numberFormatter.minimumIntegerDigits // 最小的整数位 0
numberFormatter.maximumIntegerDigits // 最大的整数位 42
numberFormatter.minimumFractionDigits // 最小的小数位数 0
numberFormatter.maximumFractionDigits // 最大的小数位数 0
numberFormatter.minimum // 最小值 nil
numberFormatter.maximum // 最大值 nil
numberFormatter.currencyGroupingSeparator // 货币分组符号 ","
numberFormatter.lenient // false
numberFormatter.usesSignificantDigits // 是否使用有效数字 false
numberFormatter.minimumSignificantDigits // 最小有效数字 1
numberFormatter.maximumSignificantDigits // 最大有效数字 6
numberFormatter.partialStringValidationEnabled // 是否部分字符串验证启用 false

// ==================== 设置属性 ====================

NSNumberFormatter *numberFormatter = [NSNumberFormatter new];
    
    numberFormatter.groupingSize = 4; // 数字分割的尺寸
    numberFormatter.usesGroupingSeparator = true;
    numberFormatter.groupingSeparator = @" "; //数字分割的格式
    
    NSNumber *number = @(123456789);
    
    NSString *spaceStr = [numberFormatter stringFromNumber:number];
    
    NSLog(@"空格 ---- %@",spaceStr);
    
    numberFormatter.numberStyle = NSNumberFormatterDecimalStyle;
    
    // 格式宽度
    numberFormatter.formatWidth = 15;
    
    // 填充符
    numberFormatter.paddingCharacter = @"?";
    
    // 填充位置
    numberFormatter.paddingPosition = kCFNumberFormatterPadBeforeSuffix;
    numberFormatter.positiveSuffix = @"元";
    
    NSLog(@"%@",[numberFormatter numberFromString:@"10000000元"]);  // 10000000
    
    // 貌似没什么用
    numberFormatter.allowsFloats = NO;
    numberFormatter.alwaysShowsDecimalSeparator = NO;
    numberFormatter.maximum = @1000;
    numberFormatter.minimum = @100;
    
    // 小数点样式
    numberFormatter.decimalSeparator = @".";
    
    // 零的样式
    numberFormatter.zeroSymbol       = @"-";
    
    // 前缀和后缀
    numberFormatter.positivePrefix = @"!";
    numberFormatter.positiveSuffix = @"元";
    numberFormatter.negativePrefix = @"@";
    numberFormatter.negativeSuffix = @"亏";
    
    // 指定符号,与我们在前面类方法中说明的一致
    NSLog(@"货币代码%@",numberFormatter.currencyCode);                     // 货币代码USD
    NSLog(@"货币符号%@",numberFormatter.currencySymbol);                   // 货币符号$
    NSLog(@"国际货币符号%@",numberFormatter.internationalCurrencySymbol);   // 国际货币符号USD
    NSLog(@"百分比符号%@",numberFormatter.percentSymbol);                   // 百分比符号%
    NSLog(@"千分号符号%@",numberFormatter.perMillSymbol);                   // 千分号符号‰
    NSLog(@"减号符号%@",numberFormatter.minusSign);                         // 减号符号-
    NSLog(@"加号符号%@",numberFormatter.plusSign);                          // 加号符号+
    NSLog(@"指数符号%@",numberFormatter.exponentSymbol);                    // 指数符号E
    
    // 整数最多位数
    numberFormatter.maximumIntegerDigits = 10;
    
    // 整数最少位数
    numberFormatter.minimumIntegerDigits = 2;
    
    // 小数位最多位数
    numberFormatter.maximumFractionDigits = 3;
    
    // 小数位最少位数
    numberFormatter.minimumFractionDigits = 1;
    
    // 数字分割的尺寸
    numberFormatter.groupingSize = 4;
    
    // 除了groupingSize决定的尺寸外,其他数字位分割的尺寸
    numberFormatter.secondaryGroupingSize = 2;
    
    // 最大有效数字个数
    numberFormatter.maximumSignificantDigits = 12;
    
    // 最少有效数字个数
    numberFormatter.minimumSignificantDigits = 3;
    
    NSLog(@"正数%@,负数%@",[numberFormatter stringFromNumber:@(+12135230.2346)],[numberFormatter stringFromNumber:@(-12135231.2346)]);  // 正数!12,13,5230.2346元,负数@12,13,5231.2346亏
    NSLog(@"零 = %@",[numberFormatter stringFromNumber:@(0)]); //  零 = -
    
    // 舍入值,比如以10为进位值,那么156就进位为160,154进位为150
    numberFormatter.roundingIncrement = @10;
    
    // 舍入方式
    numberFormatter.roundingMode = kCFNumberFormatterRoundHalfUp;
    NSLog(@"%@",[numberFormatter stringFromNumber:@123456.7890]);  // !12,3460元

LINKE:https://github.com/shenyuan000/NSNumberFormatter-

06/15/2018 08:52 上午 posted in  apple

NSObject Class 浅析

Objective-C中有两个NSObject,一个是NSObject类,另一个是NSObject协议。而其中NSObject类采用了NSObject协议。在本文中,我们主要整理一下NSObject类的使用。

说到NSObject类,写Objective-C的人都应该知道它。它是大部分Objective-C类继承体系的根类。这个类提供了一些通用的方法,对象通过继承NSObject,可以从其中继承访问运行时的接口,并让对象具备Objective-C对象的基本能力。以下我们就来看看NSObejct提供给我们的一些基础功能。

+load与+initialize

这两个方法可能平时用得比较少,但很有用。在我们的程序编译后,类相关的数据结构会保留在目标文件中,在程序运行后会被解析和使用,此时类的信息会经历加载和初始化两个过程。在这两个过程中,会分别调用类的load方法和initialize方法,在这两个方法中,我们可以适当地做一些定制处理。不当是类本身,类的分类也会经历这两个过程。对于一个类,我们可以在类的定义中重写这两个方法,也可以在分类中重写它们,或者同时重写。

load方法

对于load方法,当Objective-C运行时加载类或分类时,会调用这个方法;通常如果我们有一些类级别的操作需要在加载类时处理,就可以放在这里面,如为一个类执行Swizzling Method操作。

load消息会被发送到动态加载和静态链接的类和分类里面。不过,只有当我们在类或分类里面实现这个方法时,类/分类才会去调用这个方法。

在类继承体系中,load方法的调用顺序如下:

一个类的load方法会在其所有父类的load方法之后调用
分类的load方法会在对应类的load方法之后调用
在load的实现中,如果使用同一库中的另外一个类,则可能是不安全的,因为可能存在的情况是另外一个类的load方法还没有运行,即另一个类可能尚未被加载。另外,在load方法里面,我们不需要显示地去调用[super load],因为父类的load方法会自动被调用,且在子类之前。

在有依赖关系的两个库中,被依赖的库中的类其load方法会优先调用。但在库内部,各个类的load方法的调用顺序是不确定的。

initialize方法

当我们在程序中向类或其任何子类发送第一条消息前,runtime会向该类发送initialize消息。runtime会以线程安全的方式来向类发起initialize消息。父类会在子类之前收到这条消息。父类的initialize实现可能在下面两种情况下被调用:

子类没有实现initialize方法,runtime将会调用继承而来的实现
子类的实现中显示的调用了[super initialize]
如果我们不想让某个类中的initialize被调用多次,则可以像如下处理:

+ (void)initialize { if (self == [ClassName self]) { // ... do the initialization ... } }

因为initialize是以线程安全的方式调用的,且在不同的类中initialize被调用的顺序是不确定的,所以在initialize方法中,我们应该做少量的必须的工作。特别需要注意是,如果我们initialize方法中的代码使用了锁,则可能会导致死锁。因此,我们不应该在initialize方法中实现复杂的初始化工作,而应该在类的初始化方法(如-init)中来初始化。

另外,每个类的initialize只会被调用一次。所以,如果我们想要为类和类的分类实现单独的初始化操作,则应该实现load方法。

如果想详细地了解这两个方法的使用,可以查看《Effective Objective-C 2.0》的第51条,里面有非常详细的说明。如果想更深入地了解这两个方法的调用,则可以参考objc库的源码,另外,NSObject的load和initialize方法一文从源码层面为我们简单介绍了这两个方法。

对象的生命周期

一说到对象的创建,我们会立即想到[[NSObject alloc] init]这种经典的两段式构造。对于这种两段式构造,唐巧大神在他的”谈ObjC对象的两段构造模式“一文中作了详细描述,大家可以参考一下。

本小节我们主要介绍一下与对象生命周期相关的一些方法。

对象分配

NSObject提供的对象分配的方法有alloc和allocWithZone:,它们都是类方法。这两个方法负责创建对象并为其分配内存空间,返回一个新的对象实例。新的对象的isa实例变量使用一个数据结构来初始化,这个数据结构描述了对象的信息;创建完成后,对象的其它实例变量被初始化为0。

alloc方法的定义如下:

+ (instancetype)alloc

而allocWithZone:方法的存在是由历史原因造成的,它的调用基本上和alloc是一样的。既然是历史原因,我们就不说了,官方文档只给了一句话:

This method exists for historical reasons; memory zones are no longer used by Objective-C.
我们只需要知道alloc方法的实现调用了allocWithZone:方法。

对象初始化

我们一般不去自己重写alloc或allocWithZone:方法,不用去关心对象是如何创建、如何为其分配内存空间的;我们更关心的是如何去初始化这个对象。上面提到了,对象创建后,isa以外的实例变量都默认初始化为0。通常,我们希望将这些实例变量初始化为我们期望的值,这就是init方法的工作了。

NSObject类默认提供了一个init方法,其定义如下:

1

  • (instancetype)init
    正常情况下,它会初始化对象,如果由于某些原因无法完成对象的创建,则会返回nil。注意,对象在使用之前必须被初始化,否则无法使用。不过,NSObject中定义的init方法不做任何初始化操作,只是简单地返回self。

当然,我们定义自己的类时,可以提供自定义的初始化方法,以满足我们自己的初始化需求。需要注意的就是子类的初始化方法需要去调用父类的相应的初始化方法,以保证初始化的正确性。

讲完两段式构造的两个部分,有必要来讲讲NSObject类的new方法了。

new方法实际上是集alloc和init于一身,它创建了对象并初始化了对象。它的实现如下:

+ (instancetype)new {
	 return [[self alloc] init]; 
}

new方法更多的是一个历史遗留产物,它源于NeXT时代。如果我们的初始化操作只是调用[[self alloc] init]时,就可以直接用new来代替。不过如果我们需要使用自定义的初始化方法时,通常就使用两段式构造方式。

拷贝

说到拷贝,相信大家都很熟悉。拷贝可以分为“深拷贝”和“浅拷贝”。深拷贝拷贝的是对象的值,两个对象相互不影响,而浅拷贝拷贝的是对象的引用,修改一个对象时会影响到另一个对象。

在Objective-C中,如果一个类想要支持拷贝操作,则需要实现NSCopying协议,并实现copyWithZone:【注意:NSObject类本身并没有实现这个协议】。如果一个类不是直接继承自NSObject,则在实现copyWithZone:方法时需要调用父类的实现。

虽然NSObject自身没有实现拷贝协议,不过它提供了两个拷贝方法,如下:

1

  • (id)copy
    这个是拷贝操作的便捷方法。它的返回值是NSCopying协议的copyWithZone:方法的返回值。如果我们的类没有实现这个方法,则会抛出一个异常。

与copy对应的还有一个方法,即:

1

  • (id)mutableCopy
    从字面意义来讲,copy可以理解为不可变拷贝操作,而mutableCopy可以理解为可变操作。这便引出了拷贝的另一个特性,即可变性。

顾名思义,不可变拷贝即拷贝后的对象具有不可变属性,可变拷贝后的对象具有可变属性。这对于数组、字典、字符串、URL这种分可变和不可变的对象来说是很有意义的。我们来看如下示例:

NSMutableArray *mutableArray = [NSMutableArray array]; 
NSMutableArray *array = [mutableArray copy]; 
[array addObject:@"test1"];

实际上,这段代码是会崩溃的,我们来看看崩溃日志:

-[__NSArrayI addObject:]: unrecognized selector sent to instance 0x100107070 
*** Terminating app due to uncaught exception 'NSInvalidArgumentException', reason: '-[__NSArrayI addObject:]: unrecognized selector sent to instance 0x100107070'

从中可以看出,经过copy操作,我们的array实际上已经变成不可变的了,其底层元类是__NSArrayI。这个类是不支持addObject:方法的。

偶尔在代码中,也会看到类似于下面的情况:

@property (copy) NSMutableArray *array;

这种属性的声明方式是有问题的,即上面提到的可变性问题。使用self.array = **赋值后,数组其实是不可变的,所以需要特别注意。

mutableCopy的使用也挺有意思的,具体的还请大家自己去试验一下。

释放

当一个对象的引用计数为0时,系统就会将这个对象释放。此时runtime会自动调用对象的dealloc方法。在ARC环境下,我们不再需要在此方法中去调用[super dealloc]了。我们重写这个方法主要是为了释放对象中用到的一些资源,如我们通过C方法分配的内存空间。dealloc方法的定义如下:

- (void)dealloc

需要注意的是,我们不应该直接去调用这个方法。这些事都让runtime去做吧。

消息发送

Objective-C中对方法的调用并不是像C++里面那样直接调用,而是通过消息分发机制来实现的。这个机制核心的方法是objc_msgSend函数。消息机制的具体实现我们在此不做讨论,可以参考Objective-C Runtime 运行时之三:方法与消息

对于消息的发送,除了使用[obj method]这种机制之外,NSObject类还提供了一系列的performSelector**方法。这些方法可以让我们更加灵活地控制方法的调用。接下来我们就来看看这些方法的使用。

在线程中调用方法

如果我们想在当前线程中调用一个方法,则可以使用以下两个方法:

- (void)performSelector:(SEL)aSelector withObject:(id)anArgument afterDelay:(NSTimeInterval)delay 
- (void)performSelector:(SEL)aSelector withObject:(id)anArgument afterDelay:(NSTimeInterval)delay inModes:(NSArray *)modes

这两个方法会在当前线程的Run loop中设置一个定时器,以在delay指定的时间之后执行aSelector。如果我们希望定时器运行在默认模式(NSDefaultRunLoopMode)下,可以使用前一个方法;如果想自己指定Run loop模式,则可以使用后一个方法。

当定时器启动时,线程会从Run loop的队列中获取到消息,并执行相应的selector。如果Run loop运行在指定的模式下,则方法会成功调用;否则,定时器会处于等待状态,直到Run loop运行在指定模式下。

需要注意的是,调用这些方法时,Run loop会保留方法接收者及相关的参数的引用(即对这些对象做retain操作),这样在执行时才不至于丢失这些对象。当方法调用完成后,Run loop会调用这些对象的release方法,减少对象的引用计数。

如果我们想在主线程上执行某个对象的方法,则可以使用以下两个方法:

- (void)performSelectorOnMainThread:(SEL)aSelector withObject:(id)arg waitUntilDone:(BOOL)wait 
- (void)performSelectorOnMainThread:(SEL)aSelector withObject:(id)arg waitUntilDone:(BOOL)wait modes:(NSArray *)array

我们都知道,iOS中所有的UI操作都需要在主线程中处理。如果想在某个二级线程的操作完成之后做UI操作,就可以使用这两个方法。

这两个方法会将消息放到主线程Run loop的队列中,前一个方法使用的是NSRunLoopCommonModes运行时模式;如果想自己指定运行模式,则使用后一个方法。方法的执行与之前的两个performSelector方法是类似的。当在一个线程中多次调用这个方法将不同的消息放入队列时,消息的分发顺序与入队顺序是一致的。

方法中的wait参数指定当前线程在指定的selector在主线程执行完成之后,是否被阻塞住。如果设置为YES,则当前线程被阻塞。如果当前线程是主线程,而该参数也被设置为YES,则消息会被立即发送并处理。

另外,这两个方法分发的消息不能被取消。

如果我们想在指定的线程中分发某个消息,则可以使用以下两个方法:

- (void)performSelector:(SEL)aSelector onThread:(NSThread *)thread withObject:(id)arg waitUntilDone:(BOOL)wait 
- (void)performSelector:(SEL)aSelector onThread:(NSThread *)thread withObject:(id)arg waitUntilDone:(BOOL)wait modes:(NSArray *)array

这两个方法基本上与在主线程的方法差不多。在此就不再讨论。

如果想在后台线程中调用接收者的方法,可以使用以下方法:

- (void)performSelectorInBackground:(SEL)aSelector withObject:(id)arg

这个方法会在程序中创建一个新的线程。由aSelector表示的方法必须像程序中的其它新线程一样去设置它的线程环境。

当然,我们经常看到的performSelector系列方法中还有几个方法,即:

- (id)performSelector:(SEL)aSelector 
- (id)performSelector:(SEL)aSelector withObject:(id)anObject 
- (id)performSelector:(SEL)aSelector withObject:(id)anObject withObject:(id)anotherObject

不过这几个方法是在NSObject协议中定义的,NSObject类实现了这个协议,也就定义了相应的实现。这个我们将在NSObject协议中来介绍。

取消方法调用请求

对于使用performSelector:withObject:afterDelay:方法(仅限于此方法)注册的执行请求,在调用发生前,我们可以使用以下两个方法来取消:

+ (void)cancelPreviousPerformRequestsWithTarget:(id)aTarget 
+ (void)cancelPreviousPerformRequestsWithTarget:(id)aTarget selector:(SEL)aSelector object:(id)anArgument

前一个方法会取消所以接收者为aTarget的执行请求,不过仅限于当前run loop,而不是所有的。

后一个方法则会取消由aTarget、aSelector和anArgument三个参数指定的执行请求。同样仅限于当前run loop。

消息转发及动态解析方法

当一个对象能接收一个消息时,会走正常的方法调用流程。但如果一个对象无法接收一个消息时,就会走消息转发机制。

消息转发机制基本上分为三个步骤:

动态方法解析
备用接收者
完整转发
具体流程可参考Objective-C Runtime 运行时之三:方法与消息,《Effective Objective-C 2.0》一书的第12小节也有详细描述。在此我们只介绍一下NSObject类为实现消息转发提供的方法。

首先,对于动态方法解析,NSObject提供了以下两个方法来处理:

+ (BOOL)resolveClassMethod:(SEL)name 
+ (BOOL)resolveInstanceMethod:(SEL)name

从方法名我们可以看出,resolveClassMethod:是用于动态解析一个类方法;而resolveInstanceMethod:是用于动态解析一个实例方法。

我们知道,一个Objective-C方法是其实是一个C函数,它至少带有两个参数,即self和_cmd。我们使用class_addMethod函数,可以给类添加一个方法。我们以resolveInstanceMethod:为例,如果要给对象动态添加一个实例方法,则可以如下处理:

void dynamicMethodIMP(id self, SEL _cmd) { 
	// implementation .... 
} 
+ (BOOL) resolveInstanceMethod:(SEL)aSEL { 
if (aSEL == @selector(resolveThisMethodDynamically)) { 
	class_addMethod([self class], aSEL, (IMP) dynamicMethodIMP, "v@:"); 
	return YES; 
	} 
return [super resolveInstanceMethod:aSel]; 
}

其次,对于备用接收者,NSObject提供了以下方法来处理:

- (id)forwardingTargetForSelector:(SEL)aSelector

该方法返回未被接收消息最先被转发到的对象。如果一个对象实现了这个方法,并返回一个非空的对象(且非对象本身),则这个被返回的对象成为消息的新接收者。另外如果在非根类里面实现这个方法,如果对于给定的selector,我们没有可用的对象可以返回,则应该调用父类的方法实现,并返回其结果。

最后,对于完整转发,NSObject提供了以下方法来处理

- (void)forwardInvocation:(NSInvocation *)anInvocation

当前面两步都无法处理消息时,运行时系统便会给接收者最后一个机会,将其转发给其它代理对象来处理。这主要是通过创建一个表示消息的NSInvocation对象并将这个对象当作参数传递给forwardInvocation:方法。我们在forwardInvocation:方法中可以选择将消息转发给其它对象。

在这个方法中,主要是需要做两件事:

找到一个能处理anInvocation调用的对象。
将消息以anInvocation的形式发送给对象。anInvocation将维护调用的结果,而运行时则会将这个结果返回给消息的原始发送者。
这一过程如下所示:

- (void)forwardInvocation:(NSInvocation *)invocation { 
	SEL aSelector = [invocation selector]; 
	if ([friend respondsToSelector:aSelector]) 
		[invocation invokeWithTarget:friend]; 
	else 
	[super forwardInvocation:invocation]; 
}

当然,对于一个非根类,如果还是无法处理消息,则应该调用父类的实现。而NSObject类对于这个方法的实现,只是简单地调用了doesNotRecognizeSelector:。它不再转发任何消息,而是抛出一个异常。doesNotRecognizeSelector:的声明如下:

- (void)doesNotRecognizeSelector:(SEL)aSelector

运行时系统在对象无法处理或转发一个消息时会调用这个方法。这个方法引发一个NSInvalidArgumentException异常并生成一个错误消息。

任何doesNotRecognizeSelector:消息通常都是由运行时系统来发送的。不过,它们可以用于阻止一个方法被继承。例如,一个NSObject的子类可以按以下方式来重写copy或init方法以阻止继承:

- (id)copy { 
	[self doesNotRecognizeSelector:_cmd]; 
}

这段代码阻止子类的实例响应copy消息或阻止父类转发copy消息—虽然respondsToSelector:仍然报告接收者可以访问copy方法。

当然,如果我们要重写doesNotRecognizeSelector:方法,必须调用super的实现,或者在实现的最后引发一个NSInvalidArgumentException异常。它代表对象不能响应消息,所以总是应该引发一个异常。

获取方法信息

在消息转发的最后一步中,forwardInvocation:参数是一个NSInvocation对象,这个对象需要获取方法签名的信息,而这个签名信息就是从methodSignatureForSelector:方法中获取的。

该方法的声明如下:

- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector

这个方法返回包含方法描述信息的NSMethodSignature对象,如果找不到方法,则返回nil。如果我们的对象包含一个代理或者对象能够处理它没有直接实现的消息,则我们需要重写这个方法来返回一个合适的方法签名。

对应于实例方法,当然还有一个处理类方法的相应方法,其声明如下:

+ (NSMethodSignature *)instanceMethodSignatureForSelector:(SEL)aSelector

另外,NSObject类提供了两个方法来获取一个selector对应的方法实现的地址,如下所示:

- (IMP)methodForSelector:(SEL)aSelector 
+ (IMP)instanceMethodForSelector:(SEL)aSelector

获取到了方法实现的地址,我们就可以直接将IMP以函数形式来调用。

对于methodForSelector:方法,如果接收者是一个对象,则aSelector应该是一个实例方法;如果接收者是一个类,则aSelector应该是一个类方法。

对于instanceMethodForSelector:方法,其只是向类对象索取实例方法的实现。如果接收者的实例无法响应aSelector消息,则产生一个错误。

测试类

对于类的测试,在NSObject类中定义了两个方法,其中类方法instancesRespondToSelector:用于测试接收者的实例是否响应指定的消息,其声明如下:

1

  • (BOOL)instancesRespondToSelector:(SEL)aSelector
    如果aSelector消息被转发到其它对象,则类的实例可以接收这个消息而不会引发错误,即使该方法返回NO。

为了询问类是否能响应特定消息(注意:不是类的实例),则使用这个方法,而不使用NSObject协议的实例方法respondsToSelector:。

NSObject还提供了一个方法来查看类是否采用了某个协议,其声明如下:

+ (BOOL)conformsToProtocol:(Protocol *)aProtocol

如果一个类直接或间接地采用了一个协议,则我们可以说这个类实现了该协议。我们可以看看以下这个例子:

@protocol AffiliationRequests <Joining> 
@interface MyClass : NSObject <AffiliationRequests, Normalization> 
BOOL canJoin = [MyClass conformsToProtocol:@protocol(Joining)];

通过继承体系,MyClass类实现了Joining协议。

不过,这个方法并不检查类是否实现了协议的方法,这应该是程序员自己的职责了。

识别类

NSObject类提供了几个类方法来识别一个类,首先是我们常用的class类方法,该方法声明如下:

+ (Class)class

该方法返回类对象。当类是消息的接收者时,我们只通过类的名称来引用一个类。在其它情况下,类的对象必须通过这个方法类似的方法(-class实例方法)来获取。如下所示:

BOOL test = [self isKindOfClass:[SomeClass class]];

NSObject还提供了superclass类方法来获取接收者的父类,其声明如下:

+ (Class)superclass

另外,我们还可以使用isSubclassOfClass:类方法查看一个类是否是另一个类的子类,其声明如下:

1

  • (BOOL)isSubclassOfClass:(Class)aClass
    描述类

描述类是使用description方法,它返回一个表示类的内容的字符串。其声明如下:

1

  • (NSString *)description
    我们在LLDB调试器中打印类的信息时,使用的就是这个方法。

当然,如果想打印类的实例的描述时,使用的是NSObject协议中的实例方法description,我们在此不多描述。

归档操作

一说到归档操作,你会首先想到什么呢?我想到的是NSCoding协议以及它的两个方法:

initWithCoder:和encodeWithCoder:。如果我们的对象需要支持归档操作,则应该采用这个协议并提供两个方法的具体实现。

在编码与解码的过程中,一个编码器会调用一些方法,这些方法允许将对象编码以替代一个更换类或实例本身。这样,就可以使得归档在不同类层次结构或类的不同版本的实现中被共享。例如,类簇能有效地利用这一特性。这一特性也允许每个类在解码时应该只维护单一的实例来执行这一策略。

NSObject类虽然没有采用NSCoding协议,但却提供了一些替代方法,以支持上述策略。这些方法分为两类,即通用和专用的。

通用方法由NSCoder对象调用,主要有如下几个方法和属性:

@property(readonly) Class classForCoder 
- (id)replacementObjectForCoder:(NSCoder *)aCoder 
- (id)awakeAfterUsingCoder:(NSCoder *)aDecoder

专用的方法主要是针对NSKeyedArchiver对象的,主要有如下几个方法和属性:

@property(readonly) Class classForKeyedArchiver 
+ (NSArray *)classFallbacksForKeyedArchiver 
+ (Class)classForKeyedUnarchiver 
- (id)replacementObjectForKeyedArchiver:(NSKeyedArchiver *)archiver

子类在归档的过程中如果有特殊的需求,可以重写这些方法。这些方法的具体描述,可以参考官方文档。

在解码或解档过程中,有一点需要考虑的就是对象所属类的版本号,这样能确保老版本的对象能被正确地解析。NSObject类对此提供了两个方法,如下所示:

+ (void)setVersion:(NSInteger)aVersion 
+ (NSInteger)version

它们都是类方法。默认情况下,如果没有设置版本号,则默认是0.

总结

NSObject类是Objective-C中大部分类层次结构中的根类,并为我们提供了很多功能。了解这些功能更让我们更好地发挥Objective-C的特性。

04/20/2018 19:39 下午 posted in  apple

关于CLASS , SEL, IMP的说明

cocoa当中的函数调用,是一种以消息的方式进行的函数调用,这一点与C++,java是有很大差别的。因此该类型的理解,会涉及到三个重要的概念,class,sel,IMP。

##class
每个NSObject的第一个成员变量都是class类型的成员,isa,这个isa的对象可以访问到本类的父类,也可以访问到本类的所有方法的列表。

##SEL
这个是方法名称的描述。

##IMP
这个是具体的方法的地址。

##Class 的含义

Class 被定义为一个指向 objc_class的结构体指针,这个结构体表示每一个类的类结构。而 objc_class 在objc/objc_class.h中定义如下:

struct objc_class {
    struct objc_class super_class;  /*父类*/
    const char *name;                 /*类名字*/
    long version;                   /*版本信息*/
    long info;                        /*类信息*/
    long instance_size;               /*实例大小*/
    struct objc_ivar_list *ivars;     /*实例参数链表*/
    struct objc_method_list **methodLists;  /*方法链表*/
    struct objc_cache *cache;               /*方法缓存*/
    struct objc_protocol_list *protocols;   /*协议链表*/
};

由此可见,Class 是指向类结构体的指针,该类结构体含有一个指向其父类类结构的指针,该类方法的链表,该类方法的缓存以及其他必要信息。

NSObject 的class 方法就返回这样一个指向其类结构的指针。每一个类实例对象的第一个实例变量是一个指向该对象的类结构的指针,叫做isa。通过该指针,对象可以访问它对应的类以及相应的父类。如图一所示:

如图一所示,圆形所代表的实例对象的第一个实例变量为 isa,它指向该类的类结构 The object’s class。而该类结构有一个指向其父类类结构的指针superclass, 以及自身消息名称(selector)/实现地址(address)的方法链表。

##方法的含义:

注意这里所说的方法链表里面存储的是Method 类型的。图一中selector 就是指 Method的 SEL, address就是指Method的 IMP。 Method 在头文件 objc_class.h中定义如下:

typedef struct objc_method *Method;
typedef struct objc_ method {
    SEL method_name;
    char *method_types;
    IMP method_imp;
};

一个方法 Method,其包含一个方法选标 SEL – 表示该方法的名称,一个types – 表示该方法参数的类型,一个 IMP - 指向该方法的具体实现的函数指针。

##SEL 的含义:

在前面我们看到方法选标 SEL 的定义为:

typedef struct objc_selector   *SEL;   

它是一个指向 objc_selector 指针,表示方法的名字/签名。如下所示,打印出 selector。

-(NSInteger)maxIn:(NSInteger)a theOther:(NSInteger)b{
    return (a > b) ? a : b;
}
NSLog(@"SEL=%s", @selector(maxIn:theOther:));

输出:SEL=maxIn:theOther:

不同的类可以拥有相同的 selector,这个没有问题,因为不同类的实例对象performSelector相同的 selector 时,会在各自的消息选标(selector)/实现地址(address) 方法链表中根据 selector 去查找具体的方法实现IMP, 然后用这个方法实现去执行具体的实现代码。这是一个动态绑定的过程,在编译的时候,我们不知道最终会执行哪一些代码,只有在执行的时候,通过selector去查询,我们才能确定具体的执行代码。

##IMP 的含义:

在前面我们也看到 IMP 的定义为:

typedef id (*IMP)(id, SEL, ...);

根据前面id 的定义,我们知道 id是一个指向 objc_object 结构体的指针,该结构体只有一个成员isa,所以任何继承自 NSObject 的类对象都可以用id 来指代,因为 NSObject 的第一个成员实例就是isa。

至此,我们就很清楚地知道 IMP 的含义:IMP 是一个函数指针,这个被指向的函数包含一个接收消息的对象id(self 指针), 调用方法的选标 SEL (方法名),以及不定个数的方法参数,并返回一个id。也就是说 IMP 是消息最终调用的执行代码,是方法真正的实现代码 。我们可以像在C语言里面一样使用这个函数指针。

NSObject 类中的methodForSelector:方法就是这样一个获取指向方法实现IMP 的指针,methodForSelector:返回的指针和赋值的变量类型必须完全一致,包括方法的参数类型和返回值类型。

下面的例子展示了怎么使用指针来调用setFilled:的方法实现:

void (*setter)(id, SEL, BOOL);
int i;
 
setter = (void(*)(id, SEL, BOOL))[target methodForSelector:@selector(setFilled:)];
 
for (i = 0; i < 1000; i++)
    setter(targetList[i], @selector(setFilled:), YES);

使用methodForSelector:来避免动态绑定将减少大部分消息的开销,但是这只有在指定的消息被重复发送很多次时才有意义,例如上面的for循环。

注意,methodForSelector:是Cocoa运行时系统的提供的功能,而不是Objective-C语言本身的功能。

几个重要的辅助函数,可以在使用过程中起到很好的辅助作用,尤其是在动态编译等起到了比较大的作用。

我们可以通过NSObject的一些方法获取运行时信息或动态执行一些消息:

class 返回对象的类;

isKindOfClass 和 isMemberOfClass检查对象是否在指定的类继承体系中;

respondsToSelector 检查对象能否相应指定的消息;

conformsToProtocol 检查对象是否实现了指定协议类的方法;

methodForSelector 返回指定方法实现的地址。

performSelector:withObject 执行SEL 所指代的方法。

04/12/2018 09:07 上午 posted in  apple

iOS中的内存管理

既然是内存管理,首先要知道那么内存是用来干什么的?内存具体管理的东西是什么?当然这些东西基本都是常识了,内存当然是用来存储数据的,内存要管理的东西简单的说也就是如何将数据存储到内存中(比如说我们的声明变量就可以将数据存储到内存中),其次存储到内存中的数据怎样释放,什么时候释放,这都是内存管理需要来关心的.

正文:

1.内存中的五大区域

内存分为5个区域,分别指的是----->栈区/堆区/BSS段/数据段/代码段

栈:存储局部变量,当其作用域执行完毕之后,就会被系统立即收回

堆:存储OC对象,手动申请的字节空间,需要调用free来释放

BSS段:未初始化的全局变量和静态变量,一旦初始化就会从BSS段中回收掉,转存到数据段中

数据段:存储已经初始化的全局变量和静态变量,以及常量数据,直到结束程序时才会被立即收回

代码段:代码,直到结束程序时才会被立即收回

2.OC中堆区存储对象的特点

除了堆区,其他区域的中存储的数据,都是又系统自动释放的

堆区中的OC对象,是不会自动释放的,如果不主动释放,那么将在程序结束的时候才去释放

3.引用计数器

首先简单来说一下,每一个OC对象都有一个属性,叫做retainCount,翻译过来也就是引用计数器,类型为unsigned long,占据8个字节,每一个对象负责维护对象所引用的记数值,当一个新的引用指向对象,那么这个对象的引用值增加1,当我们新创建出一个对象的时候这个对象的引用计数器的值默认为1,当这个对象被少一次引用的时候那么就先让这个对象的引用记数值减1,当这个对象所引用的记数值为0的时候,代表这个对象没有被使用,这时系统会自动回收掉此对象,回收这个对象的同时自动调用这个对象的dealloc方法

控制规则:

为对象发送一条retain消息,那么对象的引用计数器的值就会+1

为对象发送一条release消息,那么对象的引用计数器的值就会-1

为对象发送一条retainCount消息,那么就可以得到这个对象的引用计数器的值

4.内存管理的分类

MRC:Manual Reference Counting 手动引用计数器,需要我们手动管理对象引用计数器的值

ARC:Autimatic Reference Counting 自动引用计数器,系统自动的改变对象引用计数器的值(iOS5之后),ARC是基于MRC的

5.内存管理基本原则

新创建一个对象,这个对象的引用计数器的值为1,有对象的创建,就需要匹配一个release

是谁来负责retain的,谁就要负责release,使用的时候retain,不是用的时候release

retain的次数要和release次数想匹配,有加有减,做到平衡

6.野指针

在C中,声明一个指针变量,没有为这个指针变量初始化,那么这个指针变量的值也就是一个垃圾值,指针指向随机的一块空间,那么我们叫做野指针

在OC中,一个指针指向的对象被释放了,那么这个指针叫野指针

7.对象的回收

对象所占用的字节空间,分配给别人使用,系统未分配这块空间被别人使用之前,这个对象的数据仍然处在内存中

8.僵尸对象

已经被收回但是这个对象的数据仍然处在内存中,像这样的对象叫做僵尸对象

僵尸对象有可能可以访问也有可能不可以访问,当僵尸对象所占的内存空间还没有分配给别人使用的时候,这个数据的对象其实仍然存在,通过指针仍然可以找到这个对象,所以说这个时候僵尸对象还可以被访问,当这个僵尸对象已经分配给别人使用的时候,这个对象就不存在了,这个时候不可以被访问

注意:一旦一个对象成为僵尸对象之后,这个对象无论如何都不应该被使用,无论有没有分配给别人使用,都不能用!且不可以复活!

9.避免内存泄漏

有对象的创建,就必须要匹配一个release,retain和release的次数要匹配,不要随便为一个指针赋值为nil,除非这个指针是野指针,在方法中不要随意对传入的对象进行retain

当我们通过野指针去访问僵尸对象的时候会报错,为了避免报错当一个指针成为野指针后,为这个指针赋值为nil

FROM:https://blog.csdn.net/oboe_b/article/details/78140027

04/12/2018 08:47 上午 posted in  apple

get the iOS device CPU architecture in runtime

from:http://stackoverflow.com/questions/19859388/how-can-i-get-the-ios-device-cpu-architecture-in-runtime

#include <sys/types.h>
#include <sys/sysctl.h>
#include <mach/machine.h>

NSString *getCPUType(void)
{
    NSMutableString *cpu = [[NSMutableString alloc] init];
    size_t size;
    cpu_type_t type;
    cpu_subtype_t subtype;
    size = sizeof(type);
    sysctlbyname("hw.cputype", &type, &size, NULL, 0);

    size = sizeof(subtype);
    sysctlbyname("hw.cpusubtype", &subtype, &size, NULL, 0);

    // values for cputype and cpusubtype defined in mach/machine.h
    if (type == CPU_TYPE_X86)
    {
            [cpu appendString:@"x86 "];
             // check for subtype ...

    } else if (type == CPU_TYPE_ARM)
    {
            [cpu appendString:@"ARM"];
            switch(subtype)
            {
                    case CPU_SUBTYPE_ARM_V7:
                    [cpu appendString:@"V7"];
                    break;
                    // ...
            }
    }
    return [cpu autorelease];
}
- (NSString *)getCPUType {
      NSMutableString *cpu = [[NSMutableString alloc] init];
      size_t size;
      cpu_type_t type;
      cpu_subtype_t subtype;
      size = sizeof(type);
      sysctlbyname("hw.cputype", &type, &size, NULL, 0);

      size = sizeof(subtype);
      sysctlbyname("hw.cpusubtype", &subtype, &size, NULL, 0);

      // values for cputype and cpusubtype defined in mach/machine.h
      if (type == CPU_TYPE_X86_64) {
          [cpu appendString:@"x86_64"];
      } else if (type == CPU_TYPE_X86) {
          [cpu appendString:@"x86"];
      } else if (type == CPU_TYPE_ARM) {
          [cpu appendString:@"ARM"];
          switch(subtype)
          {
              case CPU_SUBTYPE_ARM_V6:
                  [cpu appendString:@"V6"];
                  break;
              case CPU_SUBTYPE_ARM_V7:
                  [cpu appendString:@"V7"];
                  break;
              case CPU_SUBTYPE_ARM_V8:
                  [cpu appendString:@"V8"];
                  break;
          }
      }
      return cpu; 
  }
05/03/2017 15:53 下午 posted in  apple