Classe C++ matrice

Version imprimable

Classe C++ matrice

Salut

Je métrise assez bien le C. Mon problème avec les C++ c'est que la prof que l'on a eu manque cruellement de pédagogie, et a du mal à se faire comprendre (domage car elle a une forte envie d'enseigner, et cela se voit).

J'ai de grosse lacune du coté surcharge et en paticulier avec des tableaux dynamiques.

Voici ma classe 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
class CACMatrix
{
	private:
		long**		M;
		int		L;
		int		C;
 
	public:
		// Constructeur
		CACMatrix();
		CACMatrix(int l, int c);
		// Destructeur
		~CACMatrix();
 
		// Accesseur
		long		GetL();
		long		GetC();
		long		GetValeur(int l, int c);
		void		SetValeur(int l, int c, long v);
		void		SetLigne(int l, CACVector * V);
		void		AddLigne(CACVector* v);
 
		CACVector*	SommeColonne();
		CACVector*	DeriveLigne();
		void		Binariser(int Seuil);
		void		Absolu();
		void		Normaliser(int Inf, int Sup);
		void		SetAllPixel(int p);
		void		Delete();
};

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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
////////////////////////////////////////////////////////////////////////// CACMatrix
////////////// Constructeur //////////////////
 
CACMatrix::CACMatrix()
{
	C = 0;
	L = 0;
 
	M = NULL;
}
 
CACMatrix::CACMatrix(int l, int c)
{
	int x,y;
	C = c;
	L = l;
 
	M = new long*[L];
	for(y=0;y<L;y++)
	{
		M[y] = new long[C];
		for(x=0;x<C;x++) M[y][x]=0;
	}
}
 
////////////// Destructeur //////////////////
CACMatrix::~CACMatrix()
{
	for(int y=0;y<L;y++) delete [] M[y];
	delete [] M;
}
 
////////////// Oérateur  ///////////////////
CACMatrix& CACMatrix::operator*(CACMatrix& m) const {
	CACMatrix* x;
	if(C==m.GetL())
	{
		x = new CACMatrix(L,m.GetC());
		for(int l=0;l<L;l++)
		{
			for(int c=0;c<m.GetC(); c++)
			{
				int r = 0;
				for(int n=0;n<C; n++)
					r = M[l][n]*m.GetValeur(n,c);
				x->SetValeur(l,c,r);
			}
		}
	}
	else
	{
		x = new CACMatrix();
	}
	return *x
}
 
////////////// Accesseur ///////////////////
long  CACMatrix::GetL()
{
	return L;
}
 
long  CACMatrix::GetC()
{
	return L;
}
 
long  CACMatrix::GetValeur(int l, int c)
{
	return M[l][c];
}
 
void  CACMatrix::SetValeur(int l, int c, long v)
{
	M[l][c] = v;
}
 
void  CACMatrix::SetLigne(int l, CACVector* V)
{
	for(int x=0;x<C;x++)
	{
		if(x<V->GetN()) M[l][x]=V->GetValeur(x);
		else M[l][x]=0;
	}
}
 
void CACMatrix::AddLigne(CACVector* v)
{
	long** t;
	int l,c;
 
	if((v==NULL)||(L==0))
	{
		L = 0;
		C = v->GetN();
	}
 
	if(v->GetN()==C)
	{
		// création du nouveau tableau
		t = new long*[L+1];
		// recopie du tableau existant
		for(l=0;l<L;l++)
		{
			t[l] = new long[C];
			for(c=0;c<C;c++) t[l][c]=M[l][c];
		}
		for(int y=0;y<L;y++) delete [] M[y];
		delete [] M;
 
		// modification du nombre de ligne
		L = L+1;
		// ajout du vecteur
		t[l] = new long[C];
		for(int c=0;c<C; c++) t[l][c] = v->GetValeur(c);
 
		M = t;
	}
}
 
CACVector* CACMatrix::SommeColonne()
{
	CACVector * profil = new CACVector(C);
 
	for(int x=0;x<C;x++)
	{
		long v = 0;
		for(int y=0;y<L;y++)
		{
			v = v + (long)M[y][x];
		}
		profil->SetValeur(x,v);
	}
	return profil;
}
 
CACVector* CACMatrix::DeriveLigne()
{
	CACVector * S = SommeColonne();
	S->Deriver();
	S->Absolu();
 
	return S;
}
 
void CACMatrix::Absolu()
{
	for(int y=0;y<L;y++) for(int x=0;x<C;x++) if(M[y][x]<0) M[y][x]=-M[y][x];
}
 
void CACMatrix::SetAllPixel(int p)
{
	for(int y=0;y<L;y++)
	{
		for(int x=0;x<C;x++)
		{
			M[y][x]=p;
		}
	}
}
 
void CACMatrix::Delete()
{
	for(int y=0;y<L;y++) delete [] M[y];
	delete [] M;
}
 
//////////////////////////////////////////////////////////////////////////////////////

Mon probleme est que je doute de mon code qui j'en suis sur contient des erreurs.
De plus, j'ai un probleme de suturation mémoire lors de son utilisation (a grande echelle, en creant matrice sur matrice). Est ce que cela pourrait venir d'une mauvais libération mémoire.

Apres, je voudrais savoir, après une surcharge d'opérateur, si je fais "y = a * x + b"
La mémoire alloué pour réaliser les calculs successifs (a * x) apres ()+b, elle est libéré automatiquement par le destructeur ? Car comme j'ai un tableau dynamique, il faut forcer la libération sinon ca explose.

Merci, et pour le code n'hésitez pas à le lincher, je suis la pour, et je ne me vexerais pas, au contraire.

Merci

Ps : j'avais oublié, est il possible de créer un opérateur avec un nom type "t" pour transpose par exemple? Merci

26/07/2006, 12h21
jobherzt
je ne suis pas specialiste, mais :

- a priori, pour les operateurs, tu ne peux reprendre que les operateurs definis en C++, donc pas t par exemple.
- pour la memoire, tu as raison pour ton delete, mais il faut aller plus loin, avec un tableau a 2 dimension. il faut deleter chaque case, puis chaque ligne (ou colonne) puis le tout.. donc au lieu de ton code, je mettrais :
Code:

1 2 3 4 5 6 7 8 9 10 11 CACMatrix::~CACMatrix() { for(int y=0;y<L;y++) { for(int x=0;x< C;x++) delete M[y][x]; delete[] M[y]; } delete [] M; }
26/07/2006, 13h39
harsh

ERREUR8O ... la regle c'est un delete pour un new, donc le destructeur est OK... Si il y a fuite, c'est ailleurs
26/07/2006, 13h50
Laurent Gomila

Vite fait :

- Il manque un constructeur par copie et un opérateur d'affectation pour que ta classe soit correcte.

- Tu alloues des matrices dynamiquement dans tes opérateurs puis tu les renvoies par référence : boooom. Les retours de référence sont à réserver aux opérateurs qui doivent renvoyer *this, pour les autres il faut un retour par copie (et pas d'allocation dynamique).

- En général il est plus simple d'utiliser un tableau à une dimension pour coder les matrices.

- Il n'est pas possible de définir des opérateurs autres que ceux que le langage fournit (pas de "t"). Une fonction membre Transpose() sera ce qu'il y a de mieux.
26/07/2006, 13h51
harsh

Citation:

long** t;
int l,c;

if((v==NULL)||(L==0))
{
L = 0;
C = v->GetN();
}

if(v->GetN()==C)
{
// création du nouveau tableau
t = new long*[L+1];
// recopie du tableau existant
for(l=0;l<L;l++)
{
t[l] = new long[C];
for(c=0;c<C;c++) t[l][c]=M[l][c];
}
for(int y=0;y<L;y++) delete [] M[y];
delete [] M;

// modification du nombre de ligne
L = L+1;
// ajout du vecteur
t[l] = new long[C]; //tu veux ecrire sur kel indice la, L?
for(int c=0;c<C; c++) t[l][c] = v->GetValeur(c);

M = t;

Faut voire avec plus d'attention, mais quand tu delete M (c'est a dire t apres assignation), il ne me semble pas que tu desalloues jusqu'a L+1, si?
26/07/2006, 14h33
croc14

merci de toute ces reponse.

> hash, oui sur la Lieme ligne, qui est celle rajouté en fin. J'aurais peux être du marquer cela dans un autre sens !!!

> laurent, ok donc je vais faire les deux opérateurs manquants. Bien que celui d'affectation je comprenne, mais le constructeur par copie, c'est pour quoi faire ? Je ne pense que je m'en serve.
26/07/2006, 15h05
Laurent Gomila

Le constructeur par copie est appelé à chaque fois que tu effectues une copie d'une instance de la classe. Tu n'as pas l'impression de l'utiliser mais c'est le cas bien plus souvent que tu ne le croies : lorsque tu passes un paramètre par valeur, ou encore lorsque tu retournes une copie, le constructeur par copie est appelé automatiquement. Par exemple si tu écris "y = a + b" tu as déjà au moins un appel (sauf optimisation spécifique de ta part).

En gros, une classe copiable (= avec sémantique de valeur) doit toujours définir correctement ces 4 membres :

- Constructeur par défaut
- Constructeur par copie
- Destructeur
- Opérateur d'affectation

Sans quoi tu t'exposes à des problèmes un jour où l'autre

D'accord merci.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 CACMatrix::CACMatrix(CACMatrix& i) { int l,c; C = i.GetC(); L = i.GetL(); M = new long*[L]; for(l=0;l<L;l++) { M[l] = new long[C]; for(c=0;c<C;c++) M[l][c]=i.GetValeur(l,c); } } CACMatrix& CACMatrix::operator=(CACMatrix& m) const { CACMatrix* x = new CACMatrix(m); return *x; }
J'ai l'impression que c'est du n'importe quoi ??!!
Le compilateur ne me dis rien, mais est ce que c'est juste ?
J'ai mis un CACMatrix* car sinon il me dis que l'objet est local (ce qui n'est pas faut).

26/07/2006, 15h45
croc14
je pense avoir touvé une petite erreur en jouant avec mes matrices ...
Code:

1 2 3 4 5 6 7 8 9 10 ////////////// Accesseur /////////////////// long CACMatrix::GetL() { return L; } long CACMatrix::GetC() { return L; }
Si vous voyez d'autre abération, n'hésitez pas.
Les fonctions du dessus semble marcher, mais si un truc vous gène, dite me le. Merci
26/07/2006, 15h46
Laurent Gomila
Citation:

Le compilateur ne me dis rien, mais est ce que c'est juste ?
J'ai mis un CACMatrix* car sinon il me dis que l'objet est local (ce qui n'est pas faut).

Oui, mais là ce n'est qu'une feinte de cow-boy, tu auras une fuite mémoire (qui va libérer la mémoire ?).

Ton opérateur d'affectation est faux : il n'affecte rien à l'instance courante (this), tu ne fais que renvoyer une copie du paramètre.

Voici le prototype de la version correcte
Code:

1 2 3 4 5 6 CACMatrix& CACMatrix::operator =(const CACMatrix& m) { // ... return *this; }
Ton constructeur par copie devrait prendre une référence constante en paramètre, et tu n'es pas obligé d'utiliser les accesseurs : tu as accès aux données privées étant donné que tu es à l'intérieur d'une fonction membre de la classe.

Dans operator *

Code:

1
2
3
4
5
6
7
8
9
10
		for(int l=0;l<L;l++)
		{
			for(int c=0;c<m.GetC(); c++)
			{
				int r = 0;
				for(int n=0;n<C; n++)
					r += M[l][n]*m.GetValeur(n,c);
				x->SetValeur(l,c,r);
			}
		}

Dans AddLigne :
Code:

1 2 3 4 5 6 7 8 9 10 // création du nouveau tableau t = new long*[L+1]; // recopie du tableau existant for(l=0;l<L;l++) { t[l] = new long[C]; for(c=0;c<C;c++) t[l][c]=M[l][c]; } for(int y=0;y<L;y++) delete [] M[y]; delete [] M;
Créer un nouveau tableau n'est pas necéssaire pas plus que copier l'ancien. Tout cela demande de la place mémoire et consomme du temps d'exécution.
Il suffit de redimensionner le tableau M . QQ chose du genre:
Code:

1 2 3 4 5 6 7 t = new long*[L+1]; for(l=0;l<L;l++) t[l] = M[l]; delete [] M ; M = t; L = L+1; M[L] = new long[C]; for(int c=0;c<C; c++) M[L][c] = v->GetValeur(c);
[Edit]Accessoirement, il y a duplication de code entre la méthode Delete et le destructeur [\Edit]

merci diogene, j'aurais pu la chercher longtemps celle la.
Pour la modif, j'y avais pensé, mais je me preparait a faire la méthode AddColonne. Et cela n'est pas possible dans ce cas. Mais merci

J'ai du mal avec la différence entre le constructeur par copy et l'opérateur d'affectation.
Car du coup j'ai cela :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 CACMatrix& CACMatrix::operator=(CACMatrix& m) const { int l,c; C = m.GetC(); L = m.GetL(); if(M!=NULL) { for(int y=0;y<L;y++) delete [] M[y]; delete [] M; } M = new long*[L]; for(l=0;l<L;l++) { M[l] = new long[C]; for(c=0;c<C;c++) M[l][c]=m.GetValeur(l,c); } return *this; }
C'est la meme chose que le constructeur par copy, a la suppression pres. C'est ca ?

Citation:

C'est la meme chose que le constructeur par copy, a la suppression pres. C'est ca ?

Bien vu. Enfait dans sa version ultime, l'opérateur d'affectation ne fait qu'utiliser le constructeur par copie pour la duplication, et le destructeur pour la destruction.

Ce qui donne ça, quelque soit la classe :
Code:

1 2 3 4 5 6 7 8 9 10 CACMatrix& CACMatrix::operator =(const CACMatrix& m) { // Copie CACMatrix Copy(m); // Echange des données Swap(Copy); return *this; } // Libération automatique via le destructeur
Ici, seule la fonction Swap est à écrire : elle ne fait qu'échanger les données membres entre this et le paramètre.

La prochaine MAJ de la FAQ intégrera une Q/R précise sur tout ça.

26/07/2006, 16h20
diogene

Citation:

C'est la meme chose que le constructeur par copy, a la suppression pres. C'est ca ?

Oui. Comme l'objet n'est pas neuf, comme c'est le cas pour un constructeur, il faut lui faire subir un peu de "nettoyage".
Tout cela disperse du code identique un peu partout ce qui n'est pas souhaitable en général. Il faudrait un peu regrouper.
26/07/2006, 16h25
croc14

Merci a vous deux.

Vous m'avez été d'un tres grand secours.