Seg fault sur une class matrice

Version imprimable

Bonjour,

Je programme une classe matrice, héritant d'une classe vecteur (un tableau qui connais sa taille).

Malheureusement, je me tape un segmentation fault a chaque fois que je veux toucher à ma matrice ... je comprend pas :/

___Vecteur

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
 
class Vecteur
{
	int taille;
	double* value;
 
	public:
 
	Vecteur(int=1);
	~Vecteur();
        void vectrand(int n=10);
};
 
Vecteur::Vecteur(int n)
{
	int i;
 
	taille=n;
	value = new double[n];
 
	for(i=0; i<n; i++)
		value[i]=0;
}
 
 
Vecteur::~Vecteur()
{
	delete[] value;
}
 
void Vecteur::vectrand(int n)
{
	int i;
 
	for(i=0; i<taille; i++)
		value[i]= rand()%n;
}

__Matrice

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
 
class Matrice : public Vecteur
{
	int line;
	Vecteur** tvect;
 
	public:
 
	Matrice(int col=1, int line=1);
	void matrand(int n=10);
	Vecteur& operator[](int)const;
};
//Je verrai plus tard pour le destructeur ^^
 
Matrice::Matrice(int line, int col)
{
	int i;
 
	assert(line>0 && col>0);
 
	this->line = line;
 
	Vecteur** tvect = new  Vecteur*[line];
 
	for(i=0; i<line; i++)
		tvect[i] = new Vecteur(col);
}
 
Vecteur& Matrice::operator[](int i)const
{
	return (*tvect)[i];
}
 
void Matrice::matrand(int n)
{
	int i;
 
	for(i=0; i<line; i++)
		(*this)[i].vectrand(n);	
}

Merci d'avance !

Salut,

Là, tu te retrouve au final avec quelque chose à trois dimensions, vu que tu as une dimention dans le vecteur et deux autres dans ta matrice... je doute sincèrement que ce soit ce dont tu as besoin ;)

De plus, tel que ton code apparait, tu mets tout en place pour être confronté à des problèmes sans nom:

Si tu fais une copie de ta matrice (ou ne serait-ce que de ton vecteur!!!), soit te retrouveras avec une double tentative de libération de la mémoire, soit tu te retrouveras à essayer d'accéder à un élément dont la mémoire a été libérée, à un moment ou à un autre
Si l'allocation dynamique au niveau de la matrice échoue pour une raison ou une autre, tu auras une belle fuite mémoire
La classe Matrice est un puits à fuite mémoire, même si tout se passe correctement
Tous ces problèmes ont déjà été largement abordés à maintes reprises dans le forum, je vais donc te laisser un peu chercher tout seul (mais je suis tout disposé à expliquer le pourquoi du comment en cas de besoin ;))

De plus, tu te fais beaucoup de mal pour pas grand chose, dans le sens où une matrice a la particularité remarquable, quand elle est composée de X lignes et de Y colonnes de contenir... X*Y éléments.

Il est donc tout à fait possible de faire en sorte d'allouer directement l'espace pour ces X*Y éléments "d'une seule traite" ;).

A ce moment là, il "suffira" d'utiliser la formule numéro_de_ligne * nombre_de_colonnes + numéro_de_colonne (qui sont autant de données parfaitement connue :D ) pour accéder à un élément particulier.

Enfin, La gestion manuelle des allocations et désallocations de mémoire est un domaine où il est particulièrement facile de se tirer une balle dans le pied:
Si on ne prévoit pas les bons constructeur par copie et opérateurs d'affectation, on se retrouve soit avec des fuites mémoire, soit avec des tentatives de double libération, soit avec des tentatives d'accès à des éléments dont la mémoire a été libérée (ce qui est ton cas), ouvrant la porte à des erreurs de segmentation

Si on ne prévoit pas le destructeur correct, on se retrouve facilement avec des fuites mémoires (ce qui t'arrive aussi)

Si on se limite à l'utilisation des pointeurs "nus", il est difficile de savoir "qui fait quoi" (comprends: qui s'occupe de l'allocation de mémoire, qui s'occupe de la libération de la mémoire, qui se repose sur qui pour quoi,...)

Pour éviter tous ces soucis, C++ fournit, en standard, un ensemble de collections qui sont chacune adaptée à des besoins particuliers.

Parmi ces collections, il y a entre autre la classe vector, disponible dans l'espace de noms std par simple inclusion du fichier d'en-tête <vector> et qui n'est rien d'autre qu'une encapsulation "correcte" d'un tableau d'éléments contigus en mémoire (ce que tu obtiens avec un new Type[X] ;)).

Tu pourrais donc parfaitement envisager d'écrire une classe Matrice sous la forme de
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 class Matrice { public: Matrice(size_t lignes, size_t colonnes):internal_(lignes*colonnes), lignes_(lignes), colonnes_(colonnes){} /* permet de changer la valeur du double indiqué */ double & operator()(size_t ligne, size_t colonne) { assert(ligne < lignes_); assert(colonne < colonnes_); return interne_[ligne * colones_ + colonne); } /* accès en "lecture seule" */ double operator()(size_t ligne, size_t colonne) { assert(ligne < lignes_); assert(colonne < colonnes_); return interne_[ligne * colones_ + colonne); } /* parce que cela peut etre utile ;) */ size_t lignes() const{return lignes_;} size_t colonnes() const{return colonnes_;} private: std::vector<int> interne_; size_t lignes_; size_t colonnes_; }
NOTA: je ne crois pas qu'il soit opportun de fournir une fonction membre qui remplisse la matrice de manière aléatoire.

Ce n'est, à mon sens, pas un service que l'on est en droit d'attendre de la part de la matrice.

De mon avis personnel, ce serait soit un service que l'on peut attendre de la part des objets qui manipulent la matrice soit un service "totalement indépendant" (une fonction libre ;)) que l'on peut appeler à notre gré depuis "n'importe où dans le code".

Enfin, cette classe matrice pourrait être utilisée sous des formes proches de
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 void fillMatrixRandom(Matrice & mat, int max) { size_t lignes = mat.lignes(); size_t colonnes = mat.colonnes(); for (size_t i = ;i<lignes;++i) { for(size_t j = 0; j<colonnes; ++j) { mat(i,j)=rand() %max; } } } int main() { srand(); Matrice mat( 10, 10); fillMatrixRandom(mat, 999); for(size_t i = 0;i<10;++i) { for(size_t j=0;j<10;++j) { std::cout<<mat(i,j)<<" "; } std::cout<<std::endl; } }

06/03/2013, 21h59
Armas

Merci pour tout :)

Ma prof m'avais conseilé de passer par un pointeur sur un tableau de vecteur, je me rapelle plus pour quoi mais ca me semblais aussi assez compliqué pour pas grand chose ><

par contre, pour ce qui est de vector, je ne vais pas l'utiliser :) J'estime que le but de l'apprentissage, c'est de se mettre un peu de baton dans les roues, si j'avais voulu, j'aurai pu DL une classe matrice toute prête et la rendre ...

merci quand même !
07/03/2013, 02h03
koala01

Citation:

Envoyé par Armas

Merci pour tout :)

Ma prof m'avais conseilé de passer par un pointeur sur un tableau de vecteur, je me rapelle plus pour quoi mais ca me semblais aussi assez compliqué pour pas grand chose ><

Encore une prof qui enseigne le C++ comme étant du C with classes!!!

Proposes lui de faire un tour sur le forum, qu'on puisse essayer de la convaincre de se mettre à jour ;)

Citation:

par contre, pour ce qui est de vector, je ne vais pas l'utiliser :) J'estime que le but de l'apprentissage, c'est de se mettre un peu de baton dans les roues, si j'avais voulu, j'aurai pu DL une classe matrice toute prête et la rendre ...

Je ne suis mais alors là pas du tout d'accord avec ce principe.

C++ est un excellent langage, mais il offre déjà bien assez d'occasion de se tirer une balle dans le pied sans devoir en rajouter une couche à chercher la difficulté là où il n'y en a pas besoin.

Ne t'en fais pas, tu auras plus que largement l'occasion de devoir jouer avec l'allocation dynamique et de t'arracher les cheveux par la suite!

Mais, avec un peu de chance, tu auras eu l'occasion d'évoluer tant au niveau de la conception qu'au niveau de la connaissance du langage, et, si tu as de la chance, tu seras peut etre en mesure d'identifier les plus gros pièges auxquels tu risques d'être confronté.

Il y a énormément de marge entre le fait d'apprendre à utiliser ce qui est fourni par le standard et celui d'aller chercher une bibliothèque adaptée à un besoin particulier.

Le premier cas te permet d'apprendre en n'ayant à t'inquiéter que de ce qui importe réellement (la syntaxe qu'il te faut apprendre, l'algorithmie, l'appréhension du langage, ...) et te servira de toutes manières tout au long de ta carrière de développeur C++, alors que le deuxième est clairement destiné à te faciliter la vie dans ton travail et à t'assurer de travailler avec quelque chose "aussi exempt de bug que possible" (ou du moins, c'est ce que l'on en attend).

Ne vas pas croire que l'apprentissage du C++ sera "trop facile" si tu utilises la bibliothèque standard! Même en l'utilisant, tu viendras surement nous demander régulièrement des conseils, ne t'en fais pas ;)

Je crois que mon probleme c'est que je pense toujours au C en programmant ...

Ma classe matrice n'est toujours pas fonctionnel, je comprend pas -_-"
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 //a priori, ça marche, en tout cas j'ai pas d'erreur Matrice::Matrice(int line, int col) { int i; assert(line>0 && col>0); this->line = line; Vecteur* tvect = new Vecteur[line]; for(i=0; i<line; i++) tvect[i] = Vecteur(col); } // mais << et rand ne fonctionnent pas et me faire encore un abandon core T_T ostream& operator<<(ostream& o, Matrice m) { int i; for(i=0; i<m.line; i++) o << m.tvect[i] << endl; return o; } void Matrice::matrand(int n) { int i; for(i=0; i<line; i++) tvect[i].vectrand(n); }
Tu peux m'expliquer pourquoi ? Même en regardant attentivement, je vois pas ce qui pose soucis ... j'ai l'impression d'être revenue 1 an en arriere quand j'avais jamais touché au pointeur -_-"

Utilise std::vector ou std::array (en C++11), qui possèdent les opérations requises: at(i) et size()

Pour la matrice, commence par coder l'essentiel:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class matrice {
private:
    //ce qui te semble utile
public:
    matrice(int hauteur, int largeur);//matrice vide
    explicit matrice(int taille);//pour les matrices carrées vides
    ~matrice();
 
    int& operator()(int ligne, int colonne);
    int operator()(int ligne, int colonne) const;
 
    int hauteur() const;
    int largeur() const;
};

C'est l'interface que doit avoir la matrice en tant qu'objet mathématique.

puis rajoute les fonctions libre

Code:

1
2
3
4
operator*(matrice const & a, matrice const & b);
matrice operator+(matrice const & a, matrice const & b);
matrice operator-(matrice const & a, matrice<T> const & b);
std::vector<int> operator*(matrice const & m, std::vector<int> const & v);

et la fonction membre int matrice::discriminant() const;.

Je te conseille de jeter un œil à la faq sur le comment et le pourquoi du matrice::operator()(int ligne, int colonne)
L'idéal serait les templates:
Pour la matrice, commence par coder l'essentiel (remplace le template par int si ca te pose problème):

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
template <typename T> class matrice {
private:
    //ce qui te semble utile
public:
    typedef T element_t;
    matrice(int hauteur, int largeur);//matrice vide
    explicit matrice(int taille);//pour les matrices carrées vides
    ~matrice();
 
    element_t& operator()(int ligne, int colonne);
    const element_t& operator()(int ligne, int colonne) const;
 
    int hauteur() const;
    int largeur() const;
    element_t discriminant() const
};
 
template<typename T> operator*(matrice<T> const & a, matrice<T> const & b);
template<typename T> matrice<T> operator+(matrice<T> const & a, matrice<T> const & b);
template<typename T> matrice<T> operator-(matrice<T> const & a, matrice<T> const & b);
template<typename T> std::vector<T> operator*(matrice<T> const & m, std::vector<T> const & v);

07/03/2013, 12h36
Armas

Tout ca ne repond pas à ma question :/

Pour l'instant, on a vu les classes, l'heritage, la surcharges d'opérateurs etc, mais pas encore de templates, ni la classe vector, j'aimerai vraiment pouvoir faire mon programme sans utilisé tout ca ^^

Citation:
Envoyé par Armas
Je crois que mon probleme c'est que je pense toujours au C en programmant ...

Ma classe matrice n'est toujours pas fonctionnel, je comprend pas -_-"
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 //a priori, ça marche, en tout cas j'ai pas d'erreur Matrice::Matrice(int line, int col) { int i; assert(line>0 && col>0); this->line = line; Vecteur* tvect = new Vecteur[line]; for(i=0; i<line; i++) tvect[i] = Vecteur(col); } // mais << et rand ne fonctionnent pas et me faire encore un abandon core T_T ostream& operator<<(ostream& o, Matrice m) { int i; for(i=0; i<m.line; i++) o << m.tvect[i] << endl; return o; } void Matrice::matrand(int n) { int i; for(i=0; i<line; i++) tvect[i].vectrand(n); }
Tu peux m'expliquer pourquoi ? Même en regardant attentivement, je vois pas ce qui pose soucis ... j'ai l'impression d'être revenue 1 an en arriere quand j'avais jamais touché au pointeur -_-"
Et que dit le debugger ? (parce que bon, apprendre à coder, c'est bien, mais apprendre à coder sans apprendre à débugger, ça n'est pas très utile... :))

Je viens d'installer "ddd" (je sais pas trop si c'est ca qu'il fallait que j'installe, mais j'ai trouvé ça dans la faq ^^)

Et l'erreur qui surviens quand je fait un run est "program received signal sigsegv, segmentation falt

0xpleinde0400c54 in vector::operator[] (this=0x400950, i=2) at vecteur.cpp

Si je comprend bien, linux a intérompu le prog parce qu'il a touché un bout de ram lui appartenant pas, jusque la, rien de nouveau.

mais ça viendrai de ma classe vecteur ? :o

Je vous montre le code chef ! :D
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 class Vecteur { int taille; double* value; Vecteur(int i=1); ~Vecteur(); double operator[](int); }; _______Vecteur.cpp Vecteur::Vecteur(int n) { int ; taille=n; value= new double[n]; for(i)0; i<n; i++) value[i]=0: } Vecteur::~Vecteur() { delete[] value; } double Vecteur::operator[](int i) { return value[i]; }
Edit:

Je me demande si ca viens pas plutot de matrice quand même, parce que vecteur, l'affichage etc foncitonne impec; ca viens surement de mon constructeur de matrice ... le voila
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 class Matrice { int line; Vecteur* tvect; }; Matrice::Matrice(int line, int col) { int i; assert(line>0 && col>0); this->line = line; Vecteur* tvect = new Vecteur[line]; for(i=0; i<line; i++) tvect[i] = Vecteur(col); }

07/03/2013, 13h44
ternel

std::vector, c'est une classe, que tu n'as pas codée

tu peux la remplacer par la tienne, mais le principe reste le meme.

Pour les templates, je te les ai mis pour indications, parce que ce serait la bonne solution.

Rappelle toi qu'une classe doit d'abord et avant tout définir les services qu'elle rend.

La matrice est un tableau de nombre, il faut donc a priori pouvoir en créer une, et la modifier.

J'ai d'ailleurs omis par mégarde le constructeur par copie (matrice(const matrice&);) et l'opération d'affectation (matrice& operator=(const matrice& m){…; return *this;})
07/03/2013, 14h48
r0d

Bonjour,

Nous sommes sur un forum d'entraide mais:

-> Le code que tu fournis ne peux pas compiler (il y a des erreurs de syntaxes) et ne correspond pas à l'erreur dont tu parles (par exemple, dans tes classes, tout est privé, ce qui rend leur utilisation impossible).
-> Tu ne nous montre pas comment les classes incriminées sont utilisées dans ton code.
-> Tu ne nous dis pas quelle partie du code génère l'erreur.

Comment veux-tu que nous puissions t'aider?

Et effectivement, nous aimerions bien discuter avec ton professeur. Si tu parviens à le convaincre de venir discuter avec nous, je promet de t'aider jusqu'à la fin de ton cours de c++ :)
07/03/2013, 14h49
ternel

J'aime cette promesse :)

@Armas:
Ton problème d'affichage vient directement du fait que rien n'est public dans ta classe matrice.
Du coup, la fonction libre ostream& operator<<(ostream&, matrice const&) ne peut pas y accéder.

Citation:

Envoyé par r0d

Bonjour,

Nous sommes sur un forum d'entraide mais:

-> Le code que tu fournis ne peux pas compiler (il y a des erreurs de syntaxes) et ne correspond pas à l'erreur dont tu parles (par exemple, dans tes classes, tout est privé, ce qui rend leur utilisation impossible).
-> Tu ne nous montre pas comment les classes incriminées sont utilisées dans ton code.
-> Tu ne nous dis pas quelle partie du code génère l'erreur.

Comment veux-tu que nous puissions t'aider?

Et effectivement, nous aimerions bien discuter avec ton professeur. Si tu parviens à le convaincre de venir discuter avec nous, je promet de t'aider jusqu'à la fin de ton cours de c++ :)

Désolé pour le code, j'étais pas sur mon PC donc j'ai tapé de tel sorte que le code soit assez précis pour y voir les erreurs, sans pouvoir le compiler forcément ^^ je le reposte bien du coup :)

Pour mon prof, je suis pas sur qu'elle ai le temps x)

______________________matrice.hpp

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
 
#ifndef __MATRICE__
#define __MATRICE__
 
#include <iostream>
#include "vecteur.hpp"
 
using namespace std;
 
class Matrice : public Vecteur
{
	int line;
	Vecteur* tvect;
 
	public:
 
	Matrice(int col=1, int line=1);
 
	void matrand(int n=10);
 
	Vecteur& operator[](int)const;
	Matrice& operator=(const Matrice&);
 
	friend ostream& operator<<(ostream&, Matrice);
};
 
#endif

______________________matrice.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
 
#include "matrice.hpp"
#include "vecteur.hpp"
 
#include <iostream>
#include <cstdlib>
#include <assert.h>
 
using namespace std;
 
Matrice::Matrice(int line, int col)
{
	int i;
 
	assert(line>0 && col>0);
 
	this->line = line;
 
	Vecteur* tvect = new  Vecteur[line];
 
	for(i=0; i<line; i++)
		tvect[i] = Vecteur(col);
}
 
Vecteur& Matrice::operator[](int i)const
{
	return tvect[i];
}
 
void Matrice::matrand(int n)
{
	int i;
 
	for(i=0; i<line; i++)
		tvect[i].vectrand(n);	
}
 
Matrice& Matrice::operator=(const Matrice& m)
{
	int i;
	line = m.line;
 
	delete[] tvect;
 
	tvect = new Vecteur[line];
 
	for(i=0; i<line; i++)
		tvect[i] = m[i];
 
	return *this;
}
 
ostream& operator<<(ostream& o, Matrice m)
{
	int i;
 
	for(i=0; i<m.line; i++)
		o << m.tvect[i] << endl;		
 
	return o;
}

____________________vecteur.hpp

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
#ifndef __VECTEUR__
#define __VECTEUR__
 
#include <iostream>
 
using namespace std;
 
class Vecteur
{
	int taille;
	double* value;
 
	public:
 
	Vecteur(int=1);
	Vecteur(const Vecteur&);
 
	~Vecteur();
 
	double operator[](int);
	Vecteur& operator=(const Vecteur&);
	void vectrand(int n=10);
 
	friend ostream& operator<<(ostream&, const Vecteur&);
};
 
#endif

______________vecteur.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
#include "vecteur.hpp"
 
#include <iostream>
#include <cstdlib>
 
using namespace std;
 
 
Vecteur::Vecteur(int n)
{
	int i;
 
	taille=n;
	value = new double[n];
 
	for(i=0; i<n; i++)
		value[i]=0;
}
 
 
Vecteur::Vecteur(const Vecteur& v)
{
	int i;
 
	this->taille = v.taille;
 
	value = new double[v.taille];
 
	for(i=0; i<v.taille; i++)
		value[i]=v.value[i];
}
 
 
Vecteur::~Vecteur()
{
	delete[] value;
}
 
double Vecteur::operator[](int i)
{
	return value[i];
}
 
Vecteur& Vecteur::operator=(const Vecteur& v)
{
	int i;
 
	delete[] value;
 
	value = new double[v.taille];
 
	for(i=0; i<v.taille; i++)
		value[i]=v.value[i];
 
	return *this;
}
 
ostream& operator<<(ostream& o, const Vecteur& v)
{	
	int i;
 
	for(i=0; i<v.taille; i++)
		o << v.value[i] << "\t";			
 
	return o;
}
 
 
void Vecteur::vectrand(int n)
{
	int i;
 
	for(i=0; i<taille; i++)
		value[i]= rand()%n;
}

07/03/2013, 15h01
r0d

Il manque l'appel qui fait planter (dans le main certainement). D'ailleurs, autant nous donner le main en entier.
07/03/2013, 15h07
r0d

Sinon, il y a un problème dans le constructeur de la classe Matrice effectivement:

Code:

Vecteur* tvect = new Vecteur[line];

tvect est déjà déclaré dans la définition de la classe.

Code:

tvect = new Vecteur[line];

devrait suffire.

Merci beaucoup rod ! j'ai plus de seg fault :) même si je suis pas sur de comprend pourquoi :)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 #include <ctime> #include <cstdlib> #include <iostream> #include "vecteur.hpp" #include "matrice.hpp" using namespace std; int main() { Matrice m(4, 4); srand(time(NULL)); m.matrand(); cout << m << endl; return 0; }
Néanmoins, ca ne marche toujours pas :'( mon matrand et mon cout ne prennent que la premiere valeur du vecteur, whyyyy ? :'(((

07/03/2013, 15h22
r0d
Citation:

Envoyé par Armas

Merci beaucoup rod ! j'ai plus de seg fault :) même si je suis pas sur de comprend pourquoi :)

Ton code était de ce type (je ne garde que ce qui pose problème):
Code:

1 2 3 4 5 6 7 8 9 class Matrice { Vecteur * tvect; }; Matrice::Matrice { Vecteur * tvect = new Vecteur(); }
En faisant ça, tu déclares une nouvelle variable tvect, de type Vecteur*. Cette variable est une nouvelle variable locale, ce n'est pas le même tvect qui est déclaré en tant que membre de la classe Matrice. Tu peux voir le problème comme: tu déclares 2 fois la même variable, du coup le compilateur est perdu.

Il faut bien distinguer, en C++, la déclaration et l'initialisation d'une variable. La déclaration c'est juste tu "dis" au compilateur que cette variable existe. Pour ça, le compilateur a juste besoin de connaître son type. Donc une déclaration c'est juste: int n;
L'initialisation, c'est lorsque tu affecte une valeur à cette variable: n = 10;
En c++ on peut faire les deux en même temps: int n = 10; mais ce sont deux choses différentes.

En vérité, je n'aime pas trop le terme d'initialisation, mais c'est une autre histoire.
07/03/2013, 15h25
r0d

Citation:

Envoyé par Armas

mon matrand et mon cout ne prennent que la premiere valeur du vecteur

Je ne comprend pas... pourrais-tu être plus explicite?
07/03/2013, 15h30
Armas

Merci pour ton explication, c'est bien plus clair maintenant :D

Quand je declare un vecteur dans mon main, que je fait un vectrand et un cout du vecteur, il m'affiche, par exemple pour un vecteur(5) :

1 23 8 76 67

5 nombres espacés par une tabulation.

Pour une matrice, je fais pareil : Je prend chaque Vecteur de la matrice, je lui fait faire un vectrand. pareil pour cout : cout << matrice == cout << chaque vecteur de la matrice.

Or la, il me fait un "semi" vectrand sur seulement la premier colone de la matrice (donc premier element de chaque vecteur). Pareil pour l'affichage, je vois pas trop pourquoi :x
07/03/2013, 15h39
r0d

pour matrand, je ne vois pas où est le problème. Mais pour le cout, je te donnes 2 indices:
1. compares l'operateur << du vecteur et celui de la matrice, et identifie les différences entre les deux.
2. renseignes-toi sur ce qu'est le "passage de paramètre par référence" et le "passage de paramètre par valeur".
07/03/2013, 19h07
Armas
J'ai modifié
Code:

1 2 3 4 5 6 7 8 9 10 ostream& operator<<(ostream& o, Matrice m) { int i; for(i=0; i<m.line; i++) o << m.tvect[i] << endl; return o; }
en
Code:

1 2 3 4 5 6 7 8 9 10 ostream& operator<<(ostream& o, const Matrice& m) { int i; for(i=0; i<m.line; i++) o << m.tvect[i] << endl; return o; }
Mais ça change rien ...

Si je ne me trompe pas, le passage par valeur sert (en gros) à calculer/afficher des operations sans modifier l'objet envoyé dans la fonction, tandis que le passage par reference (avec un & dans le prototype) permet d'en modifier la valeur, en plus d'optimiser le code par un gain de temps (moins de données à copier dans la pile).

Mais je vois pas ce que ça a a faire ici :x
08/03/2013, 11h26
r0d
Ok, je t'ai dit une bêtise hier. Mais laisse tout de même la version const Matrice &, c'est plus standard.

En fait, le problème est un peu plus fourbe. Tout vient de la façon dont sont construits les vecteurs dans les matrices. Tu les construit en 3 temps:
1. tu les déclares (dans la déclaration de la classe)
2. tu les alloues:

Code:

tvect = new Vecteur[line];

3. tu les initialises:
Code:

1 2 for(int i = 0; i < line; i++ ) tvect[i] = Vecteur(col);
Le problème c'est que lors de l'allocation, c'est le constructeur par défaut qui est appelé, donc avec n=1. Donc la variable membre taille de Vecteur est affectée à 1. Et après elle n'est plus modifiée, donc elle reste à 1.

Une façon rapide de réparer ça c'est de remettre à jour cette variable membre taille à chaque fois qu'il le faut, c'est à dire, en gros, à chaque fois que le tableau Vecteur::value est modifié.
08/03/2013, 15h29
Armas

Merci, mais j'avais trouvé l'erreur ce matin :D

Et au final ca n'a plus d'importance, je vais retourner sur la methode que m'a expliqué ma prof, elle avait bien raison au final ^^

fallait faire un Vecteur** tvect (pointeur sur tableau de vecteur) pour pouvoir réellement alloué dynamiquement la matrice, sans passer par de petites "entourloupes" au langage comme je l'avais fait ^^

Mais du coup ça complique quand même mes autre methodes et surtout mon delete qui chie encore dans la colle :'( tu pourrai m'aider pour ça ? :D

Re...

Non, l'idéal, ca reste de n'avoir qu'une seule classe et de considérer qu'une matrice de X lignes et Y colonnes est en réalité un tableau composé de X*Y éléments.

Quitte, si tu ne veux absolument pas utiliser std::vector, et bien que je ne peux que t'inciter très fortement à l'utiliser, à utiliser l'allocation dynamique, mais en veillant dans ce cas à respecter la règle des trois grands:

Citation:

Si, pour une raison ou une autre, il faut donner une implémentation particulière à l'une des fonctions parmi le constructeur par copie, l'opérateur d'affectation ou le destructeur, alors, il faut fournir une implémentation particulière pour chacune de ces fonctions

Ainsi, ta classe Matrice pourrait elle ressembler à quelque chose comme

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
class Matrice
{
    public:
        Matrice(int ligne, int colonne):lignes_(ligne),colonnes_(colonne),tab_(new double[ligne*colonne]){}
       ~Matrice(){delete tab_;}
       // j'ai fourni une implémentation particulière au destructeur, je dois 
       // donc fournir une implémentation particulière au constructeur
       // par copie et à l'opérateur d'affectation
       Matrice(Matrice const & rhs):lignes_(rhs.lignes),colonnes_(rhs.colonnes), tab_(new double rhs.lignes_*rhs.colonnes_)
       {
            memcpy(tab_,rhs.tab_,lignes_*colones_ * sizeof(double));
        }
        Matrice & operator = (Matrice const & rhs)
        {
            Matrice temp(rhs); // crée une copie de la matrice à affecter
            swap(temp); //interverti les membres de la copie et de l'objet courent
            return *this;
        } //temp est détruit ici, le tableau alloué dynamiquement d'origine est bien libéré
        /* l'accès "en lecture seule" à un élément donné */
        double itemAt(int linge, int colonne) const
        {
              return tab_[ligne * colonnes_ + colonne];
        }
        /* l'accès "en écriture" à un élément donné */
        double& itemAt(int linge, int colonne) 
        {
              return tab_[ligne * colonnes_ + colonne];
        }
        /* et parce que ca peut etre utile, l'opérateur de flux de sortie, 
            et la possibilité de récupérer le nombre de lignes et de colonnes
         */
        std::ostream & operator <<(ostream & os)
        {
             for(int i = 0;i<lignes_;++i)
             {
                 for(int j = 0;j<colonnes_;++j)
                 {
                     os<<itemAt(i, j)<<" ";
                 }
                 os<<std::endl;
             }
             return os;
        }
        int lignes() const{return linges_;}
        int colonnes() const{return colonnes_;}
    private:
        int linges_;
        int colonnes_;
        double tab_;
        void swap(Matrice & other) // la "partie magique" de l'opérateur d'affectation :D
         {
              std::swap(lignes_, other.lignes_);
              std::swap(colonnes_,other.colonnes_);
              std::swap(tab_,other.tab_);
         }
};

Le tout pouvant être utilisé de manière assez simple sous la forme de
int main()

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
{
    Matrice mat(10, 12);
    /* si on veut remplire la matrice, on peut s'amuser à quelque 
     * chose comme
     */
    for(int i = 0;i<mat.lignes(); ++i)
    {
        for(int j = 0;j<mat.colonnes(); ++j)
        {
            mat.itemAt(i, j) = /* valeur à donner à l'élément */;
        }
    }
    /* si l'opérateur << ne nous convient pas telle qu'implémenté, on peut
     * accéder aux éléments de la matrice sous la forme de
  
    for(int i = 0;i<mat.lignes(); ++i)
    {
        for(int j = 0;j<mat.colonnes(); ++j)
        {
            std::cout<<"element en "<<i<<" "<<j<<" = "<<mat.itemAt(i, j);
        }
        std::cout<<std::endl;
    }
    return 0;
}