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;
}