Discussion :

[lufy77]

Bonjour,

j'ai quelques erreurs je suis resté tellement longtemps dessus que j'ai décidé de m'inscrire sur le site pour avoir un peu d'aide. Merci d'avance.

Alors je vous montre d'une part le code du main :

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
#include "matrice.hpp"
#include <iostream>
#include <cmath>
 
int main() {
	unsigned int N=4;
	std::vector<double> V(N,2.);
	Matrice A(N,1), B(V) , C(N);
 
	C=A+B;
 
	//C(3,2)=7.0;
 
	std::cout<<"La matrice C est : "<<C<<std::endl;
	std::cout<<" Sa taille est : "<<C.taille();
	std::cout<<"Sa trace est : "<<C.taille();
 
	return 0;
 
}

Ma classe :

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
#include <vector>
#include <iostream>
 
class Matrice {
	private:
	int N;
	std::vector<double> coeff;
 
	public:
 
	int taille() const; 
	double trace() const;
	 friend Matrice & operator+(Matrice & , Matrice &);
	//double & operator() (int, int);
 
 
	Matrice(const std::vector<double> &);
	Matrice(int, double x=0);
};
Matrice & operator+(Matrice & , Matrice &);

Ainsi que le code des méthodes :

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
#include "matrice.hpp"
#include <vector>
#include <iostream>
 
 
 
int Matrice::taille() const {
 
	return N; //on aurait pu ici le mettre en inline)
 
}
 
//double Matrice::operator() (int i, int j) {
	//double k;
	//k=coeff[N*i+j];
 
	//return k;
 
//}
 
 int Matrice::trace() const {
	double t=0;
	for (int i=0; i<N; i++)
 
	{t=t+ coeff[N*i+i]; }
 
	return t;
}
 
Matrice& operator+(Matrice & A, Matrice & B) {  
	std::vector<double> T((N-1)*(N-1));
	for (int i=0; i<=(N-1)*(N-1);i++) {
		for (int j=0; j<=(N-1)*(N-1);j++) {
			T[N*i + j]= A[N*i+j] + B[n*i+j];
 
		}
		}
		return T;
}
 
 
//on a fait les accesseurs on fait maintenant les constructeurs.
 
 
Matrice::Matrice (int p, double x):N(p), coeff(p*p,x) {}
 
Matrice::Matrice(const std::vector <double> & V):N(V.size()), coeff(V.size()*V.size(),0) {
 
	for (int i = 0; i<N;i++)
	{coeff [N*i+i]=V[i];}
 
}

J'ai des erreurs du type :
matrice.cpp:21:6: error: prototype for ‘int Matrice::trace() const’ does not match any in class ‘Matrice’
int Matrice::trace() const {
^
In file included from matrice.cpp:1:0:
matrice.hpp:12:9: error: candidate is: double Matrice::trace() const
double trace() const;
^
matrice.cpp: In function ‘Matrice& operator+(Matrice&, Matrice&)’:
matrice.cpp:31:25: error: ‘N’ was not declared in this scope
std::vector<double> T((N-1)*(N-1));
^
matrice.cpp:34:29: error: ‘n’ was not declared in this scope
T[N*i + j]= A[N*i+j] + B[n*i+j];
^
matrice.cpp:38:10: error: invalid initialization of non-const reference of type ‘Matrice&’ from an rvalue of type ‘Matrice’
return T;
^
In file included from matrice.cpp:1:0:
matrice.hpp:17:2: note: after user-defined conversion: Matrice::Matrice(const std::vector<double>&)
Matrice(const std::vector<double> &);
^


J'aimerais bien qu'on m'aide, merci beaucoup en tout cas.

[Matt_Houston]

La première, j'élague un peu le message pour t'aider :

Code :

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

1
2
error: prototype for ‘int Matrice::trace() const’ does not match any in class ‘Matrice’
       candidate is: double Matrice::trace() const

C'est assez clair, non ? Relis bien.

Code :

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

1
2
3
4
matrice.cpp: In function ‘Matrice& operator+(Matrice&, Matrice&)’:
matrice.cpp:31:25: error: ‘N’ was not declared in this scope
std::vector<double> T((N-1)*(N-1));
^

Cette fonction n'est pas définie comme méthode de la classe, il te manque un Matrice::.

Code :

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

1
2
3
matrice.cpp:34:29: error: ‘n’ was not declared in this scope
T[N*i + j]= A[N*i+j] + B[n*i+j];
^

Celle-ci, je pense que tu peux la trouver tout seul.

Code :

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

1
2
3
4
5
6
matrice.cpp:38:10: error: invalid initialization of non-const reference of type ‘Matrice&’ from an rvalue of type ‘Matrice’
return T;
^
In file included from matrice.cpp:1:0:
matrice.hpp:17:2: note: after user-defined conversion: Matrice::Matrice(const std::vector<double>&)
Matrice(const std::vector<double> &);

La fonction retourne une référence vers un objet à portée locale. Le type de retour devrait être Matrice.

[lufy77]

Merci beaucoup j'ai plus qu'une erreur apres avoir corrigé mais c'est une erreur que je n'avais pas aussi pu resoudre...

Le code corrigé :

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
#include "matrice.hpp"
#include <vector>
#include <iostream>
 
 
 
int Matrice::taille() const {
 
	return N; //on aurait pu ici le mettre en inline)
 
}
 
//double Matrice::operator() (int i, int j) {
	//double k;
	//k=coeff[N*i+j];
 
	//return k;
 
//}
 
 double Matrice::trace() const {
	double t=0;
	for (int i=0; i<N; i++)
 
	{t=t+ coeff[N*i+i]; }
 
	return t;
}
 
Matrice Matrice::operator+(Matrice & A, Matrice & B) {  
	std::vector<double> T((N-1)*(N-1));
	for (int i=0; i<=(N-1)*(N-1);i++) {
		for (int j=0; j<=(N-1)*(N-1);j++) {
			T[N*i + j]= A[N*i+j] + B[N*i+j];
 
 
		}
		return T;
}
 
 
//on a fait les accesseurs on fait maintenant les constructeurs.
 
 
Matrice::Matrice (int p, double x):N(p), coeff(p*p,x) {}
 
Matrice::Matrice(const std::vector <double> & V):N(V.size()), coeff(V.size()*V.size(),0) {
 
	for (int i = 0; i<N;i++)
	{coeff [N*i+i]=V[i];}
 
}

du coup la fameuse erreur :

Code :

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

1
2
3
4
~/Bureau/Premiereclasse$ g++ -c matrice.cpp
matrice.cpp:30:52: error: ‘Matrice Matrice::operator+(Matrice&, Matrice&)’ must take either zero or one argument
 Matrice Matrice::operator+(Matrice & A, Matrice & B) {  
                                                    ^

Je dois peut être mettre ça plutôt en fonction car je devrais pas avoir deux argument mais un ? ou alors je fais une méthode avec un argument et dans le code je fais appel a une autre variable du type Matrice ?

[Bousk]

Un opérateur + membre prend aucun ou 1 argument comme le message le dit très clairement.
Si c'est membre, y'a this et donc un opérande implicite.
https://en.wikipedia.org/wiki/Operat..._C_and_C%2B%2B

[lufy77]

J'ai donc crée la methode avec un argument mais un autre probleme persiste... Merci


La class :

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
#include <vector>
#include <iostream>
 
class Matrice {
	private:
	int N;
	std::vector<double> coeff;
 
	public:
 
	int taille() const; 
	double trace() const;
	 Matrice operator+(Matrice &);
	//double & operator() (int, int);
 
 
	Matrice(const std::vector<double> &);
	Matrice(int, double x=0);
};
Matrice & operator+(Matrice &);

voici le code des méthodes

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
#include "matrice.hpp"
#include <vector>
#include <iostream>
 
 
 
int Matrice::taille() const {
 
	return N; //on aurait pu ici le mettre en inline)
 
}
 
//double Matrice::operator() (int i, int j) {
	//double k;
	//k=coeff[N*i+j];
 
	//return k;
 
//}
 
 double Matrice::trace() const {
	double t=0;
	for (int i=0; i<N; i++)
 
	{t=t+ coeff[N*i+i]; }
 
	return t;
}
 
Matrice Matrice::operator+(Matrice & A) {  
	std::vector<double> T((N-1)*(N-1));
	for (int i=0; i<=(N-1)*(N-1);i++) {
		for (int j=0; j<=(N-1)*(N-1);j++) {
			T[N*i+j]= A[N*i+j] + coeff[N*i+j];
 
	}
		return T;
}
}
 
 
//on a fait les accesseurs on fait maintenant les constructeurs.
 
 
Matrice::Matrice (int p, double x):N(p), coeff(p*p,x) {}
 
Matrice::Matrice(const std::vector <double> & V):N(V.size()), coeff(V.size()*V.size(),0) {
 
	for (int i = 0; i<N;i++)
	{coeff [N*i+i]=V[i];}
 
}

La nouvelle erreur

Code :

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

1
2
3
4
matrice.cpp: In member function ‘Matrice Matrice::operator+(Matrice&)’:
matrice.cpp:34:17: error: no match for ‘operator[]’ (operand types are ‘Matrice’ and ‘int’)
    T[N*i + j]= A[N*i+j] + coeff[N*i+j];
                 ^

Merci.

[Bousk]

Un moment donné il faut réfléchir et pas tester n'importe quoi en espérant qu'on te serve la solution...
A est un Matrice, où tu as vu que tu pouvais utiliser l'opérateur [] sur ton type Matrice ?
Encore une fois, lis tes messages d'erreur. Ou bien l'anglais est un tel problème ?

[lufy77]

Ce que je comprends pas c'est pourquoi sur les autres méthodes le fait que j'appelle l’opérateur [] ca n'a pas posé de probleme.. pourquoi avec l'operateur + il y aurait un soucis ?

Cet operateur ne serait pas defini dans la bibliotheque standard? Est ce que je dois coder l'operateur [ ] aussi ? si oui pourquoi?

Est ce que c'est parceque tout ce quil y a dans ma classe doit etre defini? un simple include vector ne suffit alors pas

[koala01]

Salut,

Il y a deux choses à prendre en compte :

La première, c'est que ta classe Matrice utilise en interne un élément de type std::vector. C'est chouette, parce qu'il se fait (tu as du bol, sur ce coup là), que cette classe particulière (std::vector) expose effectivement une fonction membre operator[]().

Je dis que tu as de la chance, parce que, si tu avais décidé d'utiliser un autre type de collection, std::list par exemple, l'opérateur [] ne fait pas partie des fonctions exposées par la std::list. Et le compilateur t'aurait donc traité de tous les noms parce que tu aurais osé utiliser une fonction... qui n'existe pas

Par contre, ce n'est pas parce que la donnée membre coeff expose, au niveau de sa propre interface publique l'opérateur [] que ta classe Matrice expose forcément elle-aussi l'opérateur [] au niveau de sa propre interface publique. Et c'est encore heureux, car, autrement, cela voudrait dire que toutes les fonctions membres de toutes les données membres d'une classe seraient accessibles depuis l'extérieur de la classe qui contient les données!!! Ce serait totalement aberrant quand on pense que, si on place un élément dans l'accessibilité privée de la classe, c'est justement pour éviter que l'utilisateur de la classe n'aille "faire n'importe quoi" avec les données qui la composent

Si tu veux (car il arrive parfois que ce soit utile de le faire) qu'une des fonctions exposées par les données membres de ta classe soit exposée par l'interface de ta classe elle-même, tu dois le faire de manière explicite; c'est à dire

1. en déclarant la fonction au niveau de l'accessibilité publique de ta classe
2. en implémentant cette fonction de manière à ce qu'elle fasse directement appel à la fonction en question de la donnée qui t'intéresse

Allez, un petit exemple d'exercice, juste pour te faire comprendre...

Imaginons une classe Test qui ressemble à peu près à

Code :

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

1
2
3
4
5
6
7
8
9
class Test{
public:
    Test():value_{15}{}
    int value() const{
        return value_;
    }
private:
    int value_;
}

Elle n'a rien de très utile, si ce n'est qu'elle dispose (dans son interface publique) d'une fonction appelée value() et que l'opérateur [] de la classe std::vector n'est en définitive qu'une fonction qui a été déclarée de la même manière (dans l'accessibilité publique de la classe)

Mettons que je crée une autre classe User qui utilises la classe Test sous une forme proche de

Code :

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

1
2
3
4
5
6
7
8
class User{
public:
    int addValue(int i){
        return i + val_.value();
    } 
private:
    Test val_;
};

Cette classe n'a comme seul intérêt que de représenter en hyper simplifié la situation dans laquelle tu te trouves avec ta classe Matrice, qui utilise en interne un élément du type std::vector.

As ton avis :

1. pourquoi est ce que je peux faire i+val_.value(); dans la fonction addValue(int i)
2. Que devrais-je faire pour pouvoir récupérer la valeur repésentée dans la donnée membre val_ de ma classe User

[lufy77]

J'ai du mal a comprendre.... Je dirais car ta methode est defini dans le champ public de ta premiere classe?

Je suis resté une heure dessus ce matin et la ca fait deja 1h que je suis dessus et je n'y arrive toujours pas mais je continu.. C'est pas que je ne réponds pas.

En tout cas merci

EDIT :

J'ai ajouté la méthode operator[] et maintenant ca fonctionne (la compilation des méthodes marche ) mais pour lancer le main on me dit de creer la methode << aussi.. en fait je comprends pas pourquoi je dois redefinir l'operateur << ??????

[dalfab]

pour lancer le main on me dit de creer la methode << aussi.. en fait je comprends pas pourquoi je dois redefinir l'operateur << ??????

C'est comme pour l'opérateur []; en écrivant std::cout<<"La matrice C est : "<<C<<std::endl; tu demandes d'afficher la matrice, comment le compilateur pourrait-il afficher ce type d'objet qu'il découvre. C'est à toi de décrire ce que tu souhaites (par exemple des nombres séparés par des point-virgules et mis entre accolades.)
Il faut définir ici une fonction amie :

Code :

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

1
2
3
4
5
6
7
std::ostream& operator<<( std::ostream& ostr , Matrice const& mat ) {
   // utiliser ostr pour décrire les divers constituants de la matrice
   ostr << "{";
   // .....
   ostr << "}";
   return ostr; // pour continuer les enchaînements des operator<< entre-eux.
}

[lufy77]

merci ^^

J'ai compris mais alors pourquoi ne pas le coder sous forme de méthode avec deux argument comme ca :

Code :

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

1
2
3
4
5
6
7
std::ostream& Matrice::operator<<(Matrice &B) {
 
	for(int i=0; i<N; i++) {
	flux<<B[i]<< std::endl;
}
return flux;
}

:/ je suis chiant je sais mea culpa

[Bousk]

Y'a rien de bon dans ce code
- "méthode avec 2 arguments" ? j'en vois un seul
- flux n'existe pas
- const-correctness du paramètre
- utilisation de l'opérateur [] mais est-il enfin implémenté ?
- indentation au petit bonheur
y'a des règles à respecter sinon le compilateur ne comprend pas

[lufy77]

Désolé je voulais dire un argument car en mettant Matrice:: je déclare que c'est une méthode de ma classe matrice ( je peux donc accéder au champs privés coeff de la matrice B) et oui j'ai défini l'operateur []



Oui alors je remets le code a jours :


Le code de la classe :

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
#include <vector>
#include <iostream>
 
 
class Matrice {
private :
	int N;
	std::vector<double> coeff;
 
 
	public:
	double operator [](int);
 
	int taille() const; 
	double trace() const;
	Matrice operator+(Matrice &);
	std::ostream& operator<< (Matrice &);
 
 
 
	Matrice(const std::vector<double> &);
	Matrice(int, double x=0);
};

Les methodes :

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
#include "matrice.hpp"
#include <vector>
#include <iostream>
#include <fstream>
 
 
 
int Matrice::taille() const {
 
	return N; //on aurait pu ici le mettre en inline)
 
}
 
 
 double Matrice::trace() const {
	double t=0;
	for (int i=0; i<N; i++)
 
	{t=t+ coeff[N*i+i]; }
 
	return t;
}
double Matrice::operator[](int a) {
	return coeff[a];
}
 
std::ostream& Matrice::operator<<(Matrice &B) {
	std::ostream flux;
	for(int i=0; i<N; i++) {
	flux<<B[i]<< std::endl;
}
return flux;
}
 
Matrice Matrice::operator+(Matrice & A) {  
	std::vector<double> T((N-1)*(N-1));
	for (int i=0; i<=(N-1)*(N-1);i++) {
		for (int j=0; j<=(N-1)*(N-1);j++) {
			T[N*i+j]= A[N*i+j] + coeff[N*i+j];
 
	}
		return T;
}
}
 
 
//on a fait les accesseurs on fait maintenant les constructeurs.
 
 
Matrice::Matrice (int p, double x):N(p), coeff(p*p,x) {}
 
Matrice::Matrice(const std::vector <double> & V):N(V.size()), coeff(V.size()*V.size(),0) {
 
	for (int i = 0; i<N;i++)
	{coeff [N*i+i]=V[i];}
 
}

L'erreur en question maintenant :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
In file included from /usr/include/c++/5/iostream:39:0,
                 from matrice.hpp:2,
                 from matrice.cpp:1:
/usr/include/c++/5/ostream: In member function ‘std::ostream& Matrice::operator<<(Matrice&)’:
/usr/include/c++/5/ostream:384:7: error: ‘std::basic_ostream<_CharT, _Traits>::basic_ostream() [with _CharT = char; _Traits = std::char_traits<char>]’ is protected
       basic_ostream()
       ^
matrice.cpp:28:15: error: within this context
  std::ostream flux;
               ^
matrice.cpp:28:15: warning: reference to local variable ‘flux’ returned [-Wreturn-local-addr]

[Invité]

Bonsoir,

Il te faut faire attention que l'opérateur << n'est pas membre de la classe.
Cf. À quoi sert l'operator << ? Comment le coder et l'utiliser ?

[lufy77]

Je comprends toujours pas.. l'operateur << pour moi permet d'afficher ce que l'on veut sur le terminal . Mais la je veux afficher une chose qui est privée alors je le mets sous forme de méthode dans la classe Matrice.

Code :

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

1
2
3
4
5
6
7
8
std::ostream& Matrice::operator<<(Matrice &B) {  // Ici Matrice:: veut dire que je pourrai toucher aux atributs privés, et je prends en argument une matrice du type Matrice  
                                                                                   //avec son constructeur coeff
	std::ostream flux;
	for(int i=0; i<N; i++) {
	flux<<coeff[i]<< std::endl; // jai remplacé ici B[i] par coeff[i]
}
return flux;
}

[dalfab]

Il faut alors une fonction amie (ça n'est pas un opérateur ayant comme premier membre une Matrice!) que l'on déclare dans la class Matrice par friend std::ostream& operator<<( std::ostream& ostr , Matrice const& mat );.

Il faut définir ici une fonction amie :

Code :

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

1
2
3
4
5
6
7
std::ostream& operator<<( std::ostream& ostr , Matrice const& mat ) {
   // utiliser ostr pour décrire les divers constituants de la matrice
   ostr << "{";
   // .....
   ostr << "}";
   return ostr; // pour continuer les enchaînements des operator<< entre-eux.
}

[lufy77]

Ca marche je mets plus ca en méthode mais en fonction avec friend.. ca encore je comprends pas pourquoi je garde pas sous forme de méthode car en cours on avait pas encore vu le mot clé friend..


Du coup pour l'operateur + je vais aussi le coder en fonction plutôt qu'en méthode..


C'est mieux ca ?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
std::ostream& operator<<( std::ostream& ostr , Matrice const& mat ) {
 
   // utiliser ostr pour décrire les divers constituants de la matrice
   ostr << "{";
   for (int i =0; i<mat.taille();i++) {
	   ostr << mat.coeff[i]; // Pour
   }
   // .....
   ostr << "}";
   return ostr; // pour continuer les enchaînements des operator<< entre-eux.
}

Quand je mets coeff[i] seulement dans la boucle for à la place de mat.coeff[i] ca me met une erreur comme quoi coeff n'est pas déclaré.. la je veux bien une petite explication vu que je l'ai mis en friend.. ca veut dire quoi au juste mat.coeff[i] ? acceder au ieme coeeficient du vecteur construit dans l'instance mat ?