I don't quite understand static variables when defined in the implementation of an interface. In methods I do understand how they differ from local variables, but not when defined directly in an implementation.
Look at these examples. What difference do these two make practically?
#include "MyClass.h"
@implementation MyClass
int myInt;
...
@end
And:
#include "MyClass.h"
@implementation MyClass
static int myInt;
...
@end
myInt
is in both cases visible to all the methods, and if I interpreted a test I ran correctly, myInt
will in both cases be the same variable for different instances of the class.
Unfortunately, it has different effects depending on where you use it.
Static Functions:
By default, all functions have a global scope. The static specifier lets you limit the function’s scope to the current file.
Static Local Variables:
When you use the static modifier on a local variable, the function “remembers” its value across invocations. For example, the currentCount variable in the following snippet never gets reset, so instead of storing the count in a variable inside of main(), we can let countByTwo() do the recording for us.
// main.m
#import <Foundation/Foundation.h>
int countByTwo() {
static int currentCount = 0;
currentCount += 2;
return currentCount;
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSLog(@"%d", countByTwo()); // 2
NSLog(@"%d", countByTwo()); // 4
NSLog(@"%d", countByTwo()); // 6
}
return 0;
}
This use of the static keyword does not affect the scope of local variables.
Read more about the static keyword.