Originally posted by sergmagic
Как создать класс matrix, в котором размер матрицы
и её содержание задаются при объявлении? Подкинте идею, как это сделать на C++.

Попробуй создать класс.
В этом классе определи матрицу, у который размер задается динамически. Попробуй Malloc();

А на дельфе это проще! Делаешь SetLength b размер задался!

Цитировать

0 спам

11K

15 июля 2005 года

TheOS

14 / / 23.06.2005

Цитата:

Можно не динамически - создай шаблон (template)
template<int _Width,int _Height>
class Matrix
{
...
}

Цитировать

0 спам

11K

17 июля 2005 года

sergmagic

10 / / 15.07.2005

Цитата:

Originally posted by TheOS
Можно не динамически - создай шаблон (template)
template<int _Width,int _Height>
class Matrix
{
...
}

А как тогда обратиться к конкретному эменту массива(например a[j] i=0..n j=0...m) Выдает ошибку, мол размер массива не известен или нуль.:-?

Цитировать

0 спам

406

17 июля 2005 года

vitaly2003s

481 / / 27.07.2004

Цитата:

Originally posted by sergmagic
А как тогда обратиться к конкретному эменту массива(например a[j] i=0..n j=0...m) Выдает ошибку, мол размер массива не известен или нуль.:-?

Думаю ты не правильно 2-ч мерный массив создаеш массив,для шаблона показанного выше можно было бы сделать так :

template<int height,int widht>
class Matrix
{
int a[height][widht];

};

Можно создать динамически 2-х мерный:
int height = 20;
int widht = 20;
int **a=(int**)malloc(height*sizeof(int*));
for(int i=0;i<20;i++) a=(int*)malloc(widht*sizeof(int));
теперь можно обращяться к массиву
a[19][19]=1;

Либо создать 1-мерный массив но использовать его как 2-х мерный:
int height = 20;
int widht = 20;
int *a=(int*)malloc(height*widht*sizeof(int));

for(int i=0;i<height;i++)
for(int i1=0;i1<widht;i1++)
a[i*widht+i1]=1; //обращение как a[i1]=1

Цитировать

0 спам

2.0K

21 июля 2005 года

WidowMaker

212 / / 05.04.2005

#define _COPY 1
#define _OVERWRITE 0

//------------------------------------------------------------------------------
struct matrix //декларирует структуру прямоугольной таблицы чисел - матрицы
{
float **data; //элементы
int height; //высота
int width; //ширина
//- - - - - - - - - - - - - - - - - - - - - - - - - - -
matrix(int =3, int =3); //конструктор
~matrix(); //деструктор
//- - - - - - - - - - - - - - - - - - - - - - - - - - -
matrix &operator=(const matrix &m); //присваивание
bool operator==(const matrix &m); //сравнение
matrix &operator+(const matrix &m); //сложение
matrix &operator-(const matrix &m); //вычитание
matrix &operator*(const matrix &m); //умножение

matrix &operator!();
//- - - - - - - - - - - - - - - - - - - - - - - - - - -
};
//------------------------------------------------------------------------------
matrix::matrix(int _height, int _width)
{
height =_height;
width =_width;
data = new float*[height];
for(int i=0;i<height;i++) data = new float[width];
}
//------------------------------------------------------------------------------
matrix::~matrix()
{
for(int i=0;i<height;i++) delete data;
delete data;
}
//------------------------------------------------------------------------------
matrix& matrix::operator=(const matrix &m)//присваивание матрице
{
for(int y=0;y<m.height;y++)
for(int x=0;x<m.width;x++)
data[y][x]=m.data[y][x];
return *this;
}
//------------------------------------------------------------------------------
bool matrix::operator==(const matrix &m) //сравнения матриц одного(!) размера
{
if((width!=m.width)||(height!=m.height)) return false;
for(int y=0;y<height;y++)
for(int x=0;x<width;x++)
if(data[y][x]!=m.data[y][x]) return false;
return true;
}
//------------------------------------------------------------------------------
matrix& matrix::operator+(const matrix &m)//размеры первой должны быть <= второй
{
matrix *r = new matrix(height,width);
for(int y=0;y<height;y++)
for(int x=0;x<width;x++)
r->data[y][x]=data[y][x]+m.data[y][x];
return *r;
}
//------------------------------------------------------------------------------
matrix & matrix::operator-(const matrix &m)//размеры первой должны быть <= второй
{
matrix *r = new matrix(height,width);
for(int y=0;y<height;y++)
for(int x=0;x<width;x++)
r->data[y][x]=data[y][x]-m.data[y][x];
return *r;
}
//------------------------------------------------------------------------------
matrix & matrix::operator*(const matrix &m) //умножение согласованых(!) матриц
{
// if(width!=m.height) ; //проверка согласованности матриц
matrix *r = new matrix(height,m.width);
for (int y=0;y<height;y++)
{
for(int x=0;x<m.width;x++)
{
float sum=0;
for(int i=0;i<width;i++) sum+=data[y]*m.data[x];
r->data[y][x]=sum;
}
}
return *r;
}
//------------------------------------------------------------------------------
matrix& matrix::operator!()//транспонирование матрицы(с копированием),возвращение
{
matrix *trans = new matrix(width,height);
for(int i=0;i<width;i++)
for(int y=0;y<height;y++) trans->data[y]=data[y];
return *trans;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
/*AnsiString MatrixToStr(const matrix &m) //Записывает в строку АnsiString в виде:
{ //"Маtrix(<height>x<width>):
AnsiString Line="Matrix("+IntToStr(m.height)+"x"+IntToStr(m.width)+"):\n"; //A11, A12, A13, ..., A1j,
for (int y=0;y<m.height;y++) //A21, A22, A23, ..., A2j,
{ //..., ..., ..., ..., ...,
for (int x=0;x<m.width;x++) Line=Line+FloatToStr(m.data[y][x])+", "; //Ai1, Ai2, Ai3, ..., Aij,
Line=Line+"\n";
}
return Line;
}*/
//---------------------------------------------------------------------------
void MatrixFill(matrix &M, float fill=0)
{
for(int y=0;y<M.height;y++) for(int x=0;x<M.width;x++) M.data[y][x]=fill;
}
//---------------------------------------------------------------------------
void PutToMatrix(matrix &dest, const matrix &source, int xt, int yt, int mode=_COPY)
{
for(int y=0;(y<source.height)&&(y+yt<=dest.height);y++)
for(int x=0;(x<source.width)&&(x+xt<=dest.width);x++)
(mode!=_COPY)?dest.data[y+yt-1][x+xt-1]=source.data[y][x]: //y+yt+1 так как индексы мат.
dest.data[y+yt-1][x+xt-1]+=source.data[y][x]; //x аналогично
}
//---------------------------------------------------------------------------
void MatrixMirror(matrix &M)
{
for(int y=0;y<M.height-1;y++)
for(int x=M.width-1;x>=y;x--)
M.data[x][y]=M.data[y][x];
}
//---------------------------------------------------------------------------
void MatrixResize( matrix & M, int height, int width, float fill=0) //изменяет размер матрицы, обрезая или заполняя значением fill.
{
float **newdata = new float*[height];
for(int y=0;y<height;y++)
{
newdata[y] = new float[width];
if(M.height-1<y)
for(int x=0;x<width;x++)
{
if(M.height-1<y)newdata[y][x]=fill;
if(M.width-1<x) newdata[y][x]=fill;
else newdata[y][x]=M.data[y][x];
}
}
}
//---------------------------------------------------------------------------
matrix& AlgAdop(const matrix & M, int yi, int xi)//возвращает матрицу-алг.доп.(индексы математические)
{
matrix *R = new matrix(M.height-1,M.width-1);
int xa=0,ya=0;
for(int y=0;y<R->height;y++)
{
if(y==yi-1) ya=1;
for(int x=0;x<R->width;x++)
{
if(x==xi-1) xa=1;
R->data[y][x]=M.data[y+ya][x+xa];
}
xa=0;
}
return *R;
}
//---------------------------------------------------------------------------
matrix& AlgAdopLev(const matrix &M, int array[])
{
matrix *R;
float k=array[1];
for(int i=1;i<=array[0];i++)
{
R=&AlgAdop(M,1,array);
}
return *R;
}
//---------------------------------------------------------------------------
float DelimX(const matrix & M)//вычисляет определитель квадратной(!) матрицы не ниже 2(!)
{

}
//---------------------------------------------------------------------------
float Delim(const matrix & M)//вычисляет определитель квадратной(!) матрицы не ниже 2(!)
{
if((M.width==1)||(M.height==1)) return M.data[0][0];
if(M.width>3)
{
float del=0;
for(int y=0;y<M.height;y++)
{
if((y+2)%2!=0)
{
if(M.data[y][0]!=0.0) del-=M.data[y][0]*Delim(AlgAdop(M,y+1,1));
}
else
{
if(M.data[y][0]!=0.0) del+=M.data[y][0]*Delim(AlgAdop(M,y+1,1));
}
}
return del;
}
else if(M.width==3)
return M.data[0][0]*M.data[1][1]*M.data[2][2]+
M.data[0][1]*M.data[1][2]*M.data[2][0]+
M.data[0][2]*M.data[1][0]*M.data[2][1]-
M.data[0][2]*M.data[1][1]*M.data[2][0]-
M.data[0][0]*M.data[1][2]*M.data[2][1]-
M.data[0][1]*M.data[1][0]*M.data[2][2];
else
return M.data[0][0]*M.data[1][1]-M.data[0][1]*M.data[1][0];
}
//---------------------------------------------------------------------------
float AlgAdot(const matrix & M, int yi, int xi)//возвращает число-алг.доп.(индексы математические)
{
matrix *R = new matrix(M.height-1,M.width-1);
int xa=0,ya=0;
for(int y=0;y<R->height;y++)
{
if(y==yi-1) ya=1;
for(int x=0;x<R->width;x++)
{
if(x==xi-1) xa=1;
R->data[y][x]=M.data[y+ya][x+xa];
}
xa=0;
}
float result=Delim(*R);
if((yi+xi)%2!=0) return -result;
return result;
}
//------------------------------------------------------------------------------
matrix & BackMatrix(const matrix & m)//возвращает обратную матрицу,квадратную(!)
{
matrix *R = new matrix(m.height,m.width);
float del=Delim(m);
for(int y=0;y<m.height;y++)
for(int x=0;x<m.width;x++)
R->data[y][x]=AlgAdot(m,y+1,x+1)/del;
(*R)=!(*R);
return *R;
}
//------------------------------------------------------------------------------
void PrintMatrix(FILE *OUT,const matrix &m)
{
if(!OUT) OUT=stdout;
fprintf(OUT,"M(%ix%i):\n",m.height,m.width);
for(int y=0;y<m.height;y++)
{
for(int x=0;x<m.width;x++) fprintf(OUT,"%.6f\t",m.data[y][x]);
fprintf(OUT,"\n");
}
}
//------------------------------------------------------------------------------

Думаю этого хватит. Код еще времен молодости, для начинающего сойдет. Тут собрана малюсенькая либа по матрицам.

ЗЫ: не класс, а структура(это дело вкуса)

P.S: поражаюсь, пишут/просят на С++, юзают классы, а выделяют память malloc, а не new.