IOS5 added new knowledge, that is, arc, in fact, I do not really like it, because I used to manage the memory. But learning is still necessary.
In the development process of iOS, the definition of attributes is often related to retain, assign, copy, I think we are very familiar with this, I do not introduce, there are many related articles on the Internet.
Now let's look at the New keyword in iOS5 strong, weak, unsafe_unretained. can be corresponding to the previous keyword learning strong and retain similar, weak and unsafe_unretained function almost (a bit different, and so on, these two new keywords and assign similar). With these new keywords in iOS5, you can use them without having to manage your memory manually, and programmers who turn from other languages like Java are very useful.
Strong keyword and retain, using it, reference counting automatic +1, with an example to explain everything
@property (nonatomic, strong) NSString *string1;
@property (nonatomic, strong) NSString *string2;
There are two properties of this
@synthesize string1;
@synthesize string2;
Guess what results The following code will output?
Self.string1 = @ "String 1";
[self.string2 = self.string1;
[self.string1 = nil;
[NSLog (@ "String 2 =%@", self.string2);
The result is: string 2 = string 1
Since string2 is a strong-defined property, the reference count of +1 makes them point to the value @ "String 1", which is not difficult to understand if you are familiar with retain.
Then we look at the Weak keyword:
If this declares two properties:
@property (nonatomic, strong) NSString *string1;
@property (nonatomic, weak) NSString *string2;
and define
@synthesize string1;
@synthesize string2;
Let's guess, what is the output below?
Self.string1 = [[NSString alloc] initwithutf8string: "String 1"];
Elf.string2 = self.string1;
Self.string1 = nil;
NSLog (@ "String 2 =%@", self.string2);
The result is: String 2 = null
Analysis, because Self.string1 and Self.string2 point to the same address, and string2 no retain memory address, and Self.string1=nil freed memory, so string1 is nil. A pointer that is declared as weak, the pointer to the address once released, these pointers will be assigned to nil. Such a benefit can effectively prevent the wild hands. Why does Daniel say that when the pointer space is released, the pointer will be NULL when it is developed in C + +. Here we do this step with the weak keyword.
Then we'll see unsafe_unretained.
From the name can be seen, unretained and unsafe, because it is unretained so and weak a bit similar, but it is unsafe, what is unsafe, see the example below.
If this declares two properties:
and define
@property (nonatomic, strong) NSString *string1;
@property (nonatomic, unsafe_unretained) NSString *string2;
Guess what happens with the code below?
Self.string1 = [[NSString alloc] initwithutf8string: "String 1"];
Self.string2 = self.string1;
Self.string1 = nil;
NSLog (@ "String 2 =%@", self.string2);
Please note that I am not asking you to guess what the output will be because there will be no output at all, and your program will crash out. The reason is, in fact, the wild pointer caused, so the wild pointer is terrible. Why do they create wild pointers? As with the pointer declared with unsafe_unretained, the Self.string1=nil has freed the memory, but string2 does not know that it has been released, so it is a wild pointer. Then accessing the memory of the wild pointer causes crash. So try to use less unsafe_unretained keywords.
IOS5 ARC Study notes: strong, weak, etc.
