SGF解析部分来自于Super Go。昨天改掉了一些问题，但更大问题是Super Go实际上是对战类型，这个SGF解析只有最简单的功能。而作为打谱软件，要具备以下功能才行：

1.标记，例如下面这些（图片来自于http://senseis.xmp.net/?HowDiagramsWork）：

2.分支。在棋局、死活题、变化等讲解时非常有用。
3.交互。做题时候可以根据落子不同进行解说。就像EidoGo那样。
4.棋谱库。维护棋谱，并可以做出修改。

简而言之就是尽量多支持sgf的Tag。另外本来想直接沿用Super Go的各种数据结构，但一来为了支持上面这些功能，二来如果都用了人家的自己就写点UI算什么？所以重写ing。现在大概就是这样：

如果决定填坑的话，保守估计一个月的业余时间要搭进去。

p.s：著名的XGoo（在移动平台的知名度不亚于Stonebase之于PC）最近出了iOS版本！这是个值得让人去买个pad的软件，不夸张。

竟然还有wordpress专用插件，太高级了。

[Embedded SGF File: “迷你中国流” 布局浅析]

可能有人会说这种问题还用得着单写一篇文章吗，AudioPlayerAgent当然支持动态列表了。但很可惜MSDN的官方How-To的例子就是硬编码的列表（还是本地音频），不然也不会在App Hub Forum上出现这样的问题（1、2）。

一般来说将播放列表传递给Agent有这几种方式：

• IsolatedStorageSettings
• 静态方法或属性（作为BackgroundAgent，实例化它没有意义）
• IsolatedStorageFile

实验之后就会发现，前两种方法并不好用：虽然在UI线程中设置了列表或者通过静态方法、属性传递了列表，但启动后的Agent拿不到这些数据。就算是单写一个存储播放列表数据的静态类也是一样。那么留给我们的方法只有通过文件传递。

在上面提到的那个帖子中，一位微软员工Mark Chamberlain给出的方案也是如此（全文请看原帖）：

This is how I did it:
In background audio agent code:
OnUserAction.Play/SkipNext/SkipPrevious: Check if BackgroundAudioPlayer.Instance.Track == null, if yes then load playlist from IsoStorage into m_playlist and start playing first track, if no then play current/next/previous song from m_playlist
In the album viewmodel code (each time a user selects an album a new viewmodel gets created for this app):
OnInitialization:…
Another developer who reviewed this suggested that instead of calling ..Instance.Close(), which also releases all the background audio resources, a better approach is to set BackgroundAudioPlayer.Instance.Track = null, which stops and clears, but keeps the background resources allocated.

基本思路即UI存好文件，Agent初始化时候载入。任何和播放相关操作前播放列表如果为null则再次载入。

具体到我手头的例子，文件格式我直接用的Xml序列化，写起来简单。由于需要和UI保持实时，那么每修改一次播放列表（添加、删除、改动）都要保存，同时在Agent一边，任何和播放相关操作前则不仅检查是否列表为null，而是直接全部重新载入。类似于：

protected override void OnUserAction(BackgroundAudioPlayer player, AudioTrack track, UserAction action, object param) {
    var allTracks = TrackManager.GetAllTracks();
    _playList = new List<AudioTrack>();
    foreach ( TrackItem trackItem in allTracks ) {
    _playList.Add( 
            new AudioTrack( null, trackItem.Title, trackItem.Album, null, null, trackItem.Url, EnabledPlayerControls.Pause ) );
    }
    //...
}

代码写出来非常愚蠢，但目前为止找不到更好的方法。

class B1{virtual void foo(){}};
class B2{};
class D{};
D* pD=dynamic_cast<D*>(new B1()); // （1）
cout<<*(int*)(&pD)<<endl;
D* pD2=dynamic_cast<D*>(new B2()); // （2）
cout<<*(int*)(&pD2)<<endl;

可以看到B1、B2和D三个类没什么继承关系，但（1）处通过编译，（2）处提示：

cannot dynamic_cast `(((main()::B2*)operator new(1u)), (((*)  main()::B2()), ))' (of type `class main()::B2*') to type `class main()::D*' (source type is not polymorphic) 

即来源类型非多态。所以实际上并非是“有继承关系的对象指针”可用dynamic_cast<>转换，而是有vtable的类都可以转——只不过没继承关系的话转出来为NULL。
那么再想一下，既然提示了“多态”，也就是说关键点不在“继承”这里，所以形如下面的代码：

class X {};
class Y : X {};
Y* y = dynamic_cast<Y*>(new X()); // failed!

虽然两个类有继承关系，但必然通不过编译，因为基类子类并未表现出多态，编译器不会多费劲来生成vtable。在文章多继承的虚指针中提到了dynamic_cast的内部实现：

void *FindCompleteObject (void *ptr )
{
     const _s_RTTICompleteObjectLocator *pCompleteLocator =GetCompleteObjectLocator (ptr );
     ptr =ptr -pCompleteLocator ->offset ;
     if (pCompleteLocator ->cdOffset ) ptr -=*(ptr -pCompleteLocator ->cdOffset );
     return ptr ;
}
void *__RTCastToVoid (void *ptr )
{
     if (!ptr ) return NULL ;
     return FindCompleteObject (ptr );
}

可以看到只有vtable存在，寻找Complete Object Locator的行为才有意义——虚表的第一项就是RTTI Complete Object Locator（RTTI Info），其中包含RTTI类型描述（Type Descriptor）、RTTI继承关系（Class Hierarchy）^[2]。故言C++的RTTI特性也是以vtable的存在为基础，没有虚函数或其他virtual特性，RTTI不生效。
当然一般使用中其实理解成dynamic_cast<>用于向下转换带有继承关系的指针也没错，上面提到的这两个特例应该很少会出现在实际代码中吧。但此处犯错足见俺基础太差，离C++对象模型的深入理解还差得远。
p.s：真想把之前这类因为基础差犯2B错误的文章集结起来。最近几个月就写了不少。

参考资料

1. 多继承的虚指针，lw02nju
2. 浅议 Dynamic_cast 和 RTTI，RocZhang

1. 构造和拷贝构造
2. 动态特性和RTTI
3. 内存管理和标准C区别
4. 监视方式
5. 数据持久化
6. RTTI和动态特性2
7. 容器类、Block和NSPredicate

04监视方式

Protocol

用protocol实现的delegate。其实我觉得这个就是观察者，只不过默认情况下是单一的观察者。具体方法不总结了。

有什么方法可以一次性存放多个delegate？这样就可以用数组方法一口气通知完：

[array makeObjectsPerformSelector:@selector(doSomething:) withObject:aObject];

如果写N个变量第一比较罗嗦第二也不知道运行时会有多少个观察者。但问题在于NSArray和NSMutableArray不能存指针之外的对象，protocol实例不认。

KVO

KVO，也就是Key-Value Observer，是除了protocol和notification之外的又一种属性监视方式

监视别人的类重载一个方法，用于观察值变化

- (void) observeValueForKeyPath:(NSString*)aPath ofObject:(id)anObject change:(NSDictionary*)aChange context:(void*)aContext {
           NSLog( @"%@ has observered key %@ change in %@, from %@ to %@",
                [self class], aPath, anObject, [aChange objectForKey:@"old"], [aChange objectForKey:@"new"] );
}

被监视的类不用特意修改。

发送消息时，需要用NSObject里面某Category已经定义好的add/removeObserver增删observer即可

Coder* me = [Coder personWithName:@"Si Wei" andAge:25];
    [me setLanguage:@"C#"];
    Computer* computer = [[Computer alloc] init];
    [computer addObserver:me forKeyPath:@"workload" options:NSKeyValueObservingOptionNew | NSKeyValueObservingOptionNew context:nil];
    [computer setWorkload:10];
    [computer setWorkload:50];
    [computer removeObserver:me forKeyPath:@"workload"];
    [computer release];<span id="more-643586"></span>

Notification Center

监视者在初始化时候告诉NC自己要监视“哪个名字”，这个名字可以自定，只要保证post消息时候用一样的即可。

NSNotificationCenter* notifyCenter = [NSNotificationCenter defaultCenter];
    [notifyCenter addObserver:self selector:@selector(handleWorkloadNotification:) name:@"workload_notify" object:nil];

需要传入一个方法的selector。具体函数名参数名随便，但参数只能有一个NSNotification。

- (void) handleWorkloadNotification:(NSNotification*)aNotification {
    Computer* newCom = [aNotification object];
    NSLog( @"%@ has been notified with workload %d from %@", [self class], [newCom workload], newCom );
}

被监视的类不用特意修改。

发送通知时，使用NC的postNotificationName方法，这里的name就是上面那个。

Coder* me = [[Coder alloc] initWithArgs:@"Si Wei" andAge:25 andLanguage:@"C#"];
    Computer* computer = [[Computer alloc] init];
    NSNotificationCenter* notifyCenter = [NSNotificationCenter defaultCenter];
    [notifyCenter postNotificationName:@"workload_notify" object:computer];
    [computer setWorkload:10];
    [notifyCenter postNotificationName:@"workload_notify" object:computer];
    [me release];
    [computer release];

05数据持久化

plist

plist文件用于存储程序相关的一些内容，类似于ini文件或者.Net下面的app.config。NSData、NSArray和NSDictionary可以直接用xxxWithContentsOfFile和writeToFile读写：

Coder* siw = [Coder personWithName:@"Si Wei" andAge:25];
    [siw setLanguage:@"C#"];
    Coder* yexd = [Coder personWithName:@"Ye Xiaodong" andAge:25];
    [yexd setLanguage:@"Objective-C"];
    Person* nan_zhang = [Person personWithName:@"Zhang Nan" andAge:29];
    NSArray* objs = [NSArray arrayWithObjects:siw, yexd, nan_zhang, nil];
    [objs writeToFile:@"pdata1.txt" atomically:NO];
    [objs writeToFile:@"pdata1_a.txt" atomically:YES];
    NSArray* objs_fromFile = [NSArray arrayWithContentsOfFile:@"pdata1.txt"];
    //[(Coder*)[objs_fromFile objectAtIndex:0] ShowInfo]; // 不过这样不行的……

上面最后一行肯定不行，因为拿出来的是GSMutableString，可以打开存储的文件看看。序列化后的应该是XML，不过在windows上就是逗号分隔数据了。

(
    "<Coder: 0xd4d1a0>",
    "<Coder: 0xd712c0>",
    "<Person: 0xd44be0>"
)

如果希望将存储有自定义类的array或者dictionary持久化的话，可以想到的方案是实现下面NSCoding的方法，塞到array后给再下面说的NSUserDefault。

archiver

archiver以二进制方式存储数据。需要存储的类要实现两个定义在NSCoding协议里面的方法：

- (void) encodeWithCoder: (NSCoder*) coder {
    NSLog( @"encoding: %@", self );
    [coder encodeObject: name forKey:@"name"];
    [coder encodeInt: age forKey:@"pid"];
}
- (id) initWithCoder: (NSCoder*) decoder {
    NSLog( @"decoding: %@", self );
    return [self initWithArgs:[decoder decodeObjectForKey:@"name"] andAge:[decoder decodeIntForKey:@"age"]];
}

initWithCoder里面我用了自己实现的构造函数。默认情况下和init一样用[super init]再赋值也OK。注意用的时候归档和读档的类是不同的：

data = [NSKeyedArchiver archivedDataWithRootObject:siw];
    [data writeToFile:@"siwei.data" atomically:NO];
    NSData* data_fromArchive = [NSData dataWithContentsOfFile:@"siwei.data"];
    Coder* siw_fromArchive = [NSKeyedUnarchiver unarchiveObjectWithData:data_fromArchive];
    [siw_fromArchive ShowInfo];

UD

User Defaults类似于全局字典，访问数据更灵活：

NSUserDefaults* userDefaults = [NSUserDefaults standardUserDefaults];
    [userDefaults setObject:@"siwei" forKey:@"me"];
    //[userDefaults setObject:objs forKey:@"objs"];
    [userDefaults setInteger:42 forKey:@"int"];
    [userDefaults synchronize];

这样就存储完了。最后一句不必要。

NSArray* objs_fromUD = [userDefaults objectForKey:@"objs"];
    int i = 0;
    for ( i = 0; i < [objs_fromUD count]; i++ ) {
        if ( [[objs_fromUD objectAtIndex:i] respondsToSelector:@selector(GetInfo:TheSecondArg:)] ) {
            NSLog( @"array: %@", [[objs_fromUD objectAtIndex:i] GetInfo:100 TheSecondArg:YES] );
        }
    }
    NSLog( @"%@", [userDefaults objectForKey:@"me"] );
    NSLog( @"%d", [userDefaults integerForKey:@"int"] );

读取数据如上所示。不过在GNUStep上面不能把array给setObject到UD里面去，提示Argument Exception。按理说所有内置plist类型都是没问题的。

SQL

Sqlite持久化实现了传说中的ORM，适用于数据量比较大的情况。并且有第三方的开源项目进一步简化操作 Sqlist Persistent Objects。

Core Data

Core Data是基于Model、Entity和Relationship的存储方式，利用sql语句直接访问持久化文件，通过各种和数据库概念相对应的类——例如NSEntityDescription对应表结构、NSFetchRequest对应查询等——实现对数据库的封装，免得去写SQL语句。不过实现起来复杂到恶心，不愧是企业级应用。有兴趣可以看看教程@notsos.im。

06RTTI和动态特性2

isa指针

所有NSObject继承下来的对象都有一个isa指针，指向具体的Class定义，所以所有从一个类实例化出来的对象的isa指针都一样。看一下NSObject指针就能看出来，这个指针指向的是objc_class类型。所以id实际上就是一个指向指向objc_class指针的指针。

@interface NSObject <NSObject> {
   Class       isa;
 
typedef struct objc_class *Class;
typedef struct objc_object {
   Class isa;
} *id;
...

对于[class method]的调用，都会变成obj_msgSend这个函数的调用，看下面的函数原型可以知道，调用方法的时候，receiver的isa指针会首先被使用，查找SEL对象是否存在。如果不存在，就继续用当前Class对象的isa指针查找父类的SEL定义中是否有需要的，直到NSObject为止。如果都没有的话就抛一个NSInvalidArgument异常（见过最多的……）。

obj_msgSend

原型为objc_msgSend(id receiver,SEL selector,参数…)

继续沿着上面说的方法调用中的isa指针查找来看，如果找到了SEL的定义，那么拿到receiver的self指针进行SEL的调用，当然参数要传过去。

动态方法

obj-c 2.0里面引入了@property、@syncthesize指令方便地声明属性。对于仍然需要自定义setter/getter的属性来说可以用@dynamic指定。除了手动写之外，还可以在运行时指定

其实就是重写一个class method，将传入的SEL动态设定为setter或者getter

// 声明一个函数，用来动态添加。前两个参数不能变——因为要转换成IMP类型
void dynamicMethod(id self,SEL _cmd,float w){
  <a href="http://www.opengroup.org/onlinepubs/009695399/functions/printf.html">printf</a>("dynamicMethod-%s\n",[NSStringFromSelector(_cmd)
cStringUsingEncoding:NSUTF8StringEncoding]);
  <a href="http://www.opengroup.org/onlinepubs/009695399/functions/printf.html">printf</a>("%f\n",w);
}
 
// 类方法
+(BOOL) resolveInstanceMethod: (SEL) sel{
  NSString *methodName=NSStringFromSelector(sel);
  BOOL result=NO;
// 检查SEL的名字是必要的，因为只有符合命名规则的函数才可以用
  if ([methodName isEqualToString:@"setHeight:"]) {
   class_addMethod([self class], sel, (IMP) dynamicMethod,
                  "v@:f");
  result=YES;
}
  return result;
}

注意class_addMethod最后一个参数，这是函数签名的简单表示。v=void, @=id, :=SEL, f=float，要根据实际函数定义进行更改。

这段在apple的文档中也专门有一篇文章，不过写得晦涩到让人不得不觉得是故意让人看不懂。

有关self

Instance method里面的self是当前对象的首地址；Class method里面的则是Class指针，也就是isa。

下面语句位于Coder类的init方法中，会打印出来什么？第一反应肯定是Coder, Person。但实际上都是Coder……因为obj-c的消息机制是会不停地寻找父类方法。最后virtual到子类上。

NSLog( @"%@, %@", [self class], [super class] );

Method类型

定义，可以看到Method类型是SEL和IMP的合体成果

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

动态替换方法，既然METHOD是struct，就可以直接用->访问它的成员了，例如在Coder类里面可以用父类Person的某个方法替换自己的：

SEL selGetInfo = @selector(GetInfo:);
    Method myMethod = class_getInstanceMethod([self class], selGetInfo);
    Method baseMethod = class_getInstanceMethod([Person class], selGetInfo);
    // 不过10.5之后就拿不到method_imp了
   myMethod->method_imp =baseMethod->method_imp;

07容器类、Block和NSPredicate

NS(Mutable)Array

遍历队列中对象的方法，使用makeObjectsPerformSelector。

Coder* siw = [Coder personWithName:@"Si Wei" andAge:25];
    [siw setLanguage:@"C#"];
    Coder* yexd = [Coder personWithName:@"Ye Xiaodong" andAge:25];
    [yexd setLanguage:@"Objective-C"];
    Person* nan_zhang = [Person personWithName:@"Zhang Nan" andAge:29];
    NSArray* objs = [NSArray arrayWithObjects:siw, yexd, nan_zhang, nil];
    [objs makeObjectsPerformSelector:@selector(GetInfo:TheSecondArg:) withObject:(id)10]; // GetInfo有两个参数，而且返回一个NSString*
    [objs makeObjectsPerformSelector:@selector(ShowInfo)];

不过比较郁闷的是这个方法不能返回值，也不能使用一个以上的参数调用SEL。如果需要返回值或者传入多个参数，还是要用NSInvocation。

writeToFile方法的第二个参数atomically，表示的是是否采用原子操作。即如果参数为YES，那么写入文件时候先写入临时文件，完成后覆盖所要真正写入的文件。这样可以避免写入过程中系统出现问题导致文件损坏。

NSArray也支持切片操作，不过语法太不灵活了——或者说obj-c中所有容器类的访问语法都太罗嗦。连续的元素切片用subarrayWithRange，不连续的用objectsAtIndexes

// 连续
    NSRange range;
    range.location = 0;
    range.length = 2;
    NSArray* objs_new = [objs subarrayWithRange:range];
    [objs_new makeObjectsPerformSelector:@selector(ShowInfo)];
    // 不连续
    NSMutableIndexSet* indices = [NSMutableIndexSet indexSet];
    [indices addIndex:0];
    [indices addIndex:1];
    NSArray* objs_fromIndex = [objs objectsAtIndexes:indices];
    [objs_fromIndex makeObjectsPerformSelector:@selector(ShowInfo)];

排序操作，NSArray提供了N个方法，按照所利用的排序参数，简单可以分为descriptor、selector、function和block排序

function排序

需要实现一个签名为NSInteger (*)(id, id, void *)的方法

NSInteger mySortByAge(id o1, id o2, void *context) {
    int v1 = [(Person*)o1 age];
    int v2 = [(Person*)o2 age];
    if (v1 < v2)
        return NSOrderedAscending;
    else if (v1 > v2)
        return NSOrderedDescending;
    else
        return NSOrderedSame;
}

使用的时候把指针传进去就行了

NSArray* objs_sortedByFunction = [objs sortedArrayUsingFunction:mySortByAge context:nil];
    [objs_sortedByFunction makeObjectsPerformSelector:@selector(ShowInfo)];

selector排序

需要排序的类要实现一个方法，传入一个和自身类型相同的参数，同self进行自定义比较。NSString的例子看下面的应用，在NSSortDescriptor初始化的时候传入了xxxCompare方法作为具体的比较方法，而其他内置类也都实现了compare方法，例如NSNumber就可以用compare方法的SEL。对于自己的类则需要实现一个方法，返回NSComparisonResult（其实就是NSInteger，枚举），要声明，因为不是继承来的。

- (NSComparisonResult) ageCompare:(id) rhsPerson {
    int v1 = [self age];
    int v2 = [(Person*)rhsPerson age];
    if (v1 < v2)
        return NSOrderedAscending;
    else if (v1 > v2)
        return NSOrderedDescending;
    else
        return NSOrderedSame;
}

使用和function没什么区别，只不过参数是SEL而已。

NSArray* objs_sortedBySelector = [objs sortedArrayUsingSelector:@selector(ageCompare:)];
    [objs_sortedBySelector makeObjectsPerformSelector:@selector(ShowInfo)];

descriptor排序

是一种比较特殊的包含比较信息的类，主要用于自定义类型的排序。需要指定按照什么key——也就是property进行排序，以及具体的排序算法（selector）和排序选项（例如是否倒序等）。看一下代码就清楚了

NSSortDescriptor *sortDesc = [[NSSortDescriptor alloc] initWithKey:@"name" ascending:YES               selector:@selector(localizedCaseInsensitiveCompare:)];
    NSArray* objs_sortedByDescriptor = [objs sortedArrayUsingDescriptors:[NSArray arrayWithObjects:sortDesc, nil]];
    //NSArray* descriptors = [NSSortDescriptor sortDescriptorWithKey:@"name" ascending:NO];
    NSArray* objs_sortedByDescriptor = [objs sortedArrayUsingDescriptors:descriptors];
    [objs_sortedByDescriptor makeObjectsPerformSelector:@selector(ShowInfo)];

block需要特别记录一下，所以分出一个条目。

Block

数组排序时候有个sortedArrayUsingComparator方法，这里的参数类型为NSComparator。这个类其实就是Block所定义的

typedef NSComparisonResult (^NSComparator)(id obj1, id obj2);

所以我们可以直接

NSComparator myComparator = ^(id obj1, id obj2){}:

NSArray中还有指明要使用Block的方法，例如- (void)enumerateObjectsUsingBlock:(void (^)(id obj, NSUInteger idx, BOOL *stop))block

Block其实可以看作JS里面的(){}();方法以及.Net中的匿名方法，即不需要声明就直接使用的方法，主要用处包括回调、事件处理和排序。声明和实现可以像上面的NSComparator一样分开，也可以写在一起：

NSInteger (^blockExample)(int, NSString*) = ^( int i, NSString* s ) {
        NSLog( @"%d, %@", i, s );
    };
    blockExample( 42, @"hello" );

对于NSArray的排序（或者其他需要Block作为参数的函数）来说，可以写成下面两种形式：

// 声明和使用
NSComparison ( ^ageComparator )( id, id ) = ^( id o1, id o2 ) {
    // 比较函数的实现
};
    NSArray* objs_sortedByComparator = [objs sortedArrayUsingComparator:ageComparator];
// 不声明，彻底匿名使用
    NSArray* objs_sortedByComparator = [objs sortedArrayUsingComparator:^( id o1, id o2 ) { //...
    }];

枚举一个容器则可以类似于：

NSArray *tmpArray = [timeZoneNames objectsAtIndexes:areaIndexes];
[tmpArray enumerateObjectsWithOptions:NSEnumerationConcurrent|NSEnumerationReverse
                           usingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
                               [areaArray addObject:[obj substringFromIndex:[area length]+1]];
}];

实际上可以看作是obj-c里面闭包的最好例子。更多可以看http://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/Blocks/Articles/00_Introduction.html

NS(Mutable)Dictionary

基本的操作，例如初始化、插入、删除、查找等，不说了。

排序也不说了，其实就相当于将keys提取成NSArray进行排序。

那还有啥可说的呢……比如自定义的排序key。默认情况下只能使用NSString，但自定义类也可以当作hash key使用，需要实现下面这两项内容。实际情况中需要自定义key的场合非常少。
NSCopying协议。将key/value加入字典时候，系统实际上会拷贝一份key使用。所以copyWithZone必须实现。

hash()和isEqual()方法。这两个方法用于生成项目的hash值，以及比较两个对象的hash值。
- (NSUInteger) hash{
  return pid+[name hash];
}
-(BOOL) isEqual: (id) p{
  if(pid==[p pid]&&[name isEqualToString: [p name]]){     return YES;
  }else{
    return NO;
  }
}

MapTable

感觉上和NSMutableDictionary很像，也是根据key进行1-1对应的容器，也可以增删元素。但它不一样的地方在于内部是弱引用的。

NSPointerFunctionsOptions keyOptions=NSPointerFunctionsStrongMemory |
        NSPointerFunctionsObjectPersonality | NSPointerFunctionsCopyIn;
    NSPointerFunctionsOptions valueOptions=NSPointerFunctionsOpaqueMemory |
        NSPointerFunctionsOpaquePersonality;
    NSMapTable* mapTable=[NSMapTable mapTableWithKeyOptions: keyOptions valueOptions:valueOptions];
    NSString* key1 = @"siwei";
    NSMapInsert( mapTable, key1, siw );
    NSLog( @"%@, %@", *(int*)NSMapGet( mapTable, key1 ), [(Coder*)NSMapGet( mapTable, key1 ) language] );
    NSLog( @"%d", [siw retainCount] );  // 1

而其他内置容器类基本都是强引用

NSArray* objs = [NSArray arrayWithObjects:siw, yexd, nan_zhang, nil];
    NSLog( @"%d", [siw retainCount] );  // 2
    NSDictionary* dict = [NSDictionary dictionaryWithObjectsAndKeys:siw, @"siwei", yexd, @"Ye Xiaodong", nan_zhang, @"Zhang Nan", nil];
    NSLog( @"%d", [siw retainCount] );  // 3

NS(Mutable)Set

Set里面的元素是无序排列且无key的。初始化和array一样，也可以直接用initWithArray从array创建。

NSSet* set = [NSSet setWithObjects:siw, yexd, nan_zhang, nil];
    NSLog( @"%d", [siw retainCount] );  // 2

和Dictionary一样，Set也有对应的弱引用容器类，就叫Hash Table

NSHashTable* hashTable=[[NSHashTable alloc] initWithOptions:
    NSPointerFunctionsOpaqueMemory |NSPointerFunctionsOpaquePersonality
    capacity: 1];
    NSHashInsert( hashTable, siw );
    NSLog( @"%d", [siw retainCount] );  // 1

NSPredicate

这东西用起来有点像.Net的LINQ，是根据条件从集合里面筛选数据的语法糖。

NSPredicate* predicate = [NSPredicate predicateWithFormat:@"age > 28"];
    int i = 0;
    for (; i < [objs count]; ++i ) {
        if ( [predicate evaluateWithObject: [objs objectAtIndex:i]] ) {
            NSLog( @"%@", [[objs objectAtIndex:i] GetInfo:1 TheSecondArg:YES] );
        }
    }

可以使用的运算符包括AND、OR、NOT、BETWEEN、IN、LIKE等

模板

NSPredicate* templatePredicate = [NSPredicate predicateWithFormat:@"name == $NAME"];
    NSDictionary* dict = [NSDictionary dictionaryWithObjectsAndKeys:
        @"Si Wei", @"NAME", nil];
    NSPredicate *pre=[templatePredicate predicateWithSubstitutionVariables: dict];
    //NSPredicate* predicate = [NSPredicate predicateWithFormat:@"age > 28"];
    int i = 0;
    for (; i < [objs count]; ++i ) {
        if ( [templatePredicate evaluateWithObject: [objs objectAtIndex:i]] ) {
            NSLog( @"%@", [[objs objectAtIndex:i] GetInfo:1 TheSecondArg:YES] );
        }
    }

其实上面Array里面切片方法也应该包括这个NSPredicate，因为它可以用来筛选array元素

NSPredicate* predicate = [NSPredicate predicateWithFormat:@"age > 28"];
    NSArray* objs_filtered = [objs filteredArrayUsingPredicate: predicate];
    NSLog( @"%@", [[objs_filtered objectAtIndex:0] GetInfo:1 TheSecondArg:YES] );

字符串运算

• BEGINWITH, ENDWITH, CONTAINS
• c和d分别表示大小写不敏感和重音符号不敏感，例如如果是”name BEGINWITH[d]‘e’”的话，那么“étudent”这样的词也会符合条件

LIKE结合?和*可以进行通配符匹配

正则表达式

NSString* regex = @"^S.+i$";
    NSPredicate* regexPredicate= [NSPredicate predicateWithFormat:@"name MATCHES %@", regex];
    NSArray* objs_filtered = [objs filteredArrayUsingPredicate:regexPredicate];
    NSLog( @"%@", [[objs_filtered objectAtIndex:0] GetInfo:1 TheSecondArg:YES] );

容器类的深浅拷贝

默认情况下用一个容器去初始化另外一个容器是浅拷贝，也就是说只是retain里面的引用而已

可能的深拷贝，用重载的initWithArray:copyItems:YES。不过之所以说这是“可能的”，是因为容器里面的对象不一定实现了NSCopying协议！如果没有实现的话，对于对象本身的拷贝还是浅拷贝。

NSArray *deepCopyArray=[[NSArray alloc] initWithArray: someArray copyItems: YES];

真正的深拷贝，需要用到NSKeyedArchiver。但需要的时间和空间开销必然陡增。

NSArray* trueDeepCopyArray = [NSKeyedUnarchiver unarchiveObjectWithData:
          [NSKeyedArchiver archivedDataWithRootObject: oldArray]];

回来后就升级到了最新版本软件（两次，够频繁的），游戏也及时升级了，没出现过死机现象。

和之前在网上预先看到的相同，屏幕、机能的改进不是一星半点。主屏上的图标有明显的马赛克，后来仔细一看是3D模型造成的，屏幕本身就算屏气凝神也几乎看不到像素点的边界。既然屏幕大了，必然整体尺寸比PSP大了不少：

游戏方面不锁区确实很好。《神秘海域》值得入手，画面效果和游戏时间综合来看性价比不错。《三国无双NEXT》卖得也太贵了，1.5G的游戏容量，而且只有一条故事线原来是还没玩通的缘故，本作依然有光荣最喜欢的架空历史，虽然把刷各种奖杯的时间算上能延长不少游戏时间，但整体来说比《神海》还贵的价格真是让人觉得诧异。《天启之王》的手感不错，游戏方式类似于MH，如果没有人联机的话乐趣会大大减少。

PSV自带个有趣的功能NEAR，可以看到附近的玩家和热门游戏，例如我周围方圆1公里范围内有60多个人在玩（这么多？今天已经74了）。

总体体验非常好，掌机的未来还会是“专一”功能的。如果玩了3DS和PSV，还有人鼓吹手机游戏是便携型类型游戏的未来，那真的只能笑而不语了。

作用就是在程序员完成一些“成就”后给予提示和记录，获取相应的称号。例如：

• 在一个类里面声明100个成员变量（Field Master）
• 一行代码写300个字符（Scroll Bar Wizard）
• 使用“Close All But This”10次（Obsessive Compulsive Disorder）
• ……

看来以后可以加班刷成就啦！

目录

1. 构造和拷贝构造
2. 动态特性和RTTI
3. 内存管理和标准C区别

01构造和拷贝构造

首先是有关构造函数

我想实现子类基类不同数量参数的构造方式，结果昨天试验了几种方法都不行。

参见下面的代码，Person是基类，实现了一个两参数的构造函数initWithArgs。子类Coder重载了这个方法，多了一个参数，试图重用基类的方法：

// person的构造函数
- (id) initWithArgs : (NSString*) aName andAge:(int) aAge {
Person* person = [[Person alloc] init];
[person setName: aName];
[person setAge: aAge];
return person;
}
// coder的构造函数
- (id) initWithArgs : (NSString*) aName andAge:(NSInteger) aAge andLanguage:(NSString*)aLanguage {
return ???  //这里要返回什么
}

结果昨天尝试了N种方法，全都不行！

// 不行, crash!
if ( self = [super initWithArgs:aName andAge:aAge] ) {
[self setLanguage:aLanguage];
}
return self;
 
// 不行，没有crash，但是基类的参数name和age都设置失败
[super initWithArgs:aName andAge:aAge];
[self setLanguage:aLanguage];
return self;
 
// 好用，但我们的基类构造函数不就没用了吗
Coder* coder = [[Coder alloc] init];
[coder setName:aName];
[coder setAge:aAge];
[coder setLanguage:aLanguage];
return coder;

问题在于基类的构造定义，要用[self class]获取到当前self指针的类型才对

Person* person = [[[self class] alloc] init];

子类的构造函数：

Coder* coder = [super initWithArgs:aName andAge:aAge];
[coder setLanguage:aLanguage];
return coder;

或者用更单纯一点的调用：

[self initWithArgs:aName andAge:aAge];
    [self setLanguage:aLanguage];
    return self;

简洁构造函数

类似[类名]With[参数名]这样的构造函数，也是类方法，好处在于使用者不用alloc/release操作。内部通过autorelease实现

+ (id) personWithName:(NSString*)aName andAge:(NSInteger)aAge {
id ret = [[[self class] alloc] initWithArgs:aName andAge:aAge];
return [ret autorelease];
}

注意到没，构造方式很像有参数构造函数，也需要用[self class]指定类型。不然子类调用的时候就会出问题。

使用一下：

Person* siwei = [Person personWithName:@"Si Wei" andAge:25];
NSLog( @"%@", [siwei GetInfo:0 TheSecondArg:NO] );
Coder* coder = [Coder personWithName:@"Si Wei" andAge:25];
NSLog( @"%@", [coder GetInfo:0 TheSecondArg:NO] );

拷贝构造

allocWithZone

通过copy函数实现，它会调用copyWithZone，所以在NSObject为基类的类中实现这个协议即可。注意那个allocWithZone方法和刚才已经出现过两次的[self class]：

// Person 类
- (id) copyWithZone : (NSZone*)zone {
    Person* clone = [[self class] allocWithZone:zone];
    [clone setName:[self name]];
    [clone setAge:[self age]]; // 或者写成 clone->age = self->age;
    return clone;
}

对于子类来说，如果父类实现了这个方法（就像上面的Person::copyWithZone），可以直接调用，省去继承而来的数据成员的拷贝操作：

// Coder 类
- (id) copyWithZone : (NSZone*)zone {
    Coder* clone = [super copyWithZone:zone];
    [clone setLanguage:[self language]];
    [clone setComputer:[self computer]]; // shallow copy。也可以写成clone->computer = [[self computer] retain]];
    [clone setLeader:[[self leader] copyWithZone:zone]];  // deep copy
    return clone;
}

值得注意的是，在上面这段代码中，用了几种不同的copy方式

• [clone setProperty:[self property]]; 值拷贝，适用于各种值类型以及NSString*
• clone->computer = [[self computer] retain]]; 相当于浅拷贝，只引用一下
• [clone setProperty:[[self property] copyWithZone:zone]]; 深拷贝，但前提是这个属性的类必须实现copy重载才行。

所以下面代码的执行结果就一目了然了：coder1的leader重新setAge后，coder2的leader属性没有改变，age还是150。

如果在b)里面使用[clone leader:[self leader]];的话，coder2的leader属性也会随之改变。

Coder* coder1 = [Coder personWithName:@"Si Wei" andAge:25];
    [coder1 setLanguage:@"C#"];
 
    Person* leader = [[Person alloc] initWithArgs:@"Leader" andAge:150];
    [coder1 setLeader:leader];
    Computer* computer = [[Computer alloc] init];
    [coder1 setComputer:computer];
 
    Coder* coder2 = [coder1 copy];
    NSLog( @"%@", [[coder2 leader] GetInfo:0 TheSecondArg:NO] ); // Leader, 150
 
    [[coder1 leader] setAge:99];
    NSLog( @"%@", [[coder2 leader] GetInfo:0 TheSecondArg:NO] ); // Leader, 150

除了allocWithZone之外，还可以使用NSCopyObject()实现拷贝

NSCopyObject

这是二进制拷贝，也就是说对于值类型可以省去赋值的过程（当然也包括NSString*这个指针中的异类）

指针则需要自己进行操作，或者retain、或者赋值。假设基类多了一个指针成员：

- (id) copyWithZone : (NSZone*)zone {
    //Person* clone = [[self class] allocWithZone:zone];
    Person* clone = NSCopyObject( self, 0, zone );
    //[clone setName:[self name]];  // 不再需要
    //[clone setAge:[self age]];  // 不再需要
    clone->pObject = nil;  // 需要，重置指针
    [clone setPObject:self->pObject];
    return clone;
}

于子类来说，一定要知道父类的copyWithZone实现才能决定用什么方式copy：

- (id) copyWithZone : (NSZone*)zone {
//[clone setLanguage:[self language]]; // 不再需要，父类实现了NSCopyObject()
    Coder* clone = [super copyWithZone:zone];
    [clone->computer retain]; // 父类实现了NSCopyObject()，虽然指针是拷贝过来了，但需要增加引用计数
    [clone setLeader:[[self leader] copyWithZone:zone]];  // 需要也进行copy的对象必须要调用copy，不管是不是NSCopyObject()
    return clone;
       }

dummy cloning和mutable copying

简单来说就是返回一个自身引用

-(id) copyWithZone:(NSZone*)zone
{
    // 返回自身，增加一个引用
    return [self retain];
}

作用？对于Mutable对象来说可以实现对于非Mutable对象的dummy clong后增加实现可变特性的方法。例如NSMutableString对于NSString

除了刚才的NSCopy外，还有一个NSMutableCopying协议，需要实现一个方法，它返回可变对象。操作方法是[object mutableCopy]。它的用处就是可以让Mutable Object的copy也是Mutable的，例如NSMutableArray如果用copy的话，返回的对象是不能修改的，这个时候需要用mutableCopy。具体的实现方法和copyWithZone没什么区别。

-(id) mutableCopyWithZone:(NSZone*)zone;

02动态特性和RTTI

KVC（Key-Value Coding）

可以通过字符串访问类成员。有点像字典。

NSLog( @"%@", [[coder1 valueForKey:@"leader"] GetInfo:0 TheSecondArg:NO] );
    [coder1 setValue:@"New Si Wei" forKey:@"name"];
    NSLog( @"%@", [coder1 GetInfo:0 TheSecondArg:NO] );

对于成员的成员，需要用valueForKeyPath。当然对于自己的成员也可以用。

NSLog( @"%@", [coder1 valueForKeyPath:@"leader.name"] );

调用的顺序大概是

• valueForKey:@”foo”
  1. getFoo方法、foo方法、isFoo方法
  2. 如果类accessInstanceVariablesDirectly返回YES那么是依次是_foo、_isFoo、foo和isFoo
  3. 还没找到就调用类的valueForUndefinedKey，默认行为是抛出异常NSUnknownKeyException
• setValue:forKey:@”foo”
  1. setFoo方法
  2. 如果类accessInstanceVariablesDirectly返回YES那么是依次是_foo、_isFoo、foo和isFoo
  3. 还没找到就调用类的setValue:forUndefinedKey，默认行为是抛出异常NSUnknownKeyException

introspection

OOP语言必备的特性，简单说就是在运行时检查类的类型

从下面代码可以看出来，isKindOfClass检查对象是否是某类以及其子类的实例；isMemberOfClass只检查是否是某类的实例。

Class personClass = [Person class];
    Class coderClass = [Coder class];
    NSLog( @"%d, %d, %d, %d, %d, %d, %d, %d",
        [leader isMemberOfClass:personClass], [leader isKindOfClass:personClass], [leader isMemberOfClass:coderClass], [leader isKindOfClass:coderClass],
        [coder1 isMemberOfClass:personClass], [coder1 isKindOfClass:personClass], [coder1 isMemberOfClass:coderClass], [coder1 isKindOfClass:coderClass] );
//  YES, YES, NO, NO, NO, YES, YES, YES

实际编程中的一些动态特性类

• SEL：selector相当于指向成员函数的指针，需要指定target才可以调用。通过selector生成的method signature可以用来初始化NSInvocation。
  • 直接从方法名取得selector用@selector()或者NSSelectorFromString，逆操作NSStringFromSelector
  • 对于实例用performSelector调用具体的方法
• Class：类的元数据，通过[instance class]、[instance className]或者NSClassFromString拿到，也有一个逆操作NSStringFromClass
• IMP：其实就是一个函数指针，返回id，参数为id, selector, …，写着比自定义的方便而已，见下面的例子：

Person* me = [[Person alloc] initWithArgs:@"SW" TheAge:25];
SEL selector = @selector(GetInfo:TheSecondArg:);
NSString* ( *pFunc )( id, SEL, int, BOOL );
pFunc = (NSString* (*)(id, SEL, int, BOOL))[me methodForSelector:selector];
IMP imp = [me methodForSelector:selector];
NSLog( @"%@", pFunc( me, selector, 100, YES ) );
NSLog( @"%@", (NSString*)(imp( me, selector, 100, YES )) );

• Invocation Forward：proxy类的工作，需要重载三个函数

(BOOL)respondsToSelector:(SEL)aSelector：判断selector是否属于自己的某个成员
(NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector：通过selector拿到method signature
(void)forwardInvocation:(NSInvocation *)invocation：转发Invocation到相应的成员上
- (NSMethodSignature*) methodSignatureForSelector: (SEL)selector {
    NSMethodSignature* methodSig = [fwdTarget methodSignatureForSelector:selector];
    if ( methodSig ) {
        return methodSig;
    }
}
- (void) forwardInvocation: (NSInvocation*) invocation {
    [invocation invokeWithTarget:[self fwdTarget]];
}

03内存管理和标准C区别

数据成员访问器

数据成员的setter设定。不管哪个教程，都告诉我们setter是不能这么写的：

- (void) setLanguage : (NSString*) aLanguage {
    [self language: aLanguage];  // 糟糕代码！外部如果释放了aLanguage指向的对象，内部使用就会出错
}

也不能这么写

language = [aLanguage retain];  // 糟糕代码！内部成员原先指向的对象没法释放了！

当然这样也不行

[language release];
       [self setLanguage:aLanguage]; // 糟糕代码！如果language == aLanguage的话就多release了一次。

所以我们被告知应该这么写

[language autorelease];
       [self setLanguage:aLanguage]; // Good

其实从第三个例子考虑，也可以写成

[aLanguage retain];
       [language release];
       [self setLanguage:aLanguage];

数据成员的getter设定。有的时候对于开放给外界的数据成员不希望进行修改，又不想用const关键字的话，可以考虑返回一个copy

- (Person*) leader {
    return [[leader copy] autorelease];
    //return leader;
}

当然能这么做的前提是Person类实现了copyWithZone

release和垃圾收集器

什么情况才需要autorelease？显式地调用了alloc、使用了copy（mutableCopy）以及retain之后。

垃圾收集器实现了一个灵活的GC，省得我们自己去retain, release和autorelease。开启了GC之后这三个函数都没用了。不过iPhone开发环境中似乎不能用GC？

__weak和__strong声明。什么时候需要弱引用？集合类，因为如果集合对其中的元素都拥有强引用的话，那么这些引用的实际对象就没法析构了（在集合类被咔嚓之前永远有一个ref count）。而弱引用在对象消失后自动变为nil。

autorelease不能滥用，因为它实际上是lazy deallocation，一般来说thread不结束都没法回收。

对于对象引用的维护，永远是使用者责任更大。因为开发者不知道自己的对象可能被引用多少次。

这些东西不能用

• 模板
• 默认参数
• Friend
• inline（但其实Obj-C兼容C99，也可以使用inline关键字）
• initialization list
• 方法的const修饰

题外话：动画和游戏

至于动画、游戏什么的，自然用Bangumi的年鉴功能。懒得单发，记录在此了：

「Bangumi 2011 年鉴」 2011 年，我看了 28 部动画，读了 本书，听了 1 张音乐，玩了 7 部游戏，看了 1 部剧集，参与了 73 次讨论，进行了 0 次条目编辑。

在这28部动画中印象最深刻的是还在放送的《ちはやふる》（歌牌情缘），游戏里面觉得最好的是一款老游戏《枪声与钻石》。当然今年玩游戏太少了，而且基本都是PSP上的AVG，最近这三个月已经写了大概四篇相关的玩后体会。

数据

回到正题，2011年的阅读数量为112，较之前年回落较多。原因不外乎是工作太忙，另外则是去掉了漫画，轻小说也只保留第一卷，确保统计水分不太大。

尽管如此，其实这112本书中有80%还是推理小说/轻小说，专业书以及学习类书籍大概只有10本……？所以推荐列表还是从推理小说开始吧（书籍链接在图片上）。

推荐的推理小说/轻小说类作品

其他类别的书籍推荐

• 禄是遒《中国民间迷信（崇拜）》系列：徐家汇藏书楼的良心作，虽然每本都是薄薄200-300页卖到40块，但总体来说是一套很有趣的风俗讲解和记录丛书。
• 艾伯特《神奇的二维国》：小说形式的科普读物，要考虑到这是1884年的作品，那只有用“神作”才能形容。希望大家都读读，为适应二向箔打击带来的新世界做好准备。另外推荐给妄图二次元去把虚拟妹子的2D厨。
• 杨显惠《夹边沟记事》：神作。
• 王爽《汇编语言》：从未见过一本语言类教程能写得如此让人看完一章还想看下一章。在遇到此书之前数次学习汇编都是半懂。用了半个月的业余时间看完后顺利入门。
• 比目鱼《虚拟书评》：之前在比目鱼Blog上看到这种形式的文章，太好玩了。见到此书变为实体还以为也是虚拟的……
• 王新禧译本《徒然草·方丈记》：王老师文笔真是巨好——除巨好以外我词穷找不出其他可形容的了——古风浓郁但又读起来不晦涩 （当然是对于我这种古文门外汉来说） ，实是译文典范。
• Jeffrey Richter《CLR via C#》：夯实基础的必备知识，对于.net程序员来说不是只知道string有多少方法就行了。

雷区

既然有推荐肯定也有扫雷：

• 内田康夫《贵宾室的怪客》
• 东野圭吾《以眨眼干杯》。骗版税代表作。看完《新参者》再看这部，都会以为“东野圭吾”是个拥有数名文风迥异水平有天地之差的作家的写作团体。
• 麦家《风语》系列。作为麦家的死忠读者，我都以为买到盗名之作了。
• 二阶堂雷人老师的一切作品，以《双面兽事件》为代表。

虚函数

对于抽象类而言，是否应该自己负责初始化类内的数据成员？（别忘了抽象类也可以有非纯虚函数和数据成员）

• 一般情况下被认为子类要负责从基类继承来的数据成员的初始化
• 或者基类必须提供一个显式的构造函数用于自己数据成员的初始化
• 最好的方法则是将行为和数据分离，提供接口专门用于定义方法

class A_B
{
public:
    virtual ~A_B() = 0;
    virtual void Say() const = 0;
    inline char const* GetData() const { return iData; }
protected:
    A_B( char* aData ) : iData( aData ) {  }
protected:
    char* iData;
};
inline A_B::~A_B() {}
 
class C_D : public A_B // concrete derived class
{
public:
    C_D( char* aData, char* aData2 ) :
           A_B( aData ), iData2( aData2 ) { cout<<"c_d ctor"<<endl; }
    virtual ~C_D() { delete iData2; }
    virtual void Say() const { cout<<"c_d says: "<<iData<<endl; }
    void Say2() const { cout<<"c_d says2: "<<iData2<<endl; }
public:
    char* iData2;
};

纯虚函数

• 拥有定义的纯虚函数（这还叫纯虚函数么）可以在子类中进行调用。不过就是什么用都没有罢了。

//定义
inline void A_B::Say() const { cout<<"hey!"; }
//调用，发现hey!并没有打印出来
virtual void Say() const { A_B::Say(); cout<<"c_d says: "<<iData<<endl; }

• 实际上是否让纯虚函数拥有（没用的）定义由程序员说了算。
• 但唯一的例外是纯虚析构函数，必须像上面那样进行显式定义 A_B::~A_B() {}
  • 否则就会出现错误，严格来说并非编译错误，而是链接错误。
  • 原因很简单，析构函数和构造函数一样，子类的都会由编译器进行扩充，调用基类的版本。
  • 不希望这么定义的话，解决方法只有生命非纯虚的析构函数

Virtual Specification

• 不加选择地将函数设定为virtual在效率上会不升反降，不能依赖编译器的优化
• 应付const也会令人头疼，例如在基类中不需要修改的const ref或者const pointer，到了子类就需要修改了。目前最好的方法是不用const（……无语）
• 需要考虑到的（不全）
  • 抽象类的构造函数需要负责初始化自己的数据成员，可以声明为protected避免外部访问
  • 缺少多态需求的函数不要设定为virtual，尤其是inline函数
  • 慎用const，除非确定派生类也不会修改const修饰的对象

对象构造

无继承情况下的对象构造（限于一个class内都是public访问级别的对象）

• class B { public: int a, b, c; }
• C中的全局变量会被视为“临时性的定义”而只保留一个实体，位于DS的末端，称为BSS（Block Started by Symbol）的区域
• 对于new和delete运算符的操作，不会触发trivial构造函数和析构函数
• 而传值方式的return操作，感觉上会触发trivial copy constructor，但实际上只是位拷贝
• 显式地设定类对象的数据成员值如何？例如B b; b.a = 1; b.b = …
  • 效率不如初始化列表高
  • 而且所设定的成员访问范围只能是public
  • 但也不是一无是处。对于大数据量、常量赋值的情况，显示设定数据的方式反而效率更高一点

多了private接口和inline的构造函数，但无virtual特性

• class B { public: B ( int aA = 0, int aB = 0, int aC = 0 ) : a(aA), b(aB), c(aC) {} private: int a, b, c; }
• 大小不会变化，默认的构造函数、析构函数和拷贝构造也够用了。提供初始化列表会比较高效
• 编译器会进行优化，将inline的构造函数在对象声明处（不是构造函数内！）展开为显示设定成员的方式，利用常量赋值
• new运算符则会有些变化 B* b = __operator_new( sizeof (B) ); if ( b != NULL ) then b->B::B(); 多了一个指针大小非零的判断
• 而其他的，例如delete运算符、传值返回等，和上面的一样

多了virtual函数的引入

• class B { public: B ( int aA = 0, int aB = 0 ) : a(aA), b(aB) {} virtual int C(); private: int a, b, c; }
• 最先想到的：每一个B对象都会有一个vptr指向vtbl，这个vptr占用一个字长。这种额外消耗是否值得要看多态所带来的价值是否大于vptr所带来的空间消耗
• 其他的代价
  • 构造函数会自动被添加代码，用于初始化vptr。这些代码位于所有的基类构造函数之后、程序员的代码之前。（展开后）类似于

B* B::B( B* this, int aA, int aB )
{
this->__vptr_point = __vtbl_point;
this->a = aA;
this->b = aB;
return this;
}

• 不再为trivial的拷贝构造函数和拷贝运算符函数（但隐式的析构函数仍然是trivial的）
  • 类似于构造函数，需要拷贝vptr以及相关的数据成员（参看“构造函数：拷贝构造函数”），有可能是非bitwisely copy。这也是需要编译器合成不再trivial的拷贝函数（运算符）的原因之一。
• 另外一个原因则是返回值的需要。作为引用参数之一的返回值需要拷贝构造函数获得vptr，同时销毁局部变量。
• 由此引出的想法：有关显式拷贝构造函数的必要性——大量传值返回某类的情况下。

有继承对象构造

回顾：构造函数的工作

• 如果有的话，调用所有虚基类构造函数
• 如果有基类的话，调用基类的构造器。如果有多个基类，调用顺序为声明的顺序
  • 位于构造列表里面的，直接以参数进行调用
  • 并非位于列表里面的，调用默认的构造函数
  • 如果是多重继承的基类，那么需要进行this指针的调整
• 初始化vptr指向相应的vtbl
• 函数初始化列表会被编译器展开放置于构造函数之中（参见2.3）
• 没有位于列表中的数据成员，如果拥有默认构造器，那么需要进行调用

拷贝构造函数中“自我拷贝”检查的必要性

• 并非大问题，但在B b1; b2 = b1; b1 = b2;情况下，如果没有进行this指针的检查，类似的操作会导致额外的开销
• 目前的编译器都不会对此进行检查，需要程序员进行自律

有继承情况下的对象构造，虚拟继承

• 回顾：虚拟继承需要添加虚基类子对象（virtual base class subobject），几种解决方式（参见3.3）
• 在虚拟继承中单纯地对每一个构造函数进行扩充是不可行的。
  • 需要增加一个是否为最底层对象的检查，如果是才负责初始化从最上层基类所继承下来的数据成员。

vptr初始化

class Base { public: virtual void Info() { cout<<"base::info"<<endl; } protected: int iBaseValue; };
class Derive1 : public virtual Base { public: virtual void Info() { cout<<"derived1::info"<<endl; } protected: int iDerive1Value; };
class Derive2 : public virtual Base { public: virtual void Info() { cout<<"derived2::info"<<endl; } protected: int iDerive2Value; };
class DD : public Derive1, public Derive2 { public: virtual void Info() { cout<<"dd::info"<<endl; } protected: int iDDValue; };
class DDD : public DD { public: virtual void Info() { cout<<"ddd::info"<<endl; } private: int iDDDValue; };

• 基类指针指向的子类对象，调用的函数实体为子类对象的

   DDD ddd;
   Derive1 d1;
   Base* b = &ddd;
   b->Info(); //"ddd::info"
   b = &d1;
   b->Info(); //"derived1::info"

• 如果在构造函数中调用成员函数会如何？构造一个子类对象时候，每次的构造函数会被认为是调用最底层子类的还是当前类本身的？
  • 当然是类本身的！因为构造的时候是按照从上到下的顺序。derive1构造的时候，ddd还尚未在内存中出现，更不要提它继承出来的Info函数了
  • 同时这也是构造函数不可为虚函数的一个原因（抽象工厂除外）

base::info
derived1::info
derived2::info
dd::info
ddd::info

• 再考虑一种情况，如果Info()又调用了一个虚函数，例如VF()会如何？按照上面第二条的说法，运行时应该调用的是子类的函数。但构造时候很明显会调用基类的
  • 实验的结果是，构造函数时候调用了各个基类自己的VF()，而运行的时候不出所料，就算用Base*指向了子类对象，调用的也是ddd::VF()。
  • 编译器的做法是对于在构造函数中的虚函数调用进行特殊处理，声明为静态方式的调用，不要用虚拟特性解决
  • 说起来简单，但实际上编译器所做的工作要复杂得多，首先要通过vptr拿到vtbl，获取虚函数的列表，这些函数都是在构造函数调用中不能表现出虚拟特性的
  • 由此而衍生出的问题是vptr的初始化时间。显然要早于任何程序员写在构造函数中的代码，但要晚于vtbl和基类构造函数的创建
  • 通过这么多学习，再次回顾构造函数步骤时候会觉得比之前要清晰很多，显然我们在构造一个基类的时候，首先要考虑虚拟继承的情况，判断自己是否为最底层的子类，如果是的话要负责构造基类；之后按照顺序构造所有基类；接下来根据基类的信息拿到vtbl中的虚函数列表；最后执行程序员自己写的代码

构造函数初始化列表中调用虚函数是否安全？

• 形如 Derived( int aValue, int aValue2 ) : Base( F( aValue ) ), iValue ( aValue2 ) { } // F为虚函数
• 分情况讨论。如果不需要对基类在初始化列表中同样进行初始化，那么应该是安全的。考虑一下，vptr在此时应该已经设置完毕，展开初始化列表的时候，虚函数可以正确地通过指针拿到。当然有一点需要注意的是被调用的虚函数可能会使用没有初始化的数据成员，但这不是我们讨论的问题了。所以结论是，OK，没问题，只是不推荐这么做而已。
• 如果需要在初始化列表中对基类进行初始化，那么是绝对不安全的！基类的构造要早于子类的函数被创建，但在初始化列表展开之前，基类构造的时候就要使用子类虚函数的话，很显然是行不通的：有可能指向定义这个函数的vtbl的vptr尚未创建成功，或者可能指向了错误的类对象。（不过在gcc上貌似没有什么问题）

拷贝和赋值

依然先要回顾一下

• 什么时候编译器会生成一个默认的拷贝构造函数？需要的时候，但并非所有情况（参见2.2）
• 是否需要自己写拷贝构造函数需要斟酌。对于bitwise copy足够的情况没有必要自己编写

对于拷贝运算符来说以下情况是不会进行Bitwise copy的（同样参见2.2构造函数：拷贝构造函数）

• 数据成员中有拥有拷贝运算符的类型
• 基类中有拷贝运算符
• 类中有虚函数（因为等号右边的对象可能是个子类）
• 继承自虚基类

其实就是一句话……如果默认的bitwise copy（memberwise assignment）不能满足需要的时候，会出现默认的拷贝运算符 如果默认的也不能满足需要，那就得自己写一个拷贝运算符进行深拷贝 编译器在需要的时候会生成拷贝运算符

• 生成出来的类似于：

inline D& D::operator=( D* const this, D& rhs )
{
this->B::operator=( rhs );
iValue = rhs.Value;
return this;
}

• 可惜只能这么做，因为没有一个类似于构造函数一样的“拷贝初始化列表”
• 通过this指针取到基类运算符进行赋值也可以用这个代替： ( *(B*)this) ) = rhs;，这样转化成了通过基类指针对对象进行值拷贝
• 关键问题就在于怎么拿到基类的运算符重载函数，另外则是如果有多继承的情况，如何只（在最底层的子类）执行一次拷贝操作？
  • 嗯……通过指向成员函数的指针：

typedef B& (B::*POF)(const B&);
POF pOF = &B::operator=;
D.*pOF( anotherD );

• • 其丑无比！
• 其实很多编译器在虚继承的时候处理拷贝运算符比较苦手
• 所以最简单的方式就是执行多次拷贝，只要保证当前类的调用位于所有的基类之后就行——虽然这样一来虚基类子对象会复制多次

析构

同构造函数、拷贝函数的情况类似，析构函数只有在需要的时候（基类有析构函数、数据成员有析构函数）的情况下才被生成出来 顺序和构造函数正好相反

• 析构函数执行程序员的代码
• 如果类的数据成员拥有析构函数，那么也会调用，不过顺序和声明相反
• 对象内有vptr的话，那么重设vtbl
• 如果基类拥有析构函数的话，同样相反调用
• 如果虚基类拥有析构函数的话，且当前类是最底层的子类，那么同样相反调用

整个过程类似“脱壳”一样，从下至上地析构，子类逐渐地变为上层基类、上上层基类、上上上层……（如果有的话） 两种析构函数的版本

• 完整的对象，设置vptrs，调用虚基类的析构函数
• 基类子对象，除非析构函数中调用了虚函数，否则不会设置vptrs、调用虚基类的析构函数

第6章 执行期

构造和析构

局部对象的构造析构

• 对于switch/case、goto等指令析构函数可能会被安排出现多次：每个函数的退出点都需要有一个
• 但位于局部对象声明之前的，不需要

全局对象

• 全局对象的生存期为main()之前构造而函数结束前析构
• 放置的位置为DS（5.2构析拷贝：对象构造）
• 为了支持类对象的静态初始化，需要在有虚继承的情况下进行指针调整，将子类中vbc pointer的正确位置返回

局部对象

• 局部静态对象声明一次，只会初始化和销毁一次。初始化的地点和全局对象一样，即时对象所在的函数并未被调用
• 闭包的概念。

void foo2() { static int i = 0; cout<<i++<<endl; }
 
    foo2(); // 0
    foo2(); // 1

数组

• 如果数组元素没有显式的构造函数和析构函数，那么分配足够的空间就够了
• 但如果有的话，参考cfront的解法，定义一个新的函数vec_new，参数分别为数组起始地址、类对象大小、数组元素个数、构造函数和析构函数的指针
  • 与之对应的数组析构函数vec_del只接受一个析构函数指针就足够，然后针对所有元素遍历调用
• 例如B bases[10];就会变为 vec_new( &bases, sizeof( B ), 10, B::B, 0 );，函数会对于传入的所有对象分别调用其构造和析构函数
  • 程序员提供了初始值的情况呢？例如 B bases[10] = { B(), B( 1 ), 2 };
  • 编译器会解析出已经赋值的部分，将其变为构造函数的调用，再对剩余的对象调用vec_new，当然，数组起始地址和元素个数都会不同
• 大概类似于B::B( &bases[0], 0 ); B::B( &bases[1], 1 ); B::B( &bases[2], 2 ); vec_new( &bases+3, sizeof( B ), 7, B::B, 0 );
  • cfront 2.0之前，数组无法应付超过一个默认参数的构造函数或者默认构造函数，回顾上面的vec_new函数，我们如何调用到拥有多个默认参数的构造函数指针？

cfront的编译器多加了一个stub的构造函数（同样也是没有参数），里面调用程序员写的带有多个默认参数的构造函数

new和delete

new运算符

• 简单的一个new运算符语句其实包括多个步骤。例如int* pi = new int( 5 );
  1. 首先调用__new函数进行内存分配int* pi = __new ( sizeof(int ) );
  2. 赋值 *pi = 5。
  3. 实际上第一步中应该多判断一下pi是否不为0再赋值
• 对于类对象来说。例如Base* pb = new Base( pb, 5 );
  1. 类似于上面的做法，分配内存先 Base* pb; pb = __new( sizeof( B ) );
  2. 赋值 *pb = Base::Base( 5 );
  3. 实际情况需要考虑的还要更多，例如在拷贝构造的时候，函数有可能抛出异常。如果catch到的话需要__delete掉已经分配的内存空间

delete运算符

• 也是交给内置函数去做的。例如delete pi;
  1. 变为if ( pi != 0 ) __delete( pi );
  2. 不过由于不会重置内存，所以之后再判断pi是否为null甚至*p去取值都有可能成功。
• 对于类对象的析构来说。例如delete pb;
  1. 变为if ( pb != 0 ) { Base::~Base( pb ); __delete( pb ); }

new和delete运算符的实现

• 首先是size为0的情况会自动调整为1，这是因为每一次new出来的指针都应该是不同的，所以就算size为0，也要指向不同的1-byte内存区域。
• 声明void*指针，用malloc拿到相应size的空间并且返回指针
• delete采用free()实现

数组的new运算符

• 例如int* pi = new int[5]; 或者MyStruct* ps = new MyStruct[5]; //MyStruct是结构体
  • 内置类型时vec_new并不会调用，因为它作用就是遍历调用构造函数，但上面两种类型都没有
  • 只有__new用来分配空间
• 对于拥有默认构造器的类来说，数组初始化时候也需要析构函数指针，因为可能发生异常，以便清理已经分配的空间（6.1执行期：构造和析构第4节）
• C++ 2.0之前在delete掉数组时候，需要程序员手动指定元素个数，例如delete [5] pi;
  • 但之后就不用了，就像我们现在所使用的那样delete[] pi;
  • 实现这个功能需要知道数组首地址和元素的个数。但这样做需要更多性能上的开销。所以如果没带[]调用delete，只会删掉一个元素
  • 具体来说，即将vec_new返回的内存地址多加一个word长度的信息，保存数组长度（所谓cookie）
  • 但Sun编译器的做法是维护一个保存数组指针和大小的额外数组，其中还放置析构函数的地址
• 继承情况下的问题
  • D继承于B，都实现了虚析构函数。那么B* pb = new D[ 5 ];如何？
  • 语法上OK，但delete [] pb时候问题来了……vec_del只会调用5次B类的析构函数，D的却没有。因为它总是执行被删除类型的析构函数。
    • vec_del只会调用5次B类的析构函数，D的却没有。因为它总是执行被删除类型的析构函数。
    • 更可怕的是，由于传入的元素大小是sizeof( B )，显然在pb++的时候移动的距离并非预期的D的长度，也就是说析构函数指针所作用的内存区域必然会出现错误
  • 如果非得这么干的话，需要程序员自己解决问题：遍历数组每一个元素，然后 D* d = &((D*)pb)[i]; delete d;

new运算符的重载

• 例如B* b = new (arena) B();，这里的arena为指定的的内存区域
• 实际上编译器做的事情就是将传入的arena参数返回而已
• 在编译器其实就相当于B* p = (B*) arena; 不过要做的事情除了决定arena的类型，还得 p->B::B();
• 重复利用一块区域进行构造如何？例如上面操作后再 b = new (arena) B();
  • 那么之前new出来的对象不会被析构。
  • 直接delete b的话，是有问题的，虽然可以调用到析构函数，但b占用的内存区域同样也回收了
  • 所以需要b->~b();
  • 不过标准C++中不需要这么做，编译器的__delete();会进行析构但不释放内存区域
• C++标准里面规定，利用同一块内存构造新对象的时候，要么是同一类型，要么就是全新的区域，并且大小足够放下这个object
• 这么一来，继承的类就不好说了，所以这种new运算符的重载基本是不支持多态的

B b;
    b.ToString();
    b.~B();
    new ( &b ) D;
    b.ToString();

• • 哪个类的ToString被调用了？实际上是B的……

临时对象

不太严谨但清晰的定义是：没有别名的局部对象 T a, b; T c = a + b;

• 不能肯定是否调用了c的拷贝构造函数，并且利用a+b产生的临时对象作为参数
• 因为可能产生的NRV优化以及不同的加号运算符重载，可能会直接将a+b的值放入c内

对于T c = a + b; 和T c; c = a + b;来说可能导致完全不同的结果

• 前者一般都会调用重载的等号运算符，直接传入局部对象引用作为第一个参数
• 而后者总是会产生临时对象，调用其等号运算符、再析构
• 另外后者需要保证“c是全新的”，而等号运算符又不会调用析构，所以必须保证在赋值前进行析构。
• 一般而言前者效率更好

关键问题在于临时对象的生存期，即何时调用它的析构函数才合适

• C++标准规定：对于临时对象的析构应该是完整表达式求值的最后一个步骤
• 换句话说在表达式被完全求值之前，所有为此产生的临时对象都不能销毁
• 也有例外
  • 利用表达式初始化对象 String s = flag ? null : s1 + s2;，也就是说在?后s1+s2产生的临时对象就要析构了。但如果String需要用拷贝构造函数进行初始化的话，必然会位于析构之后，所得到的值也会是错误的。
  • 利用对象初始化引用时。如果String& s = s1 + s2; 如果引用的临时对象析构了，那引用就没意义了。所以这种情况下，临时对象会在引用失效或者自身失效后进行析构，哪个先到算哪个。

第7章 终章

Template

Template是个非常强大的语法，毋庸置疑。它提供了C++的泛型特性。但由于使用不便，很多人不愿意用。相较于更现代的语言，例如C#和Java，C++利用Template实现的泛型确实不太好理解。 Template的“绑定”会直接替换实际的类型到形参上 对于在Template类里面生命的各种成员而言，编译器在处理Template时候，它们还没有被生成。只有绑定了类型之后才可以使用。例如一个Class B拥有一个enum对象TStatus。但不能直接用B::Status，而只能B::Status。

• 所以对于常量之类的，尽量从Template类中提取出来，避免多次拷贝

对于指针和引用的区别对待

• B* b = 0;这样做不会产生一个B的实体出来，实际上现在C++标准也禁止编译器这么做
• B& b = 0;这样则会产生一个实体。因为引用不能为空，展开后类似于B tmp( int( 0 ) ); const B& b = tmp;

Template的实例化（instantiation）

• 指针和引用的例子参见上一条
• 并非一次性都实例化完成，用到的才实例化。例如B* b = new B(0); 只会实例化Template本身、构造、析构函数。这是出于效率的考虑。另外new运算符虽然是static的，但它也间接依赖于Template的参数：对象的大小。

Template的错误处理

• 一些潜在的错误（非语法错误）：例如给指针赋了错误的值（int* = 1024）、使用类没有实现的运算符。不过编译器都会在实例化Template时候判断出来

名称问题

• Template类的定义范围内有一个extern函数，和使用处定义的一个extern函数重名了，那么在Template类成员函数中调用的到底是那个函数？

//template定义范围内
extern double foo( double aValue );
template<class T>
class C1
{
public:
    bar() { _v1 = foo( _v2 ); }
    bar2( T aValue ) { _v1 = foo( aValue ); }
private:
    T _v1;
    int _v2;
//template使用范围内
extern int foo( int aValue );
C1<int> c;
c.bar();

• 上例中是定义范围内的那个，而不是适用范围内，符合参数类型的那个。
• 原则：调用的函数是否和使用的类型相关，不相关就直接使用定义范围的。本例中_v2是很明显的int，不会随着模板参数类型变化而变化，所以直接使用定义范围的。所以如果是调用了bar2()的话，那就会选择使用范围的那个foo()。

成员函数

• 编译器寻找函数定义：遵循一定的规则，例如一定在头文件对应的同名cpp文件内
• 寻找成员函数：Borland生成所有函数；cfront的方法是模拟链接（simulate linkage），只生成需要的
• 成员函数实体的唯一性：生成一份，然后在.o中链接

异常处理

中心思想：发生异常的时候查找catch，将局部变量析构掉后让当前函数unwind

• 所以看起来很像的代码可能由于异常处理机制的存在而拥有差别很大的执行期语义

对于类似互斥锁之类的操作，如果异常发生在lock之后，如何进行unlock？

• 提供多个unlock操作，分别放在可能的路径上
• 对于更现代的语言来说，都拥有类似finally这样子句来支持异常发生后的对象清理操作

再例如一个子类指针指向的数组，分配到某一个元素的基类区域时候发生了一场，那么之前的元素都需要分别调用子类和基类的析构，而发生错误的那个元素只要调用基类的即可，因为子类尚未构造出来。 代码会被划分为多个区段，因为在异常发生前的对象都需要调用析构进行清除，之后的则不用

• try以外的，没有局部对象的代码段、try以外的，有局部对象的代码段，try代码段
• 实现方法：program counter-rage table。记录各个代码段的起始/终止位置
• 发生异常的时候，如果当前位置位于try代码段之中，那么就寻找try字句处理

异常发生的时候会产生异常对象（exception object），放置在异常栈中

• throw出去的是地址、type identifier以及可能的异常对象TI
• 如果跑出了异常子类而catch的是基类，exObj会被slice off掉非基类的部分
• catch字句结束时，当前的局部exObj就会被销毁。所以如果再一次抛出异常的话，捕获的又是原来的对象了（这节翻译的也太烂了！）

RTTI

cfront2.0之前，转型运算符*是不能够被重载的

• 不过之后就可以了

downcast：有用、常用甚至是必要的——但不一定安全的操作 类型安全的downcast操作

• 为了支持安全的downcast需要额外开销：类型信息（TI）和运行时的类型判断（runtime type）
• 所以TI的信息就放在vtbl第一个slot位置了

类型安全的动态cast操作

• 编译器做了额外的事情帮助程序员处理downcast带来的问题——如果转换失败，返回null而不是指向错误内存的指针
• 顺便总结一下三种cast操作的特点（const不用说了）
  • reinterpret_cast。仅指针。编译器解释。不修改格式。不安全。
  • static_cast。继承。基本不用于指针，效率不高。不安全。
  • dynamic_cast。继承。运行时。指针或引用。安全。
• dynamic_cast的额外开销：执行期通过需要转换的指针获得类型描述
  • (( type_info* )( p->__vptr[0] ))->type_descriptor
  • 拿到之后要交给一个内置的函数判断p指向的类型和这个类型描述是否相符
  • 本来贝尔实验室的人准备就用type()类似这样的运算符实现dynamic_cast，但C++标委会的人认为这样做和static_cast就没区别了，体现不出来dynamic_cast需要的额外开销

重提：引用不是指针

• 和指针不同，引用不能指向到0，所以dynamic_cast失败的时候，只能引发一个异常

Typeid运算符

• typeid返回的是一个对于type_info的const reference
• 它的==运算符也是被重载的
• type_info的实际结构包括的信息：类名、和其他type_info对象的位置关系、类原名、子类型信息等