Newsgroup: it.comp.lang.c++
Titolo: Date un aiuto a un novellino

Ciao a tutti
avrei bisogno di un aiuto.
Ho creato una classe che esegue operazioni sulle matrici restituendo il
risultato su una matrice. Lo scopo è quello ad esempio di poter moltiplicare
due matrici semplicemente scrivendo
a.molt(matrice1,matrice2,righematrice1,colonnematrice1,colonnematrice2)
e leggere il risultato da a.risultato
(il vero scopo naturalmente è quello di esercitarmi e imparare il
linguaggio).
La classe funziona correttamente il problema è che mi sono accorto che
risulta inutile inquanto per passare le martrici dal programma principale
alla classe è necessario che le matrici del programma principale abbiano le
stesse dimensioni di quelle della classe e questo costringerebbe a
dimensionare una matrice a 50 x 50 (le dimensioni che ho prefissato nella
classe) anche quando devo lavorare su una matrice di 2 x 2. Naturalmente il
fatto stesso che bisogna conoscere la dimensione della matrice per
utilizzare la classe va contro i principi della programmazione a oggetti
(almeno penso).
Insomma cosa devo fare per passare una matrice di dimensione n dal programma
principale a una classe che lavora poi su matrici di dimensione m ?
Scusate la lunghezza del post e la banalità del problema ripeto che sono
agli inizi e i miei manuali non si dilungano molto sul passaggio di array.

,

Mai pensato di redefinire l'operatore di moltiplicazione per
istanze della classe matrice?
#include <iostream>
#include <string>
//using namespace std;
class matrix {
private:
  int n,m;
  int ** ppData;
public:
   matrix(int M, int N){
        ppData = new int *[M];
		int i,j;
        for (i=0;i<M;i++){
            ppData[i]=new int[N];
        };
		n=N;
		m=M;
		for (i=0;i<m;i++){
			for (j=0;j<n;j++){
				ppData[i][j]=0;
			};
		};
   }
   ~matrix(){
	   for (int i=0;i<m;i++){
		   delete [] ppData[i];
	   };
	   delete [] ppData;
   }
   void SetData(int a,int b,int c){
	   ppData[a][b]=c;
   }
   int GetM(){
	   return m;
   }
   int GetN(){
	   return n;
   }
   int ** GetppData(){
	   return ppData;
   }
   matrix & operator * (matrix & M){
	   matrix * pMatrix = new matrix(m,M.n);
       for (int i=0;i<m;i++){
		   for(int j=0;j<M.n;j++){
			   for(int k=0;k<n;k++){
				   pMatrix->ppData[i][j]+=this->ppData
[i][k]*M.ppData[k][j];
			   }
		   }
	   }
	   return *pMatrix;
   }
   friend std::ostream & operator <<(std::ostream & os, matrix & M);
};
std::ostream & operator <<(std::ostream & os,matrix & M){
	int i,j;
	//for (i=0;i<M.GetM();i++){
	for (i=0;i<M.GetM();i++){
		for(j=0;j<M.GetN();j++){
			int foo=M.GetppData()[i][j];
			os<<foo;
			os<<"  ";
		}
		os<<"\r\n";
	};
	return os;
};
int main(int argc, char ** argv)
{
	//string A;
	//cin>>A;
	//cout<<A;
	matrix A(3,3);
	A.SetData(0,0,1);
	A.SetData(1,1,3);
	A.SetData(2,2,4);
	matrix B(3,1);
    B.SetData(0,0,1);
	B.SetData(1,0,2);
	B.SetData(2,0,4);
	matrix C(3,1);
	C=A*B;
	std::cout<<A;
	std::cout<<B;
	std::cout<<C;
	return 0;
}
--== Sent via Deja.com 
http://www.deja.com/
 ==--
---Share what you know. Learn what you don't.---

    }
Ovviamente questo modo di definire l'operatore * ha il problema che
non viene liberata memoria per l'oggetto costruito all'interno
del corpo dell'operatore.
Occorre definire un costruttore di copia e creare un oggetto
automatico da far restituire all'operatore *.
Mi spiace per l'inconveniente.


Mi spiace per l'inconveniente.
Gli operatori aritmetici (+, /, -, *) dovrebbero restituire un oggetto
per valore e non per riferimento (anche se puo` sembrare
costoso). Cio` per due motivi:
1) Rispettare la semantica naturale dell'operatore: generalmente
    gli operatori semplici (ovvero non composti con l'assegnamento)
    restituiscono un nuovo oggetto (e non un riferimento o un puntatore);
2) Evitare potenziali memory leak:
    C = a*b;
    Se in questa istruzione l'operatore * allocasse dinamicamente un nuovo
    oggetto e ne restituisse un riferimento, saremmo in presenza di perdita
   di memoria perche` all'uscita dallo scope la memoria non verrebbe liberata.
Paolo
-----------------------------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
  home:   
http://www.cli.di.unipi.it/~marotta
-----------------------------------------------------------------