comment réinitialiser un grand nombre de membres de la classe à la fois, pas dans un destructeur?

Question

J'ai une classe contenant plusieurs membres d'un type de classe simple. Plus important encore, leur nombre augmente au fur et à mesure du développement.

Je dois être en mesure de les réinitialiser tous en même temps, et je voudrais le faire sans copier-coller. Le code ressemble actuellement:

typedef auto_ptr<odbc::PreparedStatement> Stmt; 

class DbProxy { 
private: 
    void reset(); 

    Stmt a; 
    Stmt b; 
    Stmt c; 
    // ... about 10 more 
}; 

void DbProxy::reset() 
{ 
    a.reset(); 
    b.reset(); 
    c.reset(); 
    // etc. 
} 

Il est évident que je n'aime pas avoir à ajouter chaque nouveau membre à la fonction reset() (juste eu une faute seg pour oublier un.).

Ce que j'ai l'intention de faire est de les rassembler tous dans une structure et d'allouer cette structure sous auto_ptr. Ainsi, le code ressemblerait à ceci:

typedef auto_ptr<odbc::PreparedStatement> Stmt; 

class DbProxy { 
public: 
    DbProxy(): stmts(new OdbcResources) {} 
private: 
    void reset() { stmts.reset(); } 

    struct OdbcResources { 
    Stmt a; 
    Stmt b; 
    Stmt c; 
    // ... about 10 more 
    }; 
    auto_ptr<OdbcResources> stmts; 
}; 

objets de DbProxy ne sont pas destinés à être copiés ou copie construite, bien que je ne l'ai pas pris la peine d'en assurer en faisant la cession et la copie-cteur privé.

Voyez-vous un problème avec cette approche? Avez-vous d'autres suggestions?

EDIT

basée sur la suggestion @DeadMG, qu'en ceci:

class DbProxy { 
public: 
    DbProxy(); 
private: 
    enum Statements { SELECT1, SELECT2, INSERT, LAST }; // never mind the names 

    void reset() { for (int i=0; i < LAST; i++) statement[i].reset(); } 

    Stmt statements[LAST]; 
}; 

Answer 1

Il n'y a pas besoin pour le auto_ptr supplémentaire (chaque Stmt étant un auto_ptr de toute façon), si vous les recueillir dans une seule classe, vous pouvez les remettre avec une simple affectation. Contrairement à une solution de tableau, vous conservez toujours leurs noms significatifs.

Notez que vous ne pouvez pas utiliser un temporaire sans nom (par exemple stmts = OdbcResources();) comme l'opérateur d'affectation de copie généré prendra une référence non const que les membres (auto_ptr) ne peut être affectée de non constauto_ptr s.

class DbProxy { 
public: 
    DbProxy() : stmts() {} 
private: 
    void reset() { OdbcResources tmp; stmts = tmp; } 

    struct OdbcResources { 
    Stmt a; 
    Stmt b; 
    Stmt c; 
    // ... about 10 more 
    }; 
    OdbcResources stmts; 
}; 

Answer 2

utiliser un tableau statique de taille.

Stmt statements[10]; 

for(int i = 0; i < sizeof(statements)/sizeof(Stmt); i++) 
    statements[i].reset(); 

Answer 3

Ce pleure pour un récipient - en supposant odbc::PreparedStatement est copiable, ont tout simplement un vecteur de ces derniers dans DbProxy

class DbProxy { 
private: 
    void reset() { resources.clear(); } // all vanish! 

    vector<odbc::PreparedStatement> resources; 
}; 

Else, shared_ptr

typedef shared_ptr<odbc::PreparedStatement> Stmt; 
class DbProxy { 
private: 
    void reset() { resources.clear(); } // all vanish! 

    vector<Stmt> resources; 
}; 

Answer 4

Vous pourriez être en mesure de il suffit de copier dans une copie par défaut:

void reset() { *this = DbProxy(); } 

Answer 5

Je ne vois rien de mal à ce type d'approche. Cela ressemble à l'idiome "implémentation privée". Vous pouvez être intéressé par le details.

MY2C