probleme de segmentation

Version imprimable

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:

1
2
3
 
PROGRAMME DE TEST
Erreur de segmentation

et voila mes trois fichier

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
 
 
/***********************************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:

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:

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:cry::cry:

03/10/2011, 22h17
Steph_ng8

Salut !

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

Code:

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).

:)
03/10/2011, 22h28
leconteconte
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:

1 2 3 4 5 6 PROGRAMME DE TEST v1 : v2 = v1 : v2++ : Erreur de segmentation
Merci de ton aide:cry::cry:
03/10/2011, 22h39
Steph_ng8
Tu ne peux pas utiliser ton Vecteur si tu l'initialises avec une taille nulle et un tableau initialisé à NULL.
Code:

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.

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

Code:

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:cry::cry:

04/10/2011, 01h05
Steph_ng8

Personnellement, je n'ai jamais vu d'erreur de ce genre... 8O :?

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 <<...

j'ai modifié comme tu l'a demandé les operateur + et - mais l'erreur persiste

Code:

1
2
3
4
5
6
7
 
 
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

:cry::cry:

04/10/2011, 07h36
3DArchi

Toutes tes boucles ressemblent à

Code:

for (int i;i<=this->taille;i++){

Or les indices doivent explicitement aller de 0 à taille-1 :

Code:

for (int i=0;i<this->taille;++i){

P.S. :comme dit dans le fil de discussion précédent, tout ces opérateurs sont absurdes car ne signifient rien.
04/10/2011, 08h17
leconteconte
Merci tu avais raison en modifiant la boucle for le long message d'erreur bizarre a disparu mais je n'ai toujours pas le resultat escompté voila ce qui en ressort de l'execution
Code:

1 2 3 4 5 6 7 PROGRAMME DE TEST v1 : v2 = v1 : v2++ : v3 = v1 + v2 : SORTIE TEST
ET quand tu dis que mes constructeurs sont absurde franchement je ne comprends pas pourraois tu me proposer quelque chose?

Merci d'avance:cry::cry:
04/10/2011, 10h48
dragonjoker59
Autre chose, ton accesseur est faux :
Code:

1 2 3 4 5 6 7 int& vecteur::operator[](int i) { for( i=0; i<=this->taille;i++) { return this->tab[i]; } }
Que penses-tu que ça va faire ? Selon moi ça va retourner le premier élément de ton tableau quel que soit le i que tu passes.
Je pense plutôt que tu veux faire quelque chose du genre :
Code:

1 2 3 4 5 6 7 8 [pseudocode] SI i est inférieur à taille ALORS RENVOYER tab[i] SINON // je dirais lancer une exception ou faire un assert( false) ... FIN [/pseudocode]
De plus, ce sont tes OPERATEURS qui sont absurdes, pas les constructeurs.
04/10/2011, 12h05
Steph_ng8

Citation:

Envoyé par 3DArchi

P.S. :comme dit dans le fil de discussion précédent, tout ces opérateurs sont absurdes car ne signifient rien.

Personnellement, ils me paraissent justifiés, au contraire.
Enfin, mis à part les opérateurs <, >, <= et >=.

On parle bien de vecteur en tant qu'entité mathématique ?
Eh bien on peut lui ajouter/retirer un scalaire, le multiplier/diviser par un scalaire, ajouter deux vecteurs, etc.
Où est l'absurdité là-dedans ?

Par contre, les opérateurs de redirection de flux (c'est bien comme ça que ça s'appelle ?), à savoir << et >>, eux sont vraiment absurdes.
Du moins de la manière dont ils sont écrits.
Ils se contentent de retourner le flux utilisé : ce ne sont rien d'autre que des fonction « identité » !

Si tu veux que ton flux de sortie affiche quelque chose, il faut lui envoyer des données ; si tu veux récupérer quelque chose depuis ton flux d'entrée, il faut lire ce qu'il y a dedans.
Je ne vais pas te donner la solution, ce serait trop facile, et vu que tu as réussi à faire un constructeur par recopie, tu devrais réussir à écrire un opérateur << qui fait que tu souhaites.
Pour l'opérateur >>, par contre, c'est un peu plus délicat.
Et à moins de définir très précisément ce qui doit être mis dans le flux d'entrée, il n'a pas de raison d'être.

Allez, bon courage ! :)
04/10/2011, 18h30
Emmanuel Deloget

Citation:

Envoyé par Steph_ng8

On parle bien de vecteur en tant qu'entité mathématique ?
Eh bien on peut lui ajouter/retirer un scalaire, le multiplier/diviser par un scalaire, ajouter deux vecteurs, etc.
Où est l'absurdité là-dedans ?

Pour +, -, +=, -=, *,*= /, /=

Pour ++, --, j'ai un peu plus de mal à voir le point commun entre les mathématiques telles que je les connais et le code :)

(et non, on ne peut pas ajouter de scalaire à un vecteur ; les opérations + et - ne sont définie que dans le cas ou les deux opérandes sont des vecteurs)
04/10/2011, 18h40
Steph_ng8

Citation:

Envoyé par Emmanuel Deloget

(et non, on ne peut pas ajouter de scalaire à un vecteur ; les opérations + et - ne sont définie que dans le cas ou les deux opérandes sont des vecteurs)

Hum...
J'ai eu un petit doute en l'écrivant.
Mais au pire, on voir l'addition (resp. la soustraction) d'un scalaire n comme un raccourci pour l'addition (resp. la soustraction) d'un vecteur dont toutes les composantes sont égales à n... :roll:

Quant aux opérateurs ++ et --, il deviennent des raccourcis de raccourci... :P

... non ? :calim2:
05/10/2011, 15h47
oodini

Je suis du même avis que Steph_ng8.
05/10/2011, 21h08
Flob90

Tu peux le faire, mais les personnes faisant de l'algèbre linéaire ne les utiliseront probablement pas, et seront surment choqués que le compilateur ne râle pas si ils écrivent une telle opération sans le vouloir.