Just trying to get a handle on blocks. I get the concept. They're like function pointers, but they're actually objects; you can declare a block variable and assign it a block value; call it like a function; they get "frozen in time," for lack of a term, when they get executed, etc. I've created a few blocks and run them successfully, in a few different formats, but when it comes to using them in a method--either with a typedef or without--I'm having a lot of trouble. For example, here's an object interface I created, just to get a handle on the syntax. I have almost no idea how to implement it.
// AnObject.h
#import <Foundation/Foundation.h>
// The idea with the block and the method below is for the block to take
// an int, multiply it by 3, and return a "tripled" int. The method
// will then repeat: this process however many times the user wants via
// the howManyTimes parameter and return that value in the form of an int.
typedef int (^triple)(int);
@interface AnObject : NSObject
{
int num;
}
-(int)repeat:(int)howManyTimes withBlock:(triple)someBlock;
@end
Here's what I have for an implementation, so far:
#import "AnObject.h"
@implementation AnObject
@synthesize num;
-(int)repeat:(int)howManyTimes withBlock:(triple)someBlock {
for (int i = 0; i <= howManyTimes; i++) {
// What the heck am I supposed to put here? I'm baffled by the
// syntax over and over again.
}
}
@end
I know I'm not addressing the instance variable yet. Again, this is a rough draft, just trying to get a handle on how blocks work. Am I even declaring this method right? I'm reading Big Nerd Ranch's Objective-C Programming, Mike Clark's article on blocks from Pragmatic Studio, and several SO threads. Can't find anything relevant. Thanks.
EDIT: XCode 4.3.2, if it matters.
FURTHER EDIT: Ok. Using BJ's (slightly modified) example, I think I've come up with a really complicated way of multiplying 5 by 3. :)
// BJ's implementation:
-(int)repeat:(int)howManyTimes withBlock:(Triple)someBlock {
int blockReturnValue;
for (int i = 0; i <= howManyTimes; i++) {
blockReturnValue = someBlock(i);
}
return blockReturnValue;
}
Main:
...
@autoreleasepool
{
AnObject *obj = [[AnObject alloc] init];
NSLog(@"%d", [obj repeat: 5 withBlock: ^ (int number) {
return number * 3;
}]);
}
return 0;
...
And the output is:
15
Now, it's kicking back 15, because the block I defined as an argument is run only once, right? It multiplies "number," which is 5 in this case, by 3 and freezes that answer, right? I'm sure I just created a completely useless method, and I don't yet understand how to utilize the benefits/features of a block. Am I correct?
/********************* UPDATE *********************/
UPDATE: I understand what you're saying, CRD. Just a correction though, for any new programmers who might be reading this, getting a different output and going, "Que?" Your for loop should be either:
for (int i = 0; i < howManyTimes; i++)
value = someBlock(value);
...or...
(i = 1; i <= howManyTimes; i++)
...to get the answer 243.
And, yes, this is exactly what I was initially trying to do with this code. At least that's what I thought was supposed to be happening. Turns out the author's intent wasn't to triple a number, store that value, triple the stored value, store that...etc., but rather just to print x * 3 for numbers 1-5 (3, 6, 9, 12, 15).
Here is the finished product. I just typedef'd a block that takes an int and returns an int, called Tripler. I also changed the name of the argument from "someBlock" to "triple" to more clearly indicate the intended use of the block. I think those are the only changes to the code.
/******************** interface ********************/
#import <Foundation/Foundation.h>
typedef int (^Tripler)(int);
@interface AnObject : NSObject
-(void)iterateFromOneTo:(int)number withBlock:(Tripler)triple;
@end
/******************** implementation ********************/
#import "AnObject.h"
@implementation AnObject
-(void)iterateFromOneTo:(int)number withBlock:(Tripler)triple {
for (int i = 1; i <= number; i++) {
NSLog(@"%d", triple(i));
}
}
@end
/******************** main.m ********************/
#import "AnObject.h"
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[])
{
@autoreleasepool
{
AnObject *obj = [[AnObject alloc] init];
[obj iterateFromOneTo:5 withBlock:^(int number) {
return number * 3;
}];
}
return 0;
}
As you can probably imagine, the resulting output is:
2012-05-05 17:10:13.418 Untitled 2[71735:707] 3
2012-05-05 17:10:13.445 Untitled 2[71735:707] 6
2012-05-05 17:10:13.446 Untitled 2[71735:707] 9
2012-05-05 17:10:13.446 Untitled 2[71735:707] 12
2012-05-05 17:10:13.447 Untitled 2[71735:707] 15
I was making it a lot more complicated than it needed to be. Sorry for explaining it so poorly in the OP. Thanks for your help! /thread? :)
Just call the block like a regular C function.
-(int)repeat:(int)howManyTimes withBlock:(triple)someBlock {
for (int i = 0; i <= howManyTimes; i++) {
int blockReturnValue = someBlock(i);
// do something with blockReturnValue
}
}
Update after your "further edit"
No, the block you passed in as an argument is run five times, each pass through the for loop.
1 as the argument, and gets back 3. It stores that in blockReturnValue, then goes on to the next iteration of the loop.2 as the argument, and gets back 6. It stores that in blockReturnValue, completely overwriting the value we stored there in the previous pass.3 as the argument, and gets back 9. Again, it overwrites the value in blockReturnValue.12 in blockReturnValue.15 in blockReturnValue.Then we exit the for loop, and return 15. So yes, you're correct that you've made a pointless method to multiply by 3. But you're doing it in a way that also does a bunch of useless calculations.