---

#include <iostream>

using namespace std;

class matrix; // Предварительное объявление

class vect {
private:
    int* p;
    int size;
public:
    vect(int s = 0) {
        size = s;
        if (s > 0) {
            p = new int[s];
            for (int i = 0; i < s; i++) p[i] = 0;
        } else {
            p = nullptr;
        }
    }

    // Деструктор для очистки памяти
    ~vect() {
        delete[] p;
    }

    // Конструктор копирования (важен для возврата из функций)
    vect(const vect& other) {
        size = other.size;
        p = new int[size];
        for (int i = 0; i < size; i++) p[i] = other.p[i];
    }

    // Оператор присваивания
    vect& operator=(const vect& other) {
        if (this != &other) {
            delete[] p;
            size = other.size;
            p = new int[size];
            for (int i = 0; i < size; i++) p[i] = other.p[i];
        }
        return *this;
    }

    void in() {
        for (int i = 0; i < size; i++) {
            cout << "vect[" << i << "] = ";
            cin >> p[i];
        }
    }

    void out() const {
        cout << "vect: ";
        for (int i = 0; i < size; i++)
            cout << p[i] << " ";
        cout << endl;
    }

    int getSize() const { return size; }

    // Обычный оператор доступа
    int& operator[](int index) { return p[index]; }

    // КОНСТАНТНЫЙ оператор доступа (нужен для работы в operator*)
    int operator[](int index) const { return p[index]; }

    friend vect operator*(const vect& v, const matrix& m);
};

class matrix {
private:
    int** base;
    int column_size, row_size;
public:
    matrix(int row = 0, int col = 0) {
        row_size = row;
        column_size = col;
        base = new int* [row];
        for (int i = 0; i < row; i++) {
            base[i] = new int[col];
            for (int j = 0; j < col; j++)
                base[i][j] = 0;
        }
    }

    ~matrix() {
        for (int i = 0; i < row_size; i++) delete[] base[i];
        delete[] base;
    }

    void in() {
        for (int i = 0; i < row_size; i++) {
            for (int j = 0; j < column_size; j++) {
                cout << "matrix[" << i << "][" << j << "] = ";
                cin >> base[i][j];
            }
        }
    }

    void out() const {
        cout << "Matrix: " << endl;
        for (int i = 0; i < row_size; i++) {
            for (int j = 0; j < column_size; j++)
                cout << base[i][j] << " ";
            cout << endl;
        }
    }

    int getColumnSize() const { return column_size; }
    int getRowSize() const { return row_size; }
    int** getBase() const { return base; }

    friend vect operator*(const vect& v, const matrix& m);
};

vect operator*(const vect& v, const matrix& m) {
    if (v.getSize() != m.getRowSize()) {
        cout << "Error: Dimension mismatch!" << endl;
        return vect(0);
    }

    vect rez(m.getColumnSize());
    for (int j = 0; j < m.getColumnSize(); j++) {
        rez[j] = 0; // Теперь работает, так как rez не константный
        for (int i = 0; i < m.getRowSize(); i++) {
            // v[i] теперь работает, так как мы добавили константный operator[]
            rez[j] += v[i] * m.getBase()[i][j];
        }
    }
    return rez;
}

int main() {
    setlocale(LC_ALL, "Russian"); // Для корректного вывода кириллицы

    vect v(3);
    matrix m(3, 2);

    cout << "Enter vector elements (size 3):" << endl;
    v.in();
    cout << endl;

    cout << "Enter matrix elements (3x2):" << endl;
    m.in();
    cout << endl;

    v.out();
    m.out();

    vect r = v * m;
    cout << "Result of v * m:" << endl;
    r.out();

    return 0;
}