Форум программистов, компьютерный форум, киберфорум
Наши страницы

Массивы (Матрицы) - C++

Войти
Регистрация
Восстановить пароль
Другие темы раздела
C++ Помошьс функциями сравнения времени. http://www.cyberforum.ru/cpp-beginners/thread37133.html
Доброго времени суток.Курсовая работа по темам:текстовые-бинарные файлы(переброс данных с одного в другой),стэки,структуры,работа с датой и временем. Задача: 1)Запись в бинарный файл:номер...
C++ Istream_iterator Есть задача: надо заменить циклы в программе на что-то с использование обобщеенного проргаммирования и std library функций: #include <string> #include <iostream> #include <sstream> #include... http://www.cyberforum.ru/cpp-beginners/thread37131.html
графические функции (анимация) C++
прошу помочь с задачей:изобразить на экране снежинки,которые падают и увеличиваются в размерах.Снежинки имеют по 6 промежутков длинной 1 с одной точки,с конца каждого лучика виходят пять лучиков...
Простая проверка почты C++
Может кто знает исходники программки на Visual C++ простой проверки почты? Например если при проверки почты пришло письмо с определённым содержанием, сделать какое-то действие. Заранее благодарю...
C++ Работа с файлами из консольного приложения http://www.cyberforum.ru/cpp-beginners/thread37096.html
Есть две задачи которые требуют работать с файлами, а опыт работы с файлами из приложения у меня очень слабый. Задача 1: "Файл содержит данные об учениках школы: фамилия, имя, адрес(улица, дом,...
C++ Обясните про функцию bioskey() :help: Обясните как работать з bioskey на С. Бо надо сделать задания(создать меню с использованиям bioskey с помощью стрелок і Ентер).А я не могу до конца понять, HELP не помагает...... подробнее

Показать сообщение отдельно
Sasuke-sama
0 / 0 / 0
Регистрация: 22.05.2009
Сообщений: 33
29.05.2009, 17:33  [ТС]
Код
#ifndef            MATRIX_CPP
#define            MATRIX_CPP

#include           <assert.h>
#include           <iostream.h>


template<class TYPE>
class TMatrix
{
   friend TMatrix  operator+    (TYPE, TMatrix &); //ñëîæåíèå ñî ñêàëÿðîì
   friend TMatrix  operator-    (TYPE, TMatrix &); //âû÷èòàíèå ñî ñêàëÿðîì
   friend TMatrix  operator*    (TYPE, TMatrix &); //óìíîæåíèå íà ñêàëÿð
   friend istream& operator>>   (istream &, TMatrix &); //ââîä ìàòðèöû
   friend ostream& operator<<   (ostream &, TMatrix &); //âûâîä ìàòðèöû
public:
   TMatrix                      ();                //êîíñòðóêòîð ïî óìîë÷àíèþ
   TMatrix                      (TMatrix &);       //êîíñòðóêòîð êîïèðîâàíèÿ
   TMatrix                      (int, int);        //êîíñòðóêòîð ñ çàäàíèåì
						   //ðàçìåðà
   ~TMatrix                     ();                //äåñòðóêòîð
   void            init         (TYPE c);          //èíèöèàëèçàöèÿ ÷èñëîì
   void            initStat     (TYPE *p, int, int);//èíèöèàëèç. ñòàòè÷.
						    //ìàññèâîì
   void            initDynam    (TYPE **p, int, int);//èíèöèàëèç. äèíàìè÷.
						   //ìàññèâîì
   void            setSize      (int, int);        //óñòàíîâêà ðàçìåðà
   int             getSizeRow   ();                //êîë-âî ñòðîê
   int             getSizeCol   ();                //êîë-âî ñòîëáöîâ
   TYPE &          operator()   (int, int);        //ýëåìåíò ìàòðèöû
   TYPE &          operator[]   (int);             //ýëåìåíò
						   //ìàòðèöû-âåêòîðà
   TMatrix &       operator=    (TMatrix &);       //ïðèñâàèâàíèå
   TMatrix         getRow       (int);             //ñòðîêà
   TMatrix         getCol       (int);             //ñòîëáåö
   void            setRow       (int, TMatrix &);  //çàäàòü ñòðîêó
   void            setCol       (int, TMatrix &);  //çàäàòü ñòîëáåö
   TMatrix         getPart      (int, int, int, int); //ïîëó÷èòü ÷àñòü
   void            setPart      (int, int, TMatrix &); //çàäàòü ÷àñòü
   void            swapRow      (int, int);        //îáìåí ñòðîê
   void            swapCol      (int, int);        //îáìåí ñòîëáöîâ
   TMatrix         operator+    (TMatrix &);       //ñëîæåíèå ìàòðèö
   TMatrix         operator-    (TMatrix &);       //âû÷èòàíèå ìàòðèö
   TMatrix         operator*    (TMatrix &);       //óìíîæåíèå ìàòðèö
   TMatrix         operator^    (TMatrix &);       //óìíîæåíèå ìàòðèö
						   //(ïåðåìíîæåíèå
						   //ñîîòâåòñòâóþùèõ
						   //ýëåìåíòîâ)
   TMatrix &       operator+=   (TMatrix &);       //ïðèñâàèâàíèÿ
   TMatrix &       operator-=   (TMatrix &);
   TMatrix &       operator*=   (TMatrix &);
   TMatrix &       operator^=   (TMatrix &);
   TMatrix         getTranspose ();                //òðàíñïîíèðîâàíèå
   TMatrix &       setSingle    (int n);           //ñäåëàòü åäèíè÷íîé
   TMatrix         operator+    (TYPE);            //îïåðàöèè ñî ñêàëÿðàìè
   TMatrix         operator-    (TYPE);
   TMatrix         operator*    (TYPE);
   TMatrix         operator/    (TYPE);
   TMatrix &       operator+=   (TYPE);
   TMatrix &       operator-=   (TYPE);
   TMatrix &       operator*=   (TYPE);
   TMatrix &       operator/=   (TYPE);
   TMatrix         operator-    ();
   TYPE            operator%    (TMatrix &);       //ñêàëÿðíîå óìíîæåíèå äëÿ
						   //ìàòðèö-âåêòîðîâ
   int             readSize     (istream &);       //÷òåíèå ðàçìåðîâ
   int             readArray    (istream &);       //÷òåíèå ìàññèâà
   int             writeSize    (ostream &);       //çàïèñü ðàçìåðîâ
   int             writeArray   (ostream &);       //çàïèñü ìàññèâà
private:
   TYPE **         array;                          //ýëåìåíòû ìàòðèöû
   int             sizeRow;                        //êîë-âî ñòðîê
   int             sizeCol;                        //êîë-âî ñòîëáöîâ
   void            error        (int);             //ñîîáùåíèå îá îøèáêå
};

template<class TYPE>
TMatrix<TYPE>::TMatrix()
{
   array=NULL;
   sizeRow=0;
   sizeCol=0;
}


template<class TYPE>
TMatrix<TYPE>::TMatrix(TMatrix<TYPE> &m)
{
   array=NULL;
   sizeRow=0;
   sizeCol=0;

   if(m.sizeRow>0 && m.sizeCol>0)
   {
      sizeRow=m.sizeRow;
      sizeCol=m.sizeCol;

      array=new TYPE*[sizeRow];
      assert(array!=NULL);

      for(int i=0; i<sizeRow; i++)
      {
	 array[i]=new TYPE[sizeCol];
	 assert(array[i]!=NULL);
      }

      for(i=0; i<sizeRow; i++)
      {
	 for(int j=0; j<sizeCol; j++)
	 {
	    array[i][j]=m.array[i][j];
	 }
      }
   }
   else
   {
      error(1);
   }
}


template<class TYPE>
TMatrix<TYPE>::TMatrix(int row, int col)
{
   array=NULL;
   sizeRow=0;
   sizeCol=0;

   if(row>0 && col>0)
   {
      sizeRow=row;
      sizeCol=col;

      array=new TYPE*[sizeRow];
      assert(array!=NULL);

      for(int i=0; i<sizeRow; i++)
      {
	 array[i]=new TYPE[sizeCol];
	 assert(array[i]!=NULL);
      }
   }
   else
   {
      error(2);
   }
}


template<class TYPE>
TMatrix<TYPE>::~TMatrix()
{
   if(array!=NULL)
   {
      for(int i=0; i<sizeRow; i++)
      {
	 if(array[i]!=NULL)
	 {
	    delete [] array[i];
	 }
      }

      delete [] array;
   }
}


template<class TYPE>
TMatrix<TYPE> &TMatrix<TYPE>::operator=(TMatrix<TYPE> &m)
{
   if(this!=&m)
   {
      if(sizeRow==0 && sizeCol==0)
      {
	 sizeRow=m.sizeRow;
	 sizeCol=m.sizeCol;

	 array=new TYPE*[sizeRow];
	 assert(array!=NULL);

	 for(int i=0; i<sizeRow; i++)
	 {
	    array[i]=new TYPE[sizeCol];
	    assert(array[i]!=NULL);
	 }
      }

      if(sizeRow==m.sizeRow && sizeCol==m.sizeCol)
      {
	 for(int i=0; i<sizeRow; i++)
	 {
	    for(int j=0; j<sizeCol; j++)
	    {
	       array[i][j]=m.array[i][j];
	    }
	 }
      }
      else
      {
	 error(3);
      }
   }

   return *this;
}


template<class TYPE>
TYPE & TMatrix<TYPE>::operator()(int row, int col)
{
   if(row>0 && row<=sizeRow && col>0 && col<=sizeCol)
   {
      return array[row-1][col-1];
   }
   else
   {
      error(4);
      return array[0][0];
   }
}


template<class TYPE>
TYPE & TMatrix<TYPE>::operator[](int k)
{
   if(sizeRow==1 && k>0 && k<=sizeCol)
   {
      return array[0][k-1];
   }
   else
   {
      if(sizeCol==1 && k>0 && k<=sizeRow)
      {
	  return array[k-1][0];
      }
      else
      {
	 error(5);
	 return array[0][0];
      }
   }
}


template<class TYPE>
int TMatrix<TYPE>::getSizeRow()
{
   return sizeRow;
}


template<class TYPE>
int TMatrix<TYPE>::getSizeCol()
{
   return sizeCol;
}


template<class TYPE>
void TMatrix<TYPE>::setSize(int row, int col)
{
   if(row==0 && col==0)
   {
      if(array!=NULL)
      {
	 for(int i=0; i<sizeRow; i++)
	 {
	    if(array[i]!=NULL)
	    {
	       delete [] array[i];
	    }
	 }

	 delete [] array;
	 array=NULL;
      }

      sizeRow=0;
      sizeCol=0;

      return;
   }

   if(row>0 && col>0)
   {
      if(array!=NULL)
      {
	 for(int i=0; i<sizeRow; i++)
	 {
	    if(array[i]!=NULL)
	    {
	       delete [] array[i];
	    }
	 }

	 delete [] array;
      }

      sizeRow=row;
      sizeCol=col;

      array=new TYPE*[sizeRow];
      assert(array!=NULL);

      for(int i=0; i<sizeRow; i++)
      {
	 array[i]=new TYPE[sizeCol];
	 assert(array[i]!=NULL);
      }
   }
   else
   {
      error(6);
   }
}


template<class TYPE>
TMatrix<TYPE> TMatrix<TYPE>::operator+(TMatrix<TYPE> &m)
{
   TMatrix t_m(sizeRow, sizeCol);

   if(sizeRow==m.sizeRow&&sizeCol==m.sizeCol)
   {
      for(int i=0; i<sizeRow; i++)
      {
	 for(int j=0; j<sizeCol; j++)
	 {
	    t_m.array[i][j]=array[i][j]+m.array[i][j];
	 }
      }
   }
   else
   {
      error(7);
   }

   return t_m;
}


template<class TYPE>
TMatrix<TYPE> TMatrix<TYPE>::operator-(TMatrix<TYPE> &m)
{
   TMatrix t_m(sizeRow, sizeCol);

   if(sizeRow==m.sizeRow&&sizeCol==m.sizeCol)
   {
      for(int i=0; i<sizeRow; i++)
      {
	 for(int j=0; j<sizeCol; j++)
	 {
	    t_m.array[i][j]=array[i][j]-m.array[i][j];
	 }
      }
   }
   else
   {
      error(8);
   }

   return t_m;
}


template<class TYPE>
TMatrix<TYPE> TMatrix<TYPE>::operator*(TMatrix<TYPE> &m)
{
   TMatrix t_m(sizeRow, m.sizeCol);

   if(sizeCol==m.sizeRow)
   {
      for(int i=0; i<t_m.sizeRow; i++)
      {
	 for(int j=0; j<t_m.sizeCol; j++)
	 {
	    TYPE sum=0;

	    for(int k=0; k<sizeCol; k++)
	    {
	       sum+=array[i][k]*m.array[k][j];
	    }

	    t_m.array[i][j]=sum;
	 }
      }
   }
   else
   {
      error(9);
   }

   return t_m;
}


template<class TYPE>
TMatrix<TYPE> TMatrix<TYPE>::operator^(TMatrix<TYPE> &m)
{
   TMatrix t_m(sizeRow, sizeCol);

   if(sizeRow==m.sizeRow&&sizeCol==m.sizeCol)
   {
      for(int i=0; i<sizeRow; i++)
      {
	 for(int j=0; j<sizeCol; j++)
	 {
	    t_m.array[i][j]=array[i][j]*m.array[i][j];
	 }
      }
   }
   else
   {
      error(10);
   }

   return t_m;
}


template<class TYPE>
TMatrix<TYPE> &TMatrix<TYPE>::operator+=(TMatrix<TYPE> &m)
{
   if(sizeRow==m.sizeRow&&sizeCol==m.sizeCol)
   {
      for(int i=0; i<sizeRow; i++)
      {
	 for(int j=0; j<sizeCol; j++)
	 {
	    array[i][j]+=m.array[i][j];
	 }
      }
   }
   else
   {
      error(11);
   }

   return *this;
}


template<class TYPE>
TMatrix<TYPE> &TMatrix<TYPE>::operator-=(TMatrix<TYPE> &m)
{
   if(sizeRow==m.sizeRow&&sizeCol==m.sizeCol)
   {
      for(int i=0; i<sizeRow; i++)
      {
	 for(int j=0; j<sizeCol; j++)
	 {
	    array[i][j]-=m.array[i][j];
	 }
      }
   }
   else
   {
      error(12);
   }

   return *this;
}


template<class TYPE>
TMatrix<TYPE> & TMatrix<TYPE>::operator*=(TMatrix<TYPE> &m)
{
   TMatrix t_m(sizeRow, m.sizeCol);

   if(sizeCol==m.sizeRow)
   {
      for(int i=0; i<t_m.sizeRow; i++)
      {
	 for(int j=0; j<t_m.sizeCol; j++)
	 {
	    TYPE sum=0;

	    for(int k=0; k<sizeCol; k++)
	    {
	       sum+=array[i][k]*m.array[k][j];
	    }

	    t_m.array[i][j]=sum;
	 }
      }

      *this=t_m;
   }
   else
   {
      error(29);
   }

   return *this;
}


template<class TYPE>
TMatrix<TYPE> &TMatrix<TYPE>::operator^=(TMatrix<TYPE> &m)
{
   if(sizeRow==m.sizeRow&&sizeCol==m.sizeCol)
   {
      for(int i=0; i<sizeRow; i++)
      {
	 for(int j=0; j<sizeCol; j++)
	 {
	    array[i][j]*=m.array[i][j];
	 }
      }
   }
   else
   {
      error(13);
   }

   return *this;
}


template<class TYPE>
TMatrix<TYPE> TMatrix<TYPE>::getTranspose()
{
   TMatrix<TYPE> new_m(sizeCol, sizeRow);

   for(int i=0; i<sizeRow; i++)
   {
      for(int j=0; j<sizeCol; j++)
      {
	 new_m.array[j][i]=array[i][j];
      }
   }

   return new_m;
}


template<class TYPE>
TMatrix<TYPE> TMatrix<TYPE>::operator+(TYPE c)
{
   TMatrix<TYPE> t_m(*this);

   if(sizeRow==sizeCol)
   {
      for(int i=0; i<sizeRow; i++)
      {
	 t_m.array[i][i]+=c;
      }
   }
   else
   {
      error(14);
   }

   return t_m;
}


template<class TYPE>
TMatrix<TYPE> TMatrix<TYPE>::operator-(TYPE c)
{
   TMatrix<TYPE> t_m(*this);

   if(sizeRow==sizeCol)
   {
      for(int i=0; i<sizeRow; i++)
      {
	 t_m.array[i][i]-=c;
      }
   }
   else
   {
      error(15);
   }

   return t_m;
}


template<class TYPE>
TMatrix<TYPE> TMatrix<TYPE>::operator*(TYPE c)
{
   TMatrix<TYPE> t_m(sizeRow, sizeCol);

   for(int i=0; i<sizeRow; i++)
   {
      for(int j=0; j<sizeCol; j++)
      {
	 t_m.array[i][j]=array[i][j]*c;
      }
   }

   return t_m;
}


template<class TYPE>
TMatrix<TYPE> TMatrix<TYPE>::operator/(TYPE c)
{
   TMatrix<TYPE> t_m(sizeRow, sizeCol);

   for(int i=0; i<sizeRow; i++)
   {
      for(int j=0; j<sizeCol; j++)
      {
	 t_m.array[i][j]=array[i][j]/c;
      }
   }

   return t_m;
}


template<class TYPE>
TMatrix<TYPE> &TMatrix<TYPE>::operator+=(TYPE c)
{
   if(sizeRow==sizeCol)
   {
      for(int i=0; i<sizeRow; i++)
      {
	 array[i][i]+=c;
      }
   }
   else
   {
      error(16);
   }

   return *this;
}


template<class TYPE>
TMatrix<TYPE> &TMatrix<TYPE>::operator-=(TYPE c)
{
   if(sizeRow==sizeCol)
   {
      for(int i=0; i<sizeRow; i++)
      {
	 array[i][i]-=c;
      }
   }
   else
   {
      error(17);
   }

   return *this;
}


template<class TYPE>
TMatrix<TYPE> &TMatrix<TYPE>::operator*=(TYPE c)
{
   for(int i=0; i<sizeRow; i++)
   {
      for(int j=0; j<sizeCol; j++)
      {
	 array[i][j]*=c;
      }
   }

   return *this;
}


template<class TYPE>
TMatrix<TYPE> &TMatrix<TYPE>::operator/=(TYPE c)
{
   for(int i=0; i<sizeRow; i++)
   {
      for(int j=0; j<sizeCol; j++)
      {
	 array[i][j]/=c;
      }
   }

   return *this;
}


template<class TYPE>
TMatrix<TYPE> TMatrix<TYPE>::getRow(int row)
{
   TMatrix<TYPE> t_m(1, sizeCol);

   if(row>0 && row<=sizeRow)
   {
      for(int i=0; i<sizeCol; i++)
      {
	 t_m.array[0][i]=array[row-1][i];
      }
   }
   else
   {
      error(18);
   }

   return t_m;
}


template<class TYPE>
TMatrix<TYPE> TMatrix<TYPE>::getCol(int col)
{
   TMatrix<TYPE> t_m(sizeRow, 1);

   if(col>0 && col<=sizeCol)
   {
      for(int i=0; i<sizeRow; i++)
      {
	 t_m.array[i][0]=array[i][col-1];
      }
   }
   else
   {
      error(19);
   }

   return t_m;
}


template<class TYPE>
TMatrix<TYPE> TMatrix<TYPE>::getPart(int i1, int j1, int m, int n)
{
   TMatrix<TYPE> res(m,n);

   if(i1>0 && i1<=sizeRow && j1>0 && j1<=sizeCol &&
      m>0 && i1+m<=sizeRow+1 && n>0 && j1+n<=sizeCol+1)
   {
      for(int i=0, i2=i1-1; i<m; i++, i2++)
      {
	 for(int j=0, j2=j1-1; j<n; j++, j2++)
	 {
	    res.array[i][j]=array[i2][j2];
	 }
      }
   }
   else
   {
      error(20);
   }

   return res;
}


template<class TYPE>
void TMatrix<TYPE>::setPart(int i1, int j1, TMatrix<TYPE> &t)
{
   int m=t.getSizeRow(), n=t.getSizeCol();

   if(i1>0 && i1<=sizeRow && j1>0 && j1<=sizeCol &&
      m>0 && i1+m<=sizeRow+1 && n>0 && j1+n<=sizeCol+1)
   {
      for(int i=0, i2=i1-1; i<m; i++, i2++)
      {
	 for(int j=0, j2=j1-1; j<n; j++, j2++)
	 {
	    array[i2][j2]=t.array[i][j];
	 }
      }
   }
   else
   {
      error(21);
   }
}


template<class TYPE>
void TMatrix<TYPE>::swapRow(int i1, int i2)
{
   if(i1>0 && i1<=sizeRow && i2>0 && i2<=sizeRow)
   {
      for(int j=0; j<sizeCol; j++)
      {
	 TYPE t=array[i1-1][j];
	 array[i1-1][j]=array[i2-1][j];
	 array[i2-1][j]=t;
      }
   }
   else
   {
      error(22);
   }
}


template<class TYPE>
void TMatrix<TYPE>::swapCol(int j1, int j2)
{
   if(j1>0 && j1<=sizeCol && j2>0 && j2<=sizeCol)
   {
      for(int i=0; i<sizeRow; i++)
      {
	 TYPE t=array[i][j1-1];
	 array[i][j1-1]=array[i][j2-1];
	 array[i][j2-1]=t;
      }
   }
   else
   {
      error(23);
   }
}


template<class TYPE>
TMatrix<TYPE> operator+(TYPE c, TMatrix<TYPE> &m)
{
   return m+c;
}


template<class TYPE>
TMatrix<TYPE> operator-(TYPE c, TMatrix<TYPE> &m)
{
   return m*(-1)+c;
}


template<class TYPE>
TMatrix<TYPE> operator*(TYPE c, TMatrix<TYPE> &m)
{
   return m*c;
}


template<class TYPE>
void TMatrix<TYPE>::setRow(int row_index, TMatrix<TYPE> &m)
{

   if(m.sizeRow==1 && sizeCol==m.sizeCol &&
      row_index>0 && row_index<=sizeRow)
   {
      for(int i=0; i<sizeCol; i++)
      {
	 array[row_index-1][i]=m.array[0][i];
      }
   }
   else
   {
      error(24);
   }
}


template<class TYPE>
void TMatrix<TYPE>::setCol(int col_index, TMatrix<TYPE> &m)
{
   if(sizeRow==m.sizeRow && m.sizeCol==1 &&
      col_index>0 && col_index<=sizeCol)
   {
      for(int i=0; i<sizeRow; i++)
      {
	 array[i][col_index-1]=m.array[i][0];
      }
   }
   else
   {
      error(25);
   }
}


template<class TYPE>
TYPE TMatrix<TYPE>::operator%(TMatrix<TYPE> &m)
{
   TYPE sum=0;

   if(sizeRow==m.sizeRow && sizeCol==m.sizeCol)
   {
      if(sizeRow==1)
      {
	 for(int i=0; i<sizeCol; i++)
	 {
	    sum+=array[0][i]*m.array[0][i];
	 }
      }
      else
      {
	 if(sizeCol==1)
	 {
	    for(int i=0; i<sizeRow; i++)
	    {
	       sum+=array[i][0]*m.array[i][0];
	    }
	 }
	 else
	 {
	    error(26);
	 }
      }
   }
   else
   {
      if(sizeRow==m.sizeCol && sizeCol==m.sizeRow)
      {
	 if(sizeRow==1)
	 {
	    for(int i=0; i<sizeCol; i++)
	    {
	       sum+=array[0][i]*m.array[i][0];
	    }
	 }
	 else
	 {
	    if(sizeCol==1)
	    {
	       for(int i=0; i<sizeRow; i++)
	       {
		  sum+=array[i][0]*m.array[0][i];
	       }
	    }
	    else
	    {
	       error(27);
	    }
	 }
      }
   }

   return sum;
}


template<class TYPE>
TMatrix<TYPE> TMatrix<TYPE>::operator-()
{
   return (*this)*(-1);
}


template<class TYPE>
TMatrix<TYPE> & TMatrix<TYPE>::setSingle(int n)
{
   if(n>0)
   {
      setSize(n,n);
      init(0);
      for(int i=0; i<n; i++)
      {
	 array[i][i]=1;
      }
   }
   else
   {
      error(28);
   }

   return *this;
}


template<class TYPE>
istream & operator>>(istream &in, TMatrix<TYPE> &m)
{
   m.readSize(in);
   m.readArray(in);

   return in;
}


template<class TYPE>
ostream & operator<<(ostream &out, TMatrix<TYPE> &m)
{
   m.writeSize(out);
   m.writeArray(out);

   return out;
}


template<class TYPE>
void TMatrix<TYPE>::init(TYPE c)
{
   for(int i=0; i<sizeRow; i++)
   {
      for(int j=0; j<sizeCol; j++)
      {
	 array[i][j]=c;
      }
   }
}


template<class TYPE>
void TMatrix<TYPE>::initStat(TYPE *p, int size_r, int size_c)
{
   this->setSize(size_r,size_c);

   for(int i=0; i<sizeRow; i++)
   {
      for(int j=0; j<sizeCol; j++)
      {
	 array[i][j]=p[i*size_c+j];
      }
   }
}


template<class TYPE>
void TMatrix<TYPE>::initDynam(TYPE **p, int size_r, int size_c)
{
   this->setSize(size_r,size_c);

   for(int i=0; i<sizeRow; i++)
   {
      for(int j=0; j<sizeCol; j++)
      {
	 array[i][j]=p[i][j];
      }
   }
}


template<class TYPE>
int TMatrix<TYPE>::readSize(istream &in)
{
   if(!in)
   {
      return 0;
   }

   int size1, size2;

   in>>size1>>size2;
   setSize(size1, size2);

   return 1;
}


template<class TYPE>
int TMatrix<TYPE>::readArray(istream &in)
{
   if(!in)
   {
      return 0;
   }

   for(int i=0; i<sizeRow; i++)
   {
      for(int j=0; j<sizeCol; j++)
      {
	 in>>array[i][j];
      }
   }

   return 1;
}


template<class TYPE>
int TMatrix<TYPE>::writeSize(ostream &out)
{
   if(!out)
   {
      return 0;
   }

   out<<sizeRow<<' '<<sizeCol<<endl;

   return 1;
}


template<class TYPE>
int TMatrix<TYPE>::writeArray(ostream &out)
{
   if(!out)
   {
      return 0;
   }

   for(int i=0; i<sizeRow; i++)
   {
      for(int j=0; j<sizeCol; j++)
      {
	 out.width(14);
	 out<<array[i][j];
      }
      out<<endl;
   }

   return 1;
}


template<class TYPE>
void TMatrix<TYPE>::error(int error_id)
{
   cout<<"TMatrix ERROR: #"<<error_id<<endl;
}


#endif
Что из этого выбрать шобы решить мою задачу!!!

Добавлено через 6 часов 56 минут 1 секунду
Вот как из этого:
Код
#include<iostream.h>
#include<conio.h>
#include<math.h>
class myclass  //opredeleniye klassa
{
	public:
	void set(float xx,float yy,float zz);//prototip functsii ustanovki znacheniy
	void run();  //prototip functsii vichisleniya virazheniya
	void print();//prototip f-ii vivoda na ekran
	private:
	float x,y,z,u;//znacheniya
};
//opredeleniya functsiy classa
void myclass::set(float xx,float yy,float zz)
{
	x=xx;
	y=yy;
	z=zz;
}
void myclass::run()
{
	u=pow(8+pow(fabs(x-y),2)+1,1./3.)/(x*x+y*y+2)-
	exp(fabs(x-y))*pow(pow(tan(z),2)+1,x);
}
void myclass::print()
{
	cout<<"X="<<x<<"\nY="<<y<<"\nZ="<<z<<"\nU="<<u;
}
//glavnaya programma
void main()
{
	myclass m;    //staticheskiy sposob
	clrscr();
	m.set(-4.5,0.75E-4,0.845E2); //ustanovka znacheniy
	m.run();    //vichisleniye rezultata
	m.print();  //vivod na ekran
	cout<<"\n\n";

	myclass *m1=&m; //dinamicheskiy sposob
	m1->set(-4.5,0.75E-4,0.845E2);
	m1->run();
	m1->print();
	getch();
}
Переделать в моё задание??????
0
 
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru