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

@Fedor N · Регистрация: 22.06.2012

Студворк — интернет-сервис помощи студентам

Здравствуйте, помогите пожалуйста. Имеется библиотека 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();
}

@Fedor N · 01.07.2012, 21:51 **[ТС]**

Спасибо вам огромное за помощь. А на счет temporary. Например, если мы присваиваем объекту C значение объекта А (С = A), последний, естественно, не должен (и не может!) быть уничтожен. Уничтожаться должны только «временные» динамические объекты, созданные методами класса.
Таким образом, нам требуется средство, позволяющее перегруженному оператору присваивания и другим методам класса определять «вид» объекта–параметра. С этой целью в определение класса и вводится компонентное данное . Если temporary!=0, объект считается «временным» и должен быть уничтожен после использования.

silent_1991 · 01.07.2012, 21:54

Fedor N, костыль. Не вижу в этом никакого смысла. Размещайте временные объекты на стеке, а не в куче, и они автоматически уничтожатся по выходу из области видимости, т.е. именно тогда, когда станут не нужны. Либо размещайте в куче, но и уничтожайте в том методе, в которым создали.

@DU · 01.07.2012, 22:33

доступ по индексу кривой.
A[x * ysize + y] или A[y * xsize + x]
с строке 69 просто new, а в деструкторе - delete []

@Fedor N · 02.07.2012, 20:17 **[ТС]**

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

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();
 
}

IGPIGP · 02.07.2012, 21:09

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;
}

Новые блоги и статьи Все статьи Все блоги /
Локальный http сервер Argus19 17.10.2026 Локальный http сервер На работе, на двух локальных компьютерах круглосуточно работают программы опроса приборов с записью в книги Excel,которые раз в сутки записываются на сервер компании. Т. к. . . .	Копировать Windows на новый диск на UEFI damix 17.10.2026 https:/ / uriesk. wordpress. com/ 2016/ 11/ 01/ move-window-10-to-ssd-on-a-uefi-dualboot-system-with-basic-linux-tools/ TL DR Вставляем диск, а старый подключаем через переходник, грузимся с лайва. . .	ИИ не может найти нужный язык в списке Supersumestria 05.10.2026 Я ему даю вот такое изображение и прошу найти и подчеркнуть немецкий язык. Возвращает он вот это: https:/ / i. **********/ vqBWLe2. png Нужную строчку в 3й колонке просто выдумал. . Это. . .	Новая последняя моя музыка в SUNO zorxor 05.10.2026 Здравствуйте, дорогие мои друзья! С большой радостью я хотел бы представить вам свою новую последнею музыку, которую сгенерировала мне по моей просьбе нейросеть SUNO. С уважением, zorxor. Это. . .
Программный домашний кинотеатр russiannick 27.09.2026 Сподобился на программный домашний кинотеатр. В качестве ЯВУ по традиции выбрал js. В помощники взял Яндекс-Алису. Было создано три зала на разные интересы. исторические и ретро сериал Хичкок. . .	Беседа с ИИ о программистах, недопускающих к созданию и правке кода генеративные ИИ и причины этого zorxor 21.09.2026 Раньше я радовался или получал некоторые эмоции, пусть небольшие, но всё же, от самого процесса написания кода, рекомпиляции и запуска, видя постепенное развитие программы и прочее. А теперь лень. . .	Мобильное приложение ColorStep pavlinmavlin 17.09.2026 Реализовал приложение Красный, Зеленый, Синий в Unity3d + c#. Название изменил на ColorStep. Приложение прошло модерацию и теперь доступно для скачивания. Делал его сам, шаг за шагом — и вот,. . .	Запрет дублирования строк в табличной части Maks 13.09.2026 Реализация из решения ниже выполнена на нетиповом справочнике "Нормы ТО" с табличной часть "Виды ТО", разработанного в КА2, со следующими реквизитами: - ВидТО (СправочникСсылка. ВидыТО); - ВидГСМ. . .

@Fedor N 0 / 0 / 0 Регистрация: 22.06.2012 Сообщений: 17
	01.07.2012, 21:51 [ТС]
	Спасибо вам огромное за помощь. А на счет temporary. Например, если мы присваиваем объекту C значение объекта А (С = A), последний, естественно, не должен (и не может!) быть уничтожен. Уничтожаться должны только «временные» динамические объекты, созданные методами класса. Таким образом, нам требуется средство, позволяющее перегруженному оператору присваивания и другим методам класса определять «вид» объекта–параметра. С этой целью в определение класса и вводится компонентное данное . Если temporary!=0, объект считается «временным» и должен быть уничтожен после использования. 0

silent_1991 5058 / 3118 / 271 Регистрация: 11.11.2009 Сообщений: 7,044
	01.07.2012, 21:54
	Fedor N, костыль. Не вижу в этом никакого смысла. Размещайте временные объекты на стеке, а не в куче, и они автоматически уничтожатся по выходу из области видимости, т.е. именно тогда, когда станут не нужны. Либо размещайте в куче, но и уничтожайте в том методе, в которым создали. 0

@DU 1500 / 1146 / 165 Регистрация: 05.12.2011 Сообщений: 2,279
	01.07.2012, 22:33
	доступ по индексу кривой. A[x * ysize + y] или A[y * xsize + x] с строке 69 просто new, а в деструкторе - delete [] 0