Blocchi ricorsivi in ​​Objective-C che perdono in ARC

Question

Quindi sto usando i blocchi ricorsivi. Capisco che affinché un blocco sia ricorsivo, deve essere preceduto dalla parola chiave __block e deve essere copiato in modo che possa essere messo sullo heap. Tuttavia, quando lo faccio, si presenta come una perdita in Strumenti. Qualcuno sa perché o come posso aggirarlo?

Si prega di notare nel codice qui sotto ho riferimenti a molti altri blocchi, ma nessuno di essi è ricorsivo.

__block NSDecimalNumber *(^ProcessElementStack)(LinkedList *, NSString *) = [^NSDecimalNumber *(LinkedList *cformula, NSString *function){ 
     LinkedList *list = [[LinkedList alloc] init]; 
     NSDictionary *dict; 
     FormulaType type; 
     while (cformula.count > 0) { 
      dict = cformula.pop; 
      type = [[dict objectForKey:@"type"] intValue]; 
      if (type == formulaOperandOpenParen || type == formulaListOperand || type == formulaOpenParen) [list add:ProcessElementStack(cformula, [dict objectForKey:@"name"])]; 
      else if (type == formulaField || type == formulaConstant) [list add:NumberForDict(dict)]; 
      else if (type == formulaOperand) [list add:[dict objectForKey:@"name"]]; 
      else if (type == formulaCloseParen) { 
       if (function){ 
        if ([function isEqualToString:@"AVG("]) return Average(list); 
        if ([function isEqualToString:@"MIN("]) return Minimum(list); 
        if ([function isEqualToString:@"MAX("]) return Maximum(list); 
        if ([function isEqualToString:@"SQRT("]) return SquareRoot(list); 
        if ([function isEqualToString:@"ABS("]) return EvaluateStack(list).absoluteValue; 
        return EvaluateStack(list); 
       } else break; 
      } 
     } 
     return EvaluateStack(list); 
    } copy]; 
    NSDecimalNumber *number = ProcessElementStack([formula copy], nil); 

UPDATE Così nella mia ricerca ho scoperto che il problema a quanto pare non hanno a che fare con i riferimenti alle altre blocchi questo blocco utilizza. Se faccio qualcosa di semplice come questo, non perde:

__block void (^LeakingBlock)(int) = [^(int i){ 
     i++; 
     if (i < 100) LeakingBlock(i); 
    } copy]; 
    LeakingBlock(1); 

Tuttavia, se posso aggiungere un altro blocco in questo, lo fa perdita:

void (^Log)(int) = ^(int i){ 
    NSLog(@"log sub %i", i); 
}; 

__block void (^LeakingBlock)(int) = [^(int i){ 
    Log(i); 
    i++; 
    if (i < 100) LeakingBlock(i); 
} copy]; 
LeakingBlock(1); 

Ho provato con il __block parola chiave per Log() e anche provato a copiarlo, ma perde ancora. Qualche idea?

UPDATE 2 Ho trovato un modo per prevenire la perdita, ma è un po 'oneroso. Se converto il blocco passato in un ID debole e quindi restituisco l'ID debole in un tipo di blocco, posso impedire la perdita.

void (^Log)(int) = ^(int i){ 
    NSLog(@"log sub %i", i); 
}; 

__weak id WeakLogID = Log; 

__block void (^LeakingBlock)(int) = [^(int i){ 
    void (^WeakLog)(int) = WeakLogID; 
    WeakLog(i); 
    if (i < 100) LeakingBlock(++i); 
} copy]; 
LeakingBlock(1); 

Sicuramente c'è un modo migliore?

Answer 1

Ok, ho trovato la risposta da solo ... ma grazie a chi ha cercato di aiutare.

Se si sta facendo riferimento/utilizzando altri blocchi in un blocco ricorsivo, è necessario passarli come variabili deboli. Ovviamente, __weak si applica solo ai tipi di puntatori a blocchi, quindi è necessario digitarli per primi. Ecco la soluzione finale:

typedef void (^IntBlock)(int); 

    IntBlock __weak Log = ^(int i){ 
     NSLog(@"log sub %i", i); 
    }; 

    __block void (^LeakingBlock)(int) = ^(int i){ 
     Log(i); 
     if (i < 100) LeakingBlock(++i); 
    }; 
    LeakingBlock(1); 

Il codice di cui sopra non perde.

Answer 2

Senza ulteriori informazioni di contesto, posso dire questo:

Si sono perdite che blocco perché si sta copiando e non rilasciarlo altrove. Devi copiarlo per spostarlo nell'heap, va bene. Ma il modo in cui hai scelto non è del tutto ok.

Un modo corretto per eseguirlo è archiviarlo come variabile di istanza di un oggetto, copiarlo e quindi rilasciarlo all'interno di dealloc. Almeno, è un modo per farlo senza perdite.

Answer 3

Aaron,

il tuo codice sembra essere a thread singolo, perché stai copiando il blocco? Se non si copia il blocco, non si ha una perdita.

Andrew