Esiste un puntatore SELF per i blocchi?

Question

Mi piacerebbe chiamare ricorsivamente un blocco da se stesso. In un oggetto obj-c, usiamo "self", c'è qualcosa di simile a fare riferimento a un'istanza di blocco dal suo interno?

Answer 1

Una storia divertente! I blocchi sono in realtà oggetti Objective-C. Detto questo, non ci sono API esposte per ottenere il puntatore dei blocchi self.

Tuttavia, se si dichiarano blocchi prima di utilizzarli, è possibile utilizzarli in modo ricorsivo. In un ambiente non-garbage collection, si dovrebbe fare qualcosa di simile:

__weak __block int (^block_self)(int); 
int (^fibonacci)(int) = [^(int n) { 
    if (n < 2) { return 1; } 
    return block_self(n - 1) + block_self(n - 2); 
} copy]; 

block_self = fibonacci; 

È necessaria per applicare il modificatore __block-block_self, perché altrimenti, il riferimento block_self all'interno fibonacci rimanda alla prima che viene assegnato (arresto anomalo del programma alla prima chiamata ricorsiva). Lo __weak garantisce che il blocco non rilevi un riferimento forte a se stesso, il che causerebbe una perdita di memoria.

Answer 2

si deve dichiarare la variabile blocco come __block:

typedef void (^MyBlock)(id); 

__block MyBlock block = ^(id param) { 
    NSLog(@"%@", param); 
    block(param); 
}; 

Answer 3

Il seguente codice di blocco ricorsivo verrà compilare ed eseguire con ARC, GC, o la gestione manuale della memoria, senza andare in crash, che perde, o l'emissione di avvisi (analizzatore o normale):

typedef void (^CountdownBlock)(int currentValue); 

- (CountdownBlock) makeRecursiveBlock 
{ 
    CountdownBlock aBlock; 
    __block __unsafe_unretained CountdownBlock aBlock_recursive; 
    aBlock_recursive = aBlock = [^(int currentValue) 
    { 
     if(currentValue >= 0) 
     { 
      NSLog(@"Current value = %d", currentValue); 
      aBlock_recursive(currentValue-1); 
     } 
    } copy]; 
#if !__has_feature(objc_arc) 
    [aBlock autorelease]; 
#endif 

    return aBlock; 
} 

- (void) callRecursiveBlock 
{ 
    CountdownBlock aBlock = [self makeRecursiveBlock]; 

    // You don't need to dispatch; I'm doing this to demonstrate 
    // calling from beyond the current autorelease pool. 
    dispatch_async(dispatch_get_main_queue(),^
        { 
         aBlock(10); 
        }); 
} 

considerazioni importanti:

• È deve copiare il blocco sull'heap manualmente altrimenti tenterà di accedere a uno stack inesistente quando lo chiamate da un altro contesto (ARC lo fa di solito per te, ma non in tutti i casi. Meglio giocare sul sicuro).
• Sono necessari due riferimenti: uno per mantenere il riferimento forte al blocco e uno per contenere un riferimento debole per il blocco ricorsivo da chiamare (tecnicamente, questo è necessario solo per ARC).
• È necessario utilizzare il qualificatore __block in modo che il blocco non acquisisca il valore non ancora assegnato del riferimento del blocco.
• Se si esegue la gestione manuale della memoria, è necessario autorizzare automaticamente il blocco copiato.

Answer 4

Non c'è ancora self per blocchi. È possibile costruire uno come questo (supponendo ARC):

__block void (__weak ^blockSelf)(void); 
void (^block)(void) = [^{ 
     // Use blockSelf here 
} copy]; 
blockSelf = block; 
    // Use block here 

Il __block è necessario in modo che possiamo impostare blockSelf al blocco dopo aver creato il blocco. Il __weak è necessario perché altrimenti il ​​blocco avrebbe un forte riferimento a se stesso, il che causerebbe un forte ciclo di riferimento e quindi una perdita di memoria. È necessario lo copy per assicurarsi che il blocco venga copiato nell'heap. Questo potrebbe non essere necessario con le versioni più recenti del compilatore, ma non farà alcun danno.