[Drongo]

Таки решил, посмотрите пожалуйста код и расскритикуйте...

Код:

//3-я Задача... Создать два класса Матрица и Вектор.
// Определить конструкторы, деструкторы.
// Определить функцию умножения вектора на матрицу как дружескую.
// Определить дружескую функцию умножения матрицы на матрицу.
// Определить дружескую функцию умножения числа на матрицу.
// Продемонстрировать работу функций в програме.
#include <iostream.h>
using std::cout;
using std::cin;
using std::endl;

#include <iomanip.h>
using std::setw;

//******************************Класс Вектор***********************************/
class Vector{ // Класс Вектор
   friend class Matrix; // класс Вектор друг класса Матрица
   // Дружеская функция умножения Вектора на Матрицу. Принимает Матрицу, Вектор
   // на который умножается и Вектор, где будет храниться результат умножения
   friend void MultiplyVectorMatrix(Matrix &mMatrix, Vector &Vec2, Vector &Vec1);
public:
   Vector(int size = 1);      // конструктор по умолчанию
   void setSizeVector(int size); // Установка размера Вектора
   void setOrientationVector(); // Установка Вектора-столбца или Вектора-Строки. В столбец или в строку...
   void UserFromKeyboardsVector(); // Ввод значений Вектора с клавиатуры   
   bool getOrientationVector() { return Orient; }; // Возвращение ориентации Вектора
   int getSizeVector() { return SizeVector; }; // Возвращение размера Вектора   
   int &elementVector(int index) { return Vector[index]; } // Индексация. Для доступа к элементу Вектора
   void PrintVector(); // Печать значений Вектора
   ~Vector();        // деструктор
private:
   int *Vector;      // Указатель на целое.
   int  SizeVector;  // Размер Вектора
   bool Orient;      // Ориентация Вектора. true - Вертикально, false - Горизонатально...
};
//*******************************Класс Матрица*********************************/
class Matrix{ // Класс Matrix
   // Дружеская функция умножения Матрицы на Матрицу
   friend void MultiplicationMatrix(Matrix &mMatrix1, Matrix &mMatrix2, Matrix &mMatrix3);
   // Дружеская функция умножения Матрицы на Число
   friend void NumberMultiplicationMatrix(Matrix &mMatrix3, Matrix &mMatrix, int);
public:
   Matrix(int height = 1, int width = 1); // Конструктор с аргументами по умолчанию
   void setMatrix(int height, int width); // Установка размера матрицы
   void UserFromKeyboardsMatrix(); // Ввод данных Матрицы с клавиатуры
   int &elementMatrix(int index) { return Matrix[index]; } // Индексация. Для доступа к элементу Матрицы
   int getSizeMatrix() { return SizeMatrix; }; // Получить размер Матрицы
   int getSizeRow()    { return row; };  // Получить количество строк Матрицы
   int getSizeColumn() { return column; }; // Получить количество столбцов Матрицы
   void PrintMatrix(); // Печать Значений Матриц
   ~Matrix(); // Деструктор
private:
   int *Matrix; // Указатель на целое
   int SizeMatrix; // Размер Матрицы
   int row; // Сколько строк в Матрице
   int column;  // Сколько столбцов в Матрице
};
/*****************************************************************************/
// РЕАЛИЗАЦИЯ КЛАССА Matrix
/*****************************************************************************/
// Конструктор Матрицы--------------------------------------------------------
Matrix::Matrix(int height, int width)
{
   setMatrix(height, width);
}
// Установка размера Матрицы--------------------------------------------------
void Matrix::setMatrix(int h, int w)
{
   SizeMatrix = h * w;
   row = h;
   column = w;

   Matrix = new int [SizeMatrix];
   // Инициализация Матрицы нулями
   for(int i = 0; i < SizeMatrix; i++)
      Matrix[i] = 0;
}
// Ввод данных с клавиатуры, для Матрицы--------------------------------------
void Matrix::UserFromKeyboardsMatrix()
{
   int counter = 1; // Счётчик вводимого элемента Матрицы...
   static int countMatrix = 1;

   // Циклический ввод в Матрицу
   for(int i = 0; i < SizeMatrix; i++){
      cout<<" Enter value in "<<countMatrix<<" 'Matrix', position "<<counter++<<" Value: ";
      cin>>Matrix[i];
    }
    countMatrix++;
}
// Вывод элементов Матрицы на экран-------------------------------------------
void Matrix::PrintMatrix()
{
   int control = 0, // Для вывода знака '|' в начале Матрицы
       counColumn = column - 1; // Для вывода знака '|' в конце Матрицы

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

   // Вывод на экран Матрицы
   for(int j = 0; j < SizeMatrix; j++){
      if(control == 0){
        cout<<'|';
        control++;
      }
      cout<<setw(7)<<Matrix[j];
      if(j == counColumn){
        counColumn += column;
        cout<<'|';
        control = 0;
        cout<<endl;
      }
    }
   // Вывод на экран символа '-' на всю ширину консоли, для читабельности...
   for(int i = 0; i < 80; i++)
      cout<<'-';
}
// Деструктор Матрицы---------------------------------------------------------
Matrix::~Matrix()
{
  delete[] Matrix;
  cout<<"Destructor"<<endl;
}
// Дружеская функция класса Matrix, умножения Матрицы на Матрицу. В качестве--
// хранения результатов используется 3-я Матрица------------------------------
void MultiplicationMatrix(Matrix &mMatrix1, Matrix &mMatrix2, Matrix &mMatrix3)
{
   // Умножение Матрицы на Матрицу.
   // Циклическое умножение элемента 1-й Матрицы на элемент 2-й Матрицы
   for(int i = 0; i < mMatrix3.getSizeMatrix(); i++)
      mMatrix3.Matrix[i] = mMatrix1.Matrix[i] * mMatrix2.Matrix[i];

   cout<<"\n Result Multiplication...\n";
}
// Дружеская функция класса Matrix, умножения Матрицы на Число. В качестве----
// хранения результатов используется 3-я Матрица------------------------------
void NumberMultiplicationMatrix(Matrix &mMatrix3, Matrix &mMatrix, int number)
{
   // Умножение Матрицы на Число.
   // Циклическое умножение элемента 1-й Матрицы на элемент 2-й Матрицы
   for(int i = 0; i < mMatrix3.getSizeMatrix(); i++)
      mMatrix3.Matrix[i] = number * mMatrix.Matrix[i];

   cout<<"\n Result Multiplication Number "<<"'"<<number<<"' to"<<" 'Matrix'\n";
}
/*****************************************************************************/
/*****************************************************************************/
// РЕАЛИЗАЦИЯ КЛАССА Vector  
/*****************************************************************************/
/*****************************************************************************/
// Дружеская функция класса Vector, умножения Матрицы на Вектор. В качестве---
// хранения результатов используется 2-ой Вектор------------------------------
void MultiplyVectorMatrix(Matrix &mMatrix1, Vector &Vec2, Vector &Vec1)
{
   int iMat = 0,
       jMat = 0;

   if(Vec1.Orient){ // Умножение Вектора-столбца на Матрицу
     for(int i = 0; i < Vec1.getSizeVector(); i++){
        jMat += mMatrix1.getSizeColumn();
        for(; iMat < jMat; iMat++)
          Vec2.Vector[i] += mMatrix1.elementMatrix(iMat) * Vec1.Vector[i];
       }
     cout<<" Result Multiply Vector-Column to a Matrix..."<<endl;
    }
   else if(!Vec1.Orient){ // Умножение Вектора-строки на Матрицу
     for(int i = 0; i < mMatrix1.getSizeRow(); i++){
        jMat += mMatrix1.getSizeColumn();
        for(int j = 0; iMat < jMat; iMat++, j++)
          Vec2.Vector[i] += mMatrix1.elementMatrix(iMat) * Vec1.Vector[j];
       }
     cout<<" Result Multiply Vector-String to a Matrix..."<<endl;
    }
}
// Деструктор Вектора---------------------------------------------------------
Vector::~Vector()
{
    delete[] Vector;
    cout<<" Dectructor Vector"<<endl;
}
// Ввод данных с клавиатуры для Вектора---------------------------------------
void Vector::UserFromKeyboardsVector()
{
   int counter = 1; // Счётчик вводимого элемента Вектора...

   // Циклический ввод в Вектор
   for(int i = 0; i < SizeVector; i++){
      cout<<" Enter value in 'Vector', position "<<counter++<<" Value: ";
      cin>>Vector[i];
    }
}
// Конструктор Вектора--------------------------------------------------------
Vector::Vector(int size)
{
   setSizeVector(size); // Функция установки размера Вектора
}
// Установка размера Вектора--------------------------------------------------
void Vector::setSizeVector(int size)
{
   SizeVector = (size >= 0) ? size : 1;
   // Выделение Вектора под заданный размер и инициализация нулями...
   Vector = new int[size];
   for(int i = 0; i < size; i++)
      Vector[i] = 0;
}
// Вывод элементов Вектора на экран-------------------------------------------
void Vector::PrintVector()
{
    cout<<"\n";
    if(!getOrientationVector()){
      cout<<"| ";
      for(int a = 0; a < SizeVector; a++){
         cout<<setw(7)<<Vector[a];
         if(a == SizeVector - 1)
            cout<<"|";
        }
      cout<<"\n\n Vector-String"<<endl;
     }
    else if(getOrientationVector()) {
      for(int i = 0; i < SizeVector; i++){
         cout<<"| "<<setw(7)<<Vector[i]<<"|"<<endl;
        }
      cout<<"\n Vector-Column"<<endl;
     }

    for(int j = 0; j < 80; j++)
       cout<<'-';
}
// Установка ориентации Вектора. Вертикаль - true, Горизонталь - false--------
// 1 - Ветрикально, 2 - Горизонтально-----------------------------------------
void Vector::setOrientationVector()
{
    int orientation;
    cout<<" Enter number '1' Vector-Stolbez or number '2' Vector-Stroka [1/2]: ";
    cin>>orientation;
    // Проверка, чтобы введённое число было или 1 или 2...
    while(orientation <= 0 || orientation >= 3){
       cout<<" Enter number '1' Vector-Stolbez or number '2' Vector-Stroka [1/2]: ";
       cin>>orientation;
     }

     if(orientation == 1)
        Orient = true;  // Вертикаль - true
     else if(orientation == 2)
        Orient = false; // Горизонталь - false
}
// Демонстрация программы. Тестирование========================================
int main()
{
  int feature, // Выбор умножаемой Матрицы, 1-я или 2-я
      num,  //  Число, на которое умножается выбранная Матрица
      matrColumn, // Столбцы Матрицы (Ширина)
      matrRow,    // Строки Матрицы (Высота)
      szVector,   // Размер Вектора
      z; // Чтобы окно не закрылось раньше срока...

  Matrix matrx1, // 1-й объект класса Matrix (1-я Матрица)
         matrx2, // 2-й объект класса Matrix (2-я Матрица)
         matrx3; // 3-й объект класса Matrix (3-я Матрица. Используется в качестве хранения результатов расчёта)

  Vector vec1, // 1-й объект класса Vector (1-й Вектор)
         vec2; // 2-й объект класса Vector (2-й Вектор. Используется в качестве хранения результатов расчёта)

  cout<<" Enter size Column: ";
  cin>>matrColumn;                 // Столбцы (Ширина)
  cout<<" Enter size Row: ";
  cin>>matrRow;                    // Строки (Высота)

  matrx1.setMatrix(matrRow, matrColumn); // Установка размера 1-й Матрицы (row * column)
  matrx1.UserFromKeyboardsMatrix();  // Ввод значений в первую Матрицу

  cout<<endl; // Для читабельности, пустая строка...

  matrx2.setMatrix(matrRow, matrColumn); // Установка размера 2-й Матрицы (row * column)
  matrx2.UserFromKeyboardsMatrix();  // Ввод значений во вторую Матрицу

  for(int i = 0; i < 80; i++) // Для читабельности
    cout<<'-';
    
  cout<<"\n Print First (1-st) Matrix"<<endl;
  matrx1.PrintMatrix();    // Печать 1-й Матрицы
  cout<<"\n Print Second (2-nd) Matrix"<<endl;
  matrx2.PrintMatrix();    // Печать 2-й Матрицы

  matrx3.setMatrix(matrRow, matrColumn); // Установка размера 3-й Матрицы (row * column)

  MultiplicationMatrix(matrx1, matrx2, matrx3); // Функция умножения Матрицы на Матрицу

  matrx3.PrintMatrix();  // Печать результата умножения Матрицы на Матрицу

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

  // Выбор умножаемой Матрицы [1 - первая Матрица, 2 - вторая Матрица]
  cout<<"  Enter Number Vibor Multiplication Matrix [1/2]: ";
  cin>>feature;
  // Проверка выбора
  while(feature >= 3 || feature <= 0){
    cout<<"  Enter Number Vibor Multiplication Matrix [1/2]: ";
    cin>>feature;
  }
  
  if(feature == 1)       // Если выбрана первая Матрица
    NumberMultiplicationMatrix(matrx3, matrx1, num); // Функция умножения Матрицы на Число
  else if(feature == 2)  // Если выбрана вторая Матрица
    NumberMultiplicationMatrix(matrx3, matrx2, num); // Функция умножения Матрицы на Число

  matrx3.PrintMatrix(); // Печать результата умножения Матрицы на Число

  // Установка ориентации Вектора (Вектор-столбец или Вектор-строка)
  vec1.setOrientationVector();
  // Размер 2-го Вектора должен быть равен кол-ву строк в Матрице
  vec2.setSizeVector(matrRow);

  if(vec1.getOrientationVector()) // Вертикальная ориентация Вектора
     vec1.setSizeVector(matrRow); // Размер должен быть равен кол-ву строк в Матрице
  else if(!vec1.getOrientationVector()) // Горизонтальная ориентация Вектора
     vec1.setSizeVector(matrColumn); // Размер должен быть равен кол-ву столбцов в Матрице

  cout<<"\n\n";   
  vec1.UserFromKeyboardsVector(); // Ввод данных с клавиатуры, для Вектора

  for(int j = 0; j < 80; j++) // Для читабельности, вывод линии...
     cout<<'-';

  cout<<"\n  Print Vector..."<<endl;
  vec1.PrintVector(); // Печать 1-го Вектора

  cout<<"\n Print First (1-st) Matrix"<<endl;
  matrx1.PrintMatrix(); // Печать Матрицы, на которую будет умножаться Вектор...

  MultiplyVectorMatrix(matrx1, vec2, vec1); // Функция умножения Вектора на 1-ю Матрицу

  vec2.PrintVector(); // Печать результата умножения Вектора на Матрицу

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

Привет Всем! В общем у меня получился такой "расклад", конечно было бы правильнее перегрузить операцию умножения, только у меня возникли сложности с возвращаемым результатом, не могу понять, для такого выражения:

Код:

Vec2 = Vec1 * Matrix;

Нужно ли реализовывать операцию присваивания? Или ещё как нужно или можно, подскажите
Правилен ли будет такой вариант:

Код:

Vector::Vector operator*(Vector &Vec, Matrix &Matr)
{
    Vector tempVec;
    
    ...
    // Здесь алгоритм умножения
    ...
    return tempVec;
}

Или если не будет сложно, опишите как правильно возвратить или перегрузить эту операцию, чтобы во всю ширь использовать перегрузку операций, буду благодарен за любой совет...