Сортировка векторов выбором по длине - обработка исключений

@БузинВладимир · Регистрация: 21.08.2017

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

Здравствуйте! Я пишу курсовую по дисциплине "Структуры и алгоритмы компьютерной обработки данных" на тему "Векторы: программная реализация сортировки выбором по длине". Как можно переделать функцию сортировки? Я ввожу массив векторов и при этом задаю количество координат, но функция сортировки не сработала, я вернулся назад к вводу и не увидел результаты.

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
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
#include <iostream>
#include <math.h>
#include <conio.h>
using namespace std;
 
class Vector
{
 double *vect; // Вектор
 double L;
 int size; // Размерность вектора
public:
 Vector(); // Конструктор по умолчанию
 explicit Vector(int); // Конструктор, позволяющий задавать
 // размерность вектора, но не являющийся
 // конструктором преобразования
 Vector(const double*, int); // Конструктор, позволяющий
 // проинициализировать вектор с помощью
 // существующего массива
 Vector(const Vector&); // Конструктор копирования
 ~Vector(); // Деструктор
 double get_L();
 Vector& operator ++ (); // Увеличение всех компонент вектора
 // на единицу (префикс)
 Vector operator ++ (int); // Увеличение всех компонент вектора
 // на единицу (постфикс)
 Vector& operator -- (); // Уменьшение всех компонент вектора
 // на единицу (префикс)
 Vector operator -- (int); // Уменьшение всех компонент вектора
 // на единицу (постфикс)
 Vector& operator = (const Vector&); // Перегруженный оператор присваивания
 double& operator [] (int); // Перегруженный оператор индексации
 Vector& operator + (); // Перегруженный оператор + (унарный)
 Vector operator - (); // Перегруженный оператор - (унарный)
 Vector operator + (const Vector&); // Сложение двух векторов
 Vector operator + (double); // Сложение вектора с числом
 Vector& operator += (const Vector&);// Перегруженный оператор += для 
 // сложения двух векторов
 Vector& operator += (double); // Перегруженный оператор += для 
 // сложения вектора с числом
 Vector operator - (const Vector&); // Вычитание двух векторов
 Vector operator - (double); // Вычитание числа из вектора
 Vector& operator -= (const Vector&);// Перегруженный оператор -= для 
 // вычитания двух векторов
 Vector& operator -= (double); // Перегруженный оператор -= для 
 // вычитания числа из вектора
 double operator * (const Vector&); // Умножение векторов
 Vector operator * (double); // Умножение вектора на число
 Vector& operator *= (double); // Перегруженный оператор *= для 
 // умножения вектора на число
 // Ввод вектора с клавиатуры
 friend istream& operator >> (istream&, Vector&);
 // Вывод вектора на экран
 friend ostream& operator << (ostream&, Vector&);
 int GetSize(); // Функция возвращает размерность вектора
};
 
Vector::Vector()
{ // Конструктор по умолчанию
 int n;
 cout << "Input array size:\t";
 cin >> n; // Запрос размерности вектора
 while(n <= 0) // Проверка корректности ввода
 {
 cout << "Input array size:\t";
 cin >> n;
 }
 size = n;
 vect = new double[size]; // Создание вектора заданной длины
}
 
Vector::Vector(int n)
{
 size = n;
 vect = new double[size]; // Создание вектора заданной длины
}
 
Vector::Vector(const double* v, int n)
{
 size = n;
 vect = new double[size];
 for(int i = 0; i < size; i++)// Копирование элементов переданного массива
 vect[i] = v[i]; // в компоненты вектора
}
 
Vector::Vector(const Vector& v)
{ // Конструктор копирования
 size = v.size;
 vect = new double[size];
 for(int i = 0; i < size; i++)
 vect[i] = v.vect[i];
}
 
Vector::~Vector()
{ // Деструктор
 delete [] vect;
}
 
Vector& Vector::operator = (const Vector& v)
{ // Перегруженный оператор присваивания
 if(&v == this) // Проверка на присваивание объекта
 return *this; // самому себе
 
 // Если передан другой объект, то копируем его
 delete [] vect; 
 size = v.size;
 vect = new double[size];
 for(int i = 0; i < size; i++)
 vect[i] = v.vect[i];
 return *this;
}
 
istream& operator >> (istream& is, Vector& v)
{ // Ввод компонент вектора с клавиатуры
 for(int i = 0; i < v.size; i++)
 {
 cout << "Input vect[" << i << "]:\t";
 is >> v.vect[i];
 }
 return is;
}
 
ostream& operator << (ostream& os, Vector& v)
{ // Вывод вектора на экран
 os << "Vector: (";
 for(int i = 0; i < v.size; i++)
 {
 os << v.vect[i];
 if(i == v.size - 1)
 os << ")\n";
 else
 os << ", ";
 }
 return os;
}
 
double Vector:: get_L ()
{
 L = 0;
 for(int i = 0; i < size; i++) L = L + pow(vect[i], 2);
 L = sqrt(L);
 return L;
}
 
Vector& Vector::operator ++ ()
{ // Увеличение всех компонент вектора
 // на единицу (префикс)
 for(int i = 0; i < size; i++)
 vect[i]++;
 return *this;
}
 
Vector& Vector::operator -- ()
{ // Уменьшение всех компонент вектора
 // на единицу (префикс)
 for(int i = 0; i < size; i++)
 vect[i]--;
 return *this;
}
 
Vector Vector::operator ++ (int n) // n - фиктивный параметр
{ // Увеличение всех компонент вектора
 // на единицу (постфикс)
 Vector temp(*this); // Создание временного объекта и 
 // инициализация его текущим объектом
 // (объектом, для которого вызвалась функция)
 for(int i = 0; i < size; i++)// Увеличение компонент вектора на единицу
 vect[i]++; // (для текущего объекта)
 return temp; // Возврат временного объекта
}
 
Vector Vector::operator -- (int n) // n - фиктивный параметр
{ // Уменьшение всех компонент вектора
 // на единицу (постфикс)
 Vector temp(*this); // Создание временного объекта и 
 // инициализация его текущим объектом
 // (объектом, для которого вызвалась функция)
 for(int i = 0; i < size; i++)// Уменьшение компонент вектора на единицу
 vect[i]--; // (для текущего объекта)
 return temp; // Возврат временного объекта
}
 
double& Vector::operator [] (int n)
{ // Перегруженный оператор индексации
 // для проверки выхода за границы массива
 if(n < 0) // В случае если индекс меньше нуля,
 // то возвращаем нулевой элемент массива
 {
 cout << "Index of array too small:\tuse zeroth element\n";
 return vect[0];
 }
 else if(n > size - 1) // В случае если индекс больше индекса
 // последнего элемента массива,
 // то возвращаем последний элемент массива
 {
 cout << "Index of array too big:\tuse last element\n";
 return vect[size - 1]; 
 }
 else
 return vect[n]; // Возврат заданного элемента массива
}
 
Vector& Vector::operator + ()
{ // Перегруженный унарный +
 return *this;
}
 
Vector Vector::operator - ()
{ // Перегруженный унарный -
 Vector temp(*this); // Создание временного объекта и 
 // инициализация его текущим объектом
 // (объектом, для которого вызвалась функция)
 for(int i = 0; i < size; i++)
 temp.vect[i] = -vect[i];
 return temp; // Возврат временного объекта
}
 
Vector Vector::operator + (const Vector& v)
{ // Сложение двух векторов с помощью 
 // перегруженного оператора бинарный +
 if(size == v.size) // Если размерности векторов совпадают
 {
 Vector temp(size); // Создание временного объекта
 for(int i = 0; i < size; i++)
 temp.vect[i] = vect[i] + v.vect[i];
 return temp; // Возврат временного объекта
 }
 else // Если размерности векторов не совпадают
 {
 cout << "Different arrays sizes !!!\nArray is truncating...\n";
 // Урезаем размерность большего вектора
 int s = (size < v.size) ? size : v.size;
 Vector temp(s); // Создание временного объекта
 for(int i = 0; i < s; i++)
 temp.vect[i] = vect[i] + v.vect[i];
 return temp; // Возврат временного объекта
 }
}
 
Vector Vector::operator + (double d)
{ // Сложение вектора с числом
 Vector temp(*this); // Создание временного объекта и 
 // инициализация его текущим объектом
 // (объектом, для которого вызвалась функция)
 for(int i = 0; i < size; i++)
 temp.vect[i] += d;
 return temp; // Возврат временного объекта
}
 
Vector& Vector::operator += (const Vector& v)
{ // Перегруженный оператор +=
 // для сложения двух векторов
 *this = *this + v; // Вызов функции this-<operator=(this-<operator+(v));
 return *this;
}
 
Vector& Vector::operator += (double d)
{ // Перегруженный оператор +=
 // для сложения вектора с числом
 *this = *this + d; // Вызов функции this-<operator=(this-<operator+(d));
 return *this;
}
 
Vector Vector::operator - (const Vector& v)
{ // Вычитание двух векторов с помощью 
 // перегруженного оператора бинарный -
 if(size == v.size) // Если размерности векторов совпадают
 {
 Vector temp(size); // Создание временного объекта
 for(int i = 0; i < size; i++)
 temp.vect[i] = vect[i] - v.vect[i];
 return temp; // Возврат временного объекта
 }
 else // Если размерности векторов не совпадают
 {
 cout << "Different arrays sizes !!!\nArray is truncating...\n";
 // Урезаем размерность большего вектора
 int s = (size < v.size) ? size : v.size;
 Vector temp(s); // Создание временного объекта
 for(int i = 0; i < s; i++)
 temp.vect[i] = vect[i] - v.vect[i];
 return temp; // Возврат временного объекта
 }
}
 
Vector Vector::operator - (double d)
{ // Вычитание числа из вектора
 Vector temp(*this); // Создание временного объекта и 
 // инициализация его текущим объектом
 // (объектом, для которого вызвалась функция)
 for(int i = 0; i < size; i++)
 temp.vect[i] -= d;
 return temp; // Возврат временного объекта
}
 
Vector& Vector::operator -= (const Vector& v)
{ // Перегруженный оператор -=
 // для вычитания двух векторов
 *this = *this - v; // Вызов функции this-<operator=(this-<operator-(v));
 return *this;
}
 
Vector& Vector::operator -= (double d)
{ // Перегруженный оператор -=
 // для вычитания числа из вектора
 *this = *this - d; // Вызов функции this-<operator=(this-<operator-(d));
 return *this;
}
 
double Vector::operator * (const Vector& v)
{ // Умножение двух векторов с помощью 
 // перегруженного оператора бинарное *
 double n = 0.0;
 if(size == v.size) // Если размерности векторов совпадают
 {
 for(int i = 0; i < size; i++)
 n += vect[i] * v.vect[i]; // Вычисляем произведение
 return n; // Возвращаем произведение
 }
 else // Если размерности векторов не совпадают
 {
 cout << "Different arrays sizes !!!\nArray is truncating...\n";
 // Урезаем размерность большего вектора 
 int s = (size < v.size) ? size : v.size;
 for(int i = 0; i < s; i++) 
 n += vect[i] * v.vect[i]; // Вычисляем произведение
 return n; // Возвращаем произведение
 }
}
 
Vector Vector::operator * (double d)
{ // Умножение вектора на число
 Vector temp(*this); // Создание временного объекта и 
 // инициализация его текущим объектом
 // (объектом, для которого вызвалась функция)
 for(int i = 0; i < size; i++)
 temp.vect[i] *= d;
 return temp; // Возврат временного объекта
}
 
Vector& Vector::operator *= (double d)
{ // Перегруженный оператор *=
 // для умножения вектора на число
 *this = *this * d; // Вызов функции this-<operator=(this-<operator*(d));
 return *this;
}
 
int Vector::GetSize()
{ // Функция, возвращающая размерность вектора
 return size;
}
 
void selectSort(Vector* arr, int size)
{
    Vector tmp;
    for(int i = 0; i < size; ++i)
    {
        int pos = i;
        tmp = arr[i];
        for(int j = i + 1; j < size; ++j)
        {
            if (arr[j].get_L() < tmp.get_L())
           {
               pos = j;
               tmp = arr[j];
           }
        }
        arr[pos] = arr[i];
        arr[i] = tmp;
    }
}
 
void main()
{
Vector v[5];
for(int i = 0; i < 5; i++) {
cin >> v[i];
}
selectSort(v, 5);
for(int i = 0; i < 5; i++) {
cout << v[i] << endl;
cout << “Dlina vectora “ <<i << “ ravna “ << v[i].get_L << endl;
}
}

Как нужно обрабатывать исключения об ошибке выделения памяти, ошибке освобождения памяти, выходе за границы массива и за пределы диапазона типа данных? Где ещё Вы порекомендуете расставить флаги ошибок? На каких экспериментальных данных моя программа может дать сбой? В конструкторах для выделения памяти я бы хотел прописать исключение вида

C++
1
2
3
4
5
6
7
double* p;
    try {
        p=new double[0x7fffffff];//выделяем память
    }catch(...)
    {
        std::cout<<"Oshibka vydelenija pamyati!\n";
    }

В перегруженных операторах ввода и вывода я бы хотел поместить исключение вида

C++
1
2
3
4
5
6
7
8
9
try
{
cout<<"Vvedite koefficient dlya "<<i<<" chlena: "; cin>>k[i]; cin.fail(); //int [-2 147 483 648 .. 2 147 483 647]
//  if(k[i]>2147483647) throw 550;
}
catch(int i)
{
cout<<"Oshibka vvoda! Vyhod za granizy diapazona!\n"<<endl;
}

Для алгоритма сортировки хотел бы проверить выход за границы массива:

C++
1
2
3
4
5
6
7
try {
    if (index < 0 || index >= currentSize)
        throw out_of_range("Index was out of range");
    }
    catch(const out_of_range& oor) { // что тут писать чтобы поймать из throw
        cout << oor.what();
    }

Две недели пишу курсовую, плохо разбираюсь, преподаватель не из лучших. Это всё, что смог. Сможете хотя бы объяснить, в каком месте надо бросать исключения и флаги ошибок, а также почему результат сортировки не вывелся?

@БузинВладимир · 12.12.2017, 23:28 **[ТС]**

Я код проверил, методы и перегруженные операторы работают, и массив векторов без функции сортировки выводится, но как только я запускаю функцию сортировки, после сортировки переданного массива деструктор "съедает" его. Как вернуть переданный массив из функции сортировки?

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
void selectSort(Vector* arr, int size)
{
Vector tmp;
for(int i = 0; i < size; ++i)
{
int pos = i;
tmp = arr[i];
for(int j = i + 1; j < size; ++j)
{
if (arr[j].get_L() < tmp.get_L())
{
pos = j;
tmp = arr[j];
}
}
arr[pos] = arr[i];
arr[i] = tmp;
}
}

Я пробовал писать

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Vector selectSort(Vector* arr, int size)
{
Vector tmp;
for(int i = 0; i < size; ++i)
{
int pos = i;
tmp = arr[i];
for(int j = i + 1; j < size; ++j)
{
if (arr[j].get_L() < tmp.get_L())
{
pos = j;
tmp = arr[j];
}
}
arr[pos] = arr[i];
arr[i] = tmp;
}
return *arr;
}

но проблема не решилась.

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
void main()
{
Vector v[5];
for(int i = 0; i < 5; i++) {
cin >> v[i];
}
selectSort(v, 5);
for(int i = 0; i < 5; i++) {
cout << v[i] << endl;
cout << "Dlina vectora ravna " << v[i].get_L() << endl;
}
_getch();
}

Исходный код:

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
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
#include <iostream>
#include <math.h>
#include <conio.h>
using namespace std;
 
class Vector
{
double *vect; // Âåêòîð
double L;
int size; // Ðàçìåðíîñòü âåêòîðà
public:
Vector(); // Êîíñòðóêòîð ïî óìîë÷àíèþ
explicit Vector(int); // Êîíñòðóêòîð, ïîçâîëÿþùèé çàäàâàòü
// ðàçìåðíîñòü âåêòîðà, íî íå ÿâëÿþùèéñÿ
// êîíñòðóêòîðîì ïðåîáðàçîâàíèÿ
Vector(const double*, int); // Êîíñòðóêòîð, ïîçâîëÿþùèé
// ïðîèíèöèàëèçèðîâàòü âåêòîð ñ ïîìîùüþ
// ñóùåñòâóþùåãî ìàññèâà
Vector(const Vector&); // Êîíñòðóêòîð êîïèðîâàíèÿ
~Vector(); // Äåñòðóêòîð
double get_L();
Vector& operator ++ (); // Óâåëè÷åíèå âñåõ êîìïîíåíò âåêòîðà
// íà åäèíèöó (ïðåôèêñ)
Vector operator ++ (int); // Óâåëè÷åíèå âñåõ êîìïîíåíò âåêòîðà
// íà åäèíèöó (ïîñòôèêñ)
Vector& operator -- (); // Óìåíüøåíèå âñåõ êîìïîíåíò âåêòîðà
// íà åäèíèöó (ïðåôèêñ)
Vector operator -- (int); // Óìåíüøåíèå âñåõ êîìïîíåíò âåêòîðà
// íà åäèíèöó (ïîñòôèêñ)
Vector& operator = (const Vector&); // Ïåðåãðóæåííûé îïåðàòîð ïðèñâàèâàíèÿ
double& operator [] (int); // Ïåðåãðóæåííûé îïåðàòîð èíäåêñàöèè
Vector& operator + (); // Ïåðåãðóæåííûé îïåðàòîð + (óíàðíûé)
Vector operator - (); // Ïåðåãðóæåííûé îïåðàòîð - (óíàðíûé)
Vector operator + (const Vector&); // Ñëîæåíèå äâóõ âåêòîðîâ
Vector operator + (double); // Ñëîæåíèå âåêòîðà ñ ÷èñëîì
Vector& operator += (const Vector&);// Ïåðåãðóæåííûé îïåðàòîð += äëÿ
// ñëîæåíèÿ äâóõ âåêòîðîâ
Vector& operator += (double); // Ïåðåãðóæåííûé îïåðàòîð += äëÿ
// ñëîæåíèÿ âåêòîðà ñ ÷èñëîì
Vector operator - (const Vector&); // Âû÷èòàíèå äâóõ âåêòîðîâ
Vector operator - (double); // Âû÷èòàíèå ÷èñëà èç âåêòîðà
Vector& operator -= (const Vector&);// Ïåðåãðóæåííûé îïåðàòîð -= äëÿ
// âû÷èòàíèÿ äâóõ âåêòîðîâ
Vector& operator -= (double); // Ïåðåãðóæåííûé îïåðàòîð -= äëÿ
// âû÷èòàíèÿ ÷èñëà èç âåêòîðà
double operator * (const Vector&); // Óìíîæåíèå âåêòîðîâ
Vector operator * (double); // Óìíîæåíèå âåêòîðà íà ÷èñëî
Vector& operator *= (double); // Ïåðåãðóæåííûé îïåðàòîð *= äëÿ
// óìíîæåíèÿ âåêòîðà íà ÷èñëî
// Ââîä âåêòîðà ñ êëàâèàòóðû
friend istream& operator >> (istream&, Vector&);
// Âûâîä âåêòîðà íà ýêðàí
friend ostream& operator << (ostream&, Vector&);
int GetSize(); // Ôóíêöèÿ âîçâðàùàåò ðàçìåðíîñòü âåêòîðà
friend Vector const operator * (double scalar, Vector const& vektor);
};
 
Vector::Vector()
{ // Êîíñòðóêòîð ïî óìîë÷àíèþ
int n;
cout << "Input array size:\t";
cin >> n; // Çàïðîñ ðàçìåðíîñòè âåêòîðà
while(n <= 0) // Ïðîâåðêà êîððåêòíîñòè ââîäà
{
cout << "Input array size:\t";
cin >> n;
}
size = n;
vect = new double[size]; // Ñîçäàíèå âåêòîðà çàäàííîé äëèíû
}
 
Vector::Vector(int n)
{
size = n;
vect = new double[size]; // Ñîçäàíèå âåêòîðà çàäàííîé äëèíû
}
 
Vector::Vector(const double* v, int n)
{
size = n;
vect = new double[size];
for(int i = 0; i < size; i++)// Êîïèðîâàíèå ýëåìåíòîâ ïåðåäàííîãî ìàññèâà
vect[i] = v[i]; // â êîìïîíåíòû âåêòîðà
}
 
Vector::Vector(const Vector& v)
{ // Êîíñòðóêòîð êîïèðîâàíèÿ
size = v.size;
vect = new double[size];
for(int i = 0; i < size; i++)
vect[i] = v.vect[i];
}
 
Vector::~Vector()
{ // Äåñòðóêòîð
delete [] vect;
}
 
Vector& Vector::operator = (const Vector& v)
{ // Ïåðåãðóæåííûé îïåðàòîð ïðèñâàèâàíèÿ
if(&v == this) // Ïðîâåðêà íà ïðèñâàèâàíèå îáúåêòà
return *this; // ñàìîìó ñåáå
 
// Åñëè ïåðåäàí äðóãîé îáúåêò, òî êîïèðóåì åãî
delete [] vect;
size = v.size;
vect = new double[size];
for(int i = 0; i < size; i++)
vect[i] = v.vect[i];
return *this;
}
 
istream& operator >> (istream& is, Vector& v)
{ // Ââîä êîìïîíåíò âåêòîðà ñ êëàâèàòóðû
for(int i = 0; i < v.size; i++)
{
cout << "Input vect[" << i << "]:\t";
is >> v.vect[i];
}
return is;
}
 
ostream& operator << (ostream& os, Vector& v)
{ // Âûâîä âåêòîðà íà ýêðàí
os << "Vector: (";
for(int i = 0; i < v.size; i++)
{
os << v.vect[i];
if(i == v.size - 1)
os << ")\n";
else
os << ", ";
}
return os;
}
 
double Vector:: get_L ()
{
L = 0;
for(int i = 0; i < size; i++) {
L = L + pow(vect[i], 2);
}
return sqrt(L);
}
 
Vector& Vector::operator ++ ()
{ // Óâåëè÷åíèå âñåõ êîìïîíåíò âåêòîðà
// íà åäèíèöó (ïðåôèêñ)
for(int i = 0; i < size; i++)
vect[i]++;
return *this;
}
 
Vector& Vector::operator -- ()
{ // Óìåíüøåíèå âñåõ êîìïîíåíò âåêòîðà
// íà åäèíèöó (ïðåôèêñ)
for(int i = 0; i < size; i++)
vect[i]--;
return *this;
}
 
Vector Vector::operator ++ (int n) // n - ôèêòèâíûé ïàðàìåòð
{ // Óâåëè÷åíèå âñåõ êîìïîíåíò âåêòîðà
// íà åäèíèöó (ïîñòôèêñ)
Vector temp(*this); // Ñîçäàíèå âðåìåííîãî îáúåêòà è
// èíèöèàëèçàöèÿ åãî òåêóùèì îáúåêòîì
// (îáúåêòîì, äëÿ êîòîðîãî âûçâàëàñü ôóíêöèÿ)
for(int i = 0; i < size; i++)// Óâåëè÷åíèå êîìïîíåíò âåêòîðà íà åäèíèöó
vect[i]++; // (äëÿ òåêóùåãî îáúåêòà)
return temp; // Âîçâðàò âðåìåííîãî îáúåêòà
}
 
Vector Vector::operator -- (int n) // n - ôèêòèâíûé ïàðàìåòð
{ // Óìåíüøåíèå âñåõ êîìïîíåíò âåêòîðà
// íà åäèíèöó (ïîñòôèêñ)
Vector temp(*this); // Ñîçäàíèå âðåìåííîãî îáúåêòà è
// èíèöèàëèçàöèÿ åãî òåêóùèì îáúåêòîì
// (îáúåêòîì, äëÿ êîòîðîãî âûçâàëàñü ôóíêöèÿ)
for(int i = 0; i < size; i++)// Óìåíüøåíèå êîìïîíåíò âåêòîðà íà åäèíèöó
vect[i]--; // (äëÿ òåêóùåãî îáúåêòà)
return temp; // Âîçâðàò âðåìåííîãî îáúåêòà
}
 
double& Vector::operator [] (int n)
{ // Ïåðåãðóæåííûé îïåðàòîð èíäåêñàöèè
// äëÿ ïðîâåðêè âûõîäà çà ãðàíèöû ìàññèâà
if(n < 0) // Â ñëó÷àå åñëè èíäåêñ ìåíüøå íóëÿ,
// òî âîçâðàùàåì íóëåâîé ýëåìåíò ìàññèâà
{
cout << "Index of array too small:\tuse zeroth element\n";
return vect[0];
}
else if(n > size - 1) // Â ñëó÷àå åñëè èíäåêñ áîëüøå èíäåêñà
// ïîñëåäíåãî ýëåìåíòà ìàññèâà,
// òî âîçâðàùàåì ïîñëåäíèé ýëåìåíò ìàññèâà
{
cout << "Index of array too big:\tuse last element\n";
return vect[size - 1];
}
else
return vect[n]; // Âîçâðàò çàäàííîãî ýëåìåíòà ìàññèâà
}
 
Vector& Vector::operator + ()
{ // Ïåðåãðóæåííûé óíàðíûé +
return *this;
}
 
Vector Vector::operator - ()
{ // Ïåðåãðóæåííûé óíàðíûé -
Vector temp(*this); // Ñîçäàíèå âðåìåííîãî îáúåêòà è
// èíèöèàëèçàöèÿ åãî òåêóùèì îáúåêòîì
// (îáúåêòîì, äëÿ êîòîðîãî âûçâàëàñü ôóíêöèÿ)
for(int i = 0; i < size; i++)
temp.vect[i] = -vect[i];
return temp; // Âîçâðàò âðåìåííîãî îáúåêòà
}
 
Vector Vector::operator + (const Vector& v)
{ // Ñëîæåíèå äâóõ âåêòîðîâ ñ ïîìîùüþ
// ïåðåãðóæåííîãî îïåðàòîðà áèíàðíûé +
if(size == v.size) // Åñëè ðàçìåðíîñòè âåêòîðîâ ñîâïàäàþò
{
Vector temp(size); // Ñîçäàíèå âðåìåííîãî îáúåêòà
for(int i = 0; i < size; i++)
temp.vect[i] = vect[i] + v.vect[i];
return temp; // Âîçâðàò âðåìåííîãî îáúåêòà
}
else // Åñëè ðàçìåðíîñòè âåêòîðîâ íå ñîâïàäàþò
{
cout << "Different arrays sizes !!!\nArray is truncating...\n";
// Óðåçàåì ðàçìåðíîñòü áîëüøåãî âåêòîðà
int s = (size < v.size) ? size : v.size;
Vector temp(s); // Ñîçäàíèå âðåìåííîãî îáúåêòà
for(int i = 0; i < s; i++)
temp.vect[i] = vect[i] + v.vect[i];
return temp; // Âîçâðàò âðåìåííîãî îáúåêòà
}
}
 
Vector Vector::operator + (double d)
{ // Ñëîæåíèå âåêòîðà ñ ÷èñëîì
Vector temp(*this); // Ñîçäàíèå âðåìåííîãî îáúåêòà è
// èíèöèàëèçàöèÿ åãî òåêóùèì îáúåêòîì
// (îáúåêòîì, äëÿ êîòîðîãî âûçâàëàñü ôóíêöèÿ)
for(int i = 0; i < size; i++)
temp.vect[i] += d;
return temp; // Âîçâðàò âðåìåííîãî îáúåêòà
}
 
Vector& Vector::operator += (const Vector& v)
{ // Ïåðåãðóæåííûé îïåðàòîð +=
// äëÿ ñëîæåíèÿ äâóõ âåêòîðîâ
*this = *this + v; // Âûçîâ ôóíêöèè this-<operator=(this-<operator+(v));
return *this;
}
 
Vector& Vector::operator += (double d)
{ // Ïåðåãðóæåííûé îïåðàòîð +=
// äëÿ ñëîæåíèÿ âåêòîðà ñ ÷èñëîì
*this = *this + d; // Âûçîâ ôóíêöèè this-<operator=(this-<operator+(d));
return *this;
}
 
Vector Vector::operator - (const Vector& v)
{ // Âû÷èòàíèå äâóõ âåêòîðîâ ñ ïîìîùüþ
// ïåðåãðóæåííîãî îïåðàòîðà áèíàðíûé -
if(size == v.size) // Åñëè ðàçìåðíîñòè âåêòîðîâ ñîâïàäàþò
{
Vector temp(size); // Ñîçäàíèå âðåìåííîãî îáúåêòà
for(int i = 0; i < size; i++)
temp.vect[i] = vect[i] - v.vect[i];
return temp; // Âîçâðàò âðåìåííîãî îáúåêòà
}
else // Åñëè ðàçìåðíîñòè âåêòîðîâ íå ñîâïàäàþò
{
cout << "Different arrays sizes !!!\nArray is truncating...\n";
// Óðåçàåì ðàçìåðíîñòü áîëüøåãî âåêòîðà
int s = (size < v.size) ? size : v.size;
Vector temp(s); // Ñîçäàíèå âðåìåííîãî îáúåêòà
for(int i = 0; i < s; i++)
temp.vect[i] = vect[i] - v.vect[i];
return temp; // Âîçâðàò âðåìåííîãî îáúåêòà
}
}
 
Vector Vector::operator - (double d)
{ // Âû÷èòàíèå ÷èñëà èç âåêòîðà
Vector temp(*this); // Ñîçäàíèå âðåìåííîãî îáúåêòà è
// èíèöèàëèçàöèÿ åãî òåêóùèì îáúåêòîì
// (îáúåêòîì, äëÿ êîòîðîãî âûçâàëàñü ôóíêöèÿ)
for(int i = 0; i < size; i++)
temp.vect[i] -= d;
return temp; // Âîçâðàò âðåìåííîãî îáúåêòà
}
 
Vector& Vector::operator -= (const Vector& v)
{ // Ïåðåãðóæåííûé îïåðàòîð -=
// äëÿ âû÷èòàíèÿ äâóõ âåêòîðîâ
*this = *this - v; // Âûçîâ ôóíêöèè this-<operator=(this-<operator-(v));
return *this;
}
 
Vector& Vector::operator -= (double d)
{ // Ïåðåãðóæåííûé îïåðàòîð -=
// äëÿ âû÷èòàíèÿ ÷èñëà èç âåêòîðà
*this = *this - d; // Âûçîâ ôóíêöèè this-<operator=(this-<operator-(d));
return *this;
}
 
double Vector::operator * (const Vector& v)
{ // Óìíîæåíèå äâóõ âåêòîðîâ ñ ïîìîùüþ
// ïåðåãðóæåííîãî îïåðàòîðà áèíàðíîå *
double n = 0.0;
if(size == v.size) // Åñëè ðàçìåðíîñòè âåêòîðîâ ñîâïàäàþò
{
for(int i = 0; i < size; i++)
n += vect[i] * v.vect[i]; // Âû÷èñëÿåì ïðîèçâåäåíèå
return n; // Âîçâðàùàåì ïðîèçâåäåíèå
}
else // Åñëè ðàçìåðíîñòè âåêòîðîâ íå ñîâïàäàþò
{
cout << "Different arrays sizes !!!\nArray is truncating...\n";
// Óðåçàåì ðàçìåðíîñòü áîëüøåãî âåêòîðà
int s = (size < v.size) ? size : v.size;
for(int i = 0; i < s; i++)
n += vect[i] * v.vect[i]; // Âû÷èñëÿåì ïðîèçâåäåíèå
return n; // Âîçâðàùàåì ïðîèçâåäåíèå
}
}
 
Vector Vector::operator * (double d)
{ // Óìíîæåíèå âåêòîðà íà ÷èñëî
Vector temp(*this); // Ñîçäàíèå âðåìåííîãî îáúåêòà è
// èíèöèàëèçàöèÿ åãî òåêóùèì îáúåêòîì
// (îáúåêòîì, äëÿ êîòîðîãî âûçâàëàñü ôóíêöèÿ)
for(int i = 0; i < size; i++)
temp.vect[i] *= d;
return temp; // Âîçâðàò âðåìåííîãî îáúåêòà
}
 
Vector& Vector::operator *= (double d)
{ // Ïåðåãðóæåííûé îïåðàòîð *=
// äëÿ óìíîæåíèÿ âåêòîðà íà ÷èñëî
*this = *this * d; // Âûçîâ ôóíêöèè this-<operator=(this-<operator*(d));
return *this;
}
 
int Vector::GetSize()
{ // Ôóíêöèÿ, âîçâðàùàþùàÿ ðàçìåðíîñòü âåêòîðà
return size;
}
 
Vector const operator * (double scalar, Vector const& vektor) {
Vector temp(vektor.size);
for(int i = 0; i < vektor.size; i++)
temp.vect[i] = scalar * vektor.vect[i];
return temp;
}
 
void selectSort(Vector* arr, int size)
{
Vector tmp;
for(int i = 0; i < size; ++i)
{
int pos = i;
tmp = arr[i];
for(int j = i + 1; j < size; ++j)
{
if (arr[j].get_L() < tmp.get_L())
{
pos = j;
tmp = arr[j];
}
}
arr[pos] = arr[i];
arr[i] = tmp;
}
}
 
void main()
{
Vector v(3), v2(3);
cin >> v;
v2 = 5 * v;
cout << v2 << endl;
cout << "Dlina V2 ravna " << v2.get_L() << endl;
_getch();
}

Добавлено через 1 час 11 минут
1) Vector();
Конструктор по умолчанию, в нём пользователь вводит размерность вектора, после чего она проверяется на принадлежность к натуральным числам. При благоприятном исходе создаётся вектор (массив) заданной размерности.
2) explicit Vector(int n);
Конструктор с параметром n, где n – размерность вектора. При работе конструктора создаётся вектор заданной размерности.
3) Vector(const double* v, int n);
Конструктор, позволяющий проинициализировать вектор с помощью существующего массива.
4) Vector(const Vector& v);
Конструктор копирования.
5) ~Vector();
Деструктор, удаляет память, отведённую под вектор.
6) double get_L();
Функция get_L возвращает длину вектора.
7) int GetSize();
Функция GetSize возвращает размерность вектора.

Перегруженные операторы:
1) friend istream& operator >> (istream&, Vector&);
Ввод вектора с клавиатуры.
2) friend ostream& operator << (ostream&, Vector&);
Вывод вектора на экран.
3) double& operator [] (int n);
Перегруженный оператор индексации для проверки выхода за границы массива. Если индекс меньше нуля, возвращается нулевой элемент массива. Если индекс больше индекса последнего элемента массива, возвращается последний элемент массива.
4) double operator * (const Vector& v);
Нахождение скалярного произведения векторов.
5) Vector operator * (double d);
Умножение вектора на вещественное число d.
6) friend Vector const operator * (double scalar, Vector const& vektor);
Умножение вещественного числа scalar на вектор vektor.
7) Vector& operator *= (double d);
Умножение вектора на вещественное число d с помощью оператора «умножение с присваиванием».
8) Vector& operator + ();
Перегруженный оператор «унарный плюс». Возвращает вектор, равный исходному.
9) Vector operator + (const Vector& v);
Перегруженный оператор «бинарный плюс» для вычисления суммы двух векторов.
10) Vector& operator += (const Vector& v);
Вычисление суммы двух векторов с использованием оператора «сложение с присваиванием».
11) Vector operator - ();
Перегруженный оператор «унарный минус». Возвращает вектор, противоположный исходному.
12) Vector operator - (const Vector& v);
Перегруженный оператор «бинарный минус» для вычисления разности двух векторов.
13) Vector& operator -= (const Vector& v);
Вычисление разности двух векторов с использованием оператора «вычитание с присваиванием».
14) Vector& operator = (const Vector& v);
Перегруженный оператор присваивания. Копирует переданный объект.
15) Vector& operator ++ ();
Увеличение всех компонент вектора на единицу (префикс).
16) Vector operator ++ (int n);
Увеличение всех компонент вектора на единицу (постфикс).
17) Vector& operator -- ();
Уменьшение всех компонент вектора на единицу (префикс).
18) Vector operator -- (int n);
Уменьшение всех компонент вектора на единицу (постфикс).

Это пояснения к коду выше. Сортировать нужно не координаты внутри вектора, а массив векторов, созданный в конструкторе по свойству get_L().

Новые блоги и статьи Все статьи Все блоги /
SDL3 для Web (WebAssembly): Обработчик клика мыши в браузере ПК и касания экрана в браузере на мобильном устройстве 8Observer8 02.02.2026 Содержание блога Для начала пошагово создадим рабочий пример для подготовки к экспериментам в браузере ПК и в браузере мобильного устройства. Потом напишем обработчик клика мыши и обработчик. . .	Философия технологии iceja 01.02.2026 На мой взгляд у человека в технических проектах остается роль генерального директора. Все остальное нейронки делают уже лучше человека. Они не могут нести предпринимательские риски, не могут. . .	SDL3 для Web (WebAssembly): Вывод текста со шрифтом TTF с помощью SDL3_ttf 8Observer8 01.02.2026 Содержание блога В этой пошаговой инструкции создадим с нуля веб-приложение, которое выводит текст в окне браузера. Запустим на Android на локальном сервере. Загрузим Release на бесплатный. . .	SDL3 для Web (WebAssembly): Сборка C/C++ проекта из консоли 8Observer8 30.01.2026 Содержание блога Если вы откроете примеры для начинающих на официальном репозитории SDL3 в папке: examples, то вы увидите, что все примеры используют следующие четыре обязательные функции, а. . .
SDL3 для Web (WebAssembly): Установка Emscripten SDK (emsdk) и CMake для сборки C и C++ приложений в Wasm 8Observer8 30.01.2026 Содержание блога Для того чтобы скачать Emscripten SDK (emsdk) необходимо сначало скачать и уставить Git: Install for Windows. Следуйте стандартной процедуре установки Git через установщик. . . .	SDL3 для Android: Подключение Box2D v3, физика и отрисовка коллайдеров 8Observer8 29.01.2026 Содержание блога Box2D - это библиотека для 2D физики для анимаций и игр. С её помощью можно определять были ли коллизии между конкретными объектами. Версия v3 была полностью переписана на Си, в. . .	Инструменты COM: Сохранение данный из VARIANT в файл и загрузка из файла в VARIANT bedvit 28.01.2026 Сохранение базовых типов COM и массивов (одномерных или двухмерных) любой вложенности (деревья) в файл, с возможностью выбора алгоритмов сжатия и шифрования. Часть библиотеки BedvitCOM Использованы. . .	SDL3 для Android: Загрузка PNG с альфа-каналом с помощью SDL_LoadPNG (без SDL3_image) 8Observer8 28.01.2026 Содержание блога SDL3 имеет собственные средства для загрузки и отображения PNG-файлов с альфа-каналом и базовой работы с ними. В этой инструкции используется функция SDL_LoadPNG(), которая. . .