›

Simuler un objet de scope local avec ARC

FKDEVFKDEV Membre
dans Objective-C, Swift, C, C++ #1
En C++, on peut créer des objets sur la pile en déclarant l'objet de cette manière :


<br />
void fonction()<br />
{<br />
    CMonType objet;<br />
<br />
    //... du code...<br />
<br />
    //destruction automatique de l&#39;objet à  la fin du scope (et donc appel du destructeur)<br />
}<br />




En pratique, on utilise souvent cette possibilité pour simplifier l'écriture de traitement qui ont un début et une fin : 


<br />
void fonction()<br />
{<br />
    EnableLogs();<br />
<br />
    //... du code...<br />
<br />
    DisableLogs();<br />
}<br />
<br />
PEUT-ETRE REMPLACER PAR :<br />
<br />
<br />
void fonction()<br />
{<br />
    CLogEnabler logs;<br />
<br />
    //... du code...<br />
<br />
<br />
//DisableLogs() sera appelé automatiquement à  la sortie de la fonction, pas de risques d&#39;oubli, même //s&#39;il y a 15 return; dans la fonction.<br />
}<br />
<br />
class CLogEnabler<br />
{<br />
    CLogEnabler() {EnableLogs();};<br />
    ~CLogEnabler() {DisableLogs();};<br />
}<br />






A votre avis, peut-on simuler ce comportement de manière fiable avec ARC en objective-C ?

Puisque ARC va appeler lui-même le release qui va libérer l'objet et donc appeler le dealloc.


<br />
- (void) fonction<br />
{<br />
    __strong LogEnabler* logEnabler = [LogEnabler createLogger]; <br />
<br />
    //... du code...<br />
<br />
}<br />






Je pose la question parce que j'aimerais bien pouvoir changer le niveau dans log de CocoaLumberjack de manière dynamique pour certains scope.

Je voudrais juste pouvoir ajouter une ligne dans une fonction pour ajuster le niveau de log.

A priori dans le cas où logEnabler n'est pas directement utilisé dans le code de la fonction, je suis coincé : ARC va faire le release juste après l'allocation.

Réponses

  • jpimbertjpimbert Membre
    #2
    En objective-C le destructeur d'un objet est dealloc.

    Mais je ne pense pas que ça fonctionne si simplement car en ARC un objet est détruit lorsqu'il n'a plus de référence. Le fait qu'il soit créé dans la pile ne va pas éliminer la référence à  la sortie de la fonction.



    Mais pourquoi ne pas utiliser simplement le défaut qui est en autorelease pour les variables locales ?
  • FKDEVFKDEV Membre
    mars 2013 modifié #3
    'jpimbert' a écrit:


    Mais pourquoi ne pas utiliser simplement le défaut qui est en autorelease pour les variables locales ?




    Parce que le dealloc ne sera pas appelé à  la fin de la fonction mais plus tard quand l'autorelease loop sera vidée.



    En fait je voudrais trouver un truc pour que le dealloc soit appelée à  la fin de la fonction, sans que j'ai à  écrire une ligne de code.

    Comme une option de ARC qui dirait : tu attends la fin de la fonction (ou du scope) pour inserer le release.
  • jpimbertjpimbert Membre
    #4
    Si tu as absolument besoin de libérer les variables locales à  la fin de la fonction il suffit de mettre le code dans un bloc autorelease.
  • FKDEVFKDEV Membre
    #5
    J'en ai pas *absolument* besoin.

    C'est juste que j'ai commencé à  le coder comme en C++ et je me suis rendu compte que ça n'avait pas de sens en Objective-C.

    Donc je cherchais un truc malin pour faire quelque chose de similaire en obj-C.

    Si cela implique d'ecrire plus d'1 ligne d'une code, ce n'est pas interessant.
  • AliGatorAliGator Membre, Modérateur
    #6
    En Objective-C, tout est pointeur. Du coup si je dis pas de bétises, tous les objets ObjC créés avec alloc/init sont créés sur le tas (comme un malloc en C), et en tout cas ne sont pas automatiquement détruis quand tu sors du contexte (quand tu sors de ton bloc "entre accolades" courant).



    Par contre tu peux utiliser d'autres solutions. Par exemple utiliser les blocks.



    Exemple, tu peux imaginer créer une méthode utilitaire [DDLog setLogLevel:andExecute:] qui ressemblerait à  ça : 
    +(void)setLogLevel:(int)logLevel andExecute:(dispatch_block_t)block<br />
{<br />
  int prevLogLevel = ddLogLevel;<br />
  ddLogLevel = logLevel;<br />
  block();<br />
  ddLogLevel = prevLogLevel;<br />
}
    (Bon je viens de taper le code depuis mon iPad au feeling sans aller relire l'API de CocoaLumberjack, c'est p'tet pas comme ça qu'il faut faire pour modifier ton logLevel le temps du scope, mais bon tu vois l'idée je te laisse adapter)



    Du coup tu pourras faire : 
    -(void)someMethod<br />
{<br />
  [DDLog setLogLevel:LOG_LEVEL_VERBOSE andExecute:^{<br />
      // .... ton code à  exécuter avec un niveau de log verbeux<br />
  }];<br />
}
  • FKDEVFKDEV Membre
    #7
    'AliGator' a écrit:


    En Objective-C, tout est pointeur. Du coup si je dis pas de bétises, tous les objets ObjC créés avec alloc/init sont créés sur le tas (comme un malloc en C), et en tout cas ne sont pas automatiquement détruis quand tu sors du contexte (quand tu sors de ton bloc "entre accolades" courant).




    Oui c'est exactement ça le problème. Alors qu'en C++ tu peux mettre un objet sur la pile et donc son destructeur sera appelé au moment où la pile sera nettoyée.




    Par contre tu peux utiliser d'autres solutions. Par exemple utiliser les blocks.
    <br />
Du coup tu pourras faire :[code]-(void)someMethod<br />
{<br />
  [DDLog setLogLevel:LOG_LEVEL_VERBOSE andExecute:^{<br />
	  // .... ton code à  exécuter avec un niveau de log verbeux<br />
  }];<br />
}





    C'est pas mal.

    Je ne vais pas l'utiliser pour les logs car cela donne trop d'importance au code de qui fait le log mais je garde l'idée pour d'autres objets qui aurait besoin d'encadrer du code par des traitements de début et de fin.
Connectez-vous ou Inscrivez-vous pour répondre.