elrincondelc.com :: Ver tema - Error lógico con clases y sobrecarga de operador +

class matrix
{
public:
// =============
// Constructores
//==============

matrix();

matrix( int Rows , int Columns ); columnas

matrix( int Rows , int Columns,
long double Value);

// ==========
// Destructor
// ==========

~matrix();

// ................................................................

// ===============================
// Funciones de acceso a elementos
// ===============================

inline void SetElement ( int Row, int Column , long double Value);

long double ReturnElement ( int Row , int Column );

void fill ( long double Value );

// Poner una funcion para rellenar aleatoriamente

inline int rows ( void );
inline int columns ( void );
inline int dimension ( void );

friend matrix operator+ ( const matrix &A , const matrix &B );

private:
// Variables bool

bool pbDefined;
bool pbIndexes;

// Variables int

int piRows;
int piColumns;
int piDimension;

// Variables long double

long double *pldData;

// Funciones privadas

inline int piCalcDimension ( void );
inline int LinearIndex ( int i, int j);
inline bool pbValidCoord ( int i, int j);

};

// 1. Constructor por defecto
matrix::matrix()
{
pbDefined = false;
pbIndexes = false;

piRows = 0;
piColumns = 0;
piDimension = piCalcDimension();

pldData = new long double [ piDimension ];
}

//2. Constructor filas-columnas

matrix::matrix( int Rows , int Columns )
{
pbDefined = false;

if ( ( Rows > 0 ) && ( Columns > 0 ) )
{
pbIndexes = true;
piRows = Rows;
piColumns = Columns;
}
else
{
pbIndexes = false;
piRows = 0;
piColumns = 0;
}

piDimension = piCalcDimension();

pldData = new long double [ piDimension ];
}

// OPERADOR +
matrix operator+ ( const matrix &A , const matrix &B )
{

if (
( A.piRows == B.piRows ) && // Coinciden las filas
( A.piColumns == B.piColumns ) && // Coinciden las columnas
( A.pbDefined && B.pbDefined ) // Las matrices son operables
)
{
matrix mReturn( A.piRows , A.piColumns );
mReturn.pbDefined = true;
mReturn.pbIndexes = true;

for ( int c = 0 ; c < A.piDimension ; c++ )
{
mReturn.pldData[c] = A.pldData[c] +
B.pldData[c];
}

for ( int i = 1 ; i<= A.piRows ; i++ )
{
for ( int j = 1 ; j<= A.piColumns ; j++ )
{
cout<<mReturn.ReturnElement(i,j)<<" ";
}
cout<<endl;
}
cout<<endl;

return mReturn;
}
else
{
matrix mReturn;
return mReturn;
}

}

long double matrix::ReturnElement( int Row , int Column )
{
long double ldReturn;

if ( ( pbDefined ) && ( pbValidCoord( Row, Column ) == true ))
ldReturn = pldData[ LinearIndex( Row, Column ) ];
else
pbIndexes = false;

return ldReturn;

}

void Print ( matrix A )
{
for ( int i = 1 ; i <= A.rows() ; i++ )
{
for ( int j = 1 ; j <= A.columns() ; j++ )
{
cout<<A.ReturnElement( i, j )<<" ";
}
cout<<endl;
}
}