Volevo progettare la classe Matrice in c++
Ho definito la classe DSA e l'ho implementata. Il programma viene compilato ed eseguito.
Mentre inserisco dati per memorizzarli nella matrice usando l'operatore>> il programma smette di funzionare. Ora non riesco a trovare l'errore... Ho provato in vari modi ma non funziona. Qualcuno che mi risolve questo problema?
Il programma è questo:
Questo è il file DoubleSubscriptedarray.h :
codice:
#ifndef DOUBLESUBSCRIPTEDARRAY_H
#define DOUBLESUBSCRIPTEDARRAY_H
#include <iostream>
using std::ostream;
using std::istream;
class DSA{ //DSA=doubleSubscriptedArray
friend ostream &operator<<( ostream &, const DSA &);
friend istream &operator>>( istream &, DSA &);
public:
DSA(int = 5, int = 5); //costruttore di default
DSA(const DSA &); //costruttore di copia
~DSA(); //distruttore
int getColonne();
int getRighe();
const DSA &operator=(const DSA &); //operatore di assegnamento
private:
int **ptr;
int colonne;
int righe;
};
#endif
Questo invece è il file DoubleSubscriptedArray.cpp
codice:
#include <iostream>
#include <iomanip>
#include "DoubleSubscriptedArray.h"
using namespace std;
DSA::DSA(int nr, int nc) //costruttore di default
{
righe = (nr > 0 ? nr : 5); // convalida delle righe della matrice
colonne = (nc > 0 ? nc : 5);
ptr = new int*[righe]; //istanzia una matrice
for(int i=0; i<righe; i++)
ptr[i] = new int[colonne];
for(int i=0; i<righe; i++) //ogni elemento della matrice viene posto uguale a 0
for(int j=0; j<colonne; j++)
ptr[i][j]=0;
}
DSA::DSA(const DSA &dsaToCopy) //costruttore di copia
: righe (dsaToCopy.righe),
colonne (dsaToCopy.colonne)
{
ptr = new int*[righe];
for(int i=0; i<righe; i++)
ptr[i] = new int[colonne];
for(int i=0; i<righe; i++)
for(int j=0; j<colonne; j++)
ptr[i][j]=dsaToCopy.ptr[i][j]; // Vengono copia nella matrice gli elementi della matrice
//passata al costruttore.
}
DSA::~DSA()
{
for(int i=0; i<righe; i++)
delete [] ptr[i];
delete [] ptr;
}
//restituisce le colenne della matrice
int DSA::getColonne()
{
return colonne;
}
//restituisce le righe della matrice
int DSA::getRighe()
{
return righe;
}
//operatore di stampa
ostream &operator<<(ostream &output, const DSA &dsa)
{
for(int i=0; i<dsa.righe; i++){
for(int j=0; j<dsa.colonne; j++){
output<< setw(12) << dsa.ptr[i][j];
}
output<<endl;
}
return output; //abilita le chiamate in cascata.
}
//operatore di input
istream &operator>>(istream &input, DSA &dsa)
{
for(int i=0; i<dsa.righe; i++){
for(int j=0; j<dsa.colonne; i++){
input>>dsa.ptr[i][j];
}
}
return input; //abilita le chiamate in cascata
}
//ridefinizione dell'operatore di assegnamento
const DSA&DSA::operator=(const DSA &right)
{
if(&right != this) //controlla che non sia stato effettuato l'autoassegnamento della matrice
{
if(righe != right.righe && colonne != right.colonne){
for(int i=0; i<right.righe; i++)
delete [] right.ptr[i];
delete [] right.ptr;
righe = right.righe;
colonne = right.colonne;
ptr = new int*[righe];
for (int i=0; i<righe; i++)
ptr[i] = new int[colonne];
}
for(int i=0; i<righe; i++){
for(int j=0; j<colonne; j++){
ptr[i][j]=right.ptr[i][j];
}
}
}
return *this; //abilita assegnamenti in cascata.
}
Infine il main.cpp
codice:
#include <iostream>
#include "DoubleSubscriptedArray.h"
using namespace std;
int main(int argc, char** argv) {
DSA dsa1;
DSA dsa2(2, 3);
cout<<"Inserisci gli elementi da inserire in dsa2: \n";
cin>>dsa2;
cout<<"Stampo dsa1 e dsa2: \n";
cout<<dsa1<<endl<<dsa2;
cout<<"ssaegno sda2 a sd1: \n";
dsa1=dsa2;
cout<<dsa1<<endl;
return 0;
}