[C++] Matrici numeriche e template

[Lews Therin Telamon]

Ciao ragazzi, ho un problema con un programmino che sto cercando di scrivere sempre per il corso di Programmazione ad Oggetti.

L'argomento da affrontare sono i template, e ci è stato richiesto di costruire un oggetto matrice; l'utente specifica nel main le dimensioni della matrice (nc=numero colonne, nr=numero righe) e il tipo di variabili che contiene (ossia se i numeri all'interno della matrice sono int, double o altro), e crea le matrici per poi farci le dovute operazioni.
Io ho scritto una cosa del genere

template <typename T>
class Matrix
{
      public:
             /*Dichiaro costruttore*/
             Matrix(unsigned int nr, unsigned int nc);
                          
             /*Metodi per leggere/scrivere nella matrice*/
             const T& operator()(unsigned int i, unsigned int j) const;
             T& operator() (unsigned int i, unsigned int j);
                   
      private:
              double** m_;
              unsigned int nr_, nc_;
            
      };

quindi ho pensato la matrice come un puntatore a puntatore, che ho chiamato m_; nel costruttore creo la matrice in questo modo

template <typename T>
Matrix<T>::Matrix(unsigned int nr, unsigned int nc)
{
    nr_=nr;
    nc_=nc;
    m_=new double*[nr];
    for (int i=0;i<nc;i++) m_[i]=new double(nc);
    }

in questo modo, m_ punta ad un array di dimensione nr (la prima colonna), i cui elementi sono puntatori, ciascuno dei quali punta ad un array di dimensioni pari al numero di colonne .

A questo punto, se nel main scrivo ad esempio

Matrix <double> A(2,2);
Matrix <double> B(2,2);
     
    A(0,0)=1;
    A(0,1)=0;
    A(1,0)=0;
    A(1,1)=1;
    
    B(0,0)=3;
    B(0,1)=0;
    B(1,0)=0;
    B(1,1)=3;

funziona tutto bene con la sola matrice A, ma si blocca se aggiungo anche la matrice B....per caso sapete dirmi dove ho sbagliato? Grazie a tutti per l'aiuto!

P.S.: Giusto per la cronaca, ho rifatto il programma con la classe standard <vector>, la sintassi è quasi identica tranne che qualche particolare nel costruttore di Matrix e funziona bene, quindi penso di aver fatto qualche errore scemo da qualche parte nel codice che ho proposto a voi...

[Gimli[2BV!2B]]

Nel costruttore:

    m_=new double*[nr];
    for (int i=0;i<nc;i++) m_[i]=new double(nc);

Però se l'esempio di utilizzo è quello che stai realmente usando, non dovrebbe essere questo il tuo problema...
Cosa intendi con "si blocca"?

Purtroppo non sono un grande esperto di template, quindi il mio contributo potrebbe finire qui...

[Lews Therin Telamon]

Ops, scusa ho sbagliato a scrivere una cosa, nel costruttore ovviamente al posto di "double" ci va sempre "T" visto che sto usando i template, quindi è così

template <typename T>
Matrix<T>::Matrix(unsigned int nr, unsigned int nc)
{
    nr_=nr;
    nc_=nc;
    m_=new T*[nr];
    for (int i=0;i<nc;i++) m_[i]=new T(nc);
    }

...in realtà però non ho capito bene la tua risposta, mi sembra che abbiamo scritto la stessa cosa, probabilmente sto fraintendendo!

Comunque hai ragione, "si blocca" è un po' troppo vago....praticamente, nel main io scrivo del codice per riempire la matrice con dei valori numerici, e per stampare a schermo questi stessi valori, il codice che uso è

    A(0,0)=1;
    A(0,1)=0;
    A(1,0)=0;
    A(1,1)=1;
    
    B(0,0)=3;
    B(0,1)=0;
    B(1,0)=0;
    B(1,1)=3;
    
    cout<<"L'elemento (0,0) della matrice A e' "<<A(0,0)<<endl;
    cout<<"L'elemento (0,1) della matrice A e' "<<A(0,1)<<endl;
    cout<<"L'elemento (1,0) della matrice A e' "<<A(1,0)<<endl;
    cout<<"L'elemento (1,1) della matrice A e' "<<A(1,1)<<endl;
    cout<<"\n\n";
    cout<<"L'elemento (0,0) della matrice B e' "<<B(0,0)<<endl;
    cout<<"L'elemento (0,1) della matrice B e' "<<B(0,1)<<endl;
    cout<<"L'elemento (1,0) della matrice B e' "<<B(1,0)<<endl;
    cout<<"L'elemento (1,1) della matrice B e' "<<B(1,1)<<endl;

io vorrei che uscissero le scritte

"L'elemento (0,0) della matrice A è 1"
"L'elemento (0,1) della matrice A è 0"
..........
"L'elemento (0,1) della matrice B è 3"
.......

e via dicendo, anche se mi accorgo solo ora che avevo fatto un po' di errori, ora è scritto bene ma si blocca anche prima, esce solo la scritta

"L'elemento (0,0) della matrice A e' "

e si blocca qui, indipendentemente dal numero di matrici che creo nel main!

EDIT: Comunque ho provato a modificare il tutto eliminando la sintassi relativa ai template e usando quindi una normale matrice di double, ma mi dà lo stesso problema....

[Gimli[2BV!2B]]

Ti ho evidenziato il punto in cui non mi pare giusto: crei un array di dimensione nr, poi fai un ciclo di nc, non credo sia ciò che volevi fare.
Tutto va bene se nc == nr, ma se nc > nr si inizia ad uscire dal seminato...

Mi sembra un errore di svista... per contrastare queste sviste credo che sia mille volte preferibile un bel nome con notazione ungherese leggermente meno ermetico.

Esempio con correzione:

Matrix<T>::Matrix( const unsigned int nRows, const unsigned int nCols )
{

[...]

    for( int nRow = 0 ; nRow < nRows ; nRow ++ )
        m_[nRow] = new T( nCols ) ;
}

[Lews Therin Telamon]

Hai ragione, sbagliavo a fare il ciclo su nc, dovevo farlo ovviamente su nr (in effetti con la notazione che mi suggerisci tu c'è meno rischio di confondersi )....ma purtroppo non cambia niente, il programma si blocca sempre alla scritta "L'elemento (0,0) della matrice A è".....

[Gimli[2BV!2B]]

Con "si blocca" intendi che il processore/core rimane al 100% e non va più avanti?
In questo caso ipotizzerei che all'interno dell'operatore che recupera il dato c'è un ciclo e che questo ciclo contiene un errore.

Se invece ottieni un errore ed il programma esce, penserei ad un accesso errato alla memoria.

[Lews Therin Telamon]

Allora, versione definitiva, con alcuni errori (tra cui quelli che mi hai indicato tu ) corretti, così nel caso non c'è bisogno di andarsi a rileggere tutti i post precedenti; questo è il file matrix.h

template <typename T>
class Matrix
{
      public:
             /*Dichiaro costruttore*/
             Matrix(unsigned int nr, unsigned int nc);

             ............
            
             /*Metodi per leggere/scrivere nella matrice*/
             const T& operator()(unsigned int i, unsigned int j) const;
             T& operator() (unsigned int i, unsigned int j);
                   
      private:
              T** m_;
              unsigned int nr_, nc_;
        
      };

/*Implemento costruttore classe Matrix*/
template <typename T>
Matrix<T>::Matrix(unsigned int nr, unsigned int nc)
{
    nr_=nr;
    nc_=nc;
    
    m_=new T*[nr];
    for (unsigned int i=0; i<nr; i++) m_[i]=new T(nc);
    
    }

e nel file main.cpp ho scritto

cout<<"Programma per calcolare prodotto di due matrici la cui dimensione "<<
    "e' stabilita dall'utente\n\n";
    
    Matrix<double> A(2,2);
    A(0,0)=1;
    A(0,1)=0;
    A(1,0)=0;
    A(1,1)=1;
        
    Matrix <double> B(2,2);
    B(0,0)=4;
    B(0,1)=1;
    B(1,0)=2;
    B(1,1)=3;
        
    cout<<"L'elemento (0,0) della matrice A e' "<<A(0,0)<<endl;
    cout<<"L'elemento (0,1) della matrice A e' "<<A(0,1)<<endl;
    cout<<"L'elemento (1,0) della matrice A e' "<<A(1,0)<<endl;
    cout<<"L'elemento (1,1) della matrice A e' "<<A(1,1)<<endl;
    cout<<"\n\n";
    cout<<"L'elemento (0,0) della matrice B e' "<<B(0,0)<<endl;
    cout<<"L'elemento (0,1) della matrice B e' "<<B(0,1)<<endl;
    cout<<"L'elemento (1,0) della matrice B e' "<<B(1,0)<<endl;
    cout<<"L'elemento (1,1) della matrice B e' "<<B(1,1)<<endl;

c'è una grossa novità....se nel main richiedo che le matrici A e B siano di qualunque tipo tranne double, quindi se scrivo ad esempio

Matrix<int> A(2,2)
Matrix<int> A(2,2)

il programma funziona, ossia escono le scritte che elencano gli elementi della matrice, mentre se le matrici contengono double, quando faccio compilare ed eseguire al compilatore (uso Dev-Cpp) mi esce una finestra tipo MS-DOS in cui c'è solo la scritta

"Programma per calcolare prodotto di due matrici la cui dimensione e' stabilita dall'utente"

se provo a far partire l'eseguibile da DOS (la compilazione va a buon fine, quindi ho l'eseguibile) stessa cosa, appare questa scritta e resta il cursore lampeggiante ma non succede altro e devo chiudere forzatamente il prompt di DOS (intendevo sempre questo con "si blocca", ossia resta aperta la finestra ad un certo punto dell'esecuzione del programma, col cursore lampeggiante).

[o4.]

Mi viene da pensare che ci sia un loop che non termina prima dell'output dei valori, o nel costruttore o nell'operator().
Nel costruttore, questa riga

for (int i=0;i<nc;i++) m_[i]=new T(nc);

alloca per ogni colonna un double inizializzato al valore nc, e non, come penso tu voglia fare un array di double di dimensione nc.
Questo significa che quando tu vai ad accedere ad un valore di una colonna oltre la prima stai andando fuori dai "boundary"

Ma questo sembra essere un altro problema

Qual'è l'implementazione di T& operator() (unsigned int i, unsigned int j) per double?

Un consiglio, visto che si tratta di un esame: un modo più semplice per tenere una matrice di dimensioni stabilite a runtime è creare un unico array di dimensione nc*nr e considerare l'elemento (i,j) come l'elemento alla posizione i * nc + j, oppure alternativamente j * nr + i. Così ti risparmi di dover creare e distruggere tutti quegli array e ne hai uno solo.

[Lews Therin Telamon]

Mi viene da pensare che ci sia un loop che non termina prima dell'output dei valori, o nel costruttore o nell'operator().
Nel costruttore, questa riga

for (int i=0;i<nc;i++) m_[i]=new T(nc);

alloca per ogni colonna un double inizializzato al valore nc, e non, come penso tu voglia fare un array di double di dimensione nc.

FUNZIONAAAAAA!!!!!!!!!!!!!!!!!!!!!!!!
Porca miseria hai ragione, che errore scemo che avevo fatto!
Grazie infinite per l'aiuto, la cosa assurda è che alla riga precedente l'avevo fatto bene, ero proprio convinto che la sintassi fosse corretta!

L'implementazione di operator () non l'avevo scritta perchè pensavo andasse bene, visto che il programma fatto con la classe <vector> al posto del puntatore a puntatore m_ funziona, ma per la cronaca era

template <typename T>
const T& Matrix<T>::operator()(unsigned int i, unsigned int j) const
{
    return (m_[i])[j];
    }
template <typename T>
T& Matrix<T>::operator() (unsigned int i, unsigned int j)
{
    return(m_[i])[j];
    }

entrambi i metodi ritornano l'elemento ij della matrice, solo che uno lo ritorna const (metodo di sola lettura), l'altro no e quindi permette di scriverci dentro....spero che la sintassi che ho usato sia corretta anche nel caso dei puntatori!

Per quanto riguarda il tuo ultimo consiglio ti ringrazio, casomai ci proverò, ad ogni modo sto facendo la stessa cosa più volte in maniere diverse più che altro per curiosità, per spratichirmi un po' col linguaggio.

Ancora grazie e buon anno nuovo a tutti!!!

[o4.]

Figurati
Buon anno e in bocca al lupo per l'esame