目标中的属性c。复制并保留

Question

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

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

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

属性---

   @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，getters和dot-syntax访问器（接口变量隐藏）的声明。

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

声明属性时，您有三个类别 - 线程锁定，访问控制和内存管理。您只能为每个类别选择一个修饰符，如果您不选择其中一个，则会自动将其自动分配给一个。

@property (<thread locking>, <access control>, <memory management>) id property;

第一个类别可以是atomic或nonatomic。 atomic修饰符强制对变量执行@synchronized（myInstance）锁定，以允许线程安全。 nonatomic不使用synchronized块，并且不是线程安全的。如果您不使用任何一个，它会自动设置为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二传手和吸气鬼; @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

Answer 2

是的，retainCount没用 - 请勿调用它 - 并假设copy将始终返回新实例是不正确的。

如果发送不可变对象copy，则通常将其实现为：

- copy { return [self retain]; }

即。由于内容无法改变，因此无需制作实际的副本。

当然，既然你正在捣乱静态，编译成二进制，字符串，实现可能更接近：

- retain { return self; }
- copy { return self; }
- (void)release { ; }
- (void)dealloc { ; }

也许 - 所有上述内容都是可能随时更改的实施细节。但最重要的是，所有上述内容都符合保留/释放/复制/等等的合同......