blocks|key|794985|text|您可以选择编写自定义的getter行为，这可能会导致完全不同的行为。因此，您不能总是假设[variable+release]与[self.variable+release]具有相同的结果。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|794986|同样，你也可以编写自定义属性，而不需要一个独占的ivar来支持它们。如果你开始从getter返回的引用中释放对象，它会变得很混乱！|794987|可能还有其他我不知道的原因...|794988|entityMap^0|18|I|1R|N|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|R|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|K|$]]

You can optionally write custom getter behavior, which may result in completely different behavior. So, you cannot always assume that <code>[variable release]</code> has the same results as <code>[self.variable release]</code>. 

As well, you can write custom properties without an exclusive ivar backing them... it can get messy fast if you start releasing objects from references returned by getters!

There may be additional reasons that I'm unaware of...

blocks|key|579115|text|对于没有自定义访问器的保留属性，可以通过以下方式释放对象：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|579116|self.variable+=+nil;|code-block|syntax|javascript|579117|这样做的效果是将ivar+(如果您只声明了属性，则不能称为“变量”)设置为nil，并释放先前的值。|579118|正如其他人所指出的，直接释放ivar+(如果可用)或使用上面的方法都是可以的-你不能做的是对从getter返回的变量调用release。|579119|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

For a retained property with no custom accessor, you can release the object by:

<pre><code>self.variable = nil;
</code></pre>

This has the effect of setting the ivar (which may not be called 'variable' if you have only declared properties) to nil and releasing the previous value. 

As others have pointed out, either directly releasing the ivar (if available) or using the method above is OK - what you must not do is call release on the variable returned from a getter.

blocks|key|795171|text|典型的getter看起来更像这样：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|795172|-+(id)variable+{
+++return+[[variable+retain]+autorelease];
}|code-block|syntax|javascript|795173|因此，如果您使用[self.variable+release]，那么当您只想释放对象并导致对象被延迟释放(当自动释放池被耗尽时)时，您实际上并不需要额外的retain和autorelease。|offset|length|style|CODE|795174|通常，您可以使用self.variable+=+nil，它的优点是还可以将变量设置为nil+(避免因指针悬空而崩溃)，或者使用[variable+release]，如果您的setter具有自定义逻辑，则它是最快的，并且在dealloc方法中可能更合适。|795175|entityMap^0|0|0|8|N|25|6|2C|B|0|8|J|16|3|1R|I|32|7|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]|$I|V|J|W|K|L]|$I|X|J|Y|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|Z|8|@$I|10|J|11|K|L]|$I|12|J|13|K|L]|$I|14|J|15|K|L]|$I|16|J|17|K|L]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|P|$]]

A typical getter will look more like this:

<pre><code>- (id)variable {
 return [[variable retain] autorelease];
}
</code></pre>

So if you use <code>[self.variable release]</code> you have an additional <code>retain</code> and <code>autorelease</code> that you don't really need when you just want to release the object and that cause the object to be released later than necessary (when the autorelease pool is drained).

Typically, you would either use <code>self.variable = nil</code> which has the benefit that it also sets the variable to <code>nil</code> (avoiding crashes due to dangling pointers), or <code>[variable release]</code> which is the fastest and may be more appropriate in a <code>dealloc</code> method if your setter has custom logic.

blocks|key|579239|text|并不是所有的getter都采用这种形式：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|579240|-+(id)variable+{+return+variable;+}|code-block|syntax|javascript|579241|...that仅仅是最原始的形式。仅属性本身就应该提供更多的组合，从而改变实现。上面的原语访问器没有考虑到与内存管理、原子性或复制语义结合使用的习惯用法。这个实现在子类覆盖中也是脆弱的。|579242|下面是一些非常简短的例子；在实现变得相当复杂的实际程序中，事情显然变得更加复杂。|579243|1)+getter可能不会返回实例变量。以下几种可能性之一：|579244|-+(NSObject+*)a+{+return+[[a+copy]+autorelease];+}|579245|2)+setter可能不保留实例变量。以下几种可能性之一：|579246|-+(void)setA:(NSObject+*)arg
{
++...
++a+=+[arg+copy];
++...
}|579247|3)你最终在整个程序中实现了内存管理，这使得它很难维护。类的语义(以及它如何处理实例变量的引用计数)应该保留在类中，并遵循预期结果的约定：|579248|-+(void)stuff:(NSString+*)arg
{
++++const+bool+TheRightWay+=+false;
++++if+(TheRightWay)+{
++++++++NSMutableString+*+string+=+[arg+mutableCopy];
++++++++[string+appendString:@"2"];
++++++++self.a+=+string;
++++++++[string+release];
++++++++//+-+or+-
++++++++NSMutableString+*+string+=+[[arg+mutableCopy]+autorelase];
++++++++[string+appendString:@"2"];
++++++++self.a+=+string;
++++}
++++else+{
++++++++NSMutableString+*+string+=+[arg+mutableCopy];
++++++++[string+appendString:@"2"];
++++++++self.a+=+string;
++++++++[self.a+release];
++++}
}|579249|如果不遵循这些简单的规则，您的代码将很难维护和调试，并且很难扩展。|579250|所以简而言之，你想让你的程序易于维护。直接在属性上调用release需要你了解该类内部工作的很多上下文；这显然是不好的，并且缺少良好的面向对象设计的强大理想。|579251|它还期望作者/子类者/客户确切地知道类是如何偏离约定的，当问题出现时，这是愚蠢和耗时的，当问题出现时，你必须重新学习所有内部细节(他们会在某个时候)。|579252|这些都是一些微不足道的例子，说明了在属性的结果上调用release是如何带来问题的。许多现实世界的问题要微妙得多，也很难定位。|579253|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|18|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|19|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|1A|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|1B|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|1C|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|1D|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|1E|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|1F|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|1G|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1H|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|1I|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|1J|8|@]|9|@]|A|$]]|$1|14|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]]|15|$]]

not all getters take this form:

<pre><code>- (id)variable { return variable; }
</code></pre>

...that is merely the most primitive form. properties alone should suggest more combinations, which alter the implementation. the primitive accessor above does not account for idioms used in conjunction with memory management, atomicity, or copy semantics. the implementation is also fragile in subclass overrides.

some really brief examples follow; things obviously become more complex in real programs where implementations become considerably more complex.

1) the getter may not return the instance variable. one of several possibilities:

<pre><code>- (NSObject *)a { return [[a copy] autorelease]; }
</code></pre>

2) the setter may not retain the instance variable. one of several possibilities:

<pre><code>- (void)setA:(NSObject *)arg
{
 ...
 a = [arg copy];
 ...
}
</code></pre>

3) you end up with memory management implementation throughout your program, which makes it difficult to maintain. the semantics of the class (and how it handles instance variables' ref counting) should be kept to the class, and follow conventions for expected results:

<pre><code>- (void)stuff:(NSString *)arg
{
 const bool TheRightWay = false;
 if (TheRightWay) {
 NSMutableString * string = [arg mutableCopy];
 [string appendString:@"2"];
 self.a = string;
 [string release];
 // - or -
 NSMutableString * string = [[arg mutableCopy] autorelase];
 [string appendString:@"2"];
 self.a = string;
 }
 else {
 NSMutableString * string = [arg mutableCopy];
 [string appendString:@"2"];
 self.a = string;
 [self.a release];
 }
}
</code></pre>

failing to follow these simple rules makes your code hard to maintain and debug and painful to extend.

so the short of it is that you want to make your program easy to maintain. calling release directly on a property requires you to know a lot of context of the inner workings of the class; that's obviously bad and misses strong ideals of good OOD.

it also expects the authors/subclassers/clients to know exactly how the class deviates from convention, which is silly and time consuming when issues arise and you have to relearn all the inner details when issues arise (they will at some point).

those are some trivial examples of how calling release on the result of a property introduces problems. many real world problems are much subtler and difficult to locate.

I was told by a <a href="https://stackoverflow.com/questions/5737312/set-to-nil-in-viewdidunload-but-release-in-dealloc/5737438#5737438">fellow StackOverflow user</a> that I should not use the getter method when releasing a property:

<pre><code>@property(nonatmic, retain) Type* variable;
@synthesize variable;

// wrong
[self.variable release]; 

// right
[variable release]; 
</code></pre>

He did not explain in detail why. They appear the same to me. <a href="https://rads.stackoverflow.com/amzn/click/com/143023024X" rel="nofollow noreferrer" rel="nofollow noreferrer">My iOS book</a> said the getter on a property will look like this:

<pre><code>- (id)variable {
 return variable;
}
</code></pre>

So doesn't this mean <code>[self variable]</code>, <code>self.variable</code>, and <code>variable</code> are all the same?

Why shouldn't I use the getter to release a property in objective-c?

内存管理

告诉我在释放属性时不应该使用getter方法：@property(nonatmic, retain) Type* variable;@synthesize variable;// wrong[self.variable release]; // right[variable release]; 他没有详细解释原因。它们...

问为什么我不应该使用getter来释放objective-c中的属性呢？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么我不应该使用getter来释放objective-c中的属性呢？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么我不应该使用getter来释放objective-c中的属性呢？
EN