1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
| #include <algorithm>
#include <iostream>
#include <iomanip>
#include <string>
#include <random>
#include <stdexcept>
template<typename T>
class Matrix {
public:
Matrix(size_t width, size_t height) : width(width), height(height), data(nullptr) {
initData();
}
template<typename Generator>
Matrix(size_t width, size_t height, Generator g) : width(width), height(height), data(nullptr) {
initData();
generateData(g);
}
virtual ~Matrix() {
deleteData();
}
Matrix &operator=(const Matrix<T> &other) {
if (this != &other) {
deleteData();
width = other.width;
height = other.height;
copy(other.data);
}
return *this;
}
Matrix(const Matrix<T> &other) : width(other.width), height(other.height), data(nullptr) {
initData();
copy(other.data);
}
Matrix(Matrix &&other) noexcept : width(other.width), height(other.height), data(std::exchange(other.data, nullptr)) {
}
Matrix &operator=(Matrix<T> &&other) noexcept {
if (this != &other) {
deleteData();
height = other.height;
width = other.width;
data = std::exchange(other.data, nullptr);
}
return *this;
}
size_t getWidth() const { return width; }
size_t getHeight() const { return height; }
T &operator()(int row, int col) { return data[row][col]; }
const T &operator()(int row, int col) const { return data[row][col]; }
private:
void copy(int **other) {
for (size_t i = 0; i < height; ++i) {
for (size_t j = 0; j < width; ++j) {
data[i][j] = std::move(other[i][j]);
}
}
}
void deleteData() {
if (data != nullptr) {
for (size_t i = 0; i < height; ++i) {
delete[] data[i];
}
delete[] data;
}
}
void initData() {
deleteData();
data = new T*[height];
for (size_t i = 0; i < height; ++i) {
data[i] = new T[width]{ 0 };
}
}
template<typename Generator>
void generateData(Generator g) {
for (size_t i = 0; i < height; ++i) {
for (size_t j = 0; j < width; ++j) {
data[i][j] = g();
}
}
}
size_t width;
size_t height;
T **data;
};
template<typename T>
std::ostream &operator<<(std::ostream &out, Matrix<T> &m) {
for (size_t i = 0; i < m.getHeight(); ++i) {
for (size_t j = 0; j < m.getWidth(); ++j) {
out << std::setw(3) << m(i, j) << " ";
}
out << std::endl;
}
return out;
}
template<typename T>
Matrix<T> operator*(const Matrix<T> &a, const Matrix<T> &b) {
if (a.getWidth() != b.getHeight()) {
throw std::runtime_error("Multiplication error: number of columns of the first matrix should be equal to the number of rows of the second matrix.");
}
Matrix<T> result(a.getHeight(), b.getWidth());
for (size_t i = 0; i < a.getHeight(); i++) {
for (size_t j = 0; j < b.getWidth(); j++) {
result(i, j) = 0;
for (size_t k = 0; k < a.getWidth(); k++) {
result(i, j) += a(i, k) * b(k, j);
}
}
}
return result;
}
int main(int argc, char **argv) {
std::random_device rd;
std::uniform_int_distribution<int> uid(-25, 25);
auto generator = [&]() { return uid(rd); };
Matrix<int> a(2, 3, generator);
Matrix<int> b(3, 2, generator);
std::cout << a << std::endl;
std::cout << b << std::endl;
std::cout << (a * b) << std::endl;
std::cout << (b * a) << std::endl;
return 0;
} |
(
