目标c中的属性。复制并保留 [英] Properties in Objective c. copy and retain

问题描述

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

What I have read from the apple document retain will increase the retain count by 1 , and release will decrease by 1. This is very much clear to me.

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

But In the case of copy and retain i am a bit confused.

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

Let me explain with the code i am trying.

属性---

   @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

但据我所知，保留对象必须具有相同的内存地址，而复制对象将创建一个具有不同内存位置的新对象。

But as per I understand from the Doc the retain object must have the same memory address , where as copy object will create a new object with different memory location.

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

Again when i change the logs to ---

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

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

Can any help me to understand the complete concept of these retain and copy. Also why I am getting these unexpected results.

非常感谢。

推荐答案

属性只是一个允许setter，getters和dot-syntax访问器（接口变量隐藏）的声明。

A property is just a declaration that allows for setters, getters, and dot-syntax accessors (interface variable hiding).

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

It does absolutely nothing on its own but allow you to use -[myInstance myProperty] to get the variable or use -[myInstance setMyProperty:] to set it (yes, the method name is auto-assigned to -setProperty: and -property).

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

When declaring a property, you have three categories - thread locking, access control, and memory management. You can only pick one of the modifiers for each category and if you do not pick one, it's auto-assigned to one automatically.

@property （<线程锁定>，<访问控制>，<内存管理>）id属性;

第一类可以是 atomic 或 nonatomic 。 atomic 修饰符强制对变量执行@synchronized（myInstance）锁定，以允许线程安全。 非原子不使用synchronized-block，并且不是线程安全的。如果你不使用它们，它会自动设置为 atomic 。

The first category can either be atomic or nonatomic. The atomic modifier forces an @synchronized(myInstance) lock on the variable, to allow thread safety. The nonatomic does not use a synchronized-block, and is NOT thread safe. If you do not use either, it is automatically set to atomic.

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

The second category can either be readonly or readwrite. The readwrite modifier allows the property to be modified as well, and allows auto-generation of the -setProperty: method. When the readonly modifier is used, you cannot use the -setProperty: method. You must use the internal variable from within the object to set the variable directly.

第三类可以是 assign ，保留，复制。 assign 修饰符表示内部对象指针设置为传递给 -setProperty：消息的指针。 retain 修饰符分配传递的指针并将 -retain 传递给对象。

The third category can either be assign, retain, and copy. The assign modifier means the internal object pointer is set to the pointer passed to the -setProperty: message. The retain modifier assigns the passed pointer and passes a -retain to the object.

copy 修饰符执行对象的直接克隆 - 指向新对象的新指针内存中的新地址。这通过在传递的对象上调用 -copy 将内部对象指针设置为传递的对象的副本。默认修饰符是 assign ，如果没有在对象上设置内存管理类别修饰符，编译器会发出警告 - 因为 assign 修饰符不赞成（除非明确声明）。

The copy modifier does a straight-up clone of the object- a new pointer to a new object at a new address in the memory. This sets the internal object pointer to the copy of the passed object, by calling -copy on the passed object. The default modifier is assign, and the compiler will warn you if you do not set the memory management category modifier on an object - because an assign modifier on an object is frowned upon (unless explicitly declared).

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

For an example on -copy, look at this:

- (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：（冒号： at at setter方法名称的结尾是必需的，因为它表示必须传递参数。）

There is an optional method name declaration modifier and is used like so: getter = myCustomPropertyGetter and setter = myCustomPropertySetter: (The colon : at the end of the setter method name is required because it denotes that an argument must be passed).

后半部分是属性合成器或动态器。声明属性后（例如， myView ），如下所示：

The second half of this is the property synthesizer or dynamizer. Once a property is declared (for example, myView) like so:

@property （非原子，保留）NSView * myView;

您可以：自己定义setter和getter; @synthesize setter和getter; @dynamic 该属性表示它存在于类别或主类中，或者可能在运行时添加（不是一个有趣的想法，请注意，并可能导致运行时错误）例外）。

You would either: define the setter and getter yourself; @synthesize the setter and getter; @dynamic the property to say that it exists in a category or the main class, or may be added at runtime (not a fun idea, mind you, and could cause bad runtime exceptions).

第一个例子，自己编写方法看起来像这样：

The first example, writing the methods yourself would look like this:

// 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 指令自动合成它：

The second example would be to auto-synthesize it using the @synthesize directive:

@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指令，你需要一些类别或运行时方法添加：

Under the last example, perhaps the most confusing, because it requires the use of the @dynamic directive, you require something of a category or a runtime method addition:

@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的访问器）。

The @property declaration requires one of the three above declarations to be present- it does not do anything on its own. What it DOES allow, however is dot-syntax accessors (Java-like accessors for setting and getting properties).

例如， @property（复制）NSString * myName; 可以使用 - [myObject myName] 进行访问，并使用设置 - [myObject setMyName：] 。

For example, @property (copy) NSString *myName; could be accessed using -[myObject myName] and set using -[myObject setMyName:].

现在可以使用 myObjectInstance.myName = @Bob设置它; 并使用 myObjectInstance.myName 。利用上述所有概念，可以创建一个对象，例如：

Now it can be set using myObjectInstance.myName = @"Bob"; and gotten using myObjectInstance.myName. Utilizing all the above concepts, one could create an object such as this one:

// 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，以下所有工作：

Note: This code was in no way tested. Now that you have a GXBufferQueue, all the following works:

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

As you can see, there's a lot possible with properties and a lot more that can be done with them than just variable declaration. If there are any questions or anything the community would like me to add/rectify to/in the post, please leave a comment! :D

这篇关于目标c中的属性。复制并保留的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！