[Drongo]

Значит 2-я задача готова... 1-ю тоже, но нужно откоментировать - откоментирую выложу... Завтра...))))))

Код:

// Программа Задачи №2, о Вертолёте и Планере---------------------------------
#include <iostream.h>
using std::cout;
using std::cin;
using std::endl;

class Helicopter{ // Класс Helicopter
public:
  Helicopter(int, int); // Конструктор Helicopter'a
  void Print() const { cout<<" Speed Helicopter: "<<Speed<<"\n"<<" Cargo Helicopter: "<<Cargo<<endl; };// Печать
private:
  int Speed;  // Скорость Вертолёта
  int Cargo;  // Грузоподъёмность Вертолёта
};
// -------------------------------------------------------------------------
class Planer{ // Класс Planer
public:
  Planer(int, int); // Конструктор Planer'a
  void Print() const { cout<<" Speed Planer: "<<Speed<<"\n"<<" Cargo Planer: "<<Cargo<<endl; };// Печать
private:
  int Speed; // Скорость Планера
  int Cargo; // Грузоподъёмность Планера
};

// Конструктор Helicopter----------------------------------------------------
Helicopter::Helicopter(int spd, int crg)
{
   Speed = (spd > 0) ? spd : 230;
   Cargo = (crg > 0) ? crg : 2000;
   cout<<" Inizialization... 'Helicopter'\n";
}
// Конструктор Planer---------------------------------------------------------
Planer::Planer(int spd, int crg)
{
   Speed = (spd > 0) ? spd : 230;
   Cargo = (crg > 0) ? crg : 1535;
   cout<<" Inizialization... 'Planer'\n\n";
}
// Выполнение программы------------------------------------------------------
int main()
{
   int z;
   Helicopter hel(21, 500); // Объект класса Helicopter, со своими значениями
   Planer plnr(53, 458);    // Объект класса Planer, со своими значениями

   hel.Print(); // Вывод данных объекта класса Helicopter
   cout<<endl;  // Пустая строка, для читабельности
   plnr.Print(); // Вывод данных объекта класса Planer

   cin>>z;
  return 0;
}
//-------------------------------------------------------------------

[elektra192]

Спасибо...каким компилятором можна компилировать???и если можна файл выложы....

[Drongo]

Borland C++ Builder 6 делал...

[Drongo]

Вот 1 задача, а вот о Матрицах, сам бы хотел увидеть правильное решение, особенно об умножении Вектора на Матрицу... И описание класса Вектор... Тем не менее я попробую решить,
Умножение Матрицы на Матрицу
Умножение Матрицы на Число

А вы раскритикуйте мой код, хотя я и сам понимаю что решил по-дилетантски, но я пробую решить, только в этом вопросе нет соответсвующих знаний, в следующий раз я выложу половину решения 3-го задания...


Код:

Код:

// Программа Задачи №1, о Функциях друзьях----------
#include <iostream.h>
using std::cout;
using std::cin;
using std::endl;

class MyClass{ // Класс MyClass 
   friend bool fr(const MyClass &mClass); // Функция друг, принимает ссылку на объект класс MyClass
   friend void printResult(const MyClass &mClass); // Функция друг, принимает ссылку на объект класс MyClass
public:
   MyClass(int x) { num = x; }; // Конструктор
private:
   int num; // Число....
};

// Булевая функция, если число положительное вернуть - true, если отрицательное - false-------
bool fr(const MyClass &mClass)
{
   return (mClass.num > 0) ? true : false;
}
// Печать результата, используя результат функции fr(const MyClass & mClass)--------------------------
void printResult(const MyClass &mClass)
{
  if(true == fr(mClass.num)) // явное сравнение с возвращаемым результатом - true
     cout<<" Num: "<<mClass.num<<".  Number Positiv"<<endl;
  else if(false == fr(mClass.num)) // явное сравнение с возвращаемым результатом - false
     cout<<" Num: "<<mClass.num<<".  Number Negativ"<<endl;
}
// Выполнение программы-------------------------------------------------------------------------
int main()
{
   int z;
   MyClass MC_1(-8); // Объект с отрицательным аргументом
   MyClass MC_2(10); // Объект с положительным аргументом

   printResult(MC_1); // Вызов функции проверки для объекта MC_1
   printResult(MC_2); // Вызов функции проверки для объекта MC_2

   cin>>z;
        return 0;
}
//---------------------------------------------------------------------------

[Drongo]

Решил часть 3-й задачи... Пожалуйста, раскритикуйте мой код... Приму любые дельные замечания..
Кроме того хочу узнать, посоветуйте, как решается данная задачка, если можно попунктно, например: шаг 1... шаг 2... шаг 3... и т.д... от чего отталкиваться, приму любые ссылки. Но больше всего хочу узнать, как определить класс "Вектор" и умножить Вектор на Матрицу... Очень бы хотелось увидеть код, выполняющий это умножение, а не сухое определение Вектора... Поскольку считаю для себя проблему в том, что я не могу определить класс "Вектор"... Передаю файл, который у меня получился... Так что критикуйте, как пожелает сердце, ведь в споре рождается истина, всем благодарен, за советы и помощь, кто откликнется!

Код:

//---------------------------------------------------------------------------
#include <iostream.h>
using std::cout;
using std::cin;
using std::endl;

#include <iomanip>
using std::setw;

class Matrix{ // Класс Matrix
   // Дружеская функция умножения Матрицы на Матрицу
   friend void MultiplicationMatrix(Matrix &mMatrix);
   // Дружеская функция умножения Матрицы на Число
   friend void NumberMultiplicationMatrix(Matrix &mMatrix, int);
public:
   Matrix(int height = 1, int width = 1); // Конструктор с аргументами по умолчанию
   void setMatrix(int height, int width); // Установка размера матрицы
   void UserFromKeyboards(); // Ввод данных с клавиатуры
   void PrintTwoMatrix(); // Печать Значений Матриц
   ~Matrix(); // Деструктор
private:
   int *Matrix_1; // Указатель на целое (Первая Матрица)
   int *Matrix_2; // Указатель на целое (Вторая Матрица)
   int SizeMatrix; // Размер Матрицы
   int row; // Сколько строк в Матрице
   int column;  // Сколько столбцов в Матрице
};
// Конструктор--------------------------------------------------------------
Matrix::Matrix(int height, int width)
{
   setMatrix(height, width);
}
// Установка размера Матрицы------------------------------------------------
void Matrix::setMatrix(int h, int w)
{
   SizeMatrix = h * w;
}
// Ввод данных с клавиатуры-------------------------------------------------
void Matrix::UserFromKeyboards()
{
   int counter_1 = 1,
   counter_2 = 1;

   cout<<" Enter size Column: ";
   cin>>column;                 // Столбцы
   cout<<" Enter size Row: ";
   cin>>row;                    // Строки

   setMatrix(row, column); // Определение размера Матрицы ( row * column )
   Matrix_1 = new int[SizeMatrix]; // Матрица 1 в виде одномерного массива
   Matrix_2 = new int[SizeMatrix]; // Матрица 2 в виде одномерного массива

   // Циклический ввод в 1-ю Матрицу 
   for(int i = 0; i < SizeMatrix; i++){
      cout<<" Enter value in 'Matrix_1', position "<<counter_1++<<" Value: ";
      cin>>Matrix_1[i];
    }

   cout<<endl; // Пустая строка (для читабельности)

   // Циклический ввод в 2-ю Матрицу
   for(int j = 0; j < SizeMatrix; j++){
      cout<<" Enter value in 'Matrix_2', position "<<counter_2++<<" Value: ";
      cin>>Matrix_2[j];
    }
}
// Вывод элементов обоих Матриц на экран------------------------------------
void Matrix::PrintTwoMatrix()
{
   int control_1 = 0, // Для вывода знака '|' в начале 1-й Матрицы
       control_2 = 0, // Для вывода знака '|' в начале 2-й Матрицы
       counColumn_1 = column, // Для вывода знака '|' в конце 1-й Матрицы
       counColumn_2 = column; // Для вывода знака '|' в конце 2-й Матрицы
       
   // Вывод на экран 1-й Матрицы
   for(int j = 0; j < SizeMatrix; j++){
      if(control_1 == 0){
        cout<<'|';
        control_1++;
      }
      cout<<setw(7)<<Matrix_1[j];
      if(j == counColumn_1-1){
        counColumn_1 += column;
        cout<<'|';
        control_1 = 0;
        cout<<endl;
      }
    }

   cout<<"\n\n";  // Пару пустых строк (для читабельности)

   // Вывод на экран 2-й Матрицы
   for(int jj = 0; jj < SizeMatrix; jj++){
      if(control_2 == 0){
        cout<<'|';
        control_2++;
      }
      cout<<setw(7)<<Matrix_2[jj];
      if(jj == counColumn_2-1){
        counColumn_2 += column;
        cout<<'|';
        control_2 = 0;
        cout<<endl;
      }
    }
}
// Деструктор---------------------------------------------------------------
Matrix::~Matrix()
{
  cout<<"Destructor"<<endl;
}
// Дружеская функция умножения Матрицы на Матрицу. В качестве---------------
// хранения результатов используется 2-я Матрица----------------------------
void MultiplicationMatrix(Matrix &mMatrix)
{
   int control = 0,
       counColumn = mMatrix.column;

   // Умножение Матрицы на Матрицу.
   // Циклическое умножение элемента 1-й Матрицы на элемент 2-й Матрицы
   for(int i = 0; i < mMatrix.SizeMatrix; i++)
      mMatrix.Matrix_2[i] *= mMatrix.Matrix_1[i];// * mMatrix.Matrix_2[i];

   cout<<"\n\n Result Multiplication...\n\n";

   // Вывод результата умножения Матрицы на Матрицу
   for(int j = 0; j < mMatrix.SizeMatrix; j++){
      if(control == 0){
        cout<<'|';
        control++;
      }
      cout<<setw(7)<<mMatrix.Matrix_2[j];
      if(j == counColumn-1){
        counColumn += mMatrix.column;
        cout<<'|';
        control = 0;
        cout<<endl;
      }
    }
}
// Дружеская функция умножения Матрицы на Число. В качестве------------------
// хранения результатов используется 2-я Матрица-----------------------------
void NumberMultiplicationMatrix(Matrix &mMatrix, int number)
{
   int control = 0,
       counColumn = mMatrix.column;

   // Умножение Матрицы на Число.
   // Циклическое умножение элемента 1-й Матрицы на элемент 2-й Матрицы
   for(int i = 0; i < mMatrix.SizeMatrix; i++)
      mMatrix.Matrix_2[i] = number * mMatrix.Matrix_1[i];

   cout<<"\n\n Result Multiplication Number "<<number<<" 'Matrix_1'\n\n";

   // Вывод результата умножения Матрицы на Число
   for(int j = 0; j < mMatrix.SizeMatrix; j++){
      if(control == 0){
        cout<<'|';
        control++;
      }
      cout<<setw(7)<<mMatrix.Matrix_2[j];
      if(j == counColumn-1){
        counColumn += mMatrix.column;
        cout<<'|';
        control = 0;
        cout<<endl;
      }
    }
}
// Выполнение программы------------------------------------------------------
int main()
{
  int z, num;
  Matrix matrx_1;

  matrx_1.UserFromKeyboards(); // Ввод
  matrx_1.PrintTwoMatrix();    // Печать

  MultiplicationMatrix(matrx_1); // Функция умножения Матрицы на Матрицу
  
  // Предложение ввести Число на которое будет умножена 1-я Матрица
  cout<<"\n\n Enter Number Multiplication Matrix: ";
  cin>>num;
  cout<<endl;
  NumberMultiplicationMatrix(matrx_1, num); // Функция умножения Матрицы на Число

  cin>>z;
        return 0;
}
//---------------------------------------------------------------------------

[Drongo]

Решённая задача о Матрицах (Код)
и
Или так

[Drongo]

Ребята, я чего то не могу отправить файл, нажал прикрепить, он загрузился, а дальше что делать - незнаю... Подскажите??

[Drongo]

Хлопцы, здоров! Вот тут в Сети нашёл, файл по Матрице и Вектору, но чего-то не доганяю... Там

Код:

#include

- пустые, вы б не могли, сказать какие нужно подключить?! И ещё, похоже там есть, в этой проге какая то синктактическая ошибка, но найти я её не могу... Если кто может помочь в этом буду рад, мне б разобраться в этом, очень хочу решить тую задачу... Файл прикрепляю, гляньте если не будет трудно... Подскажите великодушно

[Drongo]

Ещё один код решения Матрицы (Расскрыть код)

читать дальше »

Код:

// файл tmatr.cpp
#include <iostream.h>
//#include     // для setmem()
//#include
//#include

typedef unsigned char dim;

template  class Matrix {
typedef Matrix Vector;
private:
   VARTYPE *matr;      // указатель на массив матрицы
   dim m,n;      // размеры матрицы
public:

// конструкторы и деструкторы:
   Matrix() { matr=(VARTYPE*)0; m=n=0; }
   Matrix(dim,dim=1); // Обычный конструктор
   Matrix(const Matrix&); // Конструктор копирования
   ~Matrix() { delete [ ]matr; }

// доступ к элементам матрицы
   dim size_row() { return m; }   // число строк
   dim size_col() { return n; }   // число столбцов
   VARTYPE& operator() (dim x) const { return (*this)(x,0); } // элементу

// перегруженные операции и функции:
   Matrix& operator=(const Matrix&);
   Matrix& operator=(const VARTYPE&);
   Matrix operator^(int);   // возведение в степень
   Matrix operator!();      // транспонирование

   VARTYPE determ();   // определитель матрицы
   VARTYPE vmodul();   // модуль вектора

   Matrix& Gauss(dim,dim); // преобразование по Гауссу
                       // (для получ. обратной и единичной матрицы)
                       // (для получ. верхнетреугольной матрицы)
   Matrix  minor(dim,dim);  // возвращает указ. минор матрицы
   Vector  line(dim i)       // возвращает вектор-строку матрицы
         { return extract(1,n,i,0); }
   Vector  column(dim j)     // возвращает вектор-столбец матрицы
         { return extract(m,1,0,j); }
   VARTYPE& operator() (dim,dim) const;                  // доступ к
Matrix& operator<<=(const Matrix &A) { return newsize(A.m,A.n)=A;
}
                                  // безусловное приравнивание матриц
   Matrix& insert(const Matrix&, dim=0, dim=0); // вставить частьматрицы
   Matrix extract(dim, dim, dim=0, dim=0);           // извлечьчасть матрицы
   Matrix& newsize(dim, dim=1);                 // установитьновые размеры
   void swap_line(dim, dim);                             //обмен строкамиматрицы
   void swap_column(dim, dim);                           // обмен столбцамиматрицы

   friend Matrix operator+(const Matrix&,const Matrix&);     //A-B
   friend Matrix operator-(const Matrix&,const Matrix&);     //A-B
   friend Matrix operator*(const Matrix&,const Matrix&);     //A*B
   friend Matrix operator*(const double&,const Matrix&);  //k*A
   friend Matrix operator*(const Matrix&, const double&); //A*k
   friend ostream& operator<<(ostream&,Matrix&);
                        // потоковый вывод матрицы
   friend int operator>>(istream&,Matrix&);
                        // потоковый ввод существ. матрицы
                        // 0 - без. ошибок, 1 - была ошибка

   dim read(ifstream&);       // файловое чтение и запись матрицы
   dim write(ofstream&);     // в ее внутреннем, двоичном представлении.
   friend VARTYPE operator %(const Matrix&,const Matrix&);

   //Функция ошибок
   void ERROR_MATRIX(dim) const;
};
// Реализация класса матриц
template 
Matrix::Matrix(dim M, dim N)
 {
    m=M;
    n=N;
    matr=new VARTYPE[m*n];
    if(!matr) ERROR_MATRIX(1);
    setmem(matr,sizeof(VARTYPE)*m*n,0);
 }

template 
Matrix::Matrix(const Matrix &M_Obj)  //Конструктор копирования
 {
   m=M_Obj.m;
   n=M_Obj.n;
   matr=new VARTYPE[m*n];
   if(!matr) ERROR_MATRIX(1);
   movmem(M_Obj.matr, matr, sizeof(VARTYPE)*m*n);
 }
template 
Matrix& Matrix::operator=(const Matrix &M_Obj)
 {
   m=M_Obj.m;
   n=M_Obj.n;
   matr=new VARTYPE[m*n];
   if(!matr) ERROR_MATRIX(1);
   movmem(M_Obj.matr,matr,sizeof(VARTYPE)*m*n);
   return *this;
 }
//Диагональ?
template 
Matrix& Matrix::operator=(const VARTYPE &f)
 {
   for(int i=0,j;i
Matrix Matrix::operator^(int q) // Степень
 {
   if (q>0)
      {
       for(Matrix M=*this; q>1; q--)
         M=M*(*this);
       return M;
      }
   if (q!=-1) ERROR_MATRIX(3);
   // вычисление обратной метoдом преобразований Гаусса
   if (n!=m)  ERROR_MATRIX(4);
   Matrix M(m,2*n);
   M.insert(*this);
   for(int i=0;i
Matrix Matrix::operator!()  // Транспозиция
 { Matrix A(n,m);
   for(int i=0, j; i
VARTYPE Matrix::determ() // рекурсивно находит определитель матрицы
 {
   if (n!=m) ERROR_MATRIX(4);

   if (n==1)
      return (*this)(0,0);

   for(int i=0; i M;
       M <<= *this;
       VARTYPE d=M(i,0)*(i%2?-1:1);
       return d*M.Gauss(i,0).minor(i,0).determ();
      }
   return 0.0;
 }
template 
VARTYPE Matrix::vmodul()      // Модуль вектора
 {
   VARTYPE d=0;
   if (n!=1) ERROR_MATRIX(9);
   static Matrix M;
   M <<= *this;
   for(int i=0; i
Matrix& Matrix::Gauss(dim M, dim N)
 {
   Matrix& A=*this;
   if (!A(M,N))  ERROR_MATRIX(5);

   for(int i=0,j;i
Matrix Matrix::minor(dim M, dim N)     // возвращ. матрицу без
 {                                                 // строки y и столбца x
    Matrix A(m-1,n-1);
    for(int i=0,in=0,j,jn;i   // вставка
Matrix& Matrix::insert(const Matrix &A, dim M, dim N)
 {
   if (M+A.m>m || N+A.n>n)  ERROR_MATRIX(6);
   for(int i=0, j; i   // извлечение
Matrix Matrix::extract(dim LM, dim LN, dim M, dim N)
 {
    if (M+LM>m || N+LN>n)  ERROR_MATRIX(7);
    Matrix A(LM,LN);
    for(int i=0, j; i
VARTYPE& Matrix::operator() (dim M, dim N) const
 { return *(matr+n*M+N); }

template
Matrix operator+(const Matrix &A, const
Matrix&B)
 {
   Matrix C=A;
   for(int i=0,j; i
Matrix operator-(const Matrix &A, const Matrix &B)
 {
   Matrix C=A;
   for(int i=0, j; i
Matrix operator*(const Matrix &A,const Matrix &B)
{
  Matrix C(A.m,B.n);

  if (A.n!=B.m)
  {
    if(A.m==3 && A.n==1 && B.m==3 && B.n==1)
    {
      C(0)=A(1)*B(2)-A(2)*B(1);
      C(1)=A(2)*B(0)-A(0)*B(2);
      C(2)=A(0)*B(1)-A(1)*B(0);
    }
    else
      A.ERROR_MATRIX(2);
  }
  else
  {
    for(int i=0,j,k;i//умножение числа на матрицу
Matrix operator*(const double &f,const Matrix &A)
 {
   Matrix B=A;
   for(int i=0,j;i// умножение матрицы на число
Matrix operator*(const Matrix &A, const double &f)
 {
   Matrix B=A;
   for(int i=0,j;i
Matrix& Matrix::newsize(dim M, dim N)
 { delete [] matr;
   m=M;
   n=N;
   if (N && M) { matr=new VARTYPE[m*n];
   if (!matr) ERROR_MATRIX(1);
       setmem(matr,sizeof(VARTYPE)*m*n,0); }
    else { m=n=0; matr=(VARTYPE*)0; }
   return *this;
 }

template
ostream& operator<<(ostream &out,Matrix &A)
 { for(int i=0,j;i
int operator>>(istream &inp,Matrix &A)
 { for(int i=0,j;i>A(i,j)) ) return 1;
   return 0;
 }
template
void Matrix::swap_line(dim L1, dim L2)
 {
   if (L1==L2)
     return;
   double b;
   for(int j=0;j
void Matrix::swap_column(dim C1, dim C2)
 {
   if (C1==C2)
     return;
   double b;
   for(int i=0;i
dim Matrix::read(ifstream &finp)
 { (finp.get(m)).get(n); delete []matr; matr=new VARTYPE[m*n];
      if(!matr) ERROR_MATRIX(1);
   setmem(matr,sizeof(VARTYPE)*m*n,0);
   finp.read((char *)matr,sizeof(VARTYPE)*m*n); return finp.fail();
 }
template
dim Matrix::write(ofstream &fout)
 { (fout.put(m)).put(n);
   (fout.write((char *)matr,sizeof(VARTYPE)*m*n))<
VARTYPE operator%(const Matrix &A, const Matrix&B)
 {
   if(A.n!=1 || B.n!=1) A.ERROR_MATRIX(9);
   if(A.m!=B.m) A.ERROR_MATRIX(0);
   VARTYPE scalarmul = 0;
   for(int i=0; i
void Matrix::ERROR_MATRIX(dim E) const
 { static char *message[] = {
       "Матрицы должны иметь одинаковую размерность",         //0
       "Не выделена память!",                                 //1
       "Матрицы не согласованы для умножения",                //2
       "Степень должна быть больше нуля или -1",              //3
       "Матрица должна быть квадратной",                      //4
       "Нулевой ведущий элемент в преобразовании Гаусса",           //5
       "Вставка невозможна из-за перекрытия базовой матрицы", //6
       "Извлекаемая матрица выходит за границы базовой",      //7
       "Выход за границы. Попытка доступа к несущ. элементу", //8
       "Это не вектор!"};                                     //9
   cerr<<"ERROR: "<< message[E] << endl; exit(1);
 }
//----------------------------------------------------------------------------
                //   Демонстративно - тестирующая программа:
#include <iostream.h>
//#include 
//#include
//#include "tmatr.cpp"
int main()
{
int z;
  clrscr();
  Matrix A(3,3), B(3,3), C(3,3);
  Matrix V(3),X(3),H(3),U(3);
  double d;
  A(0,0)=1.1; A(0,1)=2.2; A(0,2)=3.3;
  A(1,0)=2.4; A(1,1)=1.1; A(1,2)=4.4;
  A(2,0)=1.3; A(2,1)=2.1; A(2,2)=4.1;

  B(0,0)=2; B(0,1)=7; B(0,2)=2;
  B(1,0)=4; B(1,1)=8; B(1,2)=1;
  B(2,0)=6; B(2,1)=4; B(2,2)=1;

  V(0)=2.1; V(1)=3.31; V(2)=1.4;
  H(0)=1.1; H(1)=2.1; H(2)=3.1;

//******************************
  C = A + B;
  cout<<"A:\n"< D(3,3), E(3,3);

  D(0,0) = 1; D(0,1) = 2; D(0,2) = 3;
  D(1,0) = 2; D(1,1) = 5; D(1,2) = 6;
  D(2,0) = 7; D(2,1) = 3; D(2,2) = 9;

  ofstream fout("test.mtr");
  if(!fout){
      cout<<"file not open\n";
      return 1;
    }
  D.write(fout);
  fout.close();

  ifstream fin("test.mtr");
  if(!fin){
      cout<<"file not open\n";
      return 1;
    }

  E.read(fin);  //й су«їtЎ«ј уїсС

  cout<<"D:\n";
  cout<<"Finish!";
  cin>>z;
//-------------------------------------------------------------------------