Newsgroup: it.comp.lang.c++
Titolo: Una funzione facile facile...

Ciao a tutti.
Ho da poco iniziato a studiare il C++ ed avrei una piccola questione da
porvi.
Premetto che le mie conoscenze di programmazione sono piuttosto limitate.
Infatti ho solo una conoscenza superficiale di Basic, Pascal e Fortran 77 e
tra l'altro sono ormai da anni "fuori dal giro" della programmazione.
Per la mia tesi di laurea devo realizzare un software che deve operare
spesso con matrici ed ho alcuni dubbi.
Partiamo da un caso molto semplice: supponiamo che debba relizzare una
semplice funzione che operi su 2 matrici e che ne restituisca una terza.
Per esempio voglio che la funzione esegua una banale
moltiplicazione tra due matrici A B = C di ordine noto.
Come posso definire tale funzione ?
Avevo pensato a qualcosa del tipo
void moltiplica ( double A[], double B[],  double C[])
Il mio dubbio sta nel fatto se sia corretto che la matrice dei risultati C[]
sia passata
in questo modo come argomento della funzione.
Per esempio in FORTRAN mi pare tale dichirazione abbia senso,
ma è corretta in C++ ?
La funzione scritta in questo modo dove "memorizza" C[] ? Come posso vedere
C[]
nelle altre parti del programma ?
Forse dovrei far restituire alla matrice un puntatore, ma non ho le idee
chiare.
Grazie a chiunque vorrà aiutarmi!!!

 chiare.
Ti faccio un esempio di codice, il piu' semplice possibile:
void prodotto_scalare(double mat[dimensione_x][dimensione_y], double n)
{
	// Modifica la matrice passata come argomento, moltiplicando ogni
	// elemento per n
	for (int i = 0; i < dimensione_x; i++)
		for (int j = 0; j < dimensione_y; j++)
			mat[i][j] *= n;
}
Le varianti sono molte,
- puoi allocare una matrice dinamicamente (con new) e restutuire un 
puntatore a questa (che pero' la funzione chiamante dovrebbe de-allocare, 
il che non e' una tecnica molto "pulita").
- puoi modificare in loco la matrice passata come argomento, come nel mio 
esempio
- puoi prendere un'altra matrice di uguali dimensioni come altro 
argomento, e mettere il risultato in questa
- ecc. ecc.
Altra cosa migliore sarebbe riscrivere il codice in questo modo:
void pscalare(double** mat, size_t dimensione_x, size_t dimensione_y, 
double n)
{
	// stesso codice di prima
}
che ti evita di dover usare costanti per la dimensione, ma prende 
quest'ultima come parametri aggiuntivi.
Oppure puoi scrivere una funzione template del tipo
<code tested="no" complicated="yes" forbeginner="no!">
template <typename Mat_type, size_t Size_x, size_t Size_y)
pscalare(Mat_type mat[Size_x, Size_y], double scalare)
{
	// ...
}
</code>
ma mi sa che sto esagerando... ;-)
Spero di non averti complicato troppo la vita. Ciau
-- 
Andrea Bergia - studente
Linux Registred User #281550

dato che č il forum C++ sconsiglio di operare in quel modo, molto C-like! Se
dobbiamo lavorare cosě, credo che sia piů corretto andare sul formum
int.comp.lang.c.
Si potrebbe in prima analisi creare classi e tutti gli operatori per le
matrici:
class Matrix {
    friend Matrix operator+(const Matrix &, const Matrix &);
...
...
    public:
    Matrix(int X, int Y);
 ...
    private:
    int sizeX;
    int sizeY;
    double *base; // o double **base o qualcos'altro a seconda dello stile e
delle ottimizzazioni
}
etc etc...
Poi, dato che provieni dal modo ForTran puoi usare per le implementazioni
effetive le class: valarray, slice, etc... Queste implementano lo stile
"Fortran" e della libreria BLAS (Basic Linear Algebra SubPrograms) come
riportato nella bibbia di Stroustrup "C++ Linguaggio, libreria Standard,
principi di programmazione".
--
Luigi Mantellini
Per il pessimista il bicchiere č mezzo vuoto,
per l'ottimista č mezzo pieno,
per un ingegnere č semplicemente sovradimensionato rispetto l'uso.

Scusate il lapsus, anche se ho specificato una sola dimensione intendevo
matrici...
Grazie mille Andrea e Luigi per le vostre esaurienti risposte!

 moltiplicazione tra due matrici A B = C di ordine noto.
#include<iostream>
#include "matrice.cpp"
using namespace std;
int main()
{
    matrix<float> m1(2,3); // 2x3
    matrix<float> m2(3,4); // 3x4
    matrix<float> result(2,4); // 2x4
    cout << "righe m1: " << m1.rows() << endl;
    cout << "colonne m1: " << m1.columns() << endl;
    cout << "righe m2: " << m2.rows() << endl;
    cout << "colonne m2: " << m2.columns() << endl;
    m1[0][0] = 1.1;
    m1[0][1] = 3.2;
    m1[0][2] = 2.3;
    m1[1][0] = 2.2;
    m1[1][1] = 5.0;
    m1[1][2] = 6.5;
    m2[0][0] = -3.0;
    m2[0][1] = -2.1;
    m2[0][2] = 7.0;
    m2[1][0] = -2.0;
    m2[1][1] = -4.0;
    m2[1][2] = 10.2;
    cout << endl;
    cout << "M1:" << endl;
    cout << m1[0][0] << "  " << m1[0][1] << "  " << m1[0][2]  << endl;
    cout << m1[1][0] << "  " << m1[1][1] << "  " << m1[1][2] << endl;
    cout << endl;
    cout << "M2:" << endl;
    cout << m2[0][0] << "  " << m2[0][1] << "  " << m2[0][2]  << endl;
    cout << m2[1][0] << "  " << m2[1][1] << "  " << m2[1][2] << endl;
    result = m1 * m2;
    cout << endl;
    cout << "RESULT =  M1*M2:" << endl;
    cout << result[0][0] << "  " << result[0][1] << "  " << result[0][2]
<< endl;
    cout << result[1][0] << "  " << result[1][1] << "  " << result[1][2]
<< endl;
}
N.B.
E' un po' che non ci metto le mani addosso e non ricordo
se c'erano problemi in sospeso o difetti noti.
Se trovi qualcosa che non va fammelo sapere!
--
Gerolamo