All posts by admin

Objective C stack and heap

September 10, 2015C/C++/Objective-Cblocksadmin

https://mikeash.com/pyblog/friday-qa-2010-01-15-stack-and-heap-objects-in-objective-c.html

Stack

The stack is a region of memory which contains storage for local variables, as well as internal temporary values and housekeeping.
On a modern system, there is one stack per thread of execution.
When a function is called, a stack frame is pushed onto the stack, and function-local data is stored there.
When the function returns, its stack frame is destroyed.

Heap

The heap is, essentially, everything else in memory.

Memory can be allocated on the heap at any time, and destroyed at any time.
You have to explicitly request for memory to be allocated from the heap, and if you aren’t using garbage collection, explicitly free it as well.
This is where you store things that need to outlive the current function call. The heap is what you access when you call malloc and free.

//not using garbage collection

MyClass * ptr = [[MyClass alloc] init];

//...use it...

[ptr release];

ptr = nil;

//using garbage collection such as arc, don't have to do anything

MyClass * ptr = [[MyClass alloc] init];

Stack vs Heap Objects

Given that, what’s a stack object, and what’s a heap object?

First, we must understand what an object is in general. In Objective-C (and many other languages), an object is simply a contiguous blob of memory with a particular layout.

The precise location of that memory is less important. As long as you have some memory somewhere with the right contents, it’s a working Objective-C object. In Objective-C, objects are usually created on the heap:

NSObject *obj = [[NSObject alloc] init];

The storage for the obj pointer variable itself is on the stack
but the object it points to is in the heap.
In other words, the obj pointer variable is pushed onto the stack. The NSObject object that it points to, is allocated on the heap

The [NSObject alloc] call allocates a chunk of heap memory, and fills it out to match the layout needed for an NSObject.

Using NS Collection classes with blocks

Since Blocks are objective C objects that gets pushed onto the stack…

A Block is the one instance of an Objective-C object that starts on the stack. While you can happily collect together a bunch of Blocks in one of the Foundation provided collection classes (NSArray, NSDictionary, or NSSet), make sure you copy the Block before you do!

The last thing you want is a stack based object to end up in an autorelease pool….

The reason why Blocks start on the stack is because it is really really fast. Orders of magnitude faster than allocating a chunk of memory for each Block.

other ref-

http://stackoverflow.com/questions/79923/what-and-where-are-the-stack-and-heap

Block basics

September 9, 2015C/C++/Objective-C, iOSadmin

reference
http://stackoverflow.com/questions/22996536/resolving-retain-cycles-is-there-really-a-reason-to-add-strong-strongself-wh?rq=1
http://rypress.com/tutorials/objective-c/blocks

http://www.cocoawithlove.com/2009/10/how-blocks-are-implemented-and.html

demo xCode 7.3

How To Declare

Interface: We have the return type. Then block name. Then the parameters.

Then a equals sign, which leads to our declaration of the block. In the declaration of the block, be sure to name your parameters.

return type (^blockName) ( param type, param type,... ) = ^( type param1, type param2 ) {

// code

};

int (^firstBlock)(NSString *param1, int param2) = ^(NSString * name, int age) {

return 0;

};

non-local variables are variables defined in the block’s enclosing lexical scope, but outside the block itself.

non-local variable are copied and stored with the block as const variable, which means they are read-only.

In other words, it creates “const” copy of any local variables that is referenced inside its scope.

Global Blocks – not referencing any non-local variables

With no references to the surrounding scope, clang configures the Block_literal as a global block instead.

For example,

NSString * (^firstBlock)(NSString *param1, int param2) = ^(NSString * name, int age) {

return [NSString stringWithFormat:@"%@ is %d years old", name, age];

};

If you’re familiar with how Objective-C objects are declared, the isa field in the Block_literal above should be familiar — blocks are Objective-C objects.

As you see, it does not reference any non-local variables. Thus, the compiler creates it as a global block:

This causes the block to appear in a fixed global location instead of on the local stack.

The implication of this is that global blocks are never actually copied or disposed, even if you invoke the functions to do so. This optimization is possible because without any references to the surrounding scope, no part of the block (neither its code nor its Block_literal) will ever change — it becomes a shared constant value.

Malloc Blocks – __strong block definitions

void (^whisper)() = ^() {

NSLog(@"someone has %d dollars", dough);

};

The block object was retained by the whisper variable. The strong sends a retain to the block. When a block is retained, it invokes a copy on it.

block implementation detail:

id objc_retainBlock(id x) {

return (id)_Block_copy(x);

}

Thus, the block object was moved from stack to heap by this _Block_copy. But note that there is only still 1 copy of the block. It simply increases the retain count of the block.

Stack Blocks – __weak block definitions

http://stackoverflow.com/questions/25794306/could-you-help-me-to-understand-block-types-when-added-to-containers-nsdictiona

http://stackoverflow.com/questions/19227982/using-block-and-weak

Marking it as __weak causes the whisper variable to NOT retain the block object.
Thus, the block starts off being allocated on the local stack, and it stays there. Since there is no __strong to retain it, and thus, no copy.

therefore, a weak block variable on a block object keeps the block object on the local stack.

//This knowingly leads to dangling pointers if the Block (or a copy) outlives the lifetime of this object.

__weak void (^whisper3)() = ^() {

NSLog(@"another block %d", localVariable);

};

If you copy an NSStackBlock, it will return an NSMallocBlock (indicating its changed allocation location).

A block keeps it’s own array of its non-local variables via deep copy

example:

int main(int argc, const char * argv[])

{

NSString *make = @"Honda"; //non-local variable

NSString *(^getFullCarName)(NSString *) = ^(NSString *model) {

//make = nil; //Trying to assign new value to the make variable

// from inside the block will throw a compiler error.

//Non-local variables are COPIED (deep copy) and stored with

//the block as const variables (cannot be changed), which means they are read-only.

//The fact that non-local variables are copied as constants means that a

//block doesn’t just have access

//to non-local variables—it creates a snapshot of them.

return [make stringByAppendingFormat:@" %@", model];

};

NSLog(@"%@", getFullCarName(@"Accord")); // Honda Accord

make = @"BMW";

NSLog(@"%@", make); //BMW

NSLog(@"%@", getFullCarName(@"Civic")); // Honda Civic

}

So as you can see, the non-local variable make gets copied inside of the block getFullCarName. If you try to modify make inside of the block getFullCarName, you will see a compiler error.

Notice how later, outside of the block, we change the variable make to “BMW”. However, its a deep copy, this change takes place at the outside of the closure. Hence the original make variable (outside of the closure) is BMW. The copy inside the block, the make is still Honda. We see this happening by passing @”Civic” into getFullCarName(…).

You can make non-local changeable by using __block to use them as reference

Freezing non-local variables as constant values is a safe default behavior
in that it prevents you from accidentally changing them from within the block;
however, there are occasions when this is NOT desirable.

You can override the const copy behavior by declaring a non-local variable with the __block storage modifier:

1	__block NSString *make = @"Honda";

This tells the block to capture the variable by reference, whereas if you didn’t have __block, it would capture it by deep copy.

When the block captures the variable by reference, its like creating a direct link between the variable outside the block and the one inside the block.
You can now assign a new value to make from outside the block, and it will be reflected in the block, and vice versa.

__block int i = 0;

int (^count)(void) = ^ {

i += 1;

return i;

};

NSLog(@"%d", count()); // 1

NSLog(@"%d", ++i); //2

NSLog(@"%d", count()); // 3

NSLog(@"%d", ++i); //4

NSLog(@"%d", count()); // 5

So now, you are referencing the same variable outside and inside the block. Whereas before, you have 2 deep copies of the variable depending on whether you are outside or inside of the closure.

Each block has its own copy of the non-local variables

In the example below, if we call existingBlock or vv twice, you will see that the non-blocking variables that they copy will have the same address. Their local variables, however, are all different throughout the calls. That’s because for the local variables of the block, they just go on the stack. Where as the outside scope’s variable are all copied….in an array for that particular block.

void foo(int param)

{

int x0 = param; //stack local variable, blocks will have their own copy of this variable

int x1 = param + 1; //stack local variable, blocks will have their own copy of this variable

void (^existingBlock)(void) = ^{

NSLog(@"----------existingBlock START ------");

int y0 = 8;

int y1 = 88;

printf("existingBlock: local variable y0 address is %p\n", &y0); //existingBlock local variable

printf("existingBlock: local variable y1 address %p\n", &y1); //existingBlock local variable

printf("existingBlock non-local x0 address %p\n", &x0); //existingBlock non-local variable copy

printf("existingBlock non-local x1 address %p\n", &x1); //existingBlock non-local variable copy

NSLog(@"----------existingBlock END ------");

};

void (^vv)(void) = ^{

NSLog(@"----------vv START ------");

int y2 = 888;

int y3 = 8888;

existingBlock();

printf("vv: local variable y2 address is %p\n", &y2); //vv's local variable

printf("vv: local variable y3 address is %p\n", &y3); //vv's some local variable

printf("vv: non-local variable x0 address is %p\n", &x0); //vv's non-local variable copy

printf("vv: non-local variable x1 address is %p\n", &x1); //vv's non-local variable copy

NSLog(@"----------vv END ------");

};

NSLog(@"Stack: &x: %p, %u \n", &x0, x0);

NSLog(@"Stack: &x: %p, %u \n", &x1, x1);

NSLog(@"------- on main thread -------\n");

vv();

dispatch_async(dispatch_get_global_queue(0, 0), ^{

NSLog(@"THREAD 2 start");

assert(vv);

sleep(1);

int y4 = 6680;

int y5 = 6868;

vv();

printf("dispatch async local variable y4 address: %p\n", &y4);

printf("dispatch async local variable y5 address: %p\n", &y5);

printf("non-local variable x0 address: %p\n", &x0); //block's non-local variable

printf("non-local variable x1 address: %p\n", &x1); //block's non-local varaible

NSLog(@"THREAD 2 done");

});

}

int main(int argc, const char * argv[])

{

@autoreleasepool {

foo(1);

sleep(2);

}

return 0;

}

But what about Object allocations

As show in the code above, we have a block called vv. vv calls existingBlock block.
Then, say we have an object allocation outside of the block existingBlock at the highest scope at foo function.

We have 2 parts:

1) the reference ptrToStrObj gets pushed onto the local stack,
with address say: 0x7fff5fbff708

2) and the object that’s allocated on the heap, pointed to by reference ptrToStrObj. The object has address say: 0x100102450

LOCAL – address of POINTER ptrToStrObj……0x7fff5fbff708
LOCAL – address of NSString object on heap……0x100102450

The ptrToStrObj variable is a non-local variable, which means it defined in the block’s enclosing lexical scope, but OUTSIDE of the block itself. It is deep copied inside of the block.

We display the address of the the reference ptrToStrObj inside of the block existingBlock, which then shows:

———-existingBlock START ——
existingBlock – address of POINTER ptrToStrObj……0x1020001c0
existingBlock – address of OBJECT……0x100102450
existingBlock – ricky tsao, dob 6680
———-existingBlock END ——

As you can see, the address of the object on the heap remains at 0x100102450.
But the pointer of the reference ptrToStrObj has changed from 0x7fff5fbff708 to 0x1020001c0.

That is proof that the block made a deep copy of the non-local variable reference ptrToStrObj for itself.

Furthermore, if you try to modify ptrToStrObj, it will throw an error:

After calling existingBlock(), we move on to the next line:

changing content of string object
vv – address of POINTER ptrToStrObj……0x102000248
vv – address of OBJECT……0x100102450
vv – HA DO KEN!ao, dob 6680
———-vv END ——

Keep in mind that we are now back in bloc vv.

As you can see, the address of the object in the heap remains the same at 0x100102450.
However, the pointer address changed to 0x102000248. This means that this block vv has its own DEEP COPY of the non-local variable ptrToStrObj.

Thus,

foo’s ptrToStrObj is 0x7fff5fbff708
existingBlock’s ptrToStrObj is 0x1020001c0
vv’s ptrToStrObj is 0x102000248

In much deeper details, each block has an non-local variable array list. That’s where it keeps its list of non-local variables. As we can see in the picture vv block and existingBlock each have an array of non-local variables.

The first item in their array is reference ptrToStrObj. ptrToStrObj points to the object in the heap, which never changes as we can see that the addresses all match.

However the address of the references are different, because each block has their own DEEP COPY of the reference.

Finally, let’s see what happens inside of a GCD block:

dispatch_async(dispatch_get_global_queue(0, 0), ^{

NSLog(@"THREAD 2 start");

assert(vv);

sleep(1);

vv();

NSLog(@"in dispatch_async block - address of POINTER ptrToStrObj......%p", &ptrToStrObj);

NSLog(@"existingBlock - %@", ptrToStrObj);

NSLog(@"existingBlock - address of OBJECT......%p", ptrToStrObj);

NSLog(@"THREAD 2 done");

});

THREAD 2 start
———-vv START ——
———-existingBlock START ——
existingBlock – address of POINTER ptrToStrObj……0x1020001c0
existingBlock – address of OBJECT……0x100102450
existingBlock – HA DO KEN!ao, dob 6680
———-existingBlock END ——
changing content of string object
vv – address of POINTER ptrToStrObj……0x102000248
existingBlock – address of OBJECT……0x100102450
existingBlock – HA DO KEN!N!ao, dob 6680
———-vv END ——
in dispatch_async block – address of POINTER ptrToStrObj……0x100500048
existingBlock – HA DO KEN!N!ao, dob 6680
existingBlock – address of OBJECT……0x100102450
THREAD 2 done

As you can see the object in the heap as address 0x100102450 for all blocks

existingBlock’s ptrToStrObj has 0x1020001c0
vv’s ptrToStrObj has 0x102000248
GCD’s ptrToStrObj has 0x100500048

Hence, as you can see, GCD’s block, like any other blocks, also have its own non-local variable list, and DEEP COPIES the non-local variable reference ptrToStrObj for itself.

Code

void foo(int param)

{

int x0 = param; //stack local variable, blocks will have their own copy of this variable

int x1 = param + 1; //stack local variable, blocks will have their own copy of this variable

NSMutableString * ptrToStrObj = [[NSMutableString alloc] initWithFormat:@"ricky tsao, dob %u", 6680];

NSLog(@"LOCAL - address of POINTER ptrToStrObj......%p", &ptrToStrObj);

NSLog(@"LOCAL - address of NSString object on heap......%p", ptrToStrObj);

void (^existingBlock)(void) = ^{

NSLog(@"----------existingBlock START ------");

NSLog(@"existingBlock - address of POINTER ptrToStrObj......%p", &ptrToStrObj);

NSLog(@"existingBlock - address of OBJECT......%p", ptrToStrObj);

NSLog(@"existingBlock - %@", ptrToStrObj);

NSLog(@"----------existingBlock END ------");

};

void (^vv)(void) = ^{

NSLog(@"----------vv START ------");

existingBlock();

NSLog(@"changing content of string object");

[ptrToStrObj replaceCharactersInRange:NSMakeRange(0, 8) withString:@"HA DO KEN!"];

NSLog(@"vv - address of POINTER ptrToStrObj......%p", &ptrToStrObj);

NSLog(@"existingBlock - address of OBJECT......%p", ptrToStrObj);

NSLog(@"existingBlock - %@", ptrToStrObj);

NSLog(@"----------vv END ------");

};

NSLog(@"Stack: &x: %p, %u \n", &x0, x0);

NSLog(@"Stack: &x: %p, %u \n", &x1, x1);

NSLog(@"------- on main thread -------\n");

vv();

dispatch_async(dispatch_get_global_queue(0, 0), ^{

NSLog(@"THREAD 2 start");

assert(vv);

sleep(1);

vv();

NSLog(@"in dispatch_async block - address of POINTER ptrToStrObj......%p", &ptrToStrObj);

NSLog(@"existingBlock - %@", ptrToStrObj);

NSLog(@"existingBlock - address of OBJECT......%p", ptrToStrObj);

NSLog(@"THREAD 2 done");

});

}

int main(int argc, const char * argv[])

{

@autoreleasepool {

foo(1);

sleep(2);

}

return 0;

}

output:

LOCAL – address of POINTER ptrToStrObj……0x7fff5fbff7e8
LOCAL – address of NSString object on heap……0x100211f00
Stack: &x: 0x7fff5fbff7f8, 1
Stack: &x: 0x7fff5fbff7f4, 2
——- on main thread ——-
———-vv START ——
existingBlock – address of POINTER ptrToStrObj……0x1001001e0
existingBlock – address of OBJECT……0x100211f00
existingBlock – ricky tsao, dob 6680
———-existingBlock END ——
changing content of string object
vv – address of POINTER ptrToStrObj……0x100300378
existingBlock – address of OBJECT……0x100211f00
existingBlock – HA DO KEN!ao, dob 6680
———-vv END ——
THREAD 2 start
———-vv START ——
———-existingBlock START ——
existingBlock – address of POINTER ptrToStrObj……0x1001001e0
existingBlock – address of OBJECT……0x100211f00
existingBlock – HA DO KEN!ao, dob 6680
———-existingBlock END ——
changing content of string object
vv – address of POINTER ptrToStrObj……0x100300378
existingBlock – address of OBJECT……0x100211f00
existingBlock – HA DO KEN!N!ao, dob 6680
———-vv END ——
in dispatch_async block – address of POINTER ptrToStrObj……0x100300168
existingBlock – HA DO KEN!N!ao, dob 6680
existingBlock – address of OBJECT……0x100211f00
THREAD 2 done

More Examples

GCD: dispatch_async

Contrary to what’s usually believed, dispatch_async per se will NOT cause a retain cycle

dispatch_async(queue, {

self.doSomething();

});

Here, the closure has a strong reference to self, but the instance of the class (self) does not have any strong reference to the closure, so as soon as the closure ends, it will be released, and so no cycle will be created. However, sometimes it’s (incorrectly) assumed that this situation will lead to a retain cycle.

Syntax

Blocks are declared like so:

NSString *(^getFullCarName)(NSString *) = ^(NSString *model) {

};

..and used like so:

1	NSLog(@"%@", getFullCarName(@"Accord"));

This example declares a variable called simpleBlock to refer to a block that takes no arguments and doesn’t return a value

void (^simpleBlock)(void);

simpleBlock = ^{

NSLog(@"This is a block");

};

You can also combine the variable assignment, and definition:

void (^simpleBlock)(void) = ^{

NSLog(@"This is a block");

};

Another Example

1	- (void)beginTaskWithCallbackBlock:(void (^)(void))callbackBlock;

The (void (^)(void)) specifies that the parameter is a block that doesn’t take any arguments or return any values. The implementation of the method can invoke the block in the usual way:

- (void)beginTaskWithCallbackBlock:(void (^)(void))callbackBlock {

...

callbackBlock();

}

Method parameters that expect a block with one or more arguments are specified in the same way as with a block variable:

- (void)doSomethingWithBlock:(void (^)(double, double))block {

...

block(21.0, 2.0);

}

it expects a block that does not return anything. But takes in double as the first 2 parameters.

calling method on a nil object

September 7, 2015C/C++/Objective-Cadmin

A message sent to a nil object is perfectly acceptable in Objective-C, it’s treated as a no-op. There is no way to flag it as an error because it’s not an error, in fact it can be a very useful feature of the language.

From the docs:

Sending Messages to nil

In Objective-C, it is valid to send a message to nil—it simply has no effect at runtime. There are several patterns in Cocoa that take advantage of this fact. The value returned from a message to nil may also be valid:

If the method returns an object, then a message sent to nil returns 0 (nil), for example:

Person *motherInLaw = [[aPerson spouse] mother];

If aPerson’s spouse is nil, then mother is sent to nil and the method returns nil.

If the method returns any pointer type, any integer scalar of size less than or equal to sizeof(void*), a float, a double, a long double, or a long long, then a message sent to nil returns 0.

If the method returns a struct, as defined by the Mac OS X ABI Function Call Guide to be returned in registers, then a message sent to nil returns 0.0 for every field in the data structure. Other struct data types will not be filled with zeros.

If the method returns anything other than the aforementioned value types the return value of a message sent to nil is undefined.

Fast Enumeration

September 7, 2015C/C++/Objective-Cadmin

for(BBT * bbtTimeTemp in arrayOfBBTs) {

}

for(NSString *aString in array) {

NSLog(@"Value: %@",aString);

}

Retain Cycle in iOS

September 7, 2015iOSadmin

ref – http://blog.reigndesign.com/blog/debugging-retain-cycles-in-objective-c-four-likely-culprits/
http://stackoverflow.com/questions/15266367/why-isn-t-my-weak-reference-cleared-right-after-the-strong-ones-are-gone?rq=1
http://www.quora.com/Objective-C-programming-language/What-is-the-difference-between-a-strong-and-weak-pointer

Pointers are automatically created with strong references; they are automatically retained. In this case, the strong keyword is implied when creating pointers, though you can use it if you want.

1 2	@property (strong, nonatomic) YonoCarouselView * carouselView; @property (nonatomic) YonoRSDFView * calendarView; //automatically implied that its strong

However there are times when you don’t want to retain an object (i.e. increase its reference count). To do this, you use the weak keyword when creating the pointer. Your pointer will still point to the object, but if that object is destroyed then using the pointer will cause a program error.

Note: In Objective-C every object has a reference count (i.e. the number of strong references to the object). i.e alloc, retain, new, dot retain,

In our case below, strongPtr points to newly allocated NSString object. Then it points away to another newly allocated NSString object. the original NSString object “myTestText” has no one pointing to it, even though it exists in memory because it does have a retain count of 1. Its just hanging out in memory space. Thus, ARC will either send a release or auto-release to it.

If ARC send release, weakPtr will display nil. If auto-release, then weakPtr may still display the address of the “myTestText”:

__strong NSString* strongPtr;

__weak NSString* weakPtr;

@autoreleasepool {

//NSString now have retain count of 2, alloc, and from __string

strongPtr = [[NSString alloc] initWithFormat:@"mYTeSTteXt %d", 3];

// weak pointer point to object create above (there is still strong ref to this obj)

weakPtr = strongPtr;

if(strongPtr == weakPtr) NSLog(@"They are pointing to the same obj");

NSLog(@"StrongPtr: %@", strongPtr);

NSLog(@"weakPtr: %@", weakPtr);

NSLog(@"Setting myText to different obj or nil");

// after line below, there is no strong referecene to the created object:

strongPtr = [[NSString alloc] initWithString:@"abc"];

}

if(strongPtr == weakPtr)

NSLog(@"Are the same");

else

NSLog(@"Are NOT the same");

NSLog(@"StrongPtr: %@", strongPtr);

// Why weak pointer does not point to nul

NSLog(@"weakPtr: %@", weakPtr);

1	@property (weak, nonatomic) YourClass * aVariable;

Strong variables will retain the value they point to.
Weak variables won’t retain their value and when the value is deallocated they will set their pointer to nil (to be safe).
Unsafe unretained values (as you probably can read by the name) won’t retain the value and if it gets deallocated they do nothing about it, potentially pointing to a bad piece of memory

When you’re working with garbage collection (10.5+), a weak reference is created by prefixing a variable declaration with __weak. When you assign to that variable, the GC (if enabled) keeps track of the reference and will zero it out for you automatically if all strong references to the referenced object disappear. (If GC is not enabled, the __weak attribute is ignored.)

Thus, you can safely modify the above answer to play nicer with garbage collection (currently on 10.5+, and perhaps someday on iPhone) as follows: (See the related Apple docs.)

@property (nonatomic,assign) __weak Row *yCoord;

To quote Chris Hanson (where you can find more detailed information):

“By prefixing an instance variable declaration with __weak, you tell the garbage collector that if it’s the only reference to an object that the object should be considered collectable.”

I’d clarify that by saying “if there are no non-weak references to an object”. As soon as the last strong reference is removed, the object may be collected, and all weak references will be zeroed automatically.

Note: This isn’t directly related to creating weak references, but there is also a __strong attribute, but since Objective-C object variables are strong references by default, it is generally used only for raw C pointers to things like structs or primitives that the Garbage Collector will not treat as roots, and will be collected from under you if you don’t declare them as strong. (Whereas the lack of __weak can cause retain cycles and memory leaks, the lack of __strong can result in memory stomping and really strange and insidious bugs that occur non-deterministically and can be quite difficult to track down.)

Why would you use a weak reference?

Well, one reason is if you have objects in parent-child relationships where the parent keeps pointers to its children and every child keeps a pointer to its parent. The potential with this structure is that you could no longer need your parent object and XCode will implicitly release it, but because its children keep a reference to it, the parent and its children can remain in memory even though you no longer have a way of accessing them. This is called a retain cycle.

To avoid the retain cycle, the children objects should only maintain a weak pointer to their parents. The reason for this is that when the parent is told to destroy itself, the children would be destroyed first so there is no chance they could access their parent after it had been destroyed.

NSTimer

If you create an NSTimer object on a view controller, be sure that invalidate is called on it when dismissing the view controller, otherwise it will retain self.

Observers/NSNotificationCenter

If you add an observer to NSNotificationCenter, make sure you remove all observers when dismissing the view controller, otherwise they will retain self.

Blocks

You should not call [self doSomething] from inside a block, this can easily lead to the block capturing a reference to self. Instead, make a weak reference to self:

BAD:

dispatch_async(queue, ^{

[self doSomething];

});

GOOD

__weak MyViewController *safeSelf = self;

dispatch_async(queue, ^{

[safeSelf doSomething];

});

Delegates

if you use

1	someObj.delegate = self;

inside the view controller, check the delegate property on someObj is weak.

1	@property (nonatomic, weak) id delegate;

Once you’ve made your fixes, check that dealloc is getting hit and the allocations no longer increase endlessly.

saving images from server onto ios client

September 5, 2015iOSadmin

http://stackoverflow.com/questions/6238139/ios-download-and-save-image-inside-app

Committing projects up to Github

August 30, 2015Configurationsgithubadmin

ref – http://stackoverflow.com/questions/17291995/push-existing-project-into-github
ref – https://help.github.com/articles/fork-a-repo/

Create the repo

Make sure you have created a repository on Github via
https://github.com/new
Enter a repository name, then check the box where it creates a readme file.
Click ok.

Fork

Then fork it locally, directions below are taken from the url here: https://help.github.com/articles/fork-a-repo/

Directions

On GitHub, navigate to your fork of your repository.
Clone URL buttonIn the right sidebar of your fork’s repository page, click
to copy the clone URL for your fork.

Open Terminal (for Mac users) or the command prompt (for Windows and Linux users).

Type git clone, and then paste the URL you copied in Step 2. It will look like this, with your GitHub username instead of YOUR-USERNAME:

1	$git clone https://github.com/YOUR-USERNAME/REPO-NAME

Press Enter. Your local clone will be created and the output from your terminal will be something like this:

Rickys-MacBook-Pro:Desktop rickytsao$ git clone https://github.com/redmacdev1988/face-recognizer.git
Cloning into ‘face-recognizer’…
remote: Counting objects: 3, done.
remote: Total 3 (delta 0), reused 0 (delta 0), pack-reused 0
Unpacking objects: 100% (3/3), done.
Checking connectivity… done

Clone a single branch

git clone https://your_name@gitcn.company.com:1234/hehe-haha/hehe-haha.git –branch dev

Clone with username

1	git clone https://username:password@github.com/username/repository.git

List branches of the the repository

(double dash next to “heads”)
git ls-remote –heads https://git.yourcompany.com/some_person/project_name.git

Change working branch :

Create the branch on your local machine and switch in this branch :

$ git checkout -b [name_of_your_new_branch]
Change working branch :

$ git checkout [name_of_your_new_branch]
Push the branch on github :

$ git push origin [name_of_your_new_branch]

Uploading Project

Then, you’ll see the project folder on your desktop. Copy your source files into the folder. And to upload it to Github you do:

note – The project url can be found on the repo page on the righthand side bar. It should have a little paste icon next to it. Its the HTTPS clone URL…you should be able to just copy and paste to the terminal window

If the system tell you that origin already exists, keep going with the instructions.

Make sure you are in the directory of the folder that Git created on your computer. Then within the folder (which should have a git file) you go:

git init

git add .

git commit -m "Initial commit"

git remote add origin <project url>

git push -f origin master

Rickys-MacBook-Pro:holistic-element rickytsao$ git push -f origin master

It will then ask you for your username and password:

Username for ‘https://github.com’: redmacdev1988
Password for ‘https://redmacdev1988@github.com’:

result:

Counting objects: 651, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (645/645), done.
Writing objects: 100% (650/650), 130.74 MiB | 1.45 MiB/s, done.
Total 650 (delta 19), reused 0 (delta 0)
To https://github.com/redmacdev1988/holistic-element.git
0ddae45..a74a112 master -> master

If you want to remove files, delete the files in your directory.
Then in the same directory, go:

git commit -a -m “removed fluff”
git push origin master

Pulling (cloning) the project onto your machine

git clone https://git.epam.com/ricky_tsao/badmintoneventsapp.git

src refspec does not match any ERROR

If you try pushing to a certain branch and it gives you a src refspec error, it means you are not on that branch. You need to switch to that branch first, THEN, push to it.

git checkout -b Ricky_Tsao
Switched to a new branch Ricky_Tsao

git commit -a -m “cleaned up stuff”
git push origin Ricky_Tsao

Cloning Single Branch

git clone learned –single-branch option to limit cloning to a single branch;
tags that do not point into the history of the branch are not fetched.

1	git clone -b mybranch --single-branch git://sub.domain.com/repo.git

git clone -b branch_name –single-branch (double dash in front of “single”) https://gitcn.epam..com:1234/your_name/project_name.git

Merge current local branch with remote

$ git stash
$ git pull origin release/1.0.1
// fix conflicts
// git add, git commit
$ git stash pop

// git add, git commit, git push

See the list of files that have changes between your local and remote

$ git status
On branch dev
Your branch is up-to-date with ‘origin/dev’.
Changes to be committed:
(use “git reset HEAD …” to unstage)

modified: Src/Project/Website/Code/global/css/product.css
modified: Src/Project/Website/Code/global/standalonesim.html

Stash

$ git stash save “—–”
$ git stash list
$ git stash apply stash@{0}

Delete local branch

$ git branch -d feature/login

Pushing new files onto your branch

$ git add .
$ git reset build/config (or whatever path to folder you want to exclude)
$ git commit -m “Add existing file”
$ git push -f origin Your_Branch

Javascript copy by reference

August 25, 2015javascriptadmin

With a = {}; b = a, you get

{ }

Then with a['one'] = {} you get

{ one: { } }

Then with a = a['one'] you get

a - - - -

{ one: { } }

quoted from stackoverflow:

No, JS doesn’t have pointers.

Objects are passed around by passing a copy of a reference. The programmer cannot access any C-like “value” representing the address of the object.

Within a function one may change the contents of an passed object via that reference, but you cannot modify the reference that the caller had, because your reference is only a copy:

var foo = {'bar': 1}; //1

function tryToMungeReference(obj) //3

{

obj = {'bar': 2}; // 4

}

function mungeContents(obj) // 7

{

obj.bar = 2; // 8

}

tryToMungeReference(foo); // 2

foo.bar === 1; // true, 5

mungeContents(foo); // 6

foo.bar === 2; // true, 9

Pictorial

pointers (C) vs references (Java)

August 25, 2015C/C++/Objective-Cadmin

ref – http://programmers.stackexchange.com/questions/141834/how-is-a-java-reference-different-from-a-c-pointer

References might be implemented by storing the address. Usually Java references will be implemented as pointers, but that’s not required by the specification. They may be using an additional layer of indirection to enable easier garbage collection. But in the end it will (almost always) boil down to (C-style) pointers being involved in the implementation of (Java-style) references.

You can’t do pointer arithmetic with references. The most important difference between a pointer in C and a reference in Java is that you can’t actually get to (and manipulate) the underlying value of a reference in Java. In other words: you can’t do pointer arithmetic.

In C you can add something to a pointer (i.e. the address) or substract something to point to things that are “nearby” or point to places that are at any place.

In Java, a reference points to one thing and that thing only. You can make a variable hold a different reference, but you can’t just ask it to point to “the thing after the original thing”.

References are strongly typed. Another difference is that the type of a reference is much more strictly controlled in Java than the type of a pointer is in C. In C you can have an int* and cast it to a char* and just re-interpret the memory at that location. That re-interpretation doesn’t work in Java: you can only interpret the object at the other end of the reference as something that it already is (i.e. you can cast a Object reference to String reference only if the object pointed to is actually a String).

Those differences make C pointers more powerful, but also more dangerous. Both of those possibilities (pointer arithmetic and re-interpreting the values being pointed to) add flexibility to C and are the source of some of the power of the language. But they are also big sources of problems, because if used incorrectly they can easily break assumptions that your code is built around. And it’s pretty easy to use them incorrectly.

splice

August 25, 2015javascriptadmin

Basic Usage

1st param – what index of the array to start
2nd param – how many elements to remove

1	var result = test.splice(1,2);

in firebug console, we first see what test is. Which gives us the result of the full array. Then we do test.splice(1,2), which means at index 1, we remove 2 elements. This returns us “two” and “three”, meaning we removed “two” and “three.

Then we see the results of test again to ensure that “two” and “three” are removed from the original array.

> test
Array [ “one”, “two”, “three”, “four”, “five”, “six” ]
> test.splice(1,2)
Array [ “two”, “three” ]
> test
Array [ “one”, “four”, “five”, “six” ]

//1st param - what index of the array to start

//2nd param - number of elements to remove

//3rd param - string to add in place

var result2 = test.splice(10, 2, "replacement");

in firebug console, we start at index 2, which would be “ten”.
We remove 2 elements, which would be the “ten”, and “six”. The removed elements are returned.
We then add the word “nine”.

> test
Array [ “one”, “four”, “ten”, “six” ]
> test.splice(2,2,”nine”)
Array [ “ten”, “six” ]
> test
Array [ “one”, “four”, “nine” ]

Using splice in List implmentation

We first make a List class default constructor. we initialize member variables. Then we assign function definitions append, remove, length, insert, clear, and toString.

function List() {

this.listSize = 0;

this.pos = 0; //position is current at 0

this.dataStore = []; //data store is empty

//this.clear = clear; //function clear should clear everything

this.find = find; //functind

this.toString = toString;

this.append = append; //functional variable points to func def

this.remove = remove;

this.length = length;

this.insert = insert;

this.clear = clear;

delete the array of elements. then reassign to empty array.

function clear() {

//remove from heap

delete this.dataStore;

this.dataStore = [];

this.listSize = pos = 0;

console.log("MyList.js - (clear), MyList object cleared");

}

//adds an element to our dataStore array

function append(element) {

this.dataStore[this.listSize++] = element;

}

We loop through all the elements of our dataStore array, and if the elements match, we simply return the index.

function find(element) {

for (var i = 0; i < this.dataStore.length; ++i) {

if (this.dataStore[i] == element) {

console.log("MyList.js - (find), found element " + element + ", at index " + i);

return i;

}

return -1;

}

We first get the index of where we want to remove the element.
Then when we have the index, we use the index as parameter for the splice index to know where to start. The 1 at the 2nd parameter of the splice, means to remove 1 element at that index.

//finds the index of the element

//then splices the element

function remove(element) {

var foundAt = this.find(element);

if (foundAt > -1) {

this.dataStore.splice(foundAt,1);

--this.listSize;

return true;

}

return false;

}

We insert at given position pos, removing 0 elements, and insert the element to be inserted.

//insert element into position

function insert(element, pos)

{

if(this.listSize > 0) {

this.dataStore.splice( pos, //start at what position

0, //remove 0 elements.

element); //the element to replace or in case of splice, insert

this.listSize++;

console.log("MyList.js - (insert), element " + element + " inserted at position: " + pos);

return true;

}

console.log("MyList.js - (insert), Warning: did not insert. The array does not exist.");

return false;

}