什么时候是一个自动释放的对象实际释放？ [英] When is an autoreleased object actually released?

问题描述

在阅读完优秀的内容后，

< a href =http://developer.apple.com/mac/library/documentation/cocoa/Conceptual/MemoryMgmt/MemoryMgmt.html =nofollow noreferrer>内存管理编程指南for Cocoa by apple my只有当
实际上是一个自动释放的对象在iphone / ipod应用程序中释放时。我的理解是在运行循环结束。但是什么定义了应用程序中的运行循环？

所以我想知道下面的代码是否正确。假设一个对象

  @implementation Test 
 
  - （NSString *）functionA {
 NSString * stringA; 
 stringA = [[[NSString alloc] initWithString：@Hello] autorelease] 
 return stringA; 
} 
 
  - （NSString *）functionB {
 NSString * stringB; 
 stringB = [self functionA]; 
 return stringB; 
} 
 
  - （NSString *）functionC {
 NSString * stringC; 
 stringC = [self functionB]; 
 return stringC; 
} 
 
  - （void）viewDidLoad {
 [super viewDidLoad]; 
 NSString * p = [self functionC]; 
 NSLog（@string is％@，p）; 
} 
 
 @end 
  

此代码有效吗？

从苹果文本中我了解从 functionA 返回的NSString在 functionB 的范围内有效。我不确定在 functionC 和 viewDidLoad 中是否有效。

谢谢！

解决方案

是的，您的函数是有效的，并使用正确的Cocoa约定保留/释放/自动释放/复制返回对象。

为了回答你关于runloop的问题，在你的应用程序的main（）函数中，它调用UIApplicationMain（）。你可以想象UIApplicationMain看起来像这样：

  void int UIApplicationMain（int argc，char * argv []，NSString * principalClassName， NSString * delegateClassName）{
 UIApplication * app = / *使用principalClassName * /创建应用程序; 
 [app setDelegate：/ * create delegate using delegateClassName * /]; 
 while（！[app shouldTerminate]）{
 NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; 
 event = [app getNextEvent]; 
 [app dispatchEvent：event]; 
 [pool drain]; 
} 
} 
  

while循环类似于UIKit做，并且每个旅行通过那个while循环就像一个通过runloop的旅行，其中函数getNextEvent阻塞等待某些事件发生。所有的方法通常从像dispatchEvent这样的东西中调用。您可以尝试在其中一个方法中设置断点，如IBAction，在调试器调用堆栈顶部查看处理事件和runloop的UIKit方法的名称。由于每个方法都是在该while循环中调用的，因此每次在对象上调用autorelease时，该对象都将添加到运行循环中的外层池。当当前事件完成调度时，池被耗尽，并且这些对象最终被发送释放消息。

最后一个注释。可以有多个自动释放池，并不总是在事件循环的结尾。有时，您可能在一次行程中通过事件循环分配成千上万个对象。发生这种情况时，您可以在自己的方法中设置更多的内部自动释放池，以使自动释放池中的自动释放对象数量减少。自动释放池可以堆叠。

I am new in objective-c and I am trying to understand memory management to get it right.

After reading the excellent
Memory Management Programming Guide for Cocoa by apple my only concern is when actually an autoreleased object is released in an iphone/ipod application. My understanding is at the end of a run loop. But what defines a run loop in the application?

So I was wondering whether the following piece of code is right. Assume an object

@implementation Test

- (NSString *) functionA {
    NSString *stringA;
    stringA = [[[NSString alloc] initWithString:@"Hello"] autorelease]
    return stringA;
}

- (NSString *) functionB {
    NSString *stringB;
    stringB = [self functionA];
    return stringB;
}

- (NSString *) functionC {
    NSString *stringC;
    stringC = [self functionB];
    return stringC;
}

- (void)viewDidLoad {
    [super viewDidLoad];
    NSString* p = [self functionC];
    NSLog(@"string is %@",p);
}

@end

Is this code valid?

From the apple text I understand that the NSString returned from functionA is valid in the scope of functionB. I am not sure whether it is valid in functionC and in viewDidLoad.

Thanks!

解决方案

Yes, your functions are valid, and return objects using correct Cocoa conventions for retain/release/autorelease/copy.

To answer your question about what the runloop is, in your application's main() function, it invokes UIApplicationMain(). You can imagine UIApplicationMain looks something like this:

void int UIApplicationMain (int argc, char *argv[], NSString *principalClassName, NSString *delegateClassName) {
    UIApplication *app = /* create app using principalClassName */;
    [app setDelegate:/* create delegate using delegateClassName */];
    while (![app shouldTerminate]) {
        NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
        event = [app getNextEvent];
        [app dispatchEvent:event];
        [pool drain];
    }
}

That while loops is similar to what the UIKit is actually doing, and each trip through that while loop is like a trip through the runloop, where the function getNextEvent blocks waiting for some event to happen. All of your methods are typically called from within something like dispatchEvent:. You might try setting a break point in one of your methods, like an IBAction, and looking in the debugger call stack way up at the top to see the names of the UIKit methods that handle the events and runloop. Since each of your methods are called from within that while loop, each time you call autorelease on an object, that object is added to that outter pool in the run loop. When the current event is finished being dispatched, the pool is drained, and those objects are finally sent release messages.

One last note. There can be more than one autorelease pool, that aren't always at the end of the event loop. Sometimes you might allocate tens of thousands of objects in one trip thorough the event loop. When that happens, you might setup additional inner auto release pools in your own methods to keep the number of autoreleased objects in autorelease pools down. Auto release pools can stack.

这篇关于什么时候是一个自动释放的对象实际释放？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！