gardes de portée créés Dynamiquement

Question

J'ai lu l'article sur les gardes de portée (Generic: Change the Way You Write Exception-Safe Code — Forever) dans DDJ et je comprends leur utilisation commune.

Cependant, l'utilisation commune est d'instancier un garde de pile particulier sur la pile pour une opération particulière, par exemple .:

{ 
    FILE* topSecret = fopen("cia.txt"); 
    ON_BLOCK_EXIT(std::fclose, topSecret); 
    ... use topSecret ... 
} // topSecret automagically closed 

mais si je veux planifier les opérations de nettoyage dans l'exécution, par exemple quand j'ai une boucle:

{ 
    vector<FILE*> topSecretFiles; 
    for (int i=0; i<numberOfFiles; ++i) 
    { 
     char filename[256]; 
     sprintf(filename, "cia%d.txt", i); 
     FILE* topSecret = fopen(filename); 
     topSecretFiles.push_back(topSecret); 
     ON_BLOCK_EXIT(std::fclose, topSecret); // no good 
    } 
} 

De toute évidence, l'exemple ci-dessus ne fonctionnerait pas, étant donné que topSecret serait fermé en même temps que la pour portée. Je voudrais un motif de protection de champ où je peux juste la file d'attente aussi facilement les opérations de nettoyage que je RESOLUE à être nécessaire lors de l'exécution. Y at-il quelque chose comme ça disponible?

Je ne peux pas pousser des objets de garde scope dans une file d'attente standard, faire l'objet original (celui que je fais pression) serait rejeté dans le processus. Que diriez-vous de pousser des gardes de pile affectés par tas et d'utiliser une file d'attente qui supprime ses membres sur dtor? Est-ce que quelqu'un a une approche plus intelligente?

Answer 1

Il vous semble ne pas apprécier RAII pour ce qu'elle est. Ces gardes de portée sont parfois sympas pour des choses locales ("scope") mais vous devriez essayer de les éviter en faveur de ce que RAII est supposé faire: encapsuler une ressource dans un objet. Le type FILE * n'est vraiment pas bon pour ça.

est ici une alternative:

void foo() { 
    typedef std::tr1::shared_ptr<FILE> file_sptr; 
    vector<file_sptr> bar; 
    for (...) { 
     file_sptr fsp (std::fopen(...), std::fclose); 
     bar.push_back(fsp); 
    } 
} 

Ou:

void foo() { 
    typedef std::tr1::shared_ptr<std::fstream> stream_sptr; 
    vector<stream_sptr> bar; 
    for (...) { 
     file_sptr fsp (new std::fstream(...)); 
     bar.push_back(fsp); 
    } 
} 

Ou dans "C++ 0x" (future norme C++):

void foo() { 
    vector<std::fstream> bar; 
    for (...) { 
     // streams will become "movable" 
     bar.push_back(std::fstream(...)); 
    } 
} 

Edit: Depuis que je l'aime types mobiles en C++ 0x tellement et vous avez montré un intérêt pour cela: Voici comment vous pouvez utiliser unique_ptr en combinaison avec FILE * sans tête ref comptage:

struct file_closer { 
    void operator()(FILE* f) const { if (f) std::fclose(f); } 
}; 

typedef std::unique_ptr<FILE,file_closer> file_handle; 

file_handle source() { 
    file_handle fh (std::fopen(...)); 
    return fh; 
} 

int sink(file_handle fh) { 
    return std::fgetc(fh.get()); 
} 

int main() { 
    return sink(source()); 
} 

(non testé)

Assurez-vous de vérifier Dave's blog on efficient movable value types

Answer 2

Huh, se révèle la garde de champ DDJ est "mobile", et non pas dans le C++ 0x sens, mais dans le même sens qu'un auto_ptr est mobile: lors de la copie cteur, la nouvelle garde « rejette » la vieille garde (comme le ctor copie de auto_ptr appelle auto_ptr de l'ancien :: libérer).

donc je peux simplement garder un queue<ScopeGuard> et il va travailler:

queue<ScopeGuard> scopeGuards; 

// ... 

for (...) 
{ 
    // the temporary scopeguard is being neutralized when copied into the queue, 
    // so it won't cause a double call of cleanupFunc 
    scopeGuards.push_back(MakeScopeGuard(cleanupFunc, arg1)); 
    // ... 
} 

Par ailleurs, je vous remercie de la réponse ci-dessus. C'était instructif et éducatif pour moi de différentes manières.