Esecuzione di blocchi da NSArray?

Question

Stavo solo pensando, dato che puoi trattare Blocchi come oggetti se ne creo due e poi li aggiungo ad un NSArray c'è un modo per eseguirli dall'array?

int (^Block_001)(void) = ^{ return 101; }; 
int (^Block_002)(void) = ^{ return 202; }; 
NSArray *array = [NSArray arrayWithObjects:Block_001, Block_002, nil]; 

EDIT: Aggiornamento per la chiarezza Per @ di davedelong eccellente risposta

int (^Block_001)(void) = [^{ return 101; } copy]; 
int (^Block_002)(void) = [^{ return 202; } copy]; 
NSArray *array = [NSArray arrayWithObjects:Block_001, Block_002, nil]; 

[Block_001 release]; 
[Block_002 release]; 

Answer 1

Certo, basta invocare con () come qualsiasi altro blocco, ma è necessario typecast il valore si recuperano da NSArray. Ecco un esempio (con una typedef aggiunto, perché altrimenti la mia testa fa male):

typedef int (^IntBlock)(void); 
IntBlock Block_001 = ^{ return 101; }; 
IntBlock Block_002 = ^{ return 202; }; 
NSArray *array = [NSArray arrayWithObjects:Block_001, Block_002, nil]; 
int x = ((IntBlock)[array objectAtIndex:0])(); // now x == 101 

Answer 2

Certo che puoi.

int (^x)(void) = [array objectAtIndex:0]; 
printf("%d\n", x()); // prints 101. 

Answer 3

@KennyTM e @ Davide sono corretti, ma il codice è potenzialmente sbagliato. Ecco perché:

Quando si crea uno NSArray con oggetti, verranno inseriti gli oggetti inseriti in retain. Nel caso dei blocchi, sta utilizzando la funzione Block_retain. Ciò significa che l'array ha mantenuto i blocchi che hai creato, ma che vivono nello stack (i blocchi sono uno degli esempi molto rari di oggetti Objective-C che possono essere creati sullo stack senza scavare trucchi assurdi). Ciò significa che non appena termina questo metodo, la matrice ora punta alla spazzatura, perché i blocchi che stava puntando a non esistono più. Per farlo correttamente, si dovrebbe fare:

int (^Block_001)(void) = [^{ return 101; } copy]; 
int (^Block_002)(void) = [^{ return 202; } copy]; 
NSArray *array = [NSArray arrayWithObjects:Block_001, Block_002, nil]; 

[Block_001 release]; 
[Block_002 release]; 

Invocando copy sul blocco, si sta muovendo in modo esplicito il blocco al largo della pila e sul mucchio, dove si può rimanere in modo sicuro dopo che il metodo/uscite di funzione . Quindi, dopo aver aggiunto i blocchi all'array, è necessario bilanciare lo copy (a causa della regola NARC) con una chiamata successiva a release. Ha senso?