probleme de segmentation

**leconteconte** · 03/10/2011, 22h43

Bonsoir s'il vous plait jeter un peu un coup d'oeil sur mon code ci-dessous et me dites ou je plante parce j'ai le message ci dessous à l’exécution du programme généré

Code :

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

1
2
3
 
PROGRAMME DE TEST
Erreur de segmentation

et voila mes trois fichier

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
 
 
/***********************************CLIENT.CC*********************************************/
// Include de l'application
#include "Vecteur.h"
 
int main(int argc, char **argv)
{
 
	cout << "PROGRAMME DE TEST" << endl;
 
	// Constructeurs
	vecteur v1(3);
	vecteur v2 = v1;
	vecteur v3;
 
	v1[0] = 2;
	v1[1] = 4;
	v1[2] = 6;
	cout << "v1 :	" << v1 << endl;
 
	v2 = v1;
	cout << "v2 = v1 :	" << v2 << endl;
 
	v2++;
	cout << "v2++ :	" << v2 << endl;
 
	v3 = v1 + v2;
	cout << "v3 = v1 + v2 :	" << v3 << endl;
 
 
	cout << "SORTIE TEST" << endl;
}

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
 
 
/*******************************************VECTEUR.CC******************************************/
// Type vecteur
#include "Vecteur.h"
 
// Constructeurs
vecteur::vecteur(){taille=0; tab=NULL;}
vecteur::vecteur(int){}
 
vecteur::vecteur(const vecteur& m_v){
	this->taille=m_v.taille;
	this->tab = new int [this->taille];
	for(int i=0;i<=this->taille;i++){
		this->tab[i]=m_v.tab[i];
	}
}
 
 
// Destructeur
vecteur::~vecteur(){
	delete [] this->tab;
}
 
// Nombre d'elements
//int vecteur::longueur(void)
//{
//}
 
// Acces aux elements
int& vecteur::operator[](int i)
{
	for( i=0; i<=this->taille;i++)
	{
		return this->tab[i];
	}
}
 
// affectation : =(vecteur), =(int)
vecteur& vecteur::operator=(const vecteur& m_v){
	this->taille = m_v.taille;
	delete [] this->tab;
	this->tab = new int [ this->taille];
	for(int i=0;i<=m_v.taille;i++){
		this->tab[i] = m_v.tab[i];
	}
	return *this;
}
// incrementation/decr. : ++, ++(int), --
 
vecteur& vecteur::operator++(){
 
	for (int i;i<=this->taille;i++){
	this->tab[i]+=1;
	}
	return *this;
}
 
vecteur vecteur::operator++(int){
	vecteur rec(*this);
	for(int i=0;i<=this->taille;i++)
	{
		this->tab[i]+=1;
	}
	return rec;
}
// op. booleens : ==, <, >, <=, >=
bool vecteur::operator==(const vecteur& m_v){
	for (int i =0;i<=this->taille;i++){
		return this->tab[i]==m_v.tab[i];
	}
}
 
bool vecteur::operator<(const vecteur& m_v){
	for (int i =0; i<=this->taille; i++){
		return this->tab[i]<m_v.tab[i];
	}
}
 
bool vecteur::operator>(const vecteur& m_v){
	for (int i=0; i<=this->taille;i++){
		return this->tab[i]>m_v.tab[i];
	}
}
 
bool vecteur::operator<=(const vecteur& m_v){
	for (int i =0; i<=this->taille; i++){
		return this->tab[i]<=m_v.tab[i];
	}
}
bool vecteur::operator>=(const vecteur& m_v){
	for (int i=0; i<=this->taille;i++){
		return this->tab[i]>=m_v.tab[i];
	}
}
 
// op. binaires : +, -
vecteur& vecteur::operator+(const vecteur& m_v){
	for (int i=0; i<=this->taille; i++){
		this->tab[i]+=m_v.tab[i];}
}
vecteur& vecteur::operator-(const vecteur& m_v){
	for (int i=0; i<=this->taille; i++){
		this->tab[i]-=m_v.tab[i];}
}
 
 
 
// produit scalaire : *
 
vecteur& vecteur::operator*(const vecteur& m_v){
	for (int i=0; i<=this->taille; i++){
		this->tab[i]*=m_v.tab[i];}
}
 
 
 
// produit par un scalaire: n * v, v * n
/*vecteur& vecteur::operatorµ(const vecteur& m_v, int n){	
	for (int i=0; i<=this->taille; i++){
		this->tab[i] = this->tab[i]*n;}
}*/
 
 
// auto-adition : +=, -=
 
// Operateurs d'entree/sortie: <<, >>
ostream& operator<< (ostream& o, vecteur& a)
{
	return o;
}
 
istream& operator>> (istream& i, vecteur& a)
{
	return i;
}

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
 
/***************************************VECTEUR.H**********************************************/
 
#ifndef VECTEUR_H
#define VECTEUR_H
//
// Type vecteur
//
#include <iostream>
 
using namespace std;
 
//
// Type vecteur de int
//
class vecteur
{
private:
	int taille;
	int * tab;
 
public:
 
// Constructeurs par defaut(void) , avec la taille du vect.(int), par copie(vecteur&)
vecteur(int);
vecteur();
//vecteur(int tail);
vecteur(const vecteur&);
 
// Destructeur
~vecteur();
 
// Acces a la taille du vecteur
//int longueur(void);
//int longeur();
 
// acces au element []
//int& operator[](int);
int& operator[](int);
 
// affectation : =(vecteur), =(int)
vecteur& operator=(const vecteur& m_v);
// incrementation/decr. : ++(void), ++(int), --(void)
vecteur& operator++();
vecteur	 operator++(int);
vecteur& operator--();
// op. booleens : ==(vecteur&), <, >, <=, >=
bool operator==(const vecteur& m_v);
bool operator<(const vecteur& m_v);
bool operator>(const vecteur& m_v);
bool operator<=(const vecteur& m_v);
bool operator>=(const vecteur& m_v);
// op. binaires : +(vecteur&), -
vecteur& operator+(const vecteur& m_v);
vecteur& operator-(const vecteur& m_v);
//vecteur& operatorµ(const vecteur& m_v ,int n);
 
// produit scalaire: *(vecteur&)
vecteur& operator*(const vecteur& m_v);
// produit par un scalaire: v * n, n * v
//vecteur operator*(int);
vecteur& operator*(int);
//friend vecteur operator*(int, vecteur&);
 
// auto-adition : +=(vecteur&), -=
vecteur& operator+=(const vecteur& m_v);
vecteur& operator-=(const vecteur& m_v);
// Operateurs d'entree/sortie: <<, >>
friend ostream& operator<< (ostream&, vecteur&);
friend istream& operator>> (istream&, vecteur&);
 
};
 
#endif // VECTEUR_H

merci d'avance

**Steph_ng8** · 03/10/2011, 23h17

Salut !

Je n'ai pas beaucoup de temps, alors je me contenterai de t'indiquer comment résoudre ton problème.

Code :

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

vecteur::vecteur(int) {}

Il est joli ton constructeur, sauf qu'il ne fait rien.
Mais alors rien du tout.
Il n'initialise pas le champ censé contenir la taille du vecteur, et alloue encore moins l'espace mémoire nécessaire.

Ce qui fait que quand, plus tard, tu essaies d'accéder à un élément du tableau, en interne ça pointe sur une zone indéterminée.
Par exemple, une zone non valide (enfin c'est l'adresse qui n'est pas valide), soit une zone auquel tu n'es pas censé avoir accès.

Du coup, l'erreur de segmentation peut venir aléatoirement (mais a de grandes chances de survenir).

**leconteconte** · 03/10/2011, 23h28

j'ai initialisé le constructeur avec une taille=0 et un tab pointant sur NULL je ne sais pas si c'est ce qu'il y'a faire mais je ne pense pas car lorsque je compile j'ai ceci

Code :

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

1
2
3
4
5
6
 
PROGRAMME DE TEST
v1 :	
v2 = v1 :	
v2++ :	
Erreur de segmentation

Merci de ton aide

**Steph_ng8** · 03/10/2011, 23h39

Tu ne peux pas utiliser ton Vecteur si tu l'initialises avec une taille nulle et un tableau initialisé à NULL.

Code :

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

1
2
3
4
Vecteur::Vecteur(int taille) : taille(taille), tab(NULL)
{
    this->tab = new int[taille];
}

Bon, je te le dis tout de suite, c'est la solution à ton problème, mais ce code ouvre la porte à de grosses erreurs.
Si c'est un exercice, ok, on peut voir comment l'améliorer.
Mais autrement, tu aurais grandement avantage à utiliser std::vector<int> à la place.
Ce serait beaucoup plus sûr, et ce à tous les niveaux.

**leconteconte** · 03/10/2011, 23h50

en remplaçant par le code que tu as proposé j'ai les erreures ci-dessous . Effectivement c'est une TP-exercice

Code :

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

1
2
3
4
5
6
 
PROGRAMME DE TEST
v1 :	
v2 = v1 :	
tp: malloc.c:3097: sYSMALLOc: Assertion `(old_top == (((mbinptr) (((char *) &((av)->bins[((1) - 1) * 2])) - __builtin_offsetof (struct malloc_chunk, fd)))) && old_size == 0) || ((unsigned long) (old_size) >= (unsigned long)((((__builtin_offsetof (struct malloc_chunk, fd_nextsize))+((2 * (sizeof(size_t))) - 1)) & ~((2 * (sizeof(size_t))) - 1))) && ((old_top)->size & 0x1) && ((unsigned long)old_end & pagemask) == 0)' failed.
Abandon

Merci pour ton aide

**Steph_ng8** · 04/10/2011, 02h05

Personnellement, je n'ai jamais vu d'erreur de ce genre...

Tout ce qui me saute aux yeux à l'endroit de l'erreur, c'est que le code de tes opérateurs binaires + et - ressemble plutôt à ce qu'il faudrait écrire pour les opérateurs += et -=.
En fait, alors que ces opérations devraient créer un troisième Vecteur et laisser les deux autres inchangés, tu modifies directement l'un des deux.

L'erreur ne vient peut-être pas de là, mais je ne vois rien d'autre.

Au fait, si par hasard tu te demandais pour il n'y rien qui s'écrit au moment de tes affichages de test, je te répondrais que c'est normal, vu ta définition de l'opérateur <<...

probleme de segmentation

Langage C++

Vue hybride

Discussions similaires

Partager

Partager