This post contains my perusing notes of the book , from the systems of ARC to the utilization of Blocks and Grand Central Dispatch.
Memory Management Actions in Objective-C - Reference Counting
Activity for Objective-C Object Objective-C Method
Make and have responsibility for/new/duplicate/mutableCopy gathering
Take responsibility for
Surrender it release
Discard it dealloc
+(id)alloc
implementation.m
+ (id) alloc {
return [self allocWithZone: NSDefaultMallocZone()];
}
+ (id) allocWithZone: (NSZone*)z {
return NSAllocateObject (self, 0, z);
}
struct obj_layout {
NSUInteger held;
};
inline id
NSAllocateObject (Class aClass, NSUInteger extraBytes, NSZone *zone) {
int estimate =/* required size to store the question */
id new = NSZoneMalloc(zone, estimate);
memset(new, 0, estimate);
new = (id)&((struct obj_layout *)new)[1];
}
The NSAllocateObject work calls NSZoneMalloc to apportion a memory territory. From that point forward, the territory is loaded with zero and the range pointer is returned.
Objective-C now disregards zones, which was utilized to avoid memory discontinuity. The alloc technique would now be able to be changed as:
demo.m
struct obj_layout {
NSUInteger held;
};
+ (id) alloc {
int estimate = sizeof(struct obj_layout) + size_of_the_object;
struct obj_layout *p = (struct obj_layout *)calloc(1, estimate);
return (id)(p + 1);
}
The alloc strategy restores a memory piece loaded with zero containing a struct obj_layout header, which has a variable "held" to store the quantity of references(reference tally).
hold
get reference tally an incentive by calling retainCount:
demo.m
id obj = [[NSObject alloc] init];
NSLog(@"retainCount=%d", [obj retainCount]);
/*
* retainCount=1 is shown. */
Execution of hold:
demo.m
- (id) retain{
NSIncrementExtraRefCount(self);
return self;
}
inline void NSIncrementExtraRefCount(id anObject) {
in the event that (((struct obj_layout *)anObject)[-1].retained == UINT_MAX - 1)
[NSException raise: NSInternalInconsistencyException
arrange: @"NSIncrementExtraRefCount() asked to increase excessively far"];
((struct obj_layout *)anObject)[-1].retained++; }
at the point when the variable "held" floods, it's increased.
discharge
demo.m
- (void) discharge {
on the off chance that (NSDecrementExtraRefCountWasZero(self))
[self dealloc];
}
BOOL
NSDecrementExtraRefCountWasZero(id anObject) {
on the off chance that (((struct obj_layout *)anObject)[-1].retained == 0) {
return YES;
} else {
((struct obj_layout *)anObject)[-1].retained- - ; restore NO;
}
}
"held" decremented.
dealloc
demo.m
- (void) dealloc {
NSDeallocateObject (self);
}
inline void NSDeallocateObject(id anObject) {
struct obj_layout *o = &((struct obj_layout *)anObject)[-1];
free(o);
}
a chunck of memory desposed.
autorelease
like "programmed variable" in C, which is discarded consequently when the execution leaves the degree.
autorelease implies when execution leaves a code hinder, the discharge strategy is approached the question naturally.
demo.m
- (id) autorelease {
[NSAutoreleasePool addObject:self];
}
ARC(Automatic Reference Counting)
With ARC, "id" and protest sort factors must have one of the accompanying possession qualifiers:
_strong, _weak, __unsafeunretained, _autoreleasing
Possession is appropriately overseen by factor scope, as well as by assignments between factors, which are qualified with __strong.
Utilize __weak to maintain a strategic distance from roundabout references:
A __weak possession qualifier gives a frail reference. A powerless reference does not have responsibility for protest.
demo.m
id __strong obj0 = [[NSObject alloc] init];
id __weak obj1 = obj0;
/*
* variable obj1 has a feeble reference of the made protest */
_unsafe_unretained: don't utilize it unless you need to help before iOS5, it may leave a dangling pointer. utilize _weak.
Notwithstanding, __weak is only for pointers that ought to be focused, not for primitive sorts.
_unsafe_unretained is valuable for circumstances where you have a protest pointer in a circumstance where ARC doesn't have enough control to securely oversee memory, as within a consistent C struct. That is one reason there's the "no question pointers in C struct" confinement, unless you enrich that point with _unsafe_unretained to tell the compiler you what you're doing. It's likewise used to break solid reference cycles (a.k.a. hold cycles) with obstructs under some particular conditions.
However, for 99.9% of day by day work, feeble works awesome and you can disregard __unsafe_unretained.
Source
Pieces
A Block is created from the Block strict beginning with "^". Also, the Block is relegated to the variable "blk". Obviously you can relegate the incentive to different factors of the Block sort.
Squares are Anonymous capacities together with automatic(local)variables.
Presentations ï¼sourceï¼
As a neighborhood variable:
returnType (^blockName)(parameterTypes) = ^returnType(parameters) {...};
As a property:
@property (nonatomic, duplicate) returnType (^blockName)(parameterTypes);
As a strategy parameter:
(void)someMethodThatTakesABlock:(returnType (^)(parameterTypes))blockName;
As a contention to a strategy call:
[someObject someMethodThatTakesABlock: ^returnType (parameters) {...}];
As a typedef:
typedef returnType (^TypeName)(parameterTypes);
TypeName blockName = ^returnType(parameters) {...};
block.m
int (^blk1)(int) = blk;
int (^blk2)(int); blk2 = blk1;
/*Functions can take contentions of Block type.*/
void func(int (^blk)(int)) {
/*Also, capacities can restore a Block.*/
int (^func()(int)) {
return ^(int count){return check + 1;};
}
Utilizing typedefs:
block.m
typedef int (^blk_t)(int);
Amazing Central Dispatch
The most effective method to utilize: characterize assignments you need to execute and add them to a suitable dispatch line.
GCD.m
dispatch_async(queue_for_background_threads, ^{
/*
* Here, handling a tedious errand
*
* The errand is finished. At that point, utilize the outcome on the primary string as takes after.
*/
dispatch_async(dispatch_get_main_queue(), ^{
/*
* Here, undertakings that work just on the primary, for example,
* refreshing client inteface, and so forth.
*/
});
});
Dispatch Queues
A dispatch line is a line to store undertakings to be executed (in the additional, first in first out request).
More subtle elements visit
http://infocampus.co.in/ios-training-in-bangalore.html