Segmentation fault et non exécution de commandes
Bonjour à tous !
Mon premier langage étant le python (qui n'est pas une bête de course mais a ses avantages), je me tourne maintenant vers le C++. J'ai la plupart des notions de bases même s'il me manque l'habitude et certains réflexes. Je développe avec Code::blocks et depuis quelques jours je m'arrache les cheveux sur un programme sensé être simple mais qui fait que de planter pour... je ne sais pas quoi justement. J'ai tenté plusieurs fois de compiler le code, ça marche, mais à plusieurs jours d'intervalle et avec un code identique, des fois ça bogait, des fois non, et pas toujours au même endroit du programme... (le casse tête quoi) Quand j'utilise le débogeur, il me dit "segmentation fault" (c'est ce que j'ai eu quelle que soit la ligne de l'erreur). Pourtant je n'utilise pas de pointeurs et je ne dépasse normalement pas la taille de mes tableaux.
Mais maintenant, le code : son but était de tester les performances du C++ par rapport au python pour ce qui est d'enlever le fond d'une image. Je ne me suis pas embêté à installer une bibliothèque qui capture les images de ma webcam, alors je génère aléatoirement des tableaux d'int sensés représenter l'image en niveaux de gris. J'avais rajouté quelques variables telles que verify et d'autres tests pour essayer de comprendre ce qui clochait.
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
| #include <iostream>
#include <ctime>
#include <cstdlib>
#include <string>
#include <fstream>
using namespace std;
int main()
{
cout<<"1 : ok"<<endl;//juste pour montrer où en est rendu le programme
int taille = 640*480;//la "resolution de l'image"
int fichier_un[taille];//represente l'image a traiter
srand(time(0));
for (int i=0;i<taille;i++){//on genere aleatoirement l'image
fichier_un[i]= rand() % 256;
}
cout<<"2 : ok"<<endl;
int fichier_deux[taille];//ceci représente la fourchette haute pour chaque pixel
for (int i=0;i++;i<taille){
fichier_deux[i]= rand() % 256;
}
cout<<"52 : ok"<<endl;
int fichier_trois[taille];//et là la fourchette basse (qui doit être inférieure à la fourchette haute et donc non générée aléatoirement)
for (int i=0;i++;i<taille){
if (fichier_deux[i]>=20) {fichier_trois[i]= fichier_deux[i]-20;}
else fichier_trois[i]=0;
}
cout<<"3 : ok"<<endl;
//le traitement en lui-même
time_t debut,fin;
debut=time(NULL);
int TOLERANCE=50;
cout<<"4 : ok"<<endl;
unsigned long verify = 0;//pour vérifier que le traitement s'effectue
for (int r=0;r<1000;r++){//on va effectuer 1000 fois le même traitement, sinon il est trop rapide sinon le temps d'exécution sera de 0
for (int i=0;i<taille;i++)
{
if ( (fichier_deux[i]+TOLERANCE)>=fichier_un[i]>=(fichier_trois[i]-TOLERANCE)){//si le pixel est dans la fourchette + la tolérance, il fait partie du fond
fichier_un[i]=0;
verify++;//je le mets volontairement dans chaque condition car j'obtenais des trucs très bizarres en le mettant à la fin de la boucle for : c'est comme si les if, else if et else ne s'exécutaient pas
}
else if (fichier_deux[i]<fichier_un[i]){//sinon on donne pour valeur au pixel la différence avec la fourchette, donnant donc la probabilité qu'il ne fasse pas partie du fond
fichier_un[i]=fichier_un[i]-fichier_deux[i];
verify++;
}
else {
fichier_un[i]=fichier_trois[i]-fichier_un[i];
verify++;
}
//verify++
}
}
cout<<"640*480*1000 = "<<verify<<endl;//logiquement verify doit être égal à 640*480*1000 si le programme s'est exécuté correctement
cout<<"Fichier_un[10] = "<<fichier_un[10]<<endl;//un nombre au hasard pour voir ce qu'il en est
fin=time(NULL);
cout<<"Temps ecoule : "<<fin<<" - "<<debut<<endl;
return 0;
} |
Je vous serait très reconnaissant si vous pouviez un petit peu éclairer tout ceci car j'avoue que je n'y comprends absolument rien...
