Discussion :

[Spartan03]

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

[xxiemeciel]

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

[Spartan03]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Luc Hermitte]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Laurent Gomila]

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

[Spartan03]

Ok, Merci à tous pour vos conseils!