Discussion :

[Thordax]

Hello tout le monde, je me heurte à un problème (sans doute des plus banals) :

lorsque je lance mon programme, celui-ci plante dans une boucle while, voici le code du main :

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
 
while(index !=0){			
trame_SDU.set_SDU(F1.getSDU(index));
 
string temps = trame_SDU.getTimestamp(index);
bool val = trame_SDU.trame_avec_PDU(index_PDU);
 
 
 
PDU trame_PDU;
trame_PDU.set_PDU(trame_SDU.getPDU(index_PDU));
vector<int> resultat_test_trame = trame_PDU.calc_MCMPLP(errpar, ent_mux);
 
if(resultat_test_trame[0]==0){
PDU_controle PDUC;
PDUC.set_PDU(trame_PDU.get_PDU());
PDUC.stockage_C(index_PDUC);
cout << endl<<"taille PDU : " << PDUC.get_PDU().size()/2<<endl;
cout << "index : " << index << endl;
}

Mon avis est que l'erreur provient du fait que je ne détruis pas mes objets, j'ai donc créé un destructeur dans mes classes SDU et PDU, de la manière suivante :

Code :

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

1
2
 
SDU::~SDU(){delete contenu_SDU;}

d'une part il semble que je ne puisse pas vider le contenu d'une string par la commande delete, et d'autre part, il semble que l'appel du destructeur ne résolve pas le probleme.

Pensez vous que le problème vienne d'ailleurs ? Un programme qui plante en milieu d'exécution, cela peut etre du à quoi autrement ? pointage vers "le vide" ?

Merci pour vos réponses ! si vous avez besoin du reste du code, demandez le moi, je l'afficherai !

[hegros]

Je ne pourrais pas répondre directement mais peut être qu'en essayant d'attraper certaines exceptions tu puisses avoir une piste plus précise du probléme. Récupérer l'exception la plus basse ( ca se dit ?)

[Thordax]

d'attraper certaines exceptions

qu'entends tu par la ?

mon problème est apparu des que j'ai appliqué un while, sans la boucle while, tout fonctionne bien, si cela peut aider

[vincedom]

Bonjour


Je comprend pas trop ton code ?
Quand tu sors de la boucle ? Quand tu change la valeur de l'index ?

[hegros]

d'attraper certaines exceptions

qu'entends tu par la ?

mon problème est apparu des que j'ai appliqué un while, sans la boucle while, tout fonctionne bien, si cela peut aider

Regarde dans la Faq il me semble qu'il en parle bien.

[Thordax]

en fait je ne le fais pas pour l'instant, je ne suis qu'aux prémices du balayage du fichier, je décale l'index dans les fonctions (par le biais de l'appel de &index en paramètre de la fonction).

le programme effectue le début du balayage et décale effectivement l'index, mais au bout d'une dizaine de décalages d'index, le programme s'arrete brutalement ...

[hegros]

Tu as bien un message quelque chose qui t'indique la sortie brutale du programme non ? Un message d'erreur explicite je veux dire..

[Thordax]

La console me renvoie ce message (imprécis malheureusement) :

"This application has requested the Runtime to terminate it in an unusual way. Please contact the application's support team for more information."

[bigboomshakala]

salut,

et en debug avec des points d'arrêt et/ou des traces ?

[Thordax]

apres un peu plus de recherche, il semble que mon probleme vienne de cette méthode (certes consistante !) :

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
 
std::vector<int> PDU::calc_MCMPLP(int &errpar, std::vector<int> &ent_mux){
//incremente les erreurs de parite dans errpar
//incremente la valeur correspondante a la table de multiplexage utilisee
std::vector<int> resultat;resultat.resize(2);
 
std::vector<std::string> header;header.resize(6);
for (int i = 0 ; i < 6 ; i++){
header[i] = contenu_PDU.substr(i+4,1);
}
 
std::vector<int> x; x.resize(6);
for(int j=0 ; j < 6 ; j++){
std::istringstream iss( header[j] ); 
iss >> std::hex >> x[j];}
 
//Conversion                                           //
std::bitset<4> et1a( x[0] );
std::bitset<4> et1b( x[1] );
std::bitset<4> et2a( x[2] );
std::bitset<4> et2b( x[3] );
std::bitset<4> et3a( x[4] );
std::bitset<4> et3b( x[5] );
 
std::vector<int> et1;et1.resize(8);
std::vector<int> et2;et2.resize(8);
std::vector<int> et3;et3.resize(8);
 
et1[0]=et1b[0];et1[1]=et1b[1];et1[2]=et1b[2];et1[3]=et1b[3];
et1[4]=et1a[0];et1[5]=et1a[1];et1[6]=et1a[2];et1[7]=et1a[3];
 
et2[0]=et2b[0];et2[1]=et2b[1];et2[2]=et2b[2];et2[3]=et2b[3];
et2[4]=et2a[0];et2[5]=et2a[1];et2[6]=et2a[2];et2[7]=et2a[3];
 
et3[0]=et3b[0];et3[1]=et3b[1];et3[2]=et3b[2];et3[3]=et3b[3];
et3[4]=et3a[0];et3[5]=et3a[1];et3[6]=et3a[2];et3[7]=et3a[3];
//Conversion effectuee                                 //
 
 
//RECUPERER MC
std::vector<int> mc;
  mc.resize(4);
  mc[0]=et1[0];
  mc[1]=et1[1];
  mc[2]=et1[2];
  mc[3]=et1[3];
 
 
//RECUPERER MPL
std::vector<int> mpl;
  mpl.resize(8);
  mpl[0]=et1[4];
  mpl[1]=et1[5];
  mpl[2]=et1[6];
  mpl[3]=et1[7];
  mpl[4]=et2[0];
  mpl[5]=et2[1];
  mpl[6]=et2[2];
  mpl[7]=et2[3];
 
int temp=0;
//TESTER LA PARITE
int P[12],i,test=0; //initialisation du polynome generateur en fonction des mpl et mc
P[0]=(mc[0]+mc[1]+mc[2]+mc[3]+mpl[0]+mpl[3]+mpl[6]);
P[1]=mc[1]+mc[2]+mc[3]+mpl[0]+mpl[1]+mpl[4]+mpl[7];
P[2]=mc[0]+mc[1]+mpl[1]+mpl[2]+mpl[3]+mpl[5]+mpl[6];
P[3]=mc[1]+mc[2]+mpl[2]+mpl[3]+mpl[4]+mpl[6]+mpl[7];
P[4]=mc[0]+mc[1]+mpl[0]+mpl[5]+mpl[6]+mpl[7];
P[5]=mc[0]+mc[3]+mpl[0]+mpl[1]+mpl[3]+mpl[4]+mpl[5]+mpl[7];
P[6]=mc[0]+mc[2]+mc[3]+mpl[1]+mpl[2]+mpl[3]+mpl[4];
P[7]=mc[1]+mc[3]+mpl[0]+mpl[2]+mpl[3]+mpl[4]+mpl[5];
P[8]=mc[2]+mpl[0]+mpl[1]+mpl[3]+mpl[4]+mpl[5]+mpl[6];
P[9]=mc[3]+mpl[1]+mpl[2]+mpl[4]+mpl[5]+mpl[6]+mpl[7];
P[10]=mc[0]+mc[1]+mc[2]+mc[3]+mpl[2]+mpl[5]+mpl[7];
P[11]=mc[0]+mc[2]+mpl[0]+mpl[1]+mpl[2]+mpl[6]+mpl[7];
for(i=0;i<12;i++){P[i]%=2;} //passage en binaire
if((et3[7]==P[11])&&(et3[6]==P[10])&&(et3[5]==P[9])&&(et3[4]==P[8])&&(et3[3]==P[7])&&(et3[2]==P[6])&&(et3[1]==P[5])&&(et3[0]==P[4])&&(et2[7]==P[3])&&(et2[6]==P[2])&&(et2[5]==P[1])&&(et2[4]==P[0]))
{test = 1;
ent_mux[ mc[3]*8+mc[2]*4+mc[1]*2+mc[0] ] ++;
}
//test de la parité, si vrai, on renvoie 1 et on incremente la valeur accedee au tableau de mux
 
else{test = 0;errpar++;}
//sinon on revoie 0 et on incremente errpar
 
resultat[0] = mc[3]*8+mc[2]*4+mc[1]*2+mc[0];
resultat[1] = mpl[7]*128+mpl[6]*64+mpl[5]*32+mpl[4]*16+mpl[3]*8+mpl[2]*4+mpl[1]*2+mpl[0];
resultat[2] = test;
 
//La methode renvoie en premier element l'entree dans la table de multiplexage
//					 en deuxieme element la taille de la payload
//					 en troisieme element le resultat de la parite
 
return resultat;
}

Y voyez vous quelque chose de completement aberrant ?
je vais essayer de voir d'un peu plus pret ou ca coince ..

[Luc Hermitte]

Comme d'hab: problème minimal et complet qui permette de reproduire à coups sûr le problème.

Pour l'instant, je dirais que cela sens la mauvaise définition des opérations de recopie pour une classe qui doit être copiable et qui est responsable d'une ressource (et donc problème classique de la double destruction et autres dangling pointers)
(Je suis très méfiant de tous ces set et get PDU dont on ne connait rien des prototypes et des actions réalisées.)

PS: une std::string se libère d'elle même.