[STL]Suppression d'un objet dans un vector

Bonjour à tous,
en faite, j'ai un problème concernant les vecteurs de pointeurs,
Dans une méthode "Get_Objects_Coverd_P"
Je fais un parcours sur un vecteur de pointeurs "table" qui sont des objets possedant un nom ,un min et un max. Parmi les objets stockés, je voulais récupérer les objets qui sont inclus dans un objet P bien défini (c'est à dire ,la borne inf d'un objet est >= à lla borne inf de P et la borne sup d'un objet est <= par rapport à P)
les objets retenus sont stockés dans un nouveau vecteur de pointeurs qui s'appelle "Template_Object_Covered_P". et doivent être suuprimés du vecteur "table".
j'ai utilisé erase pour les effacer mais ça fonctionne pas.les objets ne s'effacent pas.
par contre quand j'applique ça dans main sans passer par une méthode ça marche.
A votre avis ,est ce que c'est à cause que je travaille sur des pointeurs???
Aidez moi:(
ci dessous le code :

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
 
 /*************************************Objets Couverts par P**************************************************************/
vector<Object*> Get_Objects_Coverd_P(vector<Object*>table){
vector<Object*>Template_Object_Covered_P; 
Object* OD;
Object* P;
int ind_p;
 
/***********************************Recherche de l'objet dominant*********************************************************/
OD = table.front();   
cout <<"L'objet dominant est : "<<OD ->Get_Name()<<endl; 
 
/***************************************Recherche d'un objet en intersection partielle avec l'objet dominant**************/ 
P = Get_P(table);  // P est déjà calculé
 
/*************************Recherche des objets couverts par l'objet P ****************************************************/ 
if(P!=NULL){
/**************************On cherche dans la liste initiale**************************************************************/
Template_Object_Covered_P.clear();
for(ind_p=1;ind_p<table.size();ind_p++){
  if((table[ind_p]->Get_Min()>=P->Get_Min()) && (table[ind_p]->Get_Max()<=P->Get_Max())){
    Template_Object_Covered_P.push_back(table[ind_p]);
    table.erase(table.begin()+ind_p);     // Le problème est ici
    ind_p--;
  }
}
return Template_Object_Covered_P;
}
}
 
 
 
 
/******************************************************MAIN********************************************************/
int main()
{
  char fileName [LGMAX_FILE_NAME + 1] ;
  string name;
  int min, max;
  bool istemplate;
  int nb_objects=0;
  int i;
  string Z_String ;
  vector<Object*> table_objects;
  vector<Object*> objects_covered_P;
 
 
  /**************Lecture des informations dans le fichier qui contient les noms des objets leurs Xmin et leurs Xmax************/
  cout << "name of the file : " ;
  cin >> setw (LGMAX_FILE_NAME) >> fileName ;
  ifstream entree (fileName, ios::in|ios::binary) ;   // ou ios::in
  if (!entree) { cout << "Error: can not open the file " << fileName <<endl ;
                 exit (-1) ;
               }
 
  while(!entree.eof())
  {
  	entree >> name;
  	entree >> min;
  	entree >> max;
	if(name == "*") break;
	else
  	cout << "name: " << name << " min: " << min << " max: " << max << endl ;
	table_objects.push_back(new Object(name,min,max,false));
  	nb_objects++;
  }
 
  entree.close () ;
  cout << "**************************************************************\n";
  cout << " Voici les noms, les min, les max des objets de votre image \n";
  cout << "**************************************************************\n";
  cout << "Nb objects: " << nb_objects << endl;
 
 
for(i= 0; i< nb_objects;i++){
     cout<<table_objects[i]->Get_Name()<<"\t"<<table_objects[i]->Get_Min()<<"\t"<<table_objects[i]->Get_Max()<<"\n";
}
cout << "Taille du vecteur d'objets: " << table_objects.size()<<"\n";
 
objects_covered_P = Get_Objects_Coverd_P(table_objects);
cout<<"les objets couverts par P sont :"<<endl;
for(int y=0;y<objects_covered_P.size();y++)
   cout<<objects_covered_P[y]->Get_Name()<<"\t";
cout<<endl;
 
 
/*for(int z=0;z<table_objects.size();z++){
table_objects.erase(table_objects.begin()+z);
z--;
}
cout<<endl;*/
 
cout<<"Table Objects contient :"<<endl;
for(int k=0;k<table_objects.size();k++)
   cout<<table_objects[k]->Get_Name()<<"\t";
cout<<endl;
}

y'a la FAQ

Citation:

Envoyé par coyotte507

y'a la FAQ

merci pour ta proposition
j'ai fouillé la faq avant de poster !!;)

Tout est LA

Enfin presque.... ;)

oui merci
j'ai déjà vu ça
j'ai testé le code pour mon application,
la suppression des objets ne fonctionne pas !

Code:

table.erase(table.begin()+ind_p); // Le problème est ici

>>
Code:

1 2 delete table[ind_p]; table.erase(table.begin()+ind_p);

Citation:
Envoyé par coyotte507
Code:

table.erase(table.begin()+ind_p); // Le problème est ici

>>
Code:

1 2 delete table[ind_p]; table.erase(table.begin()+ind_p);
voici l'exécution:
A 5 9
B 6 12
C 10 11
D 11 12
Taille du vecteur d'objets: 4
L'objet dominant est : A
L'objet en intersection partielle avec A est :B (ça devient faux)
les objets couverts par P sont :
Erreur de segmentation //problème

Citation:

Envoyé par coyotte507

Code:

for(ind_p=1;ind_p<table.size();ind_p++)

C'est normal que tu commences pas à 0?

Merci pour votre intérêt à mon code
Voici mon code tout entier:
Object.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
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
#include <iostream>
#include <string>
#include <vector>
#include <cstdlib>                    
#include <fstream>
#include <sstream>
#include <algorithm>
#include <iterator>
#include <iomanip>
#include "Object.h"
using namespace std;
 
/**************************************Cnstructeur*************************************/
 
Object::Object(string name,int min, int max, bool istemplate){
 	Set_Name(name);		
 	Set_Min(min);
 	Set_Max(max);
	Set_Template(istemplate);
 };
 
/**************************Fonction pour convertir un int à un string******************/
 
string IntToString ( int number )
{
  ostringstream oss;
  oss<< number;
  return oss.str();
} 
 
/**************************************************************************************/ 	
/*bool operator<(const Object& x, const Object& y)
{
    return x._min < y._min;
}
 
 
/**************************Fonction qui sert au tri alphabétique*****************************/
bool StringPtrCompare( Object* p1, Object* p2 ) 
{
   return p1->Get_Name() < p2->Get_Name();
}
 
 
/**************************Fonction qui sert au tri des objets selon leurs Xmax *****************************/
bool MaxPtrCompare( Object* p1, Object* p2 ) 
{
 
   return ((p1->Get_Max() < p2->Get_Max())||((p1->Get_Max() == p2->Get_Max())&&(p1->Get_Min() < p2->Get_Min())));
}
 
/******************************Fonction pour récupérer l'objet Q**********************************/
Object* Get_Q(vector<Object*> tab){
int Min = tab[0]->Get_Min();
int Max = tab[0]->Get_Max();
int Rang = 0;
Object* Q;
for (int j = 0; j < tab.size(); j++){
  if((tab[j]->Get_Min() > Min) || ((tab[j]->Get_Min() == Min) && (tab[j]->Get_Max()< Max))){
  	Min = tab[j]->Get_Min();
	Max = tab[j]->Get_Max();
	Rang = j;
  }
 	Q = tab[Rang];
}
return Q;
}
 
 
 
/******************************Algorithme de Template Object Generation*****************************/
Object * Template_Object_Generation(vector<Object*>tab){
string Z_String;
int position_N;
 
if(tab.size()==1)
return tab[0];
/**********************TEST de l'égalité des coordonnées minimales et maximales ********/
sort(tab.begin(), tab.end(),StringPtrCompare);
int ind_obj=0; 
bool parenthese;
while(ind_obj < (tab.size() )){
int ind_obj_next = ind_obj + 1;
parenthese = false;
	while(ind_obj_next < tab.size()){
		if(*tab[ind_obj]== *tab[ind_obj_next]){
			if(!parenthese){
			tab[ind_obj]->_name = "("+tab[ind_obj]->_name+IntToString(tab[ind_obj]->Get_Size());
			parenthese = true;
			}
 
			tab[ind_obj]->_name+="=";
			tab[ind_obj]->_name+=tab[ind_obj_next]->_name;
			//if(!(tab[ind_obj]->IsTemplate()))
			tab[ind_obj]->_name+=IntToString(tab[ind_obj_next]->Get_Size());
			tab.erase(tab.begin()+ind_obj_next);
			ind_obj_next--;
			tab[ind_obj]->Set_Template(true);		
		}
 
	ind_obj_next++;	
	}
 
 
	if(parenthese){
	tab[ind_obj]->_name+=")";
	}
ind_obj++;
}
 
/*******************************Affichage*************************/
 
for(int i= 0; i< tab.size();i++){
  if(tab[i]->IsTemplate())
  cout<<tab[i]->Get_Name()<<"\t"<<" est un template object"<<"\n";
  else
  cout<<tab[i]->Get_Name()<<"\t"<<" n'est pas un template object"<<"\n";
}
 
/******************************Nombre des objets final***********/
cout << "Taille du vecteur d'objets: " << tab.size()<<"\n";
if (tab.size()==1){
cout<<"La Chaine Construite est :"<<tab[0]->Get_Name()<<"\n";
return (tab[0]);
}
 
//goto backtrack;
 
/*****************************Recherche de l'objet Q*************/
Object* Q = Get_Q(tab);
cout<<"L'objet Q est :"<< Q->Get_Name()<<"\n";
 
/************************** Recherche de N **********************/
Object* N = NULL;
for (int k = 0; k < tab.size(); k++){
	if((tab[k]->Get_Min() < Q->Get_Min()) || ((tab[k]->Get_Min() == Q->Get_Min()) && (tab[k]->Get_Max() > Q->Get_Max()))){
  /* On a trouvé un former Object */
        if(N == NULL){
  	N = tab[k];
	position_N = k;
	}
	else{
  	if((tab[k]->Get_Min() >= N->Get_Min()) || (tab[k]-> Get_Min() == N->Get_Min()) && (tab[k]->Get_Max()) < (N->Get_Max())){
  /* On a trouvé un N, mais est-ce le meilleur ?? */
  	N = tab[k];
	position_N = k;
  	}
	}
	}
}
 
 
 
cout<<"L'objet N est :"<< N -> Get_Name()<<"\n";
/************Représentation des N et Q et les opérateurs spatiaux***************/
if(Q->IsTemplate())
cout<<"L'objet Q est un template"<<"\n";
 
if(N->IsTemplate())
cout<<"L'objet N est un template"<<"\n";
 
/******************************Opérateur [ ************************************/
Z_String = "("+N->Get_Name();
if (*N <= *Q){
if(!(N->IsTemplate()))
Z_String+=IntToString(N->Get_Size());
Z_String+="[";
Q->Set_Max(N->Get_Max());
}
 
/****************************Opérateur ] ***************************************/
 
if (*N >= *Q){
if(!(N->IsTemplate()))
Z_String+=IntToString(N->Get_Size());
Z_String+="]";
Q->Set_Min(N->Get_Min());
}
 
/**************************Opérateur / ****************************************/
int distance_slach;
if (*N / *Q){
distance_slach = N->Get_Max() - Q->Get_Min();
if(!(N->IsTemplate()))
Z_String+=IntToString(N->Get_Size());
Z_String+="/";
Z_String+=IntToString(distance_slach);
Q->Set_Min(N->Get_Min());
}
 
/*************************Opérateur < ******************************************/
int distance_inf;
if (*N < *Q){
distance_inf = Q->Get_Min() - N->Get_Max();
if(!(N->IsTemplate()))
Z_String+=IntToString(N->Get_Size());
Z_String+="<";
Z_String+=IntToString(distance_inf);
Q->Set_Min(N->Get_Min());
}
 
/*************************Opérateur | ****************************************/
if (*N | *Q){
Z_String = "("+N->Get_Name();
if(!(N->IsTemplate()))
Z_String+=IntToString(N->Get_Size());
Z_String+="|";
Q->Set_Min(N->Get_Min());
}
 
/***********************Opérateur % *****************************************/
int distance_pourcent;
if (*N % *Q){
distance_pourcent = Q->Get_Min() - N->Get_Min();
if(!(N->IsTemplate()))
Z_String+=IntToString(N->Get_Size());
Z_String+="%";
Z_String+=IntToString(distance_pourcent);
Q->Set_Min(N->Get_Min());
Q->Set_Max(N->Get_Max());
}
 
Z_String+=Q->Get_Name();
if(!(Q->IsTemplate()))
Z_String+=IntToString(Q->Get_Size());
Z_String+=")";
cout<<Z_String<<"\n";
 
/********************** MISE A JOUR de Q ************************************/
Q->Set_Name(Z_String);
cout<<"L'objet Q est :"<<Q->Get_Name()<<"\n";
Q->Set_Template(true);
tab.erase(tab.begin()+position_N);
if (tab.size()==1){
cout<<"La Chaine Construite est :"<<tab[0]->Get_Name()<<"\n";
return (Q);
}
else
return Template_Object_Generation(tab);
}
 
 
/********************Récupérer l'objet en intersection partielle avec l'objet dominnat courant**********/
Object* Get_P(vector<Object*>table_objects){
 Object* OD = table_objects.front(); 
 Object *P=NULL;
 for (int k=1; k<table_objects.size(); k++){
 if(P==NULL){
 if(*OD / *table_objects[k]){
 /*************On Obtient au moins un objet mais est ce le meilleur??????P*******************************/
 P = table_objects[k];
 }
 }
 else{
 /********************Le meilleur Objet en / avec l'objet dominant qui possède le Xmax le plus petit*******/
 if ((*OD / *table_objects[k])&&(table_objects[k]->Get_Max() <= P->Get_Max())){
 P = table_objects[k];
 }
 }
 }
 if (P==NULL)
 cout<<"Pas d'objets en intersection partielle avec l'objet dominant :"<<OD->Get_Name()<<endl;
 else
 cout<<"L'objet en intersection partielle avec "<<OD->Get_Name()<<" est :" <<P->Get_Name()<<endl;
 return P;
 }
 
 
vector<Object*> Get_Objects_Coverd_P(vector<Object*>table_objects, Object* P){
vector<Object*>Template_Object_Covered_P; 
Object* OD;
int ind_p;
/***********************************Recherche de l'objet dominant*********************************************************/
OD = table_objects.front();   
cout <<"L'objet dominant est : "<<OD ->Get_Name()<<endl; 
 
/*************************Recherche des objets couverts par l'objet P ****************************************************/ 
/**************************On cherche dans la liste initiale**************************************************************/
Template_Object_Covered_P.clear();
for(ind_p=1;ind_p<table_objects.size();ind_p++){
if((table_objects[ind_p]->Get_Min()>=P->Get_Min())&&(table_objects[ind_p]->Get_Max()<=P->Get_Max())){
Template_Object_Covered_P.push_back(table_objects[ind_p]);
table_objects.erase(remove(table_objects.begin(), table_objects.end(),table_objects[ind_p] ),table_objects.end());
}
}
return Template_Object_Covered_P;
}
 
 /*************************************STRING GRNERATION****************************************************************/
string String_Generation(vector<Object*>table_objects){
vector<Object*>Template_Object_Covered_P; 
vector<Object*>Template_Object_Covered_Template;
vector<Object*>Template_Object_Covered_D; 
vector<Object*>Template;
Object* OD;
Object* P;
Object* T1;
Object* T2;
Object* T;
Object* Template_Object;
Object* Template_final;
string Chaine_Z;
int distance_slach;
int ind_D;
int ind_p;
int c;
int y;
int s;
int a;
 
/**************************************Tri des objets selon leurs Xmax****************************************************/
sort(table_objects.begin(), table_objects.end(),MaxPtrCompare);
cout << "Vecteur trié selon le max des objets :" << endl;
for(vector<Object*>::iterator it = table_objects.begin(); it != table_objects.end(); it++)
cout <<(*it)->Get_Name() <<"\t"<< (*it)->Get_Min() <<"\t"<<(*it)->Get_Max() <<endl;
cout << endl;
 
 
do{
 
/***********************************Recherche de l'objet dominant*********************************************************/
OD = table_objects.front();   
cout <<"L'objet dominant est : "<<OD ->Get_Name()<<endl; 
 
/***************************************Recherche d'un objet en intersection partielle avec l'objet dominant**************/ 
P = Get_P(table_objects);
 
/*************************Recherche des objets couverts par l'objet P ****************************************************/ 
if(P!=NULL){
/**************************On cherche dans la liste initiale**************************************************************/
Template_Object_Covered_P = Get_Objects_Coverd_P(table_objects,P);          //Quand je fais l'appel ici ,résultat faux par contre si j'utilise pas une méthode ça marche nickel ,les objets s'effacent
 
 
 
/***************************On cherche dans la liste des Template Objects*************************************************/
//Template_Object_Covered_Template = Get_Objects_Coverd_P(Template);
 
cout<<"les objets couverts par P sont :";
for(y=0;y<Template_Object_Covered_P.size();y++)
cout<<Template_Object_Covered_P[y]->Get_Name()<<"\t";
cout<<endl;
 
/***********************************Construction de T1*******************************************************************/
T1=Template_Object_Generation(Template_Object_Covered_P);
cout<<"T1  :"<<T1->Get_Name()<<endl;
 
 
/*************************Recherche des objets couverts par l'objet dominant*********************************************/ 
cout<<"Contenu de Table Objects après T1 est :"<<endl;
for(s=0;s<table_objects.size();s++)
cout<<table_objects[s]->Get_Name()<<"\t";
cout<<endl;
cout<<"Contenu de Template "<<endl;
for(a=0;a<Template.size();a++){
cout<<Template[a]->Get_Name()<<"\t";
cout<<endl;
}
/**************************On cherche dans la liste initiale**************************************************************/
Template_Object_Covered_D.clear();
for(ind_D=0;ind_D<table_objects.size();ind_D++){
if((table_objects[ind_D]->Get_Min()>=P->Get_Min())&&(table_objects[ind_D]->Get_Max()<=P->Get_Max()))
continue;
if((table_objects[ind_D]->Get_Min()>=OD->Get_Min())&&(table_objects[ind_D]->Get_Max()<=OD->Get_Max())){
Template_Object_Covered_D.push_back(table_objects[ind_D]);
table_objects.erase(table_objects.begin()+ind_D);
ind_D--;
}
}
/***************************On cherche dans la liste des Template Objects*************************************************/
for(c=0;c<Template.size();c++){
if((Template[c]->Get_Min()>=OD->Get_Min())&&(Template[c]->Get_Max()<=OD->Get_Max())){
Template_Object_Covered_D.push_back(Template[c]);
Template.erase(Template.begin()+c);
c--;
}
}
cout<<"les objets couverts par l'Objet Dominant sont :"<<endl;
for(y=0;y<Template_Object_Covered_D.size();y++)
cout<<Template_Object_Covered_D[y]->Get_Name()<<"\t";
cout<<endl;
 
/***********************************Construction de T2*******************************************************************/
T2=Template_Object_Generation(Template_Object_Covered_D);
cout<<"T2  :"<<T2->Get_Name()<<endl; 
 
/*******************Fusion de T1 et T2 àl'aide de l'opérateur / avec la distance associée et ( )****************************/
distance_slach = T2->Get_Max() - T1->Get_Min();
if(Template_Object_Covered_P.size()==1)
Chaine_Z = "("+T2->Get_Name()+"/"+IntToString(distance_slach)+T1->Get_Name()+IntToString(T1->Get_Size())+")";
if(Template_Object_Covered_D.size()==1)
Chaine_Z = "("+T2->Get_Name()+IntToString(T2->Get_Size())+"/"+IntToString(distance_slach)+T1->Get_Name()+")";
if((Template_Object_Covered_P.size()==1)&&(Template_Object_Covered_D.size()==1)){
Chaine_Z = "("+T2->Get_Name()+IntToString(T2->Get_Size())+"/"+IntToString(distance_slach)+T1->Get_Name()+IntToString(T1->Get_Size())+")";
}
else
Chaine_Z = "("+T2->Get_Name()+"/"+IntToString(distance_slach)+T1->Get_Name()+")";
cout<<Chaine_Z<<endl;
 
/*********************Construction d'un nouveau Template Object qui sera inséré dans Template***********************/
Template_Object=new Object(Chaine_Z,T2->Get_Min(),T1->Get_Max(),true);
Template.push_back(Template_Object);
 
cout<<"Contenu de Template "<<endl;
for(a=0;a<Template.size();a++){
cout<<Template[a]->Get_Name()<<"\t";
cout<<endl;
}
 
}
 
else{
/*************En cas d'absence d' / ,on récupère les objets couverts par l'objet dominant***************************/
Template_Object_Covered_D.clear();
for(ind_D=0;ind_D<table_objects.size();ind_D++){
if((table_objects[ind_D]->Get_Min()>=OD->Get_Min())&&(table_objects[ind_D]->Get_Max()<=OD->Get_Max())){
Template_Object_Covered_D.push_back(table_objects[ind_D]);
table_objects.erase(table_objects.begin()+ind_D);
ind_D--;
}
}
for(c=0;c<Template.size();c++){
if((Template[c]->Get_Min()>=OD->Get_Min())&&(Template[c]->Get_Max()<=OD->Get_Max())){
Template_Object_Covered_D.push_back(Template[c]);
Template.erase(Template.begin()+c);
c--;
}
}
 
cout<<"les objets couverts par l'Objet Dominant sont :"<<endl;
for(y=0;y<Template_Object_Covered_D.size();y++)
cout<<Template_Object_Covered_D[y]->Get_Name()<<"\t";
cout<<endl;
 
T=Template_Object_Generation(Template_Object_Covered_D);
Template_Object=new Object(T->Get_Name(),T->Get_Min(),T->Get_Max(),true);
Template.push_back(Template_Object);
cout<<"T  :"<<T->Get_Name()<<endl; 
cout<<"Taille actuelle de table_objects est :"<<table_objects.size()<<endl;
 
cout<<"Contenu de Template "<<endl;
for(a=0;a<Template.size();a++){
cout<<Template[a]->Get_Name()<<"\t";
cout<<endl;
}
 
}
 
}
/***************On répète tant qu'il n'existe plus d'objets dans la liste initiale***********************************/
while(table_objects.size()!=0);
 
cout<<"Contenu de Template "<<endl;
for(a=0;a<Template.size();a++){
cout<<Template[a]->Get_Name()<<"\t";
cout<<endl;
}
 
if(Template.size()==1)
return(Template[0]->Get_Name());
else{
Object* Template_final=Template_Object_Generation(Template);
return Template_final->Get_Name();
}
}
 
 
/******************************************************MAIN********************************************************/
int main()
{
  char fileName [LGMAX_FILE_NAME + 1] ;
  string name;
  int min, max;
  bool istemplate;
  int nb_objects=0;
  int i;
  string Z_String ;
  vector<Object*> table_objects;
 
 
  /**************Lecture des informations dans le fichier qui contient les noms des objets leurs Xmin et leurs Xmax************/
  cout << "name of the file : " ;
  cin >> setw (LGMAX_FILE_NAME) >> fileName ;
  ifstream entree (fileName, ios::in|ios::binary) ;   // ou ios::in
  if (!entree) { cout << "Error: can not open the file " << fileName <<endl ;
                 exit (-1) ;
               }
 
  while(!entree.eof())
  {
  	entree >> name;
  	entree >> min;
  	entree >> max;
	if(name == "*") break;
	else
  	cout << "name: " << name << " min: " << min << " max: " << max << endl ;
	table_objects.push_back(new Object(name,min,max,false));
  	nb_objects++;
  }
 
  entree.close () ;
  cout << "**************************************************************\n";
  cout << " Voici les noms, les min, les max des objets de votre image \n";
  cout << "**************************************************************\n";
  cout << "Nb objects: " << nb_objects << endl;
 
 
for(i= 0; i< nb_objects;i++){
  cout<<table_objects[i]->Get_Name()<<"\t"<<table_objects[i]->Get_Min()<<"\t"<<table_objects[i]->Get_Max()<<"\n";
}
cout << "Taille du vecteur d'objets: " << table_objects.size()<<"\n";
 
Z_String = String_Generation(table_objects);
cout<<"2D Z U String est :"<<Z_String<<endl;
 
}

Object.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
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
 
#include <iostream>
#include <string>
#include <vector>
#include <cstdlib>                    
#include <fstream>
#include <sstream>
#include <algorithm>
#include <iterator>
#include <iomanip>
using namespace std;
 
const int LGMAX_FILE_NAME = 20 ;
 
class Object {
public:
       string _name;
       int _min, _max;
       bool _istemplate;
 
public:
     	Object(string name, int min, int max, bool istemplate);
 
	int operator <= (Object &Q){
	if ((_min == Q._min)&&(_max > Q._max))
	return 1;
	else
	return 0;
	}
 
	int operator >= (Object &Q){
	if ((_max == Q._max)&&(_min < Q._min))
	return 1;
	else
	return 0;
	}
 
	int operator / (Object &Q){
	if ((_min < Q._min)&&(Q._min < _max)&&(_max < Q._max))
	return 1;
	else
	return 0;
	}
 
	int operator < (Object &Q){
	if (_max < Q._min)
	return 1;
	else
	return 0;
	}
 
	int operator | (Object &Q){
	if (_max == Q._min)
	return 1;
	else
	return 0;
	}
 
	int operator % (Object &Q){
	if (_max > Q._max)
	return 1;
	else
	return 0;
	}
 
	int operator == (Object &Q){
	if ((_min == Q._min) && (_max == Q._max))
	return 1;
	else
	return 0;
	}
 
 
      void Set_Name(string name){
      _name = name;
      }
 
      string Get_Name(){
      return _name;
      }
 
      void Set_Min(int min){
      _min = min;
      }
 
      int Get_Min(){
      return _min;
      }
 
      void Set_Max(int max){
      _max = max;
      }
 
      int Get_Max(){
      return _max;
      }
 
      bool IsTemplate(){
      return _istemplate;
      }
 
      void Set_Template(bool istemplate){
      _istemplate = istemplate;
      }
 
      int Get_Size(){
      return (_max - _min);
      }  
 
};

Citation:

Envoyé par coyotte507

Code:

for(ind_p=1;ind_p<table.size();ind_p++)

C'est normal que tu commences pas à 0?

oui je sais, c'est exprès que je commence par 1, car l'objet situé à l'indice 0 ne fait pas partie des objets cherchés

dsl je viens de me rendre compte du problème.

Dans ta fonction tu passe la table en statique:

Code:

vector<Object*> Get_Objects_Coverd_P(vector<Object*> table)

L'objet n'est donc pas affecté.

Il faut faire:

Code:

vector<Object*> Get_Objects_Coverd_P(vector<Object*> &table)

avec le signe '&'.

Pas besoin de changer quoi que ce soit d'autre

c'est comme avec ce code:
Code:

1 2 3 4 5 6 7 8 9 10 11 void mafonction (int i) { i = 3; } int (main) { int i = 0; mafonction(i); //i n'a pas bougé!! }
Code:

1 2 3 4 5 6 7 8 9 10 11 void mafonction (int &i) { i = 3; } int (main) { int i = 0; mafonction(i); //i a bougé!! }

Citation:
Envoyé par coyotte507
dsl je viens de me rendre compte du problème.

Dans ta fonction tu passe la table en statique:

Code:

vector<Object*> Get_Objects_Coverd_P(vector<Object*> table)

L'objet n'est donc pas affecté.

Il faut faire:

Code:

vector<Object*> Get_Objects_Coverd_P(vector<Object*> &table)

avec le signe '&'.

Pas besoin de changer quoi que ce soit d'autre

c'est comme avec ce code:
Code:

1 2 3 4 5 6 7 8 9 10 11 void mafonction (int i) { i = 3; } int (main) { int i = 0; mafonction(i); //i n'a pas bougé!! }
Code:

1 2 3 4 5 6 7 8 9 10 11 void mafonction (int &i) { i = 3; } int (main) { int i = 0; mafonction(i); //i a bougé!! }
Je te remercie beaucoooooouup
c gentil
Bon courage