Ubuntu-fr

dialloma

redefinition d'operateur d'entrées sorties par flots en C++

Bonjour à tous, j'écris un programme qui manipules des matrices, donc des tableau à deux dimensions (ici). Et j'ai un soucis de redéfinition des opérateurs d'entrées sorties par flots. ça fait trop longtemps que je suis dessus et je ne trouve pas vraiment la faille. Maintenant je compte sur les ubunteros. Voici les codes. Il y a un fichier .cpp, un .hpp (dans laquelle sont définies les classes) et un autre .inl dans laquelle se trouve  les codes des opérateurs d'entrées sorties qui m'empêchent de dormir. Je compte vraiment sur vous sur tout le code, les éventuels bugs, car je ne maitrise pas très bien encore le langage, il y a beaucoup de chose à connaitre à la fois etc...
1: le fichier .hpp

#include <iostream>

//using namespace std;

const unsigned int defaultsize = 3; //defaultsize

struct Matrice{

	//methodes virtuelle taille() et operateur parentheses()
	//pas d'implémentation dans cette class
	public:
		virtual unsigned int taille() const = 0;
		virtual float operator() (int i, int j)=0;
		virtual ~Matrice() = 0;
		

};

struct MatriceCarrePleine: public Matrice{

	//Taille de la matrice courante
	public:
		unsigned int taille() const{
			
			return _dim;
		}
		
		//operateur parenthese
		float operator()(int i, int j){
			
			return this->matCarPleine[i][j];
		}
		
		
		//Constructeurs et destructeurs
		
		MatriceCarrePleine(int d=defaultsize){
			
			//*matCarPleine = new float[_dim=d];
			matCarPleine[_dim=d][_dim=d];
		}
		
		~MatriceCarrePleine(){
			
			delete []this->matCarPleine;
		}
		
		//en attendant la redefinition des operateur d'entree sorties'
		
		
		//void affiche();
/*
		friend std::ostream& operator<<(std::ostream& o, const MatriceCarrePleine& M);

	//Opérateur d'entrée par flots    
		friend std::istream& operator>>(std::istream& i, MatriceCarrePleine& M);*/
	
		//Variables membres private
	private:
		unsigned int _dim;
		float matCarPleine[][defaultsize];
		//float * matCarPleine[defaultsize];

};

struct MatriceTriangulaireInf: public Matrice{
	
	public:
	//Taille de la matrice
		unsigned int taille() const{
			
			return _dim;// = defaultsize;
		}
		
		//Operator parentheses
		float operator()(int i, int j=1){
			
			return matTriInf[1][i];
		}
		
	//Constructeurs et destructeurs
	
		MatriceTriangulaireInf(int d = defaultsize){

			matTriInf[1][_dim=d];
		
		}
		
		~MatriceTriangulaireInf(){
			
			delete []matTriInf;
		
		}
	
		//Operator d'entré sorties
		
	//Opérateur de sortie par flots
	friend std::ostream& operator<<(std::ostream& os, const MatriceTriangulaireInf& M){

	//Opérateur d'entrée par flots    
//	friend std::istream& operator>>(std::istream& i, MatriceTriangulaireInf& M);
		
	private:
		unsigned int _dim;
		float matTriInf[1][defaultsize];
		
		

};

#include "Matrice.inl"

2. Le fichier .inl

/*
inline std::ostream& MatriceCarrePleine::operator<<(std::ostream& os, const MatriceCarrePleine& M){

	const unsigned int n = M.taille();
	for(unsigned int i=0; i<n; ++i){
		for(unsigned int j=0; j<n; ++j){
			os<<M(i,j)<<" ";
		}
		os<<"\n";	
	}
	
	return os;
}

	//Opérateur d'entrée par flots    
inline std::istream& MatriceCarrePleine::operator>>(std::istream& is, MatriceCarrePleine& M){
	
	const unsigned int n = M.taille();
	
	for(unsigned int i=0; i<n; ++i){
		for(unsigned int j=0; j<n; ++j){
			is>>M(i,j);
		}
			
	}
	
	return is;

}*/
		
		
		
		
//Opérateur de sortie par flots
inline std::ostream& MatriceTriangulaireInf::operator<<(std::ostream& os, const MatriceTriangulaireInf& M){
	
	const unsigned int n = M.taille();
	
	for(unsigned int i=0; i<n; ++i){
		
		os<<M(i);
		
	}
	os<<"\n";
	
	return os;
}
// //	Opérateur d'entrée par flots    
// inline std::istream& MatriceTriangulaireInf::operator>>(std::istream& is, MatriceTriangulaireInf& M){
// 	const unsigned int n = M.taille();
// 	
// 	for(unsigned int i=0; i<n; ++i){
// 		
// 		is>>M(i);
// 		
// 	}
// 	
// 	return is;
// }

3. Le .cpp
Pour l'instant, il ne contient rien, je ne fais que tester les methodes et operateurs d'abord:

#include <iostream>

#include "Matrice.hpp"

int main(void){

	using namespace std;

	cout<<"TP3 C++ Matrices Carrés et Héritages"<<endl;

	return EXIT_SUCCESS;
}

Je compte entièrement sur vous

Merci d'avance

dialloma

Re : redefinition d'operateur d'entrées sorties par flots en C++

A desolé je mets le Makefile avec comme ça c'est plus partique:

CPP = g++             # Nom du compilateur
CFLAGS = -Wall -O3   # options de compilation

all : Matrice

Matrice : Matrice.o 
	$(CPP) -o $@ $^

%.o : %.cpp
	$(CPP) $(CFLAGS) -o $@ -c $<

clean :
	rm -f main *.o

Desolé pour les doublons

murlock

Re : redefinition d'operateur d'entrées sorties par flots en C++

Bon, je crois qu'il y a encore un peu de boulot à fournir :

1/ essaye de comprendre les mots clés que tu utilises ( particulièrement friend, ...)

friend déclare la fonction (ou l'objet) externe à la class en cours comme pouvant avoir accès au protected/private donc quand je vois
friend std::ostream& operator<<(std::ostream& os, const MatriceTriangulaireInf& M)
puis
inline std::ostream& MatriceTriangulaireInf::operator<<(std::ostream& os, const MatriceTriangulaireInf& M);
Je bondis un peu : la deuxième implémente la méthode operator<< de la classe MatriceTriangulaireInf... qui n'est pas déclaré

2/ Notation des plus étranges :
matCarPleine[_dim=d][_dim=d];
Tu te rend bien compte que tu affectes deux fois _dim avec la valeur d ?
Je ne garantis pas (mais là, j'ai pas testé) que allouer un tableau avec ça (si ça marche pour autre chose qu'une portée locale) permet le delete []

3/ Pour les flux : voici l'exemple minimun :

#include <string>
#include <iostream>

class maClass {
public:
maClass( int a ) { ma_var = a; }
private:
int ma_var;
friend std::ostream& operator<<( std::ostream& os, const maClass &obj );
};

std::ostream& operator<<( std::ostream& os, const maClass &obj ) {
os << " => " << obj.ma_var << std::endl;
return os;
}

int main() {
    maClass a(14);
    std::cout << a;
}

PS: excuse moi si mon post parait un peu brouillon mais là j'ai hâte d'aller me coucher

---

Gloire à mon Saigneur Arioch