Discussion :

[coyotefunky]

Bonsoir à tous,

j'ai à faire un projet et implémenter une classe matrice du type:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
template <class T>
class Matrix {
 
public:
 
int nb_lines;
int nb_columns;
T** mat;
 
// ... constructeurs, fonctions membres
}

et je dois surcharger l'opérateur [] pour admettre l'écriture suivante dans un fichier .c telle par exemple :

Code :

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

1
2
3
4
 
  ...
	std::cout<<m[i][j];    // const monnamespace::Matrix<double> &m  passé en paramètre d'une fonction d'affichage
  ...

voilà ce que j'ai écrit dans ma classe (je sais c'est très moche et surement faux mais je suis débutant alors je ruse :

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
 
int i_stat,j_stat;
bool eval = false;
 
T& operator [] (const int & tmp) {
 
if (eval == false) {
 
	if (tmp >= nb_lines) {
	cerr << "\nERREUR: indice hors de domaine\n";
	exit(1);
	}
 
	i_stat = tmp;
	return;
	}
 
else {
	if (tmp >= nb_columns) {
	cerr << "\nERREUR: indice hors de domaine\n";
	exit(1);
	}
 
	eval = false;
	j_stat = tmp;
	return mat[i_stat][j_stat];
     }
}

et voilà ce que j'ai à la compile :

g++ testMatrix.c -c
testMatrix.c: In function `void affiche(const umlv::Matrix<double>&, const umlv::Matrix<double>&)':
testMatrix.c:11: error: passing `const umlv::Matrix<double>' as `this' argument of `T& umlv::Matrix<T>::operator[](const int&) [with T = double]' discards qualifiers
testMatrix.c:11: error: invalid types `double[int]' for array subscript
matrixbeta.h: In member function `T& umlv::Matrix<T>::operator[](const int&) [with T = double]':
testMatrix.c:11: instantiated from here
matrixbeta.h:126: error: return-statement with no value, in function returning 'double&'
make: *** [matrix.o] Erreur 1

donc je fais quelque chose de très mal mais j'ai entendu dire que la gestion des [][] était assez délicate à coder et qu'il fallait mieux utiliser les "()" à la place, oui mais voilà, c'était sans compter sur la perversité de mes profs ... je dois le faire.

Si quelqu'un peut me donner un tuyau car je bloque depuis 3 heures et j'ai d'autres projets qui attendent leurs tours ....

Merci pour le coup de main, vais manger et vous lis ensuite, j'espère !!

BYE

[Balise [code] et [quote] ajouté par netah_25 - Merci d'y penser a l'avenir][/b]

[Luc Hermitte]

Bonsoir,

Il faut effectivement feinter, mais différemment.
Le principe est de renvoyer (avec l'opérateur[]) un objet d'une classe qui elle supportera à son tour les opérateurs [], qui renverront les "T&" et "T const&".
On parle de classe proxy. Dans ce cas particulier, il s'agit d'un vecteur.

[coyotefunky]

merci pour la réponse,

il est indiquer dans mon sujet que je ne dois pas utiliser la STL et ses conteneurs, donc pas de vecteur je crois.

Autrement dit il me faut redéfinir la classe vector (ie. Vector) juste pour palier le problème du [][] ??

car pour l'instant je n'avais qu'une classe dans mon prog et ça m'arrangeais bien (cella colle complètement au sujet).

je devrais certainement changer la structure de la matrice par un tableau de vecteur<T> plutôt qu'une matrix<T> ??

Vos lumières svp !!

[jmv]

salut
si tu ne dois pas utiliser la STL, ton operator[](int i) peut renvoyer un pointeur ( mat[i] ) à la place d'un vector, sur ce pointeur tu peut encore utiliser une fois [].

Ou alors tu crée ta propre classe vecteur, c'est pas si difficile que ça si tu implémente peu de méthode.

[coyotefunky]

T* operator[](int line) { return mat[line];}
const T* operator[](int line) const { return mat[line];}

c'est bon ça ?

je ne comprends pas le système de l'opérateur [] qui se rappelle une deuxième fois ...

pouvez vous m'expliquer le processus ?

merci beaucoup

[jmv]

T* operator[](int line) { return mat[line];}
const T* operator[](int line) const { return mat[line];}

c'est bon ça ?

ça m'a l'air juste.

je ne comprends pas le système de l'opérateur [] qui se rappelle une deuxième fois ...
pouvez vous m'expliquer le processus ?

tu ne peux pas définir d'operator[][] mais seulement un operator[].
Donc ta fonction operator[](int i) doit retourner quelque chose sur laquelle tu peux de nouveau appliquer un operateur[].

objet[i][j] est interprété comme objet.operator[](i)[j]

[Ti-R]

Et pourquoi ne pas faire comme ceci ?

Code :

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

std::cout<<m[i+(m.nb_columns*j)];

C'est + rapide à l'execution + facile à coder....

Ou alors...

Code :

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

std::cout<<m.elementAt(i,j);

[coyotefunky]

merci à vous tous mais l'écriture m'ai imposé par le prof, donc pas d'échapatoire.

J'ai bien compris le mécanisme mais ne vois toujours pas très bien comment gérer lles appels à l'opérateur [] selon le type.

Je vais tenter de coder ce que je viens de comprendre et vous solliciterai au besoin.

Bonne nuit.

[coyotefunky]

coucou,

je viens encore de perdre une journée car mon pb n'est pas résolu:

voici les nouveautés dans mon code:


-> nouvelle classe vecteur

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
template <class T>
class Vector {
 
int length;
T* vec;
 
public:
 
Vector (const int & init_length) { ...}
Vector (const int & init_length, const T & init_value) { ....}
// ...
T operator [] (const int & i) {
 
if (i < 0 || i >= length) {
	cerr << "\nERREUR: indice hors de domaine\n";
	exit(1);
	}
 
return vec[i];
}
 
 
const T operator [] (const int & i) const {
 
if (i < 0 || i >= length) {
	cerr << "\nERREUR: indice hors de domaine\n";
	exit(1);
	}
 
return vec[i];
}
};

et plus loin dans ma classe Matrix, les changements et les redéfinitions de l'op [] :

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
Vector<T> * mat; // bien placé dans le code
 
Vector<T> & operator [] (const int & i) {
 
if (i < 0 || i >= nb_lines) {
	cerr << "\nERREUR: indice hors de domaine\n";
	exit(1);
	}
 
return *mat[i];
}
 
const Vector<T> & operator [] (const int & i) const {
 
if (i < 0 || i >= nb_lines) {
	cerr << "\nERREUR: indice hors de domaine\n";
	exit(1);
	}
 
return *mat[i];
}

Si j'ai bien compris, les appels de l'op à l'objet Matrix, puis Vector devrait me permettre d'accéder à une valeur par mat[i].vec[j]

Mais j'ai un autre pb maintenant :

matrixbeta.h: In constructor `umlv::Matrix<T>::Matrix(int, int) [with T = int]':
testMatrix.c:24: instantiated from here
matrixbeta.h:120: error: no matching function for call to `umlv::Vector<int>::Vector()'
matrixbeta.h:47: note: candidates are: umlv::Vector<T>::Vector(const umlv::Vector<T>&) [with T = int]
matrixbeta.h:32: note: umlv::Vector<T>::Vector(const int&, const T&) [with T = int]
matrixbeta.h:19: note: umlv::Vector<T>::Vector(const int&) [with T = int]
testMatrix.c:24: instantiated from here
matrixbeta.h:123: error: invalid conversion from `umlv::Vector<int>*' to `int'
matrixbeta.h:123: error: initializing argument 1 of `umlv::Vector<T>::Vector(const int&) [with T = int]'

l'erreur de la ligne 123 me trouble complètement (les autres aussi), bref encore perdu je suis.

Aidez moi !! SVP merci


[Balises CODE rajoutées par Loulou24, merci d'y penser à l'avenir]

[Laurent Gomila]

Tu as pas mal d'erreurs dans ton code (pas le temps de détailler ce soir, désolé, mais quelqu'un d'autre le fera sûrement), prends bien le temps de faire les choses, de comprendre ce que tu fais, et surtout, petit à petit.

En gros :
- Tu n'as pas de constructeur par défaut pour ton vecteur
- Il faut écrire (*mat)[i] (mais bon... pas besoin de pointeur, et ta matrice devrait contenir un tableau de vecteurs pour faire bien)

Pour les matrices, en général on redéfinit l'opérateur (), qui peut lui prendre 2 paramètres.

-> Matrix(i, j) = 5 par exemple

[coyotefunky]

bonsoir,

un constructeur par défaut ? en voilà une idée qu'elle est bonne, même si je vois pas trop comment l'écrire, j'ai déjà celui la et d'autres:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
Vector (const int & init_length, const T & init_value) {
 
if (length <= 0) {
	cerr << "\nERREUR: taille incorrecte pour un vecteur\n";
	exit(1);
	}
 
length = init_length;
 
vec = new T[length];
 
for (int i = 0 ; i < length ; i++) vec[i] = init_value;
}

Pour l'emploi des parenthèses je suis d'accord, mais faut savoir écrire les 2, et donc gérer [][], c'est souhaité par mon prof.

Je comprends pas mon erreur, dans la logique, cà a l'air pourtant simple :

je déclare une matrice en tant que tableau de vecteurs
j'alloue ce même tableau avec un mat = new Vector<T>[nb_lines] pour les lignes.
pour chaque ligne, j'alloue le vecteur correspondant par appel à un constructeur.

Bref, le constructeur par défaut appelé par l'instruction : mat = new Vector<T>[nb_lines] ca me dépasse ...

encore un coup de pouce avant que vous partez en boîte, car moi je reste bien au chaud devant mon ordi

Schuss

[JolyLoic]

bonsoir,

un constructeur par défaut ? en voilà une idée qu'elle est bonne, même si je vois pas trop comment l'écrire, j'ai déjà celui la et d'autres:

Vector (const int & init_length, const T & init_value) {

if (length <= 0) {
cerr << "\nERREUR: taille incorrecte pour un vecteur\n";
exit(1);
}

length = init_length;

vec = new T[length];

for (int i = 0 ; i < length ; i++) vec[i] = init_value;
}

Pour l'emploi des parenthèses je suis d'accord, mais faut savoir écrire les 2, et donc gérer [][], c'est souhaité par mon prof.

Je comprends pas mon erreur, dans la logique, cà a l'air pourtant simple :

je déclare une matrice en tant que tableau de vecteurs
j'alloue ce même tableau avec un mat = new Vector<T>[nb_lines] pour les lignes.
pour chaque ligne, j'alloue le vecteur correspondant par appel à un constructeur.

Bref, le constructeur par défaut appelé par l'instruction : mat = new Vector<T>[nb_lines] ca me dépasse ...

C'est pourtant ce qui se passe : Dès qu'on crée un objet, on a bien besoin d'un constructeur, et le code mat = new Vector<T>[nb_lines] crée nb_lines objets. En l'absence d'autres constructeurs spécifiés, seul le constructeur par défaut pourra être appellé.

Comment faire ? Quelques pistes :

- Ajouter un constructeur par défaut à Vector, qui fait par exemple un Vecteur vide, puis juste après appeler une fonction sur tous les Vecteurs crées pour en changer la taille.
- Séparer l'allocation de mémoire de mat de la construction des Vecteurs qui y sont, en utilisant le placement new.
- Ne pas parler du tout de Vecteur dans Matrix, sauf dans l'opérateur [], quelque chose du genre :

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
template <class T>
class Vector {
  int length;
  T* startingPosition; 
  Vector (int length, T* startingPos) {/*... Pas d'allocation..*/}
  // Comme avant
};
 
template <class T>
class Matrix{
  T* mat; 
  int nbLine, nbCol;
  Matrix(int nbl, int nbc) : mat(new T[nbl*nbc)), nbLine(nbl), nbCol(nbc){}
  Vector<T> operator[] (int line)
  {
    // Vérifie validité line
    return Vector<T>(nbCol, mat+line*nbCol);
  }
};

Dans ce cas, la classe Vector n'est plus vraiment un Vector indépendant, mais juste un proxy pour accèder à une ligne de la matrice, et j'en changerais donc probablement le nom.

[coyotefunky]

merci pour ta participation JolyLoic,

alors ...

le constructeur par défaut, je l'avais écrit entre temps mais le coup du je remet la bonne taille tout de suite après, j'y avais pas pensé (demain me fera grand bien).

Ta deuxième piste avec le maniement du new, j'ai rien compris désolé (l'allocation est vraiment un de mes points faibles dans la mesure où je débute)

et la troisième piste (merci pour le code) aurait pu être envisageable MAiS j'ai commencé par un tableau de vecteur<T> puis une matrice T** puis revenu au vecteur, je veux pas passer à un tableau à une dimension, il va me falloir ruser et calculer sur les nbLine et nbCol pour trouver l'indice 2D de ma matrice, c'est du code en plus et surement encore des erreurs.

SI vraiment je ne trouve pas avant demain soir, j'appliquerai cette méthode, PROMIS

Bref, il me reste ce fameux message d'erreur que ne comprend pas et après je pense avoir tout bon :

matrixbeta.h:134: error: invalid conversion from `umlv::Vector<int>*' to `int'
matrixbeta.h:134: error: initializing argument 1 of `umlv::Vector<T>::Vector(int) [with T = int]'
matrixbeta.h: In constructor `umlv::Matrix<T>::Matrix(int, int, T) [with T = int]':
testMatrix.c:25: instantiated from here
matrixbeta.h:151: error: invalid conversion from `umlv::Vector<int>*' to `int'
matrixbeta.h:151: error: initializing argument 1 of `umlv::Vector<T>::Vector(int) [with T = int]'

issu de la ligne :

Code :

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

1
2
3
4
for (int i = 0 ; i < nb_lines ; i++) 
	mat[i] = new Vector<T>(nb_columns);                 // l.134
 
// ici, ma structure est encore Vector<T> * mat;

Alors qui veut s'acharner à m'expliquer un samedi soir au lieu d'aller faire la fête ?

A toute.


[Balises CODE rajoutées par Loulou24, merci d'y penser à l'avenir]

[JolyLoic]

A première vue, je ne vois pas le problème. Peux tu poster un ECM pour qu'on t'aide plus ?

ECM = Exemple Complet et Minimal
-> Complet => On peut le compiler tel quel
-> Minimal => Il n'y a dedans que ce qui est nécessaire à la compréhension du problème en cours.

Un des avantages de ce genre d'exemple, c'est qu'en général, en nettoyant le code pour l'aspect minimal, on trouve le problème tout seul...

[Laurent Gomila]

Alors qui veut s'acharner à m'expliquer un samedi soir au lieu d'aller faire la fête ?

Merci de s'acharner à utiliser les balises CODE et QUOTE pour rendre tes messages plus lisibles, à l'avenir

Bref, il me reste ce fameux message d'erreur que ne comprend pas

Visiblement, mat[i] est de type int. Peux-tu nous montrer la déclaration de mat ?

[coyotefunky]

Bonjour !

Et bien il semble que mon pb soit résolu car plus d'erreur à la compile. Ceci dit elles sont peut être cachée par des erreurs liées à mes opérateurs + et += qui stoppent le tout.

Il semble que l'accès par [][] à l'une des valeurs de la matrice fonctionne.

pour info, j'ai déclaré comme ça: Vector<t> * mat;

Si dans deux heures je comfirme que l'erreur est belle et bien partie, j'afficherai résolu au post !

merci à vous tous et bonne fin de we.

PS: pour l'ECM, j'en posterai peut être un sur mes autres erreurs mais celles-ci sont déjà plus faciles à corriger.

[coyotefunky]

Re-bonjour,

tout est résolu mais je rencontre un autre pb maintenant:

je veux écrire une fonction "affiche(...)" prenant en paramêtre des références sur matrices de type const Matrix<double> & m alors que dans mon main(), j'e l'appelle avec des matrices définies en Matrix<int> ...

Il s'agit d'un problème de conversion de Matrix<T> en Matrix<U> et j'ai aucune idée de comment on fait,

pourriez vous me donnez un indice pour continuer à coder ?

MERCi

[JolyLoic]

Créer un constructeur templaté :

Code :

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

1
2
3
4
5
6
 
template <class T> class Matrix
{
  template <class U> Matrix(Matrix<U> other);
  //....
};

Mais je pense qu'il serait plus simple que ta fonction Affiche soit tout simplement templatée (et d'ailleurs qu'elle s'appelle operator<<, comme toute fonction d'affichage se respectant).

Code :

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

1
2
3
4
5
template <class T> ostream &
operator<< (ostream &os, Matrix<T> mat)
{
  // Implémentation
}

[coyotefunky]

je suis bien d'accord mais c'est le fichier test de mon projet qui m'impose ces choix.
On doit redéfinir << mais respecter aussi l'appel à la fonction suivante:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
void affiche(const umlv::Matrix<double> &m, const umlv::Matrix<double> &n)
{
  for(int i=0;i<m.getLines();i++)
    {
      for(int j=0;j<m.getColumns();j++)
	std::cout<<m[i][j];
      std::cout<<std::endl;
    }
  std::cout<<m+n+m+n<<std::endl;
  std::cout<<m*n<<std::endl;
}

et biensur mon pb viient du fait que les matrices balancées en param sont pas toujousr de type "double" ... d'où la conversion à faire.

Alors la solution serait de templater cette foncion, oui mais dans le sujet il me demande d'implémenter un " opérateur de conversion de Matrix<T> en Matrix<U>, et dans ce cas c'est je sais pas trop entre consructeur templaté ou autre ...

A l'aide !!

[coyotefunky]

Coucou !

(pardon pour les fautes du précédent post, c'est la fatigue ...)

mon projet est presque fini, il ne me manque plus que l'implémentation de ce fameux opérateur de conversion Matrix<T> en Matrix<U>.

Rendre la fonction affiche(...) template n'est pas permise puisqu'elle appartient au fichier de test intouchable pour la validation de mon projet.

En fait, li'idée du constructeur template n'a pas sa place ici (du moins je crois) car il s'agit de conversion de matrice(s) passée(s) en argument de fonction avec un type qui varie.

Si vous pouvez me mettre sur la voie car c'est la dernière à chose à faire pour passer à un autre projet et je bloque depuis le début de soirée.

Merci pour toutes vos participations.

A +