objective-c内存管理方面

有的自己都还没来得及看，先放在这里：
 
1，把对象视为内存。

每个对象实例的状态都被保存在不同的内存区域中。因此对象的创建与删除动作等价于它所占用内存的分配与回收。基于Foundation的类库，都通过一个根对象“NSObject”或有同样接口的其它类，为实例提供关联记数的机制（包括延迟释放的对象）。大多在Apple类库的类与基于“NSObject”的子类或它接口的实现类，都可以享有内存记数策略带来的管理能力。

Apple类库（Apple's frameworks）出台后，内存管理机制就被放在对象创建与销毁的生命周期中（虽然有些地方还是些Ｃ的方法与结构）。你会发现这其实是件很有意思的事情，它不像Ｃ一样有方法直接操作内存（malloc/free），也不像带ＧＣ的语言（Java & Smalltalk & Ruby & Python ...）自动管理内存。 它是一种基于关联记数与延时释放（Autorelease机制，下面会讲到）的机制管理内存，我们可以认为它是基于以上两种内存管理方案中间，一个比较中庸的内存管理解决方案。


2，对象持有制

（Object Ownership，不知道要翻译成啥，暂时叫他持有制，其实这个叫法本身就有些字面上的误导。了解它的本质就ＯＫ了，不必太在意它叫什么。^_^）

 基础类库与其它类库都推荐我们下面两个对象创建与销毁的策略：
 a 如果你创建了一个对象，你有责任把它销毁
 b 如果你想持有一个并不是你创建的对象，你需要”retain”它，并在不需要时”release”掉
 
 首先，对象的创建者就是它的拥有者，只有它的拥有者才可以销毁它。贯彻这条策略会使你的代码变的更简单，更强壮，并且可以绕开很多的引用已经销毁对象或内存泄露（没有用的对象却始终保持关系）造成的BUG。使用”NSAutoreleasePool”可以实现延迟释放机制，创建者可以把销毁的责任交给”NSAutoreleasePool”的对象实例（在下面会有详细原理说明）。



3，对象的内存分配与初始化

 SomeClass *anInstance = [[SomeClass alloc] init];

这是一个传统的创建对象的方法，首先分配一段内存，然后初始化。另外，在操作系统层面上还有内存区的概念，为了提高内存区域的定位使用能力，可以用”allocWithZone:”方法来尝试分配一段指定的区域。”NSObject”的有状态的子类都必需要扩展初始化方法，例如：

@interface CartesianCoordinate : NSObject
{
        NSNumber *abscissa;
        NSNumber *ordinate;
}

- (CartesianCoordinate *) initWithAbscissa: (NSNumber *)anAbscissa
                                 ordinate: (NSNumber *)anOrdinate;

@end

“NSObject”还提供了”copy,mutableCopy,copyWithZone,mutableCopyWithZone”方法可以分配内存，复属性 来达到复制对象实例的目的。


4，对象的回收

  如果你不想再使用一个对象时，就发送”release”的消息。当所有人都不在使用它，当没有任何一个关联时，它就会被自动发送”dealloc”方法回收。持有属性的类，应该它在的”dealloc”方法内释放所有它持有的对象实例。

@implementation CartesianCoordinate

...
- (void) dealloc
{
        [abscissa release];
        [ordinate release];

        return [super dealloc];
}

@end

5，对象实例的关联记数

  其实你应该可以了解到，关联记数是一个非常非常简单的事情。每个对象都持有一关联记数器”retain count”，它仅仅负责记录关联它的总个数。当一个对象以”init,initWith...”或其它复制方法创建时，这个数就被系统隐式的记为”1”。所有其它的对象可以发送”retain”消息持有它，这个方法也仅仅是在这个记数上加”1”而已。相对应的，每一个”realease”方法也只是把这个数减”1”。当它为”0”时，这个对象被回收（调用它的”dealloc”方法）。你也可以调用”retainCount”方法来查询这个数字。

- (void) notifyUserOfError: (NSString *)errorString
{
        NSMutableString *alertString = nil;

        alertString = [[NSMutableString alloc] initWithString:
                        @"The following error occurred: "];
        [alertString appendString: errorString];
        NSRunAlertPanel( alertString ...);
        [alertString release];

        return;
}


6,临时对象与自动释放方法

  就像你上面看到的，经常需要创建一个只用一次的对象，然后销毁它。在上面的例子里，当作用域定义好后它是很简单的一件事。但存在一个问题，不能返回一个临时的对象给调用者!!! 在Ｃ语言中有一个常用的方法，就是使用已经存在的静态缓存或是返回动态分配的内存，可能你已经想到了，它的调用者负责释放它。这个方案跟咱们上面提到的内存管理策略相左，在Foundation架构中已经提供了一个更优雅的解决方案。通过延迟释放机制让创建临时的对象可以最终自动释放，看以下代码：

- (void) notifyUserOfError: (NSString *)errorString
{
        NSMutableString *alertString = nil;

        alertString = [NSMutableString stringWithString:
                        @"The following error occurred: "];
        [alertString appendString: errorString];
        NSRunAlertPanel( alertString ...);

        return;
}

你可以看到”alertString”对象在创建后并没有调用”release”，而这个方法的调用者也不用担心要不要去释放它，因为在这里创建的对象是一个”autoreleased”对象，而这种对象会被自动释放。一个自动释放对象会在将来的某一时间被自动调用”release”方法。自动释放对象被创建后，若没有被显示的”retain”，在有限的生命周期中被会自动销毁。如果你想指定一个对象为自动释放的话，可以调用”autorelease”方法。

    alertString = [NSMutableString stringWithString:
                    @"The following error occurred: "];

完全和以下是一样的:

    alertString =
        [[[NSMutableString alloc] initWithString:
            @"The following error occurred: "] autorelease];


有这么一个贯例，就是像stringWithString:类似的方法都会创建一个自动释放的实例，在类库里随处可见。


7，自动释放进阶，让我们更深一步了解它的工作原理

  虽然自动释放对象的概念是如此简单，但了解它更多的工作原理还是很有必要的。不然在我们的嵌入式设备的开发中，仍然会走入内存漏洞深渊。

  其实，在我们的一个应用中，是有很多的”NSAutoreleasePool”对象实例的，就像它的命名一样，它们用来收集所有自动释放的对象。只要在调用”autorelease”方法后，它就会被加入到这个池中。在未来的某个时刻，一般指在”Foundation”与”AppKit”应用一个事件循环结束时，或者在响应完”WebObjects”类应用请求时，或调用”NSAutoreleasePool”对象的”release”方法。这里需要注意，”NSAutoreleasePool”并不止一个，为什么需要多个”NSAutoreleasePool”来管理内存呢？因为，在一个代码段内就回收所有自动释放对象是很有用处的，多线程应用中，每个线程可以拥有一个自动释放池的栈，当你创建了一堆临时对象时，而仅仅是在一段很短的上下文中，比如一个简单循环，你并不希望在下面的代码中，他们仍然占用保宝贵的内存资源，你就可以为这段短小紧凑本地上下文创建一个”NSAutoreleasePool”对象来管理他们:

- (id) findSomething
{
        id theObject = nil;
        // Whatever we're looking for
        NSAutoreleasePool *localPool = [[NSAutoreleasePool alloc] init];
        // Autoreleased objects are now automatically placed in localPool.

        // Loop that creates many temporary objects
        while ( theObject == nil )
        {
            ...
            if ( [temporaryObject matchesSomeCondition] )
            {
                theObject = [temporaryObject retain];
                // We want this one
            }
        }

        // Get rid of all those temporary objects
        [localPool release];

        return [theObject autorelease];
}

上段代码我们做了什么：

A,我们创建了一个”NSAutoreleasePool”对象，把它压到当前上下文中的内存管理池顶，在它下面的所有自动内存管理对象都被放入到这个池中。

B,我们调用了自动释放对象”temporaryObject”的”retain”方法，使它的生命周期超过本地池的管理。

C,释放池操作，同时把它从栈中POP出去。

D,紧接着，我们又在返回它前调用了 ”autorelease”方法，把这个对象放入当前池栈的TOP池中。


这东西有点绕，但原理其实还算简单。如果上面的能明白了，恭喜你，Objective-C的水平又上了一个台阶。

同理可证，还有一段更精练的代码：

- (NSArray *) findAListOfThings
{
        NSMutableArray *thingArray =
            [[NSMutableArray alloc] initWithCapacity: 25];
        // The list of 25 things we're looking for
        NSAutoreleasePool *outerPool = [[NSAutoreleasePool alloc] init];
        NSAutoreleasePool *innerPool = nil;
        NSArray *largeObjectArray = nil;
        id temporaryObject = nil;
        NSEnumerator *arrayEnumerator = nil;

        // Loops that create many temporary objects
        while ( [thingArray count] != 25 )
        {
            largeObjectArray = [self fetchLotsOfObjects];
            // largeObjectArray is autoreleased and contained in the
            // outer autorelease pool
            arrayEnumerator = [largeObjectArray objectEnumerator];
            // Note that the enumerator itself is a temporary object!
            // It will be released by the outerPool

            // Create the inner pool on each iteration. When
            // a pool is created, it automatically becomes the
            // "top" pool on the current thread's stack of pools.
            innerPool = [[NSAutoreleasePool alloc] init];
            // autoreleased objects now go into innerPool

            while ( temporaryObject = [arrayEnumerator nextObject] )
            {
                ...
                if ( [temporaryObject matchesSomeCondition] )
                {
                    [thingArray addObject: temporaryObject];
                    // Collections retain their members
                }            
            }

            // Dispose temporary objects created on this iteration;
            // Note that the objects added to thingArray during this
            // iteration are also in innerPool and thus sent a release
            // message, but are not destroyed because they have been
            // retained by thingArray and so have an additional reference
            // (their retainCount > 1)
            [innerPool release];
        }

        [outerPool release];

        return [thingArray autorelease];
}


写到这里所有的概念都已经讲完了，内存管理的东西也就是这么多〜〜〜
有兴趣的可以在这里再讨论些实例〜或是发我邮箱〜ＭＳＮ〜