ضرب عدد در ماتریس

[alirezabe]

سلام
من یک کلاس ماتریس تعریف کردم که در آن هم ضرب ماتریس در ماتریس دارد هم ماتریس در عدد ولی ضرب ماتریس در عدد من جواب اشتباه و گاهی هم runtime error می دهد لطفا کمک کنید
کد عملگر ضربم

MATRIX MATRIX::operator *(int k)
{
MATRIX tempMAT;
tempMAT.row = row;
tempMAT.column = column;
tempMAT.MatrixArray = new int *[row];
for (int i=0 ; i<row ; i++)
{
tempMAT.MatrixArray[i] = new int [column];
}
for (int l=0 ; i<row ; i++)
{
for (int j ; j<column ; j++)
{
tempMAT.MatrixArray[l][j]=0;
}
}

for (int j=0 ; j<row ; j++)
{
for (int k=0 ; k<column ; k++)
{
tempMAT.MatrixArray[j][k] *= k;
}
}
return tempMAT;
}
این هم main

void main()
{
MATRIX mat1;
MATRIX mat2;
MATRIX mat3;
MATRIX mat4;
MATRIX mat5;
MATRIX mat6;
int kk;
cin >> kk;

mat1.getMatrix();
mat2.getMatrix();
mat3 = mat2 + mat1;
mat4 = mat2 - mat1;
mat5 = mat2 * mat1;
mat6 = mat2 * kk;
mat1.setMatrix();
cout<<endl;
mat2.setMatrix();
cout<<endl;
mat3.setMatrix();
cout<<endl;
mat4.setMatrix();
cout<<endl;
mat5.setMatrix();
cout<<endl;
mat6.setMatrix();
}
با تشکر
علیرضا

[clover]

ممکنه که مشکل مشخصا در ضرب اسکالر نباشه، کد ها را به صورت کامل بذارید تا بررسی کنیم.

[alirezabe]

اینم کد کامل

#include <iostream>

using namespace std;


class MATRIX
{
private:
int row;
int column;
int **MatrixArray;
public:
MATRIX();
void getMatrix();
void setMatrix();
MATRIX operator+(MATRIX mat);
MATRIX operator-(MATRIX mat);
MATRIX operator*(MATRIX mat);
MATRIX operator*(int k);
};

MATRIX:: MATRIX()
{
for (int i=0 ; i<row ; i++)
{
for (int j=0 ;j<column ; j++)
{
MatrixArray[i][j]=0;
}
}
}
/*################################################# ###########################*/
void MATRIX::getMatrix()
{
cout << "please enter number of the matrix row: " ;
cin >> row ;
cout << "please enter number of the matrix column: " ;
cin >> column;

MatrixArray = new int *[row];
for (int i=0 ; i<row ; i++)
{
MatrixArray[i] = new int [column];
}

cout << "palease enter the dray of matrix: " << endl ;
for (int j=0 ; j<row ; j++)
{
for (int k=0 ; k<column ; k++)
{
cout << "dray["<<j<<"]"<<"["<<k<<"]=";
cin>> MatrixArray[j][k];
}
}
}
/*################################################# ##############################*/
void MATRIX::setMatrix()
{
for(int i=0 ; i<row ; i++)
{
for (int j=0 ; j<column ; j++)
{
cout << MatrixArray[i][j]<< "\t"/*?*/ ;
}
cout << endl;
}
}
/*################################################# ##############################*/
MATRIX MATRIX::operator +(MATRIX mat)
{
MATRIX tempMAT;
tempMAT.row = row;//?
tempMAT.column = column;//?
tempMAT.MatrixArray =new int *[row];
for (int i=0 ; i<row ; i++)
{
tempMAT.MatrixArray[i] = new int [column];
}

for (int j=0 ; j<row ; j++)
{
for ( int k=0 ; k<column ; k++)
{
tempMAT.MatrixArray[j][k] = MatrixArray[j][k] + mat.MatrixArray[j][k];
}
}
return tempMAT;//?
}
/*################################################# #############################*/
MATRIX MATRIX::operator -(MATRIX mat)
{
MATRIX tempMAT;
tempMAT.row = row ;
tempMAT.column = column;
tempMAT.MatrixArray = new int *[row];
for (int i=0 ; i<row ; i++)
{
tempMAT.MatrixArray[i] = new int [column];
}

for (int j=0 ; j<row ; j++)
{
for (int k=0 ; k<column ; k++)
{
tempMAT.MatrixArray[j][k] = MatrixArray[j][k] - mat.MatrixArray[j][k];
}
}
return tempMAT;
}
/*################################################# ###########################*/
MATRIX MATRIX::operator *(MATRIX mat)
{
MATRIX tempMAT;
tempMAT.row = row;
tempMAT.column = mat.column;
tempMAT.MatrixArray = new int *[row];
for (int i=0 ; i<row ; i++)
{
tempMAT.MatrixArray[i] = new int [mat.column];
}

for (int j=0 ; j<row ; j++)
{
for (int k=0 ; k<mat.column ; k++)
{
tempMAT.MatrixArray[j][k]=0;//?
for (int l=0 ; l<mat.column ; l++)
{
tempMAT.MatrixArray[j][k] += (MatrixArray[j][l]) * (mat.MatrixArray[l][k]);
}
}
}
return tempMAT;
}
/*################################################# ###########################*/
MATRIX MATRIX::operator* (int k)
{
MATRIX tempMAT;
tempMAT.row = row;
tempMAT.column = column;
tempMAT.MatrixArray = new int *[row];
for (int i=0 ; i<row ; i++)
{
tempMAT.MatrixArray[i] = new int [column];
}
for (int l=0 ; i<row ; i++)
{
for (int j ; j<column ; j++)
{
tempMAT.MatrixArray[l][j]=0;
}
}

for (int j=0 ; j<row ; j++)
{
for (int k=0 ; k<column ; k++)
{
tempMAT.MatrixArray[j][k] *= k;
}
}
return tempMAT;
}
/*################################################# #########################*/
void main()
{
MATRIX mat1;
MATRIX mat2;
MATRIX mat3;
MATRIX mat4;
MATRIX mat5;
MATRIX mat6;
int kk;
cin >> kk;

mat1.getMatrix();
mat2.getMatrix();
mat3 = mat2 + mat1;
mat4 = mat2 - mat1;
mat5 = mat2 * mat1;
mat6 = mat2 * kk;
mat1.setMatrix();
cout<<endl;
mat2.setMatrix();
cout<<endl;
mat3.setMatrix();
cout<<endl;
mat4.setMatrix();
cout<<endl;
mat5.setMatrix();
cout<<endl;
mat6.setMatrix();
}

[clover]

کد زیر به درستی کار میکنه اما این کد هنوز هم ایراداتی داره که ممکنه منجر به بروز خطا بشه از جمله:
1 - عدم بررسی سایز و تطبیق آرایه ها در هنگام ضرب (برای جمع و تفریق به صورت ساده اضافه شد)
2 - عدم پیاده سازی سازنده کپی (عملگر انتساب به صورت ساده سربار گذاری شد، در کار با کلاس هایی که عضو داده ای اشاره گر دارند حتما سازنده کپی و عملگر انتساب را تعریف کنید)
3 - عدم آزاد سازی حافظه های تخصیص داده شده

البته اشکالات دیگه ای هم ممکنه داشته باشه که من فرصت نکردم بررسی کنم و به خودتون واگذار می کنم.
موفق باشید.


#include <iostream>

using namespace std;


class MATRIX
{
private:
int row;
int column;
int **MatrixArray;
public:
MATRIX();
void getMatrix();
void setMatrix();
MATRIX operator=(MATRIX mat);
MATRIX operator+(MATRIX mat);
MATRIX operator-(MATRIX mat);
MATRIX operator*(MATRIX mat);
MATRIX operator*(int k);
};

MATRIX:: MATRIX()
{
for (int i=0 ; i<row ; i++)
{
for (int j=0 ;j<column ; j++)
{
MatrixArray[i][j]=0;
}
}
}
/*################################################# ###########################*/
void MATRIX::getMatrix()
{
cout << "please enter number of the matrix row: " ;
cin >> row ;
cout << "please enter number of the matrix column: " ;
cin >> column;

MatrixArray = new int *[row];
for (int i=0 ; i<row ; i++)
{
MatrixArray[i] = new int [column];
}

cout << "palease enter the dray of matrix: " << endl ;
for (int j=0 ; j<row ; j++)
{
for (int k=0 ; k<column ; k++)
{
cout << "dray["<<j<<"]"<<"["<<k<<"]=";
cin>> MatrixArray[j][k];
}
}
}
/*################################################# ##############################*/
void MATRIX::setMatrix()
{
for(int i=0 ; i<row ; i++)
{
for (int j=0 ; j<column ; j++)
{
cout << MatrixArray[i][j]<< "\t"/*?*/ ;
}
cout << endl;
}
}
/*################################################# ##############################*/
MATRIX MATRIX::operator +(MATRIX mat)
{
MATRIX tempMAT;

if (row != mat.row || column != mat.column) // Added
{
cout << "Error: operator+ !";
return tempMAT;
}


tempMAT.row = row;//?
tempMAT.column = column;//?
tempMAT.MatrixArray =new int *[row];
for (int i=0 ; i<row ; i++)
{
tempMAT.MatrixArray[i] = new int [column];
}

for (int j=0 ; j<row ; j++)
{
for ( int k=0 ; k<column ; k++)
{
tempMAT.MatrixArray[j][k] = MatrixArray[j][k] + mat.MatrixArray[j][k];
}
}
return tempMAT;//?
}

/*################################################# ##############################*/
MATRIX MATRIX::operator =(MATRIX mat)
{
row = mat.row;//?
column = mat.column;//?
MatrixArray =new int *[row];
for (int i=0 ; i<row ; i++)
{
MatrixArray[i] = new int [column];
}

for (int j=0 ; j<row ; j++)
{
for ( int k=0 ; k<column ; k++)
{
MatrixArray[j][k] = mat.MatrixArray[j][k];
}
}
return *this;//?
}

/*################################################# #############################*/
MATRIX MATRIX::operator -(MATRIX mat)
{
MATRIX tempMAT;

if (row != mat.row || column != mat.column) // Added
{
cout << "Error: operator+ !";
return tempMAT;
}

tempMAT.row = row ;
tempMAT.column = column;
tempMAT.MatrixArray = new int *[row];
for (int i=0 ; i<row ; i++)
{
tempMAT.MatrixArray[i] = new int [column];
}

for (int j=0 ; j<row ; j++)
{
for (int k=0 ; k<column ; k++)
{
tempMAT.MatrixArray[j][k] = MatrixArray[j][k] - mat.MatrixArray[j][k];
}
}
return tempMAT;
}
/*################################################# ###########################*/
MATRIX MATRIX::operator *(MATRIX mat)
{
MATRIX tempMAT;
tempMAT.row = row;
tempMAT.column = mat.column;
tempMAT.MatrixArray = new int *[row];
for (int i=0 ; i<row ; i++)
{
tempMAT.MatrixArray[i] = new int [mat.column];
}

for (int j=0 ; j<row ; j++)
{
for (int k=0 ; k<mat.column ; k++)
{
tempMAT.MatrixArray[j][k]=0;//?
for (int l=0 ; l<mat.column ; l++)
{
tempMAT.MatrixArray[j][k] += (MatrixArray[j][l]) * (mat.MatrixArray[l][k]);
}
}
}
return tempMAT;
}
/*################################################# ###########################*/
MATRIX MATRIX::operator* (int k)
{
MATRIX tempMAT;
tempMAT.row = row;
tempMAT.column = column;
tempMAT.MatrixArray = new int *[row];
for (int i=0 ; i<row ; i++)
{
tempMAT.MatrixArray[i] = new int [column];
}
for (int i=0 ; i<row ; i++) // Fixed
{
for (int j=0 ; j<column ; j++) // Fixed
{
tempMAT.MatrixArray[i][j]=0; // Fixed
}
}

for (int i=0 ; i<row ; i++)
{
for (int j=0 ; j<column ; j++) // Fixed
{
tempMAT.MatrixArray[i][j] = MatrixArray[i][j]* k; // Fixed
}
}
return tempMAT;
}
/*################################################# #########################*/
void main()
{
MATRIX mat1;
MATRIX mat2;
MATRIX mat3;
MATRIX mat4;
MATRIX mat5;
MATRIX mat6;
int kk;
cin >> kk;

mat1.getMatrix();
mat2.getMatrix();
mat3 = mat2 + mat1;
mat4 = mat2 - mat1;
mat5 = mat2 * mat1;
mat6 = mat2 * kk;
mat1.setMatrix();
cout<<endl;
mat2.setMatrix();
cout<<endl;
mat3.setMatrix();
cout<<endl;
mat4.setMatrix();
cout<<endl;
mat5.setMatrix();
cout<<endl;
mat6.setMatrix();

}

[mortezamsp]

اشتباهت این بود :

tempMAT.MatrixArray[j][k] *= k
درستش کن اینطوری :

tempMAT.MatrixArray[l][j] = MatrixArray[l][j] * k ;

یه اشتباه دیگه هم داشتی :

for (int l=0 ; i<row ; i++)
درستش کن اینطوری :

for (int l=0 ; l<row ; l++)