Форум программистов, компьютерный форум CyberForum.ru

Матрицы - перегрузка оператора * - C++

Восстановить пароль Регистрация
 
 
Рейтинг: Рейтинг темы: голосов - 17, средняя оценка - 4.88
Fedor N
 Аватар для Fedor N
0 / 0 / 0
Регистрация: 22.06.2012
Сообщений: 17
26.06.2012, 15:38     Матрицы - перегрузка оператора * #1
Здравствуйте, помогите пожалуйста. Имеется библиотека Matrixclass.h, необходимо в ней перегрузить оператор умножения. Как только я не пытался его реализовать, но выводит не понять что. Посоветуйте что-нибудь по этому поводу.



Matrixclass.h

C++
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
#include <iostream>
#include <stdlib.h>
#include <time.h> // Srand, Randomize
#include <math.h>
using namespace std;
 
enum ElemStatus {minimal = -5000, maximal};
enum Action {sum = -6000, prod};
enum ConvertType {row, column};
 
class Matrix {
    private:
        // Размеры массива
        unsigned xsize, ysize;
 
        // Указатель на начало массива в динамической памяти
        double *Array;
 
        // Флаг временности
        int temporary;
    public:
 
        // Возвратить размеры матрицы
        unsigned getxsize(void) {
            return xsize;
        }
 
        unsigned getysize(void) {
            return ysize;
        }
 
        // Функция вычисления определителя
        double determinant(Matrix& M, unsigned size);
 
        // конструктор, заполняет матрицу
        Matrix(unsigned y, unsigned x);
        Matrix(unsigned y, unsigned x, double v);
 
        // конструктор копирования
        Matrix(Matrix &);
 
        // Конструктор "скалярной матрицы" xsize=ysize=1
        Matrix(double v);
 
        // деструктор, вывод "!" для отслеживания вызовов
        ~Matrix() {
//          delete [] Array;
//          cout << "!";
        }
 
        void add(unsigned x, unsigned y, double v);
 
        // "Примитивный" вывод
        void show(void);
 
        // Последовательный доступ к элементу
        double & operator()(unsigned n) const;
        Matrix & operator*(Matrix& M);
        Matrix & operator()(unsigned x1, unsigned x2, unsigned y1, unsigned y2) const;
};
 
double Matrix::determinant(Matrix& M, unsigned size) {
    double det = 0, sum1, sum2;
 
    // Если размерость 1, то первый элемент есть определитель
    if(size == 1)
        det = M(0);
    // Иначе если два элемента
    else if(size == 2)
        det = M(0) * M(3) - M(1) * M(2);
    else {
        // находим детерминант
        for(unsigned i = 0; i < size; i++) {
            sum2 = sum1 = 1;
            int l = 2 * size - 1 - i;
 
            for(unsigned j = 0; j < size; j++) {
                sum2 *= M(j * size + l % size);
                l--;
                sum1 *= M(j * size + ((j + i) % size));
            }
 
            det += sum1 - sum2;
        }
    }
 
    return det;
}
 
Matrix::Matrix(unsigned x, unsigned y) {
    Array = new double[(xsize = x)*(ysize = y)];
 
    temporary = 0;
    for(unsigned i = 0; i < xsize; i++)
        for(unsigned j = 0; j < ysize; j++)
//      cout << "Enter " << i + 1 << " elemet ";
//      cout << (v = rand() % 100) << endl;
            Array[i*x+j] = rand() % 100;
 
}
 
void Matrix::add(unsigned x, unsigned y, double v) {
    Array[x*xsize+y] = v;
}
 
void Matrix::show(void) {
    cout << endl;
    //cout << "{";
    for(int i = 0; i < xsize; i++) {
        cout << "{";
        for(int j = 0; j < ysize; j++)
            if(j != ysize - 1)
                cout << Array[i*xsize+j] << ", ";
            else if(j == 0)
                cout << Array[i*xsize+j];
            else
                cout << Array[i*xsize+j];
 
        cout << "}";
        if(i != xsize - 1)
            cout << "," << endl;
    }
 
    cout << " " << endl;
 
    if(temporary)
        delete this;
}
 
Matrix& Matrix::operator()(unsigned x1, unsigned x2, unsigned y1, unsigned y2) const {
    if((y2 < y1) || (x2 < x1) || (y2 > ysize) || (x2 > xsize)) {
        cout << "error";
        exit(1);
    }
 
    Matrix*A = new Matrix(y2 - y1 + 1, x2 - x1 + 1);
    A->temporary = 1;
    int i = 0;
 
    for(int y = y1; y <= y2; y++)
        for(int x = x1; x <= x2; x++)
            A->Array[i++] = Array[(y-1)*xsize+(x-1)];
 
    if(temporary)
        delete this;
 
    return *A;
}
 
double &Matrix::operator()(unsigned n) const {
    if(n > xsize * ysize) {
//  cout << n << " > " << xsize << " * " << ysize << endl;
        cerr << "Index exceeds matrix dimensions!";
        exit(1);
    }
 
    if(temporary) {
        cerr << "Operation is not allowed!";
        exit(1);
    }
 
//  cout << n << " > " << xsize << " * " << ysize << endl;
 
    return Array[n];
}
 
Matrix &Matrix::operator*(Matrix &M) const //умножение матриц
 
{
    Matrix result(*this);
 
    for (int i = 0; i < 3; i++)
     {
        for (int j = 0; j < 3; j++)
         {
            result.A[i][j] *= n.A[i][j];
         }
     }
    return result;
}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
{
   /** Matrix result(*this);
    //Matrix T(ysize, M.xsize);
     double temp=0;
    if(xsize == M.ysize) {
        //реализация алгоритма перемножения матриц
         for(int j=0;j<M.ysize;j++)
        {
            for(int i = 0; i < M.xsize; i++)
            {
                temp+=Array[i][j]*M(i*M.xsize+j);
                //result.Array[i][j] *= M.Array[i][j];
            }
          Array[j]=temp;
          temp=0;
        }
                    /**for(int j = 0; j < M.ysize; j++)
                        for(int k = 0; k < xsize; k++)
                            Array[i *j] += Array[j * k] * M(k * i);**/
 
 
    /** for(unsigned a = 0; a < ysize; a++)
            for(unsigned b = 0; b < M.xsize; b++) {
                T(a * M.xsize + b) = 0;
 
                for(unsigned k = 0; k < M.xsize; k++) {
                    cout << T(a * M.ysize + b) << " = " << Array[b * ysize + k] << " * " << M(k + b) << endl;
                    T(a* M.ysize + b) += Array[b * ysize + k] * M(k + b);
 
//                  M(a * M.xsize + b) += Array[b * ysize + k] * M(k * M.ysize + a);
                }
            }**/
    } else
        cout << "Wrong matrix size" << endl;
 
    //return T;
    return result;
}

main
C++
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
#include <iostream>
#include <time.h> // Srand, Randomize
#include "Matrixclass_.h"
#include <conio.h>
using namespace std;
 
int main(int argc, char **argv) {
    cout << "program begin" << endl;
    srand((unsigned) time(NULL)); // Randomize
 
    unsigned n;
 
    cout << "Enter size matrix: ";
    cout << (n = rand() % 1 + 3) << endl;
 
    Matrix A(n, n);
    A.show();
 
    cout << endl << "Output determinant of matrix " << endl;
    cout << A.determinant(A, n) << endl << endl;
 
 
    cout << "Output matrix free elements" << endl;
    Matrix B(n, 1);
 
    B.show();
 
    B*A;
 
    B.show();
 
    cout << "program end" << endl;
    getch();
}
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
26.06.2012, 15:38     Матрицы - перегрузка оператора *
Посмотрите здесь:

Перегрузка оператора C++
Перегрузка оператора == C++
Перегрузка оператора - C++
Перегрузка оператора *= C++
Перегрузка оператора + для динамической матрицы C++
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
Fedor N
 Аватар для Fedor N
0 / 0 / 0
Регистрация: 22.06.2012
Сообщений: 17
01.07.2012, 21:51  [ТС]     Матрицы - перегрузка оператора * #21
Спасибо вам огромное за помощь. А на счет temporary. Например, если мы присваиваем объекту C значение объекта А (С = A), последний, естественно, не должен (и не может!) быть уничтожен. Уничтожаться должны только «временные» динамические объекты, созданные методами класса.
Таким образом, нам требуется средство, позволяющее перегруженному оператору присваивания и другим методам класса определять «вид» объекта–параметра. С этой целью в определение класса и вводится компонентное данное . Если temporary!=0, объект считается «временным» и должен быть уничтожен после использования.
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
silent_1991
Эксперт C++
4938 / 3014 / 149
Регистрация: 11.11.2009
Сообщений: 7,024
Завершенные тесты: 1
01.07.2012, 21:54     Матрицы - перегрузка оператора * #22
Fedor N, костыль. Не вижу в этом никакого смысла. Размещайте временные объекты на стеке, а не в куче, и они автоматически уничтожатся по выходу из области видимости, т.е. именно тогда, когда станут не нужны. Либо размещайте в куче, но и уничтожайте в том методе, в которым создали.
DU
1477 / 1053 / 45
Регистрация: 05.12.2011
Сообщений: 2,279
01.07.2012, 22:33     Матрицы - перегрузка оператора * #23
доступ по индексу кривой.
A[x * ysize + y] или A[y * xsize + x]
с строке 69 просто new, а в деструкторе - delete []
Fedor N
 Аватар для Fedor N
0 / 0 / 0
Регистрация: 22.06.2012
Сообщений: 17
02.07.2012, 20:17  [ТС]     Матрицы - перегрузка оператора * #24
Здравствуйте, дописал я значит функции(работают), но вот с умножением опять беда
C++
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
#include <iostream>
#include <stdlib.h>
#include <time.h>
#include <math.h>
//#include <conio.h>
using namespace std;
 
class Matrix {
private:
    // размеры матрицы
    unsigned xsize;
    unsigned ysize;
 
    // указатель на начало массива в динамической памяти
    double *Array;
public:
 
    // функции возвращающие размеры матрицы
 
    unsigned getxsize(void) const {
        return xsize;
    }
 
    unsigned getysize(void) const {
        return ysize;
    }
 
    // конструкторы, которые создают и заполняют матрицу значениями
    Matrix(unsigned y = 1, unsigned x = 1, double v = 0);
    Matrix(const Matrix&);
    Matrix(double);
 
    // деструктор, вывод "!" для отслеживания вызовов
 
    ~Matrix() {
        delete [] Array;
        //cout << "!";
    }
 
    // функция вычисления определителя
    double determinant(const unsigned);
 
    // определитель матрицы
    double minors(const unsigned, const unsigned);
 
    // союзная матрица
    double *cofactor(void);
 
    // транспонирование
    void transpose(const bool);
 
    // обратная матрица
    void inverse(double, const bool);
 
    // вывод матрицы
    void show(void) const;
 
    // последовательный доступ к элементу
    double& operator()(unsigned y, unsigned x);
    double operator()(unsigned y, unsigned x) const;
 
    // перегруженные операции
    Matrix operator*(const Matrix &) const;
    Matrix operator+(const Matrix &) const;
    Matrix operator+(double) const;
    Matrix operator-(const Matrix &) const;
    Matrix operator-(double) const;
};
 
Matrix::Matrix(unsigned x, unsigned y, double v) {
    unsigned asize = (xsize = x) * (ysize = y);
    Array = new double[asize];
 
    for (unsigned i = 0; i < asize; i++)
        Array[i] = rand() % 100;
}
 
Matrix::Matrix(const Matrix& M) {
    unsigned asize = (xsize = M.xsize) * (ysize = M.ysize);
    Array = new double[asize];
 
    for (unsigned i = 0; i < asize; i++)
        Array[i] = M.Array[i];
}
 
Matrix::Matrix(double v) {
    xsize = ysize = 1;
    Array = new double;
    *Array = v;
}
 
void Matrix::show(void) const {
    cout << endl << "{";
 
    for (unsigned i = 0; i < xsize; i++) {
        cout << "{";
        for (unsigned j = 0; j < ysize; j++)
            if (j != ysize - 1)
                cout << (*this)(i, j) << ", ";
            else
                if (j == 0)
                cout << (*this)(i, j);
            else
                cout << (*this)(i, j);
 
        cout << "}";
        if (i != xsize - 1)
            cout << "," << endl;
    }
 
    cout << "}" << endl << endl;
}
 
double &Matrix::operator()(unsigned x, unsigned y) {
    if (y > ysize - 1 || x > xsize - 1) {
        cerr << "Index exceeds matrix dimensions!";
        exit(1);
    }
 
    return Array[x * xsize + y];
}
 
double Matrix::operator()(unsigned x, unsigned y) const {
    if (y > ysize - 1 || x > xsize - 1) {
        cerr << "Index exceeds matrix dimensions!";
        exit(1);
    }
 
    return Array[x * xsize + y];
}
 
// приведение матрицы в верхнетреугольному виду
// определитель матрицы по Гауссу
 
double Matrix::determinant(const unsigned size) {
    double determinan = 1;
    Matrix result(size, size);
 
    for (unsigned i = 0; i < size; i++)
        for (unsigned j = 0; j < size; j++)
            result(i, j) = (*this)(i, j);
 
    for (unsigned i = 0; i < size - 1; i++) {
        double element = result(i, i);
 
        // рабочий элемент корректен - обрабатываем все строки ниже
        if (element) { // если элемент не равен единице
            for (unsigned j = i + 1; j < size; j++)
                for (unsigned k = size - 1; k > i; k--)
                    result(j, k) -= result(i, k) * result(j, i) / element;
 
        } else // ищем строку с ненулевым элементом среди строк, лежащих ниже
            for (unsigned j = i + 1; i < size; i++) {
                element = result(j, i);
                if (element != 0) {
                    // добавляем найденную строку к обрабатываемой строке
                    for (unsigned k = 0; k < size; k++)
                        result(i, k) += result(j, k);
                    break;
                }
            }
    }
 
    for (unsigned i = 0; i < size; i++)
        determinan *= result(i, i);
 
    return determinan;
}
 
// дополнительный минор элемента матрицы n-го порядка есть определитель порядка (n-1),
// соответствующий той матрице, которая получается из матрицы путем вычеркивания i-ой строки и j-го столбца.
 
double Matrix::minors(const unsigned row, const unsigned col) {
    Matrix tmp(*this);
 
    unsigned n = 0;
    for (unsigned i = 0; i < xsize; i++)
        for (unsigned j = 0; j < xsize; j++)
            if (i != row && j != col)
                tmp(n++ / xsize, n % xsize) = (*this)(i, j);
 
    return tmp.determinant(--tmp.xsize);
}
 
// союзная матрица
 
double *Matrix::cofactor(void) {
    double *result = new double[xsize * ysize];
 
    for (unsigned i = 0; i < xsize; i++)
        for (unsigned j = 0; j < ysize; j++)
            result[i * xsize + j] = pow((double) - 1, i + j) * (*this).minors(i, j);
 
    return result;
}
 
// вывод транспонированной союзной матрицы
// второй параметр отвечает за модифицирование массива *this
 
void Matrix::transpose(const bool modify) {
    // создаём два массива типа double
    // 1-ый будет для хранения конечных результатов
 
    // 2-ой для хранения союзной матрицы от матрицы *this,
    // для котороый мы вызвали метод transpose
 
    double *result_cof = new double[xsize * ysize];
 
    for (unsigned i = 0; i < xsize; i++)
        for (unsigned j = 0; j < ysize; j++)
            result_cof[i * xsize + j] = pow((double) - 1, i + j) * (*this).minors(i, j);
 
    // находим союзную матрицу
    //    result_cof = (*this).cofactor();
 
    if (modify) {
        for (unsigned i = 0; i < xsize; i++)
            for (unsigned j = 0; j < ysize; j++) // делаем перестановку элементов
                (*this)(i, j) = result_cof[j * xsize + i];
 
        (*this).show();
    } else {
        Matrix tmp(*this);
 
        for (unsigned i = 0; i < xsize; i++)
            for (unsigned j = 0; j < ysize; j++) // делаем перестановку элементов
                tmp(i, j) = result_cof[j * xsize + i];
 
        tmp.show();
    }
}
 
// вывод обратной матрицы, путём деления матрицы *this на её определитель
// второй параметр отвечает за модифицирование матрицы *this
 
void Matrix::inverse(double determinant, const bool modify) {
    if (!determinant) // если определитель равен нулю, то матрица вырождена
        cout << endl << "matrix is singular" << endl << endl;
    else if (modify) {
        for (unsigned i = 0; i < xsize; i++)
            for (unsigned j = 0; j < ysize; j++)
                (*this)(i, j) /= determinant;
 
        (*this).show();
    } else {
        Matrix tmp(*this);
 
        for (unsigned i = 0; i < xsize; i++)
            for (unsigned j = 0; j < ysize; j++)
                tmp(i, j) = (*this)(i, j) / determinant;
 
        tmp.show();
    }
}
 
// перегруженые операторы
 
Matrix Matrix::operator*(const Matrix& M) const {
    Matrix tmp(*this);
 
    for (unsigned i = 0; i < xsize; i++) {
        for (unsigned j = 0; j < ysize; j++) {
            tmp(i, j) = 0;
 
            for (unsigned k = 0; k < xsize; k++)
                tmp(i, j) += (*this)(i, k) * M(k, j);
        }
    }
 
    return tmp;
}

main.cpp
C++
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
#include "Matrixclass.h"
#include <iostream>
#include <stdlib.h>
//#include <conio.h>
 
using namespace std;
 
int main() {
 
    srand((unsigned) time(NULL));
 
    unsigned n = rand() % 3 + 2; // генерирует число от 2 до 5
    bool modify = true;
    double determinant;
 
    Matrix A(n, n);
    cout << "A:";
    A.show();
 
    cout << "Determinant of A:" << endl << (determinant = A.determinant(n)) << endl;
 
    cout << endl << "Output transpose of cofactor of matrix:";
    // если modify равен 1 (true), то матрица А заменится на транспонированную союзную матрицу
    A.transpose(modify);
 
    cout << "Output inverse of matrix:";
    // если modify равен 1 (true), то матрица А заменится на обратну
    A.inverse(determinant, modify);
 
    Matrix B(n, 1);
    cout << "B:";
    B.show();
 
    cout << "A * B:";
    (A * B).show();
 
}
Миниатюры
Матрицы - перегрузка оператора *  
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
02.07.2012, 21:09     Матрицы - перегрузка оператора *
Еще ссылки по теме:

C++ Перегрузка оператора =
C++ Перегрузка оператора ++
Перегрузка оператора () для разреженной матрицы в CSR-формате C++

Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
IGPIGP
Комп_Оратор)
 Аватар для IGPIGP
6167 / 2896 / 282
Регистрация: 04.12.2011
Сообщений: 7,704
Записей в блоге: 3
02.07.2012, 21:09     Матрицы - перегрузка оператора * #25
Fedor N, вот класс в котором, к массиву можно обратиться индексно. Конечно одномерный массив + указательная арифметика универсальней. Но с индексами легче работать. Я то и в начале подумал, что Вы делаете это же. Посмотрите как вариант. Может понравится.
C++
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
#include "stdafx.h"
#include<iostream>
#include<cstdlib>
#include<locale.h>
#include<conio.h>
#include<cstdio>
#include<windows.h>
 
using namespace std;
class MyArr2D  {
public:
double **m_pArr;
int sizex;
int sizey;
//----------------------------------------
MyArr2D();
MyArr2D(int a, int b);
MyArr2D(double **ar, int a, int b);//передача указателя на 2D динамический массив
MyArr2D(const MyArr2D& a);
~MyArr2D();
//----------------------------------------
void show();
MyArr2D operator=(MyArr2D a);
MyArr2D operator+(MyArr2D a);
MyArr2D operator+(double a);
MyArr2D operator*(MyArr2D a);
MyArr2D operator*(double a);
};
//----------------------------------------
MyArr2D MyArr2D::operator*(MyArr2D a){
int nszx=sizex<a.sizex?sizex:a.sizex;
int nszy=sizey<a.sizey?sizex:a.sizey;
MyArr2D temp(nszx,nszy);    
for(int i=0; i<nszx; i++){
for(int j=0; j<nszy; j++){
temp.m_pArr[i][j]=m_pArr[i][j]*a.m_pArr[i][j];
}
}
return temp;
}
MyArr2D MyArr2D::operator*(double a){
MyArr2D temp(sizex,sizey);  
for(int i=0; i<sizex; i++){
for(int j=0; j<sizey; j++){
temp.m_pArr[i][j]=m_pArr[i][j]*a;
}
}
return temp;
}
MyArr2D MyArr2D::operator+(MyArr2D a){
int nszx=sizex<a.sizex?sizex:a.sizex;
int nszy=sizey<a.sizey?sizex:a.sizey;
 
MyArr2D temp(nszx,nszy);    
for(int i=0; i<nszx; i++){
for(int j=0; j<nszy; j++){
temp.m_pArr[i][j]=m_pArr[i][j]+a.m_pArr[i][j];
}
}
return temp;
}
MyArr2D MyArr2D::operator+(double a){
MyArr2D temp(sizex,sizey);  
for(int i=0; i<sizex; i++){
for(int j=0; j<sizey; j++){
temp.m_pArr[i][j]=m_pArr[i][j]+a;
}
}
return temp;
}
MyArr2D MyArr2D::operator=(MyArr2D a){
    if(sizex!=a.sizex||sizey!=a.sizey){
for(int i=0; i<sizex; i++){
delete  [] m_pArr[i];
}
sizex=a.sizex; sizey=a.sizey;
m_pArr=new double* [sizex];
for(int i=0; i<sizex; i++){
m_pArr[i]=new double[sizey];
}
}
for(int i=0; i<sizex; i++){
for(int j=0; j<sizey; j++){
m_pArr[i][j]=a.m_pArr[i][j];
}
}
return *this;
}
//--------------------------------------
void MyArr2D::show(){
cout<<"\nВ массиве такие элементы"<<"\n";
for(int i=0; i<sizex; i++){
for(int j=0; j<sizey; j++){
cout<<m_pArr[i][j]<<"\t";
}
cout<<"\n";
}
}
//----------------------------------------
MyArr2D::MyArr2D(){
sizex=0;
sizey=0;
m_pArr=0;
}
MyArr2D::MyArr2D(int sx, int sy){
sizex=sx;
sizey=sy;
m_pArr=new double* [sizex];
for(int i=0; i<sizex; i++){
m_pArr[i]=new double[sizey];
}
for(int i=0; i<sizex; i++){
for(int j=0; j<sizey; j++){
m_pArr[i][j]=0;
}
}
}
MyArr2D::MyArr2D(double **ar, int sx, int sy){
sizex=sx;
sizey=sy;
m_pArr=new double* [sizex];
for(int i=0; i<sizex; i++){
m_pArr[i]=new double[sizey];
}
for(int i=0; i<sizex; i++){
for(int j=0; j<sizey; j++){
m_pArr[i][j]=ar[i][j];
}
}
}
MyArr2D::MyArr2D(const MyArr2D& a){
 
    sizex=a.sizex ; sizey=a.sizey;
    if(a.m_pArr){
m_pArr=new double* [sizex];
for(int i=0; i<sizex; i++){
m_pArr[i]=new double[sizey];
}
for(int i=0; i<sizex; i++){
for(int j=0; j<sizey; j++){
m_pArr[i][j]=a.m_pArr[i][j];
        }
    }
    }else{
m_pArr=0;
    }
}
//--------------------------------------
MyArr2D::~MyArr2D(){
    
for(int i=0; i<sizex; i++){
delete  [] m_pArr[i];
}
delete [] m_pArr;
}
//---------------------------------------
int _tmain(int argc, _TCHAR* argv[])
{
setlocale(LC_ALL,"");
MyArr2D mAr=MyArr2D(4,4);
mAr.show();
double arr[3][2]={1,2,3,4,5,6};
 
int sizex=10;
int sizey=5;
double **m_pArrd=new double* [sizex];
for(int i=0; i<sizex; i++){
m_pArrd[i]=new double[sizey];
}
for(int i=0; i<sizex; i++){
for(int j=0; j<sizey; j++){
m_pArrd[i][j]=i*i+j*j;
}
}
MyArr2D mAr1=MyArr2D(m_pArrd,sizex,sizey);
mAr1.show();
MyArr2D mAr2=MyArr2D(mAr1);
mAr2.show();
mAr.m_pArr[0][0]=23;
mAr.m_pArr[0][1]=35;
mAr.m_pArr[0][3]=11;
mAr1=mAr;
mAr1.show();
mAr1=mAr2+mAr1;
mAr1.show();
mAr2.show();
mAr1=mAr1+mAr2;
mAr1.show();
mAr2.show();
mAr1=mAr2*mAr1;
mAr1.show();
mAr2.show();
mAr1=(mAr1+3)*10;
mAr1.show();
system("pause");
    return 0;
}
Yandex
Объявления
02.07.2012, 21:09     Матрицы - перегрузка оператора *
Ответ Создать тему
Опции темы

Текущее время: 15:42. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru