iphone - objective-c 中的属性。复制并保留

Question

我从苹果文档中读到的内容保留将保留计数增加 1 ，发布将减少 1 。这对我来说非常清楚。

但是在复制和保留的情况下，我有点困惑。

让我用我正在尝试的代码解释一下。

属性(property) - -

   @property(nonatomic, retain) NSMutableString *a;

   @property(nonatomic, copy) NSMutableString *b;


   @synthesize a = _a ,b = _b

   a=[[NSMutableString alloc]initWithString:@"Hello Ankit"];
   NSLog(@"a memory location A - %p", &a );
   b=[[NSMutableString alloc]initWithString:@"Hello Nigam"];
   NSLog(@"a memory location B- %p", &b );
   c= [[NSMutableString alloc]initWithString:@"Ankit Nigam"];
   NSLog(@"a memory location C %p",&c);


NSMutableString *temp =[[NSMutableString alloc]initWithString:@"hey"];

NSLog(@"temp = %@ %p",temp,&temp);
self.b = temp;
NSLog(@"B is now %@ %p",self.b,&b);

self.a = temp;
NSLog(@"A is now %@ %p",self.a,&a);

And i get the output as -- - -

2012-05-10 03:24:34.756 retainCountTest[2655:f803] a memory location A - 0x6d314fc
2012-05-10 03:24:34.757 retainCountTest[2655:f803] a memory location B- 0x6d31500
2012-05-10 03:24:34.764 retainCountTest[2655:f803] a memory location C 0x6d31504
2012-05-10 03:24:34.764 retainCountTest[2655:f803] temp = hey 0xbfffdd04
2012-05-10 03:24:34.764 retainCountTest[2655:f803] B is now hey 0x6d31500
 2012-05-10 03:24:34.765 retainCountTest[2655:f803] A is now hey 0x6d314fc

但据我从文档中了解到，保留对象必须具有相同的内存地址，其中复制对象将创建一个具有不同内存位置的新对象。

再次当我将日志更改为 ---

self.b = temp;
NSLog(@"B is now %@ %p",self.b,&_b);

self.a = temp;
NSLog(@"A is now %@ %p",self.a,&_a);
It return me a complete different memory location for both the object.

2012-05-10 03:28:49.905 retainCountTest[2688:f803] a memory location A - 0x6d4a4ac
2012-05-10 03:28:49.906 retainCountTest[2688:f803] a memory location B- 0x6d4a4b0
2012-05-10 03:28:49.907 retainCountTest[2688:f803] a memory location C 0x6d4a4b4
2012-05-10 03:28:49.907 retainCountTest[2688:f803] temp = hey 0xbfffdd04
2012-05-10 03:28:49.908 retainCountTest[2688:f803] B is now hey 0x6d4a4c0
2012-05-10 03:28:49.908 retainCountTest[2688:f803] a is now hey 0x6d4a4bc

任何人都可以帮助我理解这些保留和复制的完整概念。也是为什么我会得到这些意想不到的结果。

非常感谢。

Answer 1

属性只是一个声明，允许使用 setter、getter 和点语法访问器(接口(interface)变量隐藏)。

它本身绝对没有任何作用，但允许您使用 -[myInstance myProperty]获取变量或使用 -[myInstance setMyProperty:]设置它(是的，方法名称自动分配给 -setProperty: 和 -property )。

声明属性时，您分为三类 - 线程锁定、访问控制和内存管理。您只能为每个类别选择一个修饰符，如果您不选择一个，它会自动分配给一个。
@property (<thread locking>, <access control>, <memory management>) id property;
第一类可以是 atomic或 nonatomic . atomic修饰符强制对变量使用 @synchronized(myInstance) 锁，以实现线程安全。 nonatomic不使用同步块(synchronized block)，并且不是线程安全的。如果你都不使用，它会自动设置为 atomic .

第二类可以是 readonly或 readwrite . readwrite修饰符也允许修改属性，并允许自动生成 -setProperty: 方法。当readonly使用了修饰符，不能使用 -setProperty:方法。您必须使用对象内部的内部变量来直接设置变量。

第三类可以是 assign , retain , 和 copy . assign修饰符表示内部对象指针设置为传递给 -setProperty: 的指针信息。 retain修饰符分配传递的指针并传递 -retain到对象。
copy修改器对对象进行直接克隆 - 指向内存中新地址处的新对象的新指针。这通过调用 -copy 将内部对象指针设置为传递对象的副本。在传递的对象上。默认修饰符是 assign ，如果您没有在对象上设置内存管理类别修饰符，编译器会警告您 - 因为 assign对象上的修饰符不受欢迎(除非明确声明)。

有关 -copy 的示例，请查看:

- (void)setProperty:(GXMyObject *)property {

    // This points to the original passed object.
    GXMyObject *original = property;

    // This points to a copy of the passed object.
    CGMyObject *copied = [property copy];

    // This points to yet another copy of the passed object-
    // Independent of the other copies and original.
    _property = [property copy];

    // The anotherProperty is now different on this copy
    // than on the original and the other copies.
    _property.anotherProperty = 4;

    // This will prove that they are all individual objects.
    NSLog(@"%p, %p, %p", original, copied, _property);
}

有一个可选的方法名称声明修饰符，用法如下:getter = myCustomPropertyGetter和 setter = myCustomPropertySetter: (setter 方法名称末尾的冒号 : 是必需的，因为它表示必须传递一个参数)。

这的后半部分是属性合成器或动态生成器。一旦声明了一个属性(例如， myView )，如下所示:
@property (nonatomic, retain) NSView *myView;
您可以:自己定义 setter 和 getter； @synthesize二传手和 setter/getter ； @dynamic属性表示它存在于一个类别或主类中，或者可以在运行时添加(请注意，这不是一个有趣的想法，并且可能导致糟糕的运行时异常)。

第一个示例，您自己编写方法将如下所示:

// In Apple's LLVM 3.1 Compiler, instance variables can be added 
// within {} below the @implementation as well as the @interface, 
// and in private categories (@interface GXMyClass ()) like before.
@implementation GXMyClass {
    // The internal object pointer is prefixed with an _ to avoid name confusions.
    NSView *_myView;
}

- (NSView *)myView {
    return _myView;
}

- (void)setMyView:(NSView *)myView {
    _myView = [myView retain];
}

@end

第二个例子是使用 @synthesize 自动合成它指示:

@implementation GXMyClass

// In the new Apple LLVM 3.1 Clang compiler, the = operator when used 
// next to the @synthesize directive declares an internal private 
// variable and automatically sets to that variable.
@synthesize myView = _myView;

// The internal variable name is now myOtherView, because we did not use the
// = operator to assign an internal variable name to the property.
@synthesize myOtherView;

@end

在最后一个示例中，也许是最令人困惑的，因为它需要使用 @dynamic 指令，您需要添加一些类别或运行时方法:

@interface GXMyClass (InternalMethods)
@end

@implementation GXMyClass

// The = assignment operator does not work here.
@dynamic myView;

@end

@implementation GXMyClass (InternalMethods)

- (NSView *)myView {
    return [self methodThatReturnsAnNSView];
}

- (void)setMyView:(NSView *)myView {
    [self methodThatAcceptsAnNSViewArgument:myView];
}

@end

@property声明要求存在上述三个声明之一-它自己不做任何事情。然而，它允许的是点语法访问器(用于设置和获取属性的类 Java 访问器)。

例如，@property (copy) NSString *myName;可以使用 -[myObject myName] 访问并使用 -[myObject setMyName:] 设置.

现在可以使用 myObjectInstance.myName = @"Bob"; 进行设置并开始使用 myObjectInstance.myName .利用上述所有概念，可以创建一个这样的对象:

// The GXBufferQueue is a queue which buffers all requests, till they are read
// asynchronously later. The backing store is an NSMutableArray to which all
// buffer writes are appended to, and from which the first object is pulled and
// returned when the buffer is read to.   
@interface GXBufferQueue

@property (nonatomic, readwrite, copy, setter = write:, getter = read) id buffer;

+ (GXBufferQueue *)queue;

@end

@implementation GXBufferQueue {
    // This queue is an internal array and is 'tacked on' to the @implementation
    // so no others can see it, and it can be marked @private so subclasses cannot
    // use it. It is also good code practice to have @interfaces composed of only
    // @properties, setters, and getters, rather than expose internal variables.
    NSMutableArray *_internalQueue;
}

+ (GXBufferQueue *)queue {
    return [[[GXBufferQueue alloc] init] autorelease];
}

- (id)init {
    if((self = [super init])) {
        _internalQueue = [[NSMutableArray alloc] init];
    }
}

- (void)write:(id)buffer {
    [_internalQueue addObject:buffer];
}

- (id)read {
    if(!(_internalQueue.count > 0)) return nil;

    id buffer = [_internalQueue objectAtIndex:0];
    [_internalQueue removeObjectAtIndex:0];
    return buffer;
}

@end

注意:此代码未经过任何测试。
既然你有一个 GXBufferQueue，下面所有的工作:

GXBufferQueue *queue = [GXBufferQueue queue];

// Option One: using the traditional message syntax:
[queue write:@"This will be now added to the buffer."];
NSLog(@"Now the string written to the queue will be read \
and removed from the queue, like a stack pop. ", [queue read]);

// Option Two: using the new dot-syntax accessors:
queue.buffer = @"As clunky as this looks, it works the same as above.";
NSLog(@"These lines work just the same as the ones above: ", queue.buffer);

正如您所看到的，属性有很多可能，而且除了变量声明之外，它们还可以做更多的事情。如果有任何问题或社区希望我在帖子中添加/纠正的任何内容，请发表评论! :D