Appeler le constructeur d'une classe après création

Bonjour à tous,

Je rencontre un petit problème avec les classes.
Je voudrais tout simplement appeler l'un des constructeur de ma classe :
j'ai crée une classe de nom TVOC, qui a deux constructeur : TVOC() et TVOC(LPSTR pFichier)
Si le second echoue je voudrais que l'on appelle le premier constructeur.

Mais je ne sais pas du tout comment réappeler un constructeur de classe, encore moins dans une des méthodes de cette dernière!
(Ah oui! J'oubliais, je veux appeler le constructeur au sein d'une méthode).

Merci d'avance de votre aide!

Spartan03

Salut,

Un constrcuteur n'est appelé qu'une seul fois, c'est lui qui crée ton objet, si il en est autrement y'a un probleme.

Par contre rien ne t'empeche de te creer une fonction d'initialisation et de reinitialiser ton objet plusieurs fois.

en passant ton constructeur ne devrait pas echouer, peut etre pourrais tu donner plus de details.

XXiemeciel

En fait, j'ai évité de donner trop de détails car ma classe n'es pas écrite à 100% en c++, elle utilise beaucoup de fonctions de l'ApiWin32 vu qu'elle est prévue pour fonctionner avec un programme Windows.

Mais j'ai trouvé comment faire pour réappeler le constructeur et cela ne déclanche aucune erreur, ni à la compilation, ni à l'éxecution.

Je vais qand même décrire ma classe :

Elle contient un tableau de VOC, VOC est une struct que j'ai crée et qui a deux membres : char mFrancais[250], char mAllmd[250]
Le programme final est un logiciel qui permet d'entrer un mot/expression en Francais et sa traduction en allemand, d'afficher le lexique sous fome de tableau (genre tableur) et enfin, d'interroger l'utilisateur : il lui donne le mot en français, et l'utilisateur doit donner la réponse en allemand.

J'ai donc ma classe TVOC qui contient un tableau de VOC (la ou je range mes entrées), un HANDLE de fichier (ça c'est du Windows, il contient plusieurs paramètres comme le chemin du fichier, la protection de l'accès à ce dernier : lecture/écriture/effacement, bien plus poussé que la librairie fstream, bien moins portable surtout...) et enfin le n° de l'entrée courante.

Ensuite, j'ai deux constructeurs :

TVOC() et TVOC(LPSTR/*type Windows, comme un string*/chemin_du_fichier)!

Dans la première on crée le tableau vide, dans la seconde on appelle la méthode ouvrir() de la classe. Mais si le chemin est erroné, la fonction qui va ouvrir le fichier (CreateFile()) échoue et donc je renvoie sur le constructeur sans chemin qui va crer un tableau vide, sinon si le nom du fichier est bon alors on décode son contenu avant de la mettre dans le tableau de VOC* et avant tout cela on compte les entrées pour définir la taille du tableau (on rajoute 100entrées que l'utilisateur pourra remplir, cette limite passée, il devra enregistrer, recréer la classe et pourra de nouveau entrer 100entrées).

Pas très clair tout ça???

Je mets quand même mon code (je n'ai pas utilisé de pointeurs ici, j'aurai pu mais j'aime autant pas)

voc.cpp

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320

#include "voc.h"   /******************************************************************************* LE CONSTRUCTEUR de la classe TVOC, il prend en argument le chemin d'un fichier .voc sous forme de chaine de caractères. Il construit le tableau voc à partir de ce chemin de fichier! *******************************************************************************/ //1er constructeur : aucun fichier n'est spécifié... TVOC::TVOC() { MessageBox(NULL,"Appel au constructeur de base","Construction",MB_OK); //On initialise juste le tableau voc voc = new VOC[100]; //On ne donne pas de valeurs au hande du fichier hfVoc=INVALID_HANDLE_VALUE; } //2ème constructeur : on a spécifié le chemin du fichier TVOC::TVOC(LPSTR pFichier) { MessageBox(NULL,"Appel au constructeur évolué","Construction",MB_OK); //On ouvre le fichier spécifié ouvrir(pFichier); } /******************************************************************************* Cette méthode ouvre le fichier passé en agument en LPSTR pFichier *******************************************************************************/ void TVOC::ouvrir(LPSTR pFichier) {   //1°) On lit le fichier --------------------------------------------------------   /******************************************************************************  On donne un HANDLE au fichier dont le chemin, relatif ou absolu est pFichier.  On utilise pour cela la fonction CreateFile() de la librairie "windows.h"  ******************************************************************************/ hfVoc=CreateFile(pFichier,GENERIC_READ|GENERIC_WRITE,FILE_SHARE_READ,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL); if(hfVoc!=INVALID_HANDLE_VALUE) { MessageBox(NULL,"Le fichier spécifié a bien été ouvert, travaillez bien!","Succes",MB_OK|MB_ICONINFORMATION); /******************************************************************************  On compte le nombre d'octets du fichier que l'on va enregistrer dans un DWORD  de nom longueurFichier  ******************************************************************************/ DWORD longueurFichier = GetFileSize(hfVoc, NULL); /******************************************************************************  On crée un buffer ou stocker le contenu du fichier en attendant sa mise en  tableau!  ******************************************************************************/ char* buffer = new char[longueurFichier + 1]; /******************************************************************************  On crée une variable qui contiendra le nombre d'octets lus dans le fichier,  utile pour la fonction Readfile()  ******************************************************************************/ DWORD nbOctsLus = 0; /******************************************************************************  Enfin, on lit le fichier et l'on stocke son contenu dans le buffer  bufferfichier!  ******************************************************************************/ ReadFile(hfVoc,buffer,longueurFichier,&nbOctsLus,NULL);   //------------------------------------------------------------------------------   //2°) On met son contenu dans le tableau voc de la classe-----------------------   /******************************************************************************* METHODE : En théorie, c'est pas dur!   1°)On crée une variable int qui contiendra le n° de la case courante du tableau de char (la chaine avec le contenu du fichier quoi!).   2°)On crée un autre faux pointeur sur la case courante (mFr ou mAllmd) du tableau voc ; Rappel : la struct voc contient des char[250] pour chaque case.   3°)On crée une variable qui contient le nombre d'entrée (pour le tableau voc)   4°)On compte le nombre d'entrées dans le fichier :      On incrémente le pointeur sur le buffer, chaque fois qi'il est sur un # on      incrémente nEntree! C'est simple, c'est une boucle for!      En effet le programme met un '#' après chaque entrée       5°)On initialise le tableau de voc en fonction du nombre d'entrées       En effet on lui donne le nombre d'entrées plus 100 entrées de rab,       l'utilisateur ne devra donc pas entrer plus de 100 mots entre chaque       enregistrement!   6°)On remplis le tableau voc de la classe       Pour cela on exécute une boucle tant que l'entrée courante (nCentree)       est inférieure au nombre total d'entrées (nEntrees).       Mais tout d'abord on replace le faux-pointeur sur tout le buffer sur le       premier caractère de la chaine.       On enregistre les caractères du buffer dans la première case ([1]mFr)       jusqu'à ce qu'on rencontre un '|', alors on place le pointeur sur le char       après le '|' puis on stocke la suite du buffer dans la seconde case ([1]mA       llmd), et ce jusqu'à ce que l'on trouve un '#' dans le buffer, alors on se       place sur l'entrée suivante (nCentree++) et on recomence la boucle!       Ah! J'oubliais, à chaque fois on incrémente le buffer *******************************************************************************/   //Creation du faux-pointeur sur le buffer ................................... DWORD pBuffer = 0; //Creation du faux pointeur sur la case courante ............................ DWORD pCase; //Creation d'une variable cntenant le nombre d'entrée ....................... int nEntrees =0;   //4°)Comptage du nombre d'entrées for(pBuffer=0;pBuffer<longueurFichier;pBuffer++) { //On vérifie si le signe n'est pas un '#' if(buffer[pBuffer]=='#') nEntrees++; }   //5°)On initialise le tableau... voc = new VOC[nEntrees+100];   /*Test (en pur c) pour afficher le contenu de la variable nEntrees   printf("Nombre entrees : %d \n",nEntrees);   //*/   //6°)a)On replace le faux pointeur pBuffer au début du buffer pBuffer = 0;     //6°)b)On éxecute la boucle des entrées ------------------------------------- for(nCentree=0;nCentree<nEntrees;nCentree++) { //On remplis la case mFrançais for(pCase=0;buffer[pBuffer]!='|';pCase++) { voc[nCentree].mFrancais[pCase]=buffer[pBuffer]; pBuffer++; } //On ajoute un '\0' à la fin du l'expression en Francais voc[nCentree].mFrancais[pCase]='\0'; //On place le pointeur sur le buffer sur le char après le '|' pBuffer++; //-----------------------------------------------------------   //On fait de même pour la case mAllmd for(pCase=0;buffer[pBuffer]!='#';pCase++) { voc[nCentree].mAllmd[pCase]=buffer[pBuffer]; pBuffer++; } //On ajoute un '\0' à la fin du l'expression en Allemand voc[nCentree].mAllmd[pCase]='\0'; //On place le pointeur sur le buffer sur le char après le '#' pBuffer++; //----------------------------------------------------------- /*Test (console seulement) pour afficher le tableau voc   printf("%s | %s \n",voc[nCentree].mFrancais,voc[nCentree].mAllmd);   //*/ } //Fin de la boucle des entrées ----------------------------------------------     //------------------------------------------------------------------------------   /******************************************************************************  On jarte le buffer de la RAM, ça libère un peu d'espace!  ******************************************************************************/ delete[] buffer; } //Si la fonction échoue else { MessageBox(NULL,"Le fichier spécifié n'existe pas ou est utilisé actuellement!","Erreur",MB_OK|MB_ICONERROR); TVOC(); } }           //##############################################################################       /******************************************************************************* Cette fonction ajoute une entrée dans le tableau TVOC et déplace le faux pointeur sur l'entrée suivant la nouvelle entrée (vide). Rien de bien compliqué dans tout ça! *******************************************************************************/ void TVOC::ajouter(char mFrancais[250],char mAllemand[250]) { /**************************************************************************      Mise au point :      Tous les faux pointeurs crées pour le constructeur ont été supprimés      dès que la fonction a fini d'être exécutée. On n'a plus accès qu'aux      membres de la classe TVOC a partir de ses méthodes (car ils sont private)      Parmi ces trois membres on va surtout utiliser voc et nCentree!      Le handle du fichier ne nous intéresse plus beaucoup désormais, on va      travailler uniquement sur le tableau VOC* voc!      La variable int nCentree va nous permettre d'écrire directement dans une      case "vide" du tableau (pas plus de 100 nouvelles entrées)!      ---------------------------------------------------------------------------      Le faux pointeur sur l'entrée courante est déja sur l'entrée vide suivant      la dernière entrée pleine!!!      On va donc entrer le nouveau mot de voc à la ligne courante puis      incrémenter nCntree au cas où on ajoute encore une nouvelle entrée après      celle ci!      On va créer un faux pointeur pCase qui va pointer sur le caractère courant      de la chaine et sur celui du tableau en même temps!      **************************************************************************/ DWORD pCase;   //On stocke le mot en français dans la case Français for(pCase=0;mFrancais[pCase]!='\0';pCase++) voc[nCentree].mFrancais[pCase]=mFrancais[pCase]; voc[nCentree].mFrancais[pCase]='\0';   //On stocke le mot en allemand dans la case allemand for(pCase=0;mAllemand[pCase]!='\0';pCase++) voc[nCentree].mAllmd[pCase]=mAllemand[pCase]; voc[nCentree].mAllmd[pCase]='\0';   //On place nCentree sur l'entrée suivante nCentree++; }     //##############################################################################     /******************************************************************************* La fonction suivante enregistre le tableau voc courant dans le fichier spécifié à l'ouverture (de HANDLE hfVoc). Dans le projet final elle sera appelée lors du clique sur enregistrer, on vérifiera si le HANDLE a bien été initialisé, si c'est le cas on enregistre sur le fichier de HANDLE correspondant sinon on appelle la fonction enregistrerSous qui crée un nouveau HANDLE! Cette fonction enregistre le tableau dans un fichier, le détruit puis refait appel au constructeur de la classe afin de recréer le tableau, comme ça on peut à nouveau entrer 100 nouvelles entrées! Pas dur en théorie mais en pratique euh... *******************************************************************************/ void TVOC::enregistrer() { /*****************************************************************************   On crée le buffer qui va contenir le contenu du futur fichier voc, ce buffer   est sous forme de chaine de caractères. Sa taille maximale est de   (250*2+2)*(nCentree-1). 250*2 car 250 est la taille maximale d'un mot/expression   *2 car il y'a deux expressions par entree ; +2 car il faut aussi compter les   signes "|" et "#" (2 par ligne); enfin *nCentree car on multiplie par le   d'entree, le faux pointeur nCentree est placé sur l'entrée suivant la derniere   on fait donc - 1 pour ne pas placer 1 entrée de trop (déja qu'il y'en a une)   *****************************************************************************/ char* buffer = new char[(250*2+2)*(nCentree-1)]; /*****************************************************************************   On crée un pointeur sur la lettre de la case courante ainsi qu'un autre   pointeur sur la totalité du buffer et un autre sur l'entree courante a ecrire.   *****************************************************************************/ DWORD pCase, pEntree; DWORD pBuffer=0; /*****************************************************************************   Maintenant on remplis le buffer, il contient le futur contenu du fichier à la   lettre.   *****************************************************************************/ for(pEntree=0;pEntree<nCentree;pEntree++) { //On copie la case mFrancais for(pCase=0;voc[pEntree].mFrancais[pCase]!='\0';pCase++) { //On stocke le contenu de la première case dans le buffer lettre par lettre buffer[pBuffer]=voc[pEntree].mFrancais[pCase]; //On incrémente le buffer pBuffer++; } //On ajoute un signe de fin de colonne ('|') buffer[pBuffer]='|'; //On place le pointeur sur le buffer sur la lettre suivant le '|' pBuffer++;   //On copie la case mAllmd for(pCase=0;voc[pEntree].mAllmd[pCase]!='\0';pCase++) { //On continue de remplir le buffer avec la case mAllmd de l'entrée courante buffer[pBuffer]=voc[pEntree].mAllmd[pCase]; //On incrémente le pointeur du buffer pBuffer++; } //On ajoute le signe de fin de ligne ('#') buffer[pBuffer]='#'; //On place le pointeur sur le buffer sur la lettre suivant le '#' pBuffer++;   //Et on ré-éxécute la boucle }   /*****************************************************************************   On crée une variable qui contiendra le nombre d'octects érits dans le fichier   (nécéssaire à la fonction WriteFile())   *****************************************************************************/ DWORD nbOctetsEcrits = 0; //Si le fichier existe déja if(hfVoc!=INVALID_HANDLE_VALUE) { /************************************************************************        On place le pointeur sur le fichier au début du fichier       *************************************************************************/ SetFilePointer(hfVoc,0,NULL,FILE_BEGIN); /*************************************************************************       On remplit le fichier avec le buffer       *************************************************************************/ WriteFile(hfVoc,buffer,pBuffer,&nbOctetsEcrits, NULL); } else { nouveau(); }   //On détruit le buffer pour éviter de bouffer trop de mémoire delete[] buffer;       }   void nouveau(LPSTR pFichier); { hfVoc=CreateFile(pFichier,GENERIC_READ|GENERIC_WRITE,FILE_SHARE_READ,NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL); }

---

Voc.h

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83

/*****************Etienne LAFARGE alias Spartan03*******************************   Nom : Voc.h le : 06/11/05 à 19:35   Description :   Ce fichier est le header de la classe TVOC, il est lié au fichier voc.cpp   Prescision : Il est écris avec des fonctions de c standard pour ce qui est des sorties, elles ne sont présentes qu'à titre de test et seront retirées du header final!   *******************************************************************************/       #ifndef _VOC_H #define _VOC_H     #include <windows.h> #include <stdio.h>   struct VOC { char mFrancais[250]; char mAllmd[250]; };   class TVOC { protected: //Le tableau de VOC qui contient les entrées VOC* voc; //Le handle du fichier .voc associé à la classe HANDLE hfVoc; //Le faux-pointeur sur la totalité du fichier int nCentree;     public:   /******************************************************************************* LE CONSTRUCTEUR de la classe TVOC, il prend en argument le chemin d'un fichier .voc sous forme de chaine de caractères. Il construit le tableau voc à partir de ce chemin de fichier! Il s'agit en fait d'un appel à la fonction ouvrir(). *******************************************************************************/ //1er constructeur : aucun fichier n'est spécifié... TVOC(); //2ème constructeur : on a spécifié le chemin du fichier TVOC(LPSTR); /******************************************************************************* Cette méthode ouvre le fichier passé en agument en LPSTR *******************************************************************************/ void ouvrir(LPSTR ); /******************************************************************************* Cette méthode crée un nouveau fichier sur lequel travailler *******************************************************************************/ void nouveau(LPSTR); /******************************************************************************* Cette fonction ajoute une entrée dans le tableau TVOC et déplace le faux pointeur sur l'entrée suivant la nouvelle entrée (vide). Rien de bien compliqué dans tout ça! *******************************************************************************/ void ajouter(char [250],char [250]); /******************************************************************************* La fonction suivante enregistre le tableau voc courant dans le fichier spécifié à l'ouverture (de HANDLE hfVoc). Dans le projet final elle sera appelée lors du clique sur enregistrer, on vérifiera si le HANDLE a bien été initialisé, si c'est le cas on enregistre sur le fichier de HANDLE correspondant sinon on appelle la fonction enregistrerSous qui crée un nouveau HANDLE! Cette fonction enregistre le tableau dans un fichier, le détruit puis refait appel au constructeur de la classe afin de recréer le tableau, comme ça on peut à nouveau entrer 100 nouvelles entrées! Pas dur en théorie mais en pratique euh... *******************************************************************************/ void enregistrer(); };   #endif

---

Ces sources sont un peu en bordel mais pour la version final, je vais tous réécrire porprement!

J'ai trouvé commment appeler le constructeur dans une méthode, il suffit de faire NOM_DE_LA_CLASSE(arguments du constructeur);

Spartan03

Citation:

---

Envoyé par Spartan03

J'ai trouvé commment appeler le constructeur dans une méthode, il suffit de faire NOM_DE_LA_CLASSE(arguments du constructeur);

---

Non. Ca c'est pour avoir une variable temporaire non nommée. L'intérêt est supra limité.

Sinon, std::string, c'est mieux que les buffers statiques (une sémantique de valeur, pas de limitations, idiotes, de bugs idiots, de buffers overflows pénibles, ...)

Au pire, tu peux très bien procéder de la sorte:

Code:

---

1 2 3 4 5 6 7 8 9

T * createT(std::string const& arg) { try { return new T(arg); } catch (ExceptionBienPrecise &) { return new T(); } } ... std::auto_ptr<T> t (createT("toto"));

---

Tu dois aussi pouvoir procéder par la construction d'un objet temporaire préalable qui va réaliser des pré-calculs et pour déterminer ensuite quel constructeur appeler.

http://c.developpez.com/faq/cpp/?pag...R_appel_chaine

Ok, Merci à tous pour vos conseils!