Как работать с членами класса? Как определить отдельную функцию?

[Люсь]

Всем привет!

У меня такое задание:

Составить программу для умноэения матрицы на вектор. Матрица и вектор задаются в своих класах. Операция умножения производится с использованием отдельного оператора. Данные считываются из файла. Результат записывается в выходной файл.
Размер матрицы 3х3
Размер вектора 1х3
Элемент матрицы - целые числа.

У меня получилось вот что:

Код:

#include <iostream.h>
#include <fstream.h>

struct vector{int el[3];};
struct matrica{int el[3][3];};
struct result{int el[3][3];};

void main()

{

   ifstream mfs("matrica.txt", ios::in);
   if (mfs.is_open())
      {
         cout<<"ok\n";
      } else {
         exit (0);
      }

   ifstream vfs("vector.txt", ios::in);

   ofstream rfs("result.txt", ios::out);

   int i, j;
   for (i=1; i<=3; i++)
   {
      for (j=1; j<=3; j++)
      {
         matrica.el[i][j] = mfs;
         vector.el[i] = vfs;
         result.el[i][j]=matrica.el[i][j]*vector.el[i];
         rfs = result.el[i][j];
         cout << rfs;
      }
   }

   return 0;
}

Но прога не компилится, спотыкаясь на шаге

Код:

matrica.el[i][j] = mfs;

Что я делаю неправильно в обращении к членам класса?

Тестить мне негде, вот это написала пока с компа не выгнали.
Ещё я так и не поняла, как переопределять функцию?

Жду помощи.

[Вад]

Вот исправленный вариант. На непогрешимость не претендую, но работает и результат на тесте нормальный выводит:

Код:

#include "stdafx.h"
#include <iostream>
#include <fstream>

struct vector{int el[3];};
struct matrica{int el[3][3];};
struct result{int el[3][3];};
using namespace std;

void main()
{
    vector vec;
    matrica matr;
    result res;
    ifstream mfs("matrica.txt", ios::in);
    if (mfs.is_open())
    {
        cout<<"ok\n";
    } else {
        exit (0);
    }

    ifstream vfs("vector.txt", ios::in);

    ofstream rfs("result.txt", ios::out);

    int i, j;
    for (i=0; i<=2; i++)
    {
        vfs >> vec.el[i];
        for (j=0; j<=2; j++)
        {
            mfs >> matr.el[i][j] ;
            
            res.el[i][j]=matr.el[i][j]*vec.el[i];
            rfs << res.el[i][j] << "  ";
            cout << res.el[i][j] << "  " ;
        }
        cout << endl;
        rfs << endl;
    }
    mfs.close();
    vfs.close();
    rfs.close();
    return;
}

Ошибки:
1) matrica etc - это типы, использовать в вычислениях нужно объекты (экземпляры) типов (они объявлены у меня в первых строках main).
2) чтение из стримов - см. как у меня. К тому же, вектор считывался внутри 2го цикла (то есть, пытались считать 9 значений вместо 3х)
3) номерация массивов в С++ всегда начинается с 0, поэтому в циклах i,j 0..2. Старый вариант приводил бы к ошибкам при выполнении.
Остальное - по мелочи, разделил пробелами вывод в стрим, добавил перевод строк и закрытие самих потоков ввода-вывода.

[Люсь]

Спасибо, будет доступ - разберусь.
А как насчёт переопределённой функции умножения матрицы на вектор? Выделила в задании это место жирным шрифтом.

[Вад]

Вот самый простой вариант с переопределением, сделанный на коленке Опять же, на эталонность не претендую, пусть меня поправят, если что не так. Но код рабочий.

Код:

#include "stdafx.h"
#include <iostream>
#include <fstream>
using namespace std;

struct vector{int el[3];};
struct matrica{
    int el[3][3];
    matrica operator*(vector& vec)
    {
        matrica res;
        for (int i=0; i<3; i++)
        {
            for (int j=0; j<3; j++)
            {
                res.el[i][j]=el[i][j]*vec.el[i];
            }
        }
        return res;
    };
};

void main()
{
    vector vec;
    matrica matr;
    matrica res;
    ifstream mfs("matrica.txt", ios::in);
    if (mfs.is_open())
    {
        cout<<"ok\n";
    } else {
        exit (0);
    }

    ifstream vfs("vector.txt", ios::in);

    ofstream rfs("result.txt", ios::out);

    int i, j;
    for (i=0; i<=2; i++)
    {
        vfs >> vec.el[i];
        for (j=0; j<=2; j++)
        {
            mfs >> matr.el[i][j] ;
        }
    }

    // multiply matrix by vector
    res = matr * vec;

    for (i=0; i<=2; i++)
    {
        for (j=0; j<=2; j++)
        {
            res.el[i][j]=matr.el[i][j]*vec.el[i];
            rfs << res.el[i][j] << "  ";
            cout << res.el[i][j] << "  " ;
        }
        cout << endl;
        rfs << endl;
    }
    mfs.close();
    vfs.close();
    rfs.close();
    return;
}

Поскольку результат - такая же матрица 3*3, как и исходная, то я упразднил лишний тип. Видно, что оператор принимает в качестве параметра вектор, внутри создаётся новая матрица, в которую считаем произведение, и возвращаем её.

[Sands]

1) Я, конечно, не претендую на единственно правильное мнение, но ИМХО матрица на вектор умножается не так, как ето реализовано в данных листингах. Потому как
A*x = y
A={a[ i ][j]} i = 1..n, j = 1..m; x={x[j]}, j=1..m; y = {y[ i ]} i = 1..n
при етом
y[ i ]=sum(a[ i ][j]*x[j])
Сразу оговорюсь, что для матрицы i - количество строк, j - количество столбцов
2) Для реализации операции умножения отдельным оператором необходимо перегрузить оператор умножения(прошу прощения за каламбур). Сделать етоможно двумя способами - либо обьявить етот оператор методом класса либо friend-функцией
семантика обьявления
vector operator *(matrix a, vector b);
3) У тебя в задании значится что матрица и вектор должны быть классами, а ты пока только структуры реализовала - подумай об етом. И еще <матрица>*<вектор>=<вектор> а ты еще и дополнительный тип для результата ввела, изилшество выходит )).

З.Ы Пока писал тебе уже и оператор переопределили ))

[Вад]

Да, я вот тоже сижу думаю, что с умножением я что-то намудрил - опирался на исходный листинг
По сути, модификация сводится к изменению оператора, чтобы он вычислял вектор, как написал Sands, и возвращал его же.
А между структурами и классами не столь уж большая разница назвать это всё class и расставить private и public. Разве вот только придётся сделать некоторый метод для установки значений элементам векторов и матриц, чтобы не напрямую к свойствам объекта обращаться, а как положено

[Люсь]

Sands, я пока не вижу разницы между структурами и классами, и как начинающий программист, и вообще по смыслу.

Как именно матрица на вектор перемножается - не суть важно, если вдруг перпендикулярно моему способу - проще пареной репы i заменить на j. Просто когда я искала определение вектора - я такого вообще не нашла относительно числового массива. Был метод перемножения двух матриц, исходя из чего я решила матрицу 1х3 считать вектором. Но как именно перемножать - параллельно или перпендикулярно - мне не было определено, решение пришлось принимать самой.

Надеюсь, мне самой понятно, чё я сказала )))

Вад, ага, я тоже разницы пока не чувствую.
Жаль, помучить препода мало придётся. Мне почему-то приятнее усваивать знания от чуткого преподавателя, а не из книжки с непонятными заданиями

С перегрузкой оператора всё же пока не очень понятно...

[Вад]

Разница только в том, что в структурах по умолчанию разрешён доступ извне ко всем полям (свойствам) - это используется в примере. Всё равно, что в начале определения класса написать public:
А так класс - та же завуалированная структура

Что касается перегрузки оператора, то в приведённом решении будет так: оператор * - это метод, вызываемый для матрицы (она стоит слева от *, соответственно), в него передаётся параметр, стоящий справа (чтобы не копировать, принимаем его по ссылке). Далее, поскольку оператор - это метод структуры (класса) matrica, то он имеет непосредственный доступ к содержимому объекта, для которого был вызван (поэтому в правой части умножения просто el[ i ][ j ]). Ну и наконец, возвращаем новый объект - другую матрицу (а нужно - значение типа вектор, как верно заметил Sands), чтобы наше умножение не изменяло значение текущих участвующих в операции объектов (нам ведь этого не нужно - когда мы умножаем, скажем, int на int, значения перемножаемых переменных не меняются).
В общем, описать такой оператор - почти то же самое, что задать некоторую внешнюю функцию, которая у себя внутри умножает матрицу на вектор и возвращает результат, с той лишь разницей, что внешняя функция будет принимать два параметра явно, а оператор принимает первый параметр неявно, при этом получая прямой доступ к элементам этого первого операнда.

[Люсь]

фух, сложности какие...
ладно, вся жизнь впереди
жаль только, что учить начинают сначала по одному (процедурное), а потом бац - и надо переучиваться, потому что так делают все, - и ни фига непонятно на базе полученных знаний...

[Вад]

Тут пришло в голову, что, возможно, описание принципа действия оператора * будет несколько нагляднее, если упомянуть, что альтернативная форма вызова этого метода выглядит так:

Код:

res = matr.operator*(vec);

[Люсь]

Спасибо, я щас распечатаю, дома попробую докопаться до сути.

[Джон]

Люсь, поздравляю с посвящением в ООП.

[Sands]

Люсь, я к тому писал про умножение матриц, что есть отдельная категория преподавателей, которые лабораторки(ну или еще какие вещи для контроля за знаниями) проверяют не чтением кода, а "листиком". Тоесть у него есть вход и выход, так вот в твоем случае даже если ты правильно все сделаеш но умножение будет реализовано неправильно, то твой выход не совпадет с требуемым, и будет очень трудно доказать что ты не верблюд )))

[Dimka]

Я бы для такой задачи сделал класс матрицы, написал бы умножение матриц, а вектор сделал бы частным случаем матрицы - производным от матрицы классом.

Вместе с тестом у меня получилось так:

Код: (C++)

#include <iostream>
#include <exception>

using namespace std;

class ArgumentException: public exception {};
class InternalError: public exception {};

class Matrix {
        int _rows, _columns;
        int *_ptr_items;
        int _size() const {
                return _rows * _columns;
        }
        int _index(int row, int column) const throw(ArgumentException) {
                if(row <= 0 || row > _rows || column <= 0 || column > _columns)
                        throw ArgumentException();
                return (row - 1) * _columns + (column - 1);
        }
public:
        Matrix(int rows, int columns) throw(ArgumentException) {
                if(rows <= 0 || columns <= 0)
                        throw ArgumentException();
                _rows = rows;
                _columns = columns;
                _ptr_items = new int[_size()];
        }
        virtual ~Matrix() {
                delete _ptr_items;
        }
        int getRows() const {
                return _rows;
        }
        int getColumns() const {
                return _columns;
        }
        int getItem(int row, int column) const throw(ArgumentException) {
                return _ptr_items[_index(row, column)];
        }
        void setItem(int row, int column, int value) throw(ArgumentException) {
                _ptr_items[_index(row, column)] = value;
        }
};

Matrix operator*(const Matrix &m1, const Matrix &m2) throw(ArgumentException, InternalError) {
        if(m1.getColumns() != m2.getRows())
                throw ArgumentException();
        Matrix result(m1.getRows(), m2.getColumns());
        for(int i = 1; i <= m1.getRows(); ++i)
                for(int j = 1; j <= m2.getColumns(); ++j) {
                        int item = 0;
                        for(int k = 1; k <= m1.getColumns(); ++k)
                                try {
                                        item += m1.getItem(i, k) * m2.getItem(k, j);
                                } catch(ArgumentException) {
                                        throw InternalError();
                                }
                        try {
                                result.setItem(i, j, item);
                        } catch(ArgumentException) {
                                throw InternalError();
                        }
                }
        return result;
}

class Vector: public Matrix {
public:
        Vector(int size) throw(ArgumentException):
                Matrix(size, 1)
        {}
        int getSize() const {
                return Matrix::getRows();
        }
        int getItem(int index) const throw(ArgumentException) {
                return Matrix::getItem(index, 1);
        }
        void setItem(int index, int value) throw(ArgumentException) {
                return Matrix::setItem(index, 1, value);
        }
};

void printMatrix(const Matrix &m) {
        for(int i = 1; i <= m.getRows(); ++i) {
                for(int j = 1; j <= m.getColumns(); ++j)
                        cout << m.getItem(i, j) << " ";
                cout << endl;
        }
}

int main() {
        try {
                cout << "Матрица" << endl;
                Matrix a(2, 2);
                a.setItem(1, 1, 1);
                a.setItem(1, 2, 2);
                a.setItem(2, 1, 3);
                a.setItem(2, 2, 4);
                printMatrix(a);

                cout << "умножается на вектор" << endl;
                Vector b(2);
                b.setItem(1, 5);
                b.setItem(2, 6);
                printMatrix(b);

                Matrix c = a * b;
                cout << "результат" << endl;
                printMatrix(c);

                if(c.getItem(1, 1) == 17 && c.getItem(2, 1) == 39)
                        cout << "ВЕРНО" << endl;
                else
                        cout << "НЕВЕРНО" << endl;
        } catch(ArgumentException) {
                cout << "ОШИБКА ПРОГРАММИРОВАНИЯ" << endl;
        } catch(InternalError) {
                cout << "ОШИБКА ПРОГРАММИРОВАНИЯ" << endl;
        }
}

А ещё можно int в матрице заменить на шаблонный тип <class T>, чтобы и вещественные числа охватить, и определяемые пользователем числа, поддерживающие операции + и *.

[Вад]

dimka, в классе Vector тогда лучше бы сделать 2й параметр конструктора, определяющий, что это: вектор-столбец или вектор-строка. В противном случае можно будет умножать вектор на матрицу только с одной стороны.
А ещё, меня смущает отсутствие конструктора копирования для класса Matrix (конструктор копирования по умолчанию будет копировать значение указателя _ptr_items, что будет приводить к проблемам с использованием памяти):

Код:

    Matrix(const Matrix &parent){
        _rows = parent._rows;
        _columns = parent._columns;
        _ptr_items = new int[_size()];
        memcpy(_ptr_items, parent._ptr_items, sizeof(int)*_size());
    }

Вектор с реализацией "столбцов" и "строк" (набросок на основе вышеприведённого):

Код:

class Vector: public Matrix {
    bool _column;
public:
	Vector(int size, bool column = true) throw(ArgumentException):
           Matrix(column ? size : 1, column ? 1 : size),
           _column(column)
	{}

	int getSize() const {
        return _column ? Matrix::getRows() : Matrix::getColumns();
	}
	int getItem(int index) const throw(ArgumentException) {
        return Matrix::getItem(_column ? index : 1, _column ? 1 : index);
	}
	void setItem(int index, int value) throw(ArgumentException) {
        return Matrix::setItem(_column ? index : 1, _column ? 1 : index, value);
	}
};

тогда можно будет делать так:

Код:

Matrix a(2, 2);
a.setItem(1, 1, 1);
a.setItem(1, 2, 2);
a.setItem(2, 1, 3);
a.setItem(2, 2, 4);
printMatrix(a);

// умножение матрицы на вектор справа, по умолчанию создаём вектор-столбец:
Vector b(2);
b.setItem(1, 5);
b.setItem(2, 6);
printMatrix(b);
// само умножение
Matrix c = a * b;
printMatrix(c);

// умножение на вектор слева, создаём вектор-строку:
Vector d(2, false);
d.setItem(1, 5);
d.setItem(2, 6);
printMatrix(d);
// второе умножение
Matrix e = d * a;
printMatrix(e);

[Dimka]

Вад, согласен и с конструктором, и усовершенствованием вектора.

Разве что для пущей читабельности кода булевый атрибут лучше заменить на значение типа

Код: (C++)

enum VectorOrientation { COLUMN, ROW };

Меня ещё смущает возврат значения типа Matrix из оператора умножения. Терзают меня подозрения, что там один раз выполняется копирование матрицы. Ссылку туда не подставить. А с указателями не так элегантно будет: пользователю оператора придётся возиться с выделением и очисткой памяти.

[Dimka]

Ещё я в main забыл return 0 написать, а комплиятор даже не заикнулся.

[Dimka]

Ещё хорошо бы в конструктор матрицы передавать значение, которое элементы матрицы принимают по умолчанию при инициализации. Это особенно актуально при использовании шаблонов.

[Dimka]

После учёта разных замечаний улучшенная версия получилась такой:

Код: (C++)

#include <cstdlib>
#include <iostream>
#include <exception>

using namespace std;

class ArgumentException: public exception {};
class InternalError: public exception {};

template<class T>
class Matrix;

template<class T>
Matrix<T> operator*(const Matrix<T> &m1, const Matrix<T> &m2) throw(ArgumentException, InternalError) {
        if(m1.getColumns() != m2.getRows())
                throw ArgumentException();
        Matrix<T> result(m1.getRows(), m2.getColumns());
        for(int i = 1; i <= m1.getRows(); ++i)
                for(int j = 1; j <= m2.getColumns(); ++j) {
                        T item = 0;
                        for(int k = 1; k <= m1.getColumns(); ++k)
                                try {
                                        item += m1.getItem(i, k) * m2.getItem(k, j);
                                } catch(ArgumentException) {
                                        throw InternalError();
                                }
                        try {
                                result.setItem(i, j, item);
                        } catch(ArgumentException) {
                                throw InternalError();
                        }
                }
        return result;
}

template<class T>
class Matrix {
        friend Matrix<T> operator*<T>(const Matrix<T> &, const Matrix<T> &);
        int _rows, _columns;
        T *_ptr_items;
        int _size() const {
                return _rows * _columns;
        }
        int _index(int row, int column) const throw(ArgumentException) {
                if(row <= 0 || row > _rows || column <= 0 || column > _columns)
                        throw ArgumentException();
                return (row - 1) * _columns + (column - 1);
        }
        void _init(int rows, int columns) throw(ArgumentException) {
                if(rows <= 0 || columns <= 0)
                        throw ArgumentException();
                _rows = rows;
                _columns = columns;
                _ptr_items = new T[_size()];
        }
        Matrix(int rows, int columns) throw(ArgumentException) {
                _init(rows, columns);
        }
public:
        Matrix(int rows, int columns, const T defaultValue) throw(ArgumentException) {
                _init(rows, columns);
                for(int i = 0; i < _size(); ++i)
                        _ptr_items[i] = defaultValue;          
        }
        Matrix(const Matrix &other) {
                _rows = other._rows;
                _columns = other._columns;
                memcpy(_ptr_items, other._ptr_items, _size() * sizeof(T));
        }
        virtual ~Matrix() {
                delete _ptr_items;
        }
        int getRows() const {
                return _rows;
        }
        int getColumns() const {
                return _columns;
        }
        T getItem(int row, int column) const throw(ArgumentException) {
                return _ptr_items[_index(row, column)];
        }
        void setItem(int row, int column, T value) throw(ArgumentException) {
                _ptr_items[_index(row, column)] = value;
        }
};

template<class T>
class Vector: public Matrix<T> {
public:
        enum Orientation {
                ROW, COLUMN
        };
private:
        Orientation _orientation;
        int _getRows(int size, Orientation orientation) const {
                switch(orientation) {
                case ROW:
                        return 1;
                case COLUMN:
                        return size;
                default:
                        throw InternalError();
                }
        }
        int _getColumns(int size, Orientation orientation) const {
                switch(orientation) {
                case ROW:
                        return size;
                case COLUMN:
                        return 1;
                default:
                        throw InternalError();
                }
        }
public:
        Vector(int size, const T defaultValue, Orientation orientation) throw(ArgumentException, InternalError):
                        Matrix<T>(_getRows(size, orientation), _getColumns(size, orientation), defaultValue),
                        _orientation(orientation) {
        }
        int getSize() const throw(InternalError) {
                switch(_orientation) {
                case ROW:
                        return Matrix<T>::getColumns();
                case COLUMN:
                        return Matrix<T>::getRows();
                default:
                        throw InternalError();
                }
        }
        T getItem(int index) const throw(ArgumentException, InternalError) {
                switch(_orientation) {
                case ROW:
                        return Matrix<T>::getItem(1, index);
                case COLUMN:
                        return Matrix<T>::getItem(index, 1);
                default:
                        throw InternalError();
                }
        }
        void setItem(int index, T value) throw(ArgumentException, InternalError) {
                switch(_orientation) {
                case ROW:
                        Matrix<T>::setItem(1, index, value);
                        break;
                case COLUMN:
                        Matrix<T>::setItem(index, 1, value);
                        break;
                default:
                        throw InternalError();
                }
        }
};

template<class T>
void printMatrix(const Matrix<T> &m) {
        for(int i = 1; i <= m.getRows(); ++i) {
                for(int j = 1; j <= m.getColumns(); ++j)
                        cout << m.getItem(i, j) << " ";
                cout << endl;
        }
}

int main() {
        try {
                cout << "Матрица" << endl;
                Matrix<int> a(2, 2, 0);
                a.setItem(1, 1, 1);
                a.setItem(1, 2, 2);
                a.setItem(2, 1, 3);
                a.setItem(2, 2, 4);
                printMatrix<int>(a);

                typedef Vector<int> MyVector;

                cout << "умножается на вектор" << endl;
                MyVector b(2, 0, MyVector::COLUMN);
                b.setItem(1, 5);
                b.setItem(2, 6);
                printMatrix<int>(b);

                Matrix<int> c = a * b;
                cout << "результат" << endl;
                printMatrix<int>(c);

                if(c.getItem(1, 1) == 17 && c.getItem(2, 1) == 39)
                        cout << "ВЕРНО" << endl;
                else
                        cout << "НЕВЕРНО" << endl;

                cout << "Вектор" << endl;
                MyVector d(2, 0, MyVector::ROW);
                d.setItem(1, 5);
                d.setItem(2, 6);
                printMatrix<int>(d);

                cout << "умножается на матрицу" << endl;
                printMatrix<int>(a);

                Matrix<int> e = d * a;
                cout << "результат" << endl;
                printMatrix<int>(e);

                if(e.getItem(1, 1) == 23 && e.getItem(1, 2) == 34)
                        cout << "ВЕРНО" << endl;
                else
                        cout << "НЕВЕРНО" << endl;

        } catch(ArgumentException) {
                cout << "ОШИБКА ПРОГРАММИРОВАНИЯ" << endl;
        } catch(InternalError) {
                cout << "ОШИБКА ПРОГРАММИРОВАНИЯ" << endl;
        }
        return 0;
}

Оператор умножения объявлен другом для доступа к закрытому конструктору, который не инициализирует новую матрицу значениями по умолчанию, поскольку в результате умножения и так все элементы матрицы будут определены. Для пользователя такая возможность закрыта.

[Scorp__)]

Offtopic:

Ну вот как всегда ) Вместо объяснения увлеклись и решили за человека задачу. Теперь Люсе еще одну надо, чтобы все-таки научиться )

Поставлю в угол.

[Люсь]

Scorp__), точно
Пока читала, у меня было такое ощущение, что ещё чуть-чуть - и такое развитие поиска решений может сойти за курсовую
По идее, это я должна была написать

После учёта разных замечаний улучшенная версия получилась такой:

[Вад]

Люсь, ничего, в приведённой последней версии от dimka ещё можно найти источник дальнейших доработок: так, можно реализовать оператор *=, чтобы можно было делать так:

Код:

Matrix a(x, y);
Matrix b(y, z);
// заполнение матриц
...
a *= b;

То есть, умножать с изменением содержимого первого аргумента. Например, Александреску с Саттером в "Стандартах программирования на C++" советуют в принципе реализовывать operator* через operator*= Хотя, как вспоминаю, была у них оговорка, кажется, как раз насчёт математических структур, дескать, здесь operator*= может быть сложнее, и потому не стоит его использовать при реализации operator*
Так что, тут ещё для деятельности поле непаханое, ну или, скажем так, сильно недопаханое 

[Dimka]

В задании ещё сказано про файловый ввод и вывод - этого в программе нет, так как интересовала в первую очередь реализация умножения матриц.

И, кстати, использование defaultValue можно обобщить до заполнения матрицы значениями при помощи какого-нибудь внешнего генератора значений. Поскольку присвоение одинакового значения - частный случай присвоения разных значений. Заводится метод типа void setItems(generator), где каждое значение для каждой позиции в матрицы запрашивается у этого генератора.

Через него можно задавать как значения по умолчанию, так и осуществлять ввод данных из файла или от пользователя с консоли, или в GUI-приложении читать какой-нибудь grid.

В общем, работы тут ещё непочатый край

[Dimka]

После внедрения генераторов значений получилось следующее

Код: (C++)

#include <cstdlib>
#include <iostream>
#include <exception>

using namespace std;

// Разные исключительные ситуации.
class InvalidArgument: public exception {};
class OperationFailed: public exception {};
class InternalError: public exception {};

// Классы работы с матрицами.
namespace matrix
{
        template<class T>
        class Matrix;

        // Умножение матриц.
        template<class T>
        Matrix<T> operator*(const Matrix<T> &m1, const Matrix<T> &m2) throw(InvalidArgument, InternalError) {
                if(m1.getColumns() != m2.getRows())
                        throw InvalidArgument();
                Matrix<T> result(m1.getRows(), m2.getColumns());
                for(int i = 1; i <= m1.getRows(); ++i)
                        for(int j = 1; j <= m2.getColumns(); ++j) {
                                T item = 0;
                                for(int k = 1; k <= m1.getColumns(); ++k)
                                        try {
                                                item += m1.getItem(i, k) * m2.getItem(k, j);
                                        } catch(InvalidArgument) {
                                                throw InternalError();
                                        }
                                try {
                                        result.setItem(i, j, item);
                                } catch(InvalidArgument) {
                                        throw InternalError();
                                }
                        }
                return result;
        }

        // Матрица.
        template<class T>
        class Matrix {
        public:
                // Стратегия заполнения матрицы значениями.
                class FillStrategy {
                public:
                        virtual T getItemBy(int row, int column) throw(OperationFailed) = 0;
                };
        private:
                friend Matrix<T> operator*<T>(const Matrix<T> &, const Matrix<T> &);
                int _rows, _columns;
                T *_ptr_items;
                int _size() const {
                        return _rows * _columns;
                }
                int _index(int row, int column) const throw(InvalidArgument) {
                        if(row <= 0 || row > _rows || column <= 0 || column > _columns)
                                throw InvalidArgument();
                        return (row - 1) * _columns + (column - 1);
                }
                void _init(int rows, int columns) throw(InvalidArgument) {
                        if(rows <= 0 || columns <= 0)
                                throw InvalidArgument();
                        _rows = rows;
                        _columns = columns;
                        _ptr_items = new T[_size()];
                }
                Matrix(int rows, int columns) throw(InvalidArgument) {
                        _init(rows, columns);
                }
        public:
                Matrix(int rows, int columns, FillStrategy &defaultsGenerator) throw(InvalidArgument, OperationFailed) {
                        _init(rows, columns);
                        setItems(defaultsGenerator);
                }
                Matrix(const Matrix &other) {
                        _rows = other._rows;
                        _columns = other._columns;
                        memcpy(_ptr_items, other._ptr_items, _size() * sizeof(T));
                }
                virtual ~Matrix() {
                        delete _ptr_items;
                }
                int getRows() const {
                        return _rows;
                }
                int getColumns() const {
                        return _columns;
                }
                T getItem(int row, int column) const throw(InvalidArgument) {
                        return _ptr_items[_index(row, column)];
                }
                void setItem(int row, int column, T value) throw(InvalidArgument) {
                        _ptr_items[_index(row, column)] = value;
                }
                void setItems(FillStrategy &generator) throw(OperationFailed) {
                        for(int row = 1; row <= _rows; ++row)
                                for(int column = 1; column <= _columns; ++column)
                                        setItem(row, column, generator.getItemBy(row, column));
                }
        };

        // Вектор - это матрица-строка или матрица-столбец.
        template<class T>
        class Vector: public Matrix<T> {
        public:
                enum Orientation {
                        ROW, COLUMN
                };
        private:
                Orientation _orientation;
                int _getRows(int size, Orientation orientation) const {
                        switch(orientation) {
                        case ROW:
                                return 1;
                        case COLUMN:
                                return size;
                        default:
                                throw InternalError();
                        }
                }
                int _getColumns(int size, Orientation orientation) const {
                        switch(orientation) {
                        case ROW:
                                return size;
                        case COLUMN:
                                return 1;
                        default:
                                throw InternalError();
                        }
                }
        public:
                Vector(int size, typename Matrix<T>::FillStrategy &defaultsGenerator, Orientation orientation) throw(InvalidArgument, OperationFailed, InternalError):
                                Matrix<T>(_getRows(size, orientation), _getColumns(size, orientation), defaultsGenerator),
                                _orientation(orientation) {
                }
                int getSize() const throw(InternalError) {
                        switch(_orientation) {
                        case ROW:
                                return Matrix<T>::getColumns();
                        case COLUMN:
                                return Matrix<T>::getRows();
                        default:
                                throw InternalError();
                        }
                }
                T getItem(int index) const throw(InvalidArgument, InternalError) {
                        switch(_orientation) {
                        case ROW:
                                return Matrix<T>::getItem(1, index);
                        case COLUMN:
                                return Matrix<T>::getItem(index, 1);
                        default:
                                throw InternalError();
                        }
                }
                void setItem(int index, T value) throw(InvalidArgument, InternalError) {
                        switch(_orientation) {
                        case ROW:
                                Matrix<T>::setItem(1, index, value);
                                break;
                        case COLUMN:
                                Matrix<T>::setItem(index, 1, value);
                                break;
                        default:
                                throw InternalError();
                        }
                }
        };
}

// ПРИМЕРЫ ПРИМЕНЕНИЯ.

using namespace matrix;

// Матрица целых чисел.
typedef Matrix<int> MyMatrix;
// Вектор целых чисел.
typedef Vector<int> MyVector;

// Стратегии заполнения матриц значениями.
namespace strategyusing
{
        // Заполнение значением по умолчанию.
        class MyDefaultsGenerator: public MyMatrix::FillStrategy {
        public:
                virtual int getItemBy(int row, int column) throw(OperationFailed) {
                        return 0;
                }
        };

        // Ввод значений пользователем.
        class MyUserValuesGenerator: public MyMatrix::FillStrategy {
        public:
                virtual int getItemBy(int row, int column) throw(OperationFailed) {
                        cout << "В позиции (" << row << ", " << column << ")? ";
                        int value;
                        cin >> value;
                        return value;
                }      
        };

        // Операция транспонирования матрицы.
        class MyTransposition : public MyMatrix::FillStrategy {
                MyMatrix &_source;
        public:
                MyTransposition(MyMatrix &source):
                                _source(source) {
                }
                virtual int getItemBy(int row, int column) throw(OperationFailed) {
                        try {
                                return _source.getItem(column, row);
                        } catch(InvalidArgument) {
                                throw OperationFailed();
                        }
                }              
        };
}

using namespace strategyusing;

// Вывод матрицы на экран.
template<class T>
void printMatrix(const Matrix<T> &m) {
        for(int i = 1; i <= m.getRows(); ++i) {
                for(int j = 1; j <= m.getColumns(); ++j)
                        cout << m.getItem(i, j) << " ";
                cout << endl;
        }
}

int main() {
        try {
                MyDefaultsGenerator defaultsGenerator;
                MyUserValuesGenerator userValuesGenerator;

                cout << "Матрица размера 2 на 2" << endl;
                MyMatrix a(2, 2, userValuesGenerator);
                printMatrix<int>(a);


                cout << "умножается на вектор" << endl;
                MyVector b(2, defaultsGenerator, MyVector::COLUMN);
                b.setItem(1, 5);
                b.setItem(2, 6);
                printMatrix<int>(b);

                MyMatrix c = a * b;
                cout << "результат" << endl;
                printMatrix<int>(c);

                cout << "Вектор" << endl;
                MyVector d(2, defaultsGenerator, MyVector::ROW);
                d.setItem(1, 5);
                d.setItem(2, 6);
                printMatrix<int>(d);

                MyTransposition transposition(a);

                cout << "умножается на матрицу" << endl;
                MyMatrix e(2, 2, transposition);
                printMatrix<int>(e);

                Matrix<int> f = d * e;
                cout << "результат" << endl;
                printMatrix<int>(f);

        } catch(InvalidArgument) {
                cout << "ОШИБКА ПРОГРАММИРОВАНИЯ" << endl;
        } catch(InternalError) {
                cout << "ОШИБКА ПРОГРАММИРОВАНИЯ" << endl;
        }
        return 0;
}

Так как количество классов быстро растёт, то для удобства отделения "зёрен от плевел" ввёл пространства имён.

Для демонстрации возможностей подхода сделал три разных генератора, решающих разные задачи.

[Люсь]

охохохохо...

спасибо вам всем, прогу сдала
кто-то был прав насчёт формата выходных данных - это должен был быть вектор
переделывала у него на глазах, попутно ещё кое-что подправила

Код:

#include <iostream>
#include <fstream>
using namespace std;

class vector{ public: int el[3];};
class matrica{
public:
    int el[3][3];
    vector operator*(vector& vec)
    {
        vector res;
        vector prom;
        for (int i=0; i<=2; i++)
        {
            res.el[i]=0;
            for (int j=0; j<=2; j++)
            {
               prom.el[j] = el[i][j] * vec.el[j];
               res.el[i] += prom.el[j];
            }
        }
        return res;
    };
};

void main()
{
    vector vec;
    matrica matr;
    vector res;

    ifstream mfs("matrica.txt", ios::in);
    ifstream vfs("vector.txt", ios::in);
    ofstream rfs("result.txt", ios::out);

    int i, j;
    for (i=0; i<=2; i++)
    {
        vfs >> vec.el[i];
        for (j=0; j<=2; j++)
        {
            mfs >> matr.el[i][j] ;
        }
    }

    // matrica * vector
    
    res = matr * vec;

    for (j=0; j<=2; j++)
    {
       rfs << res.el[j] << endl;
       cout << res.el[j] << endl ;
    }

    mfs.close();
    vfs.close();
    rfs.close();
    return;
}

щас теорию почитаю - пойду теоретическую часть сдавать

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

Джон, спасибо!

[Люсь]

Прикольно ))

Полезла в инет искать ответ на конкретный вопрос - первая же ссылка - переписка нас с вами ))))
http://www.yandex.ru/yandsearch?text=%D0%BE%D1%82%D0%BB%D0%B8%D1%87%D0%B8%D0%B5+%D1%81%D1%82%D1%80%D1%83%D0%BA%D1%82%D1%83%D1%80%D1%8B+%D0%BE%D1%82+%D0%BA%D0%BB%D0%B0%D1%81%D1%81%D0%B0

https://forum.shelek.ru/index.php?action=printpage;topic=12347.0

Я вас люблю!!!

[Алексей++]

Люськин, молоток! Так держать!!

[Люсь]

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

[McZim]

Люсь, давай поможем!

[Люсь]

Ага Погоди тока, с мыслями соберусь...