Первый class Array. Проверить и указать на ошибки, если таковые имеются

@Genn55 · Регистрация: 26.12.2012

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

Доброго всем времени суток!Осмелюсь показать свой первый class Array.Код работает."заточен" он на программу.Большая просьба кому не трудно покритиковать и указать на мои косяки желательно с разъяснениями.Изучаю я с++ самостоятельно и показать код просто больше не кому.За ранее всем спасибо.
Вот мой,наверное далеко не лучший код.

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
#include <ctime>
#include <cstdlib>
#include <algorithm>
#include <iostream>
#include <fstream>
#include <cmath>
#include <iomanip>
#include <cstring>
 
using namespace std;
 
class Array
{
    friend istream &operator>> (istream &, Array &); // перегруженный оператор ввода
    friend ostream &operator<< (ostream &, const Array &); // перегруженный оператор вывода
private:
    double *ptr; // указатель на массив
    size_t size; // размер массива
public:
    Array(); // конструктор по умолчанию
    Array(size_t ); // конструктор с параметрами
    Array( const Array & ); // конструктор копии
    ~Array(); // деструктор
     //set методы
    void setArray(); // заполнение массива с клавиатуры
    bool ReadFile(const char *);//заполняем из файла
     //get методы
    size_t PrintSize() const; // возвратить количество элементов массива
    void PrintMass(); // вывод массива
    //перегруженные операторы
    bool operator== (const Array &) const; // оператор сравнения
    const Array &operator= (const Array &); // оператор присваивания
    double &operator[] (size_t );//взятие индекса
    Array &operator+= (const double &); // оператор добавления элемента в конец массива
    Array &CopiMas (const size_t &,const size_t &);//копируем и определяем размер нового массива
    //поиск
    size_t Search(const double &) const;// поиск по ключу
    size_t IndMin (const double &)const;//минимальный индекс
    size_t IndMax (const double &)const;//максимальный индекс
    void SortMass ();// сортировка
    void InvertMass();
    //вспомогательные ф-ции
    double MaxElement ();//макс элемент
    double MinElement ();//мин элемент
 
};
 
Array::Array() // конструктор по умолчанию, без параметров
{
    size = 28; // по умолчанию размер массива = 10 элементов
    ptr = new double [size]; // выделить место в памяти для массива
   for (size_t i = 0; i < size; i++) // обнуляем массив
        ptr[i] = 0;
}
Array::Array(size_t arraySize) // конструктор с параметрами
{
    // если значение параметра больше 0, присвоить size значение arraySize, иначе - 28
    size = (arraySize > 0 ? arraySize : 0);
    ptr = new double [size]; // выделить место в памяти для массива
 
    for (size_t i = 0; i < size; i++) // обнуляем массив
        ptr[i] = 0;
}
Array::Array( const Array &arrayToCopy ) // конструктор копии
    :size(arrayToCopy.size)              // инициализатор размера массива
{
    ptr = new double [size]; // выделить место в памяти для массива
 
    for (size_t i = 0; i < size; i++)
        ptr[i] = arrayToCopy.ptr[i]; // заполняем массив значениями массива arrayToCopy
}
Array::~Array() // деструктор класса Array
{
    delete  [] ptr; // освободить память, удалив массив
}
istream &operator>> (istream & input, Array &obj)// перегруженный оператор ввода с клавиатуры
{
    for (size_t i = 0; i < obj.size; i++)
        input >> obj.ptr[i]; // заполняем массив объекта obj
    return input; // позволяет множественный ввод
}
ostream &operator<< (ostream &output, const Array &obj)// перегруженный оператор вывода
{
    for (size_t i = 0; i < obj.size; i++)
    {
        output << setw(10)<< setiosflags(ios::left) // под каждое число выделяется 5 позиций
               << obj.ptr[i];
    }
 
    output << endl;
 
    return output; // позволяет множественный вывод
}
void Array::setArray() // заполнение массива
{
    for (size_t i = 0; i < size; i++)
        cin >> ptr[i]; // ввод элемента массива с клавиатуры
}
bool Array::ReadFile(const char *filename)//заполняем из файла
{
    ifstream in(filename);
    if (!in) return false;
        for (size_t i = 0;i< size; i++)  //чтение чисел
    {
    in >> ptr[i];
    //arr[i] = ((arr[i]/2)*(arr[i]/2))*3.14;             //     из файла
    }
    in.close(); //Закрываем файл
  return true;
}
size_t Array::IndMin(const double &key)const//ищем минимальный индекс
{
 size_t min = 0;
    for (size_t i = 0; i < size+1; i++)
        if (fabs(ptr[i]-key)<= fabs(ptr[i+1]-key))//поиск по условию
        return (i >= 2)?min = i - 2: min = 0;//нижняя граница
 
 return -1;
}
 size_t Array::Search(const double &key) const // поиск по ключу
 {
     for (size_t i = 0; i < size; i++)
         if ( key == ptr[i] ) // поиск по ключу
             return (i + 1);             // позиция искомого элемента
     return -1;
 }
double Array::MaxElement ()//вспомогательная ф-ция макс элемент
{
 
double max_el = ptr[0];
for (size_t i =0 ;i< size; i++)
{
    if (max_el < ptr[i])
    max_el= ptr[i];
    }
    return max_el;
}
double Array::MinElement ()//вспомогательная ф-ция min элемент
{
double min_el = ptr[0];
for (size_t i =0 ;i< size; i++)
{
    if (min_el > ptr[i])
    min_el= ptr[i];
    }
    return min_el;
}
size_t Array::IndMax (const double  &key)const//максимальный индекс
{
 int max = 0;
    for (size_t i = 0; i < size+1; i++)
      if (fabs(ptr[i]-key)<= fabs(ptr[i+1]-key))//поиск по условию
      return (i <= size-3)? max=i +3 : max = size;//верхняя граница
 
 return -1;
}
void Array::PrintMass() // вывод массива
{
    for (size_t i = 0; i < size; i++)
        cout << setw(10)<< setiosflags(ios::left)<< ptr[i]; // вывод элементов массива на экран
 
    cout << endl; // новая строка
}
size_t Array::PrintSize() const // возвратить количество элементов массива
{
    return size;
}
const Array &Array::operator= (const Array &mass) // оператор присваивания
{
    if (&mass != this) // чтобы не выполнялось самоприсваивание
    {
        if (size != mass.size)
        {
            delete [] ptr; // освободить пространство
            size = mass.size; // установить нужный размер массива
            ptr = new double [size]; // выделить память под копируемый массив
        }
        for (size_t i = 0; i < size; i++)
            ptr[i] = mass.ptr[i]; // скопировать массив
    }
 
    return *this; // множественное присваивание
}
double &Array::operator[] (size_t index)
{
    if(index < 0 || index >= size)
    {
        std::cerr << "\n Ошибка индекса: " << index << std::endl;
        exit(1); // завершить работу программы, неправильный индекс
    }
    return ptr[index]; // возврат ссылки на элемент массива
}
bool Array::operator== (const Array &mass) const// оператор сравнения
{
    if (size != mass.size)
        return false; // массивы с разным количеством элементов
    for (size_t i = 0; i < size; i++)
        if (ptr[i] != mass.ptr[i])
            return false; // массивы не равны
 
    return true; // массивы равны
}
 Array &Array::CopiMas (const size_t &max,const size_t &min)//копируем и определяем размер нового массива
{
 Array temp(size);
     temp = *this; // сохраняем текущий массив во временный объект
     delete [] ptr; // освобождае память
     size = max-min; // переопределяем размер
     ptr = new double [size];
 size_t i,len = 0;
    for ( i = min; i < max; i++ )//читаем в ptr
    for ( i = min; i < max; i++ )//переносим в temp
     {if (temp[i]!=0) ptr[len++]= temp[i];}//переприсваиваем из temp в ptr
     return *this;
   }
 Array &Array::operator+= (const double &num) // оператор добавления элемента в конец массива
{
    Array result(size);
    result = *this; // временно сохраним текущий массив
    delete [] ptr; // освобождаем память
    size = size + 1; // увеличиваем размер массива на 1
    ptr = new double [size]; // выделяем память
    for (size_t i = 0; i < (size - 1); i++)
        ptr[i] = result.ptr[i]; // скопировать массив
        ptr[size - 1] = num; // добавляем число в конец массива
 
    return *this; // вызов перегруженного оператора
}
void Array::SortMass ()
{
 for (size_t i = 0; i < size; i++)
    {
        for (size_t j= i+ 1; j< size; j++)
           {
             if (ptr[j] < ptr[i]) swap (ptr[i], ptr[j]);
           }
    }
}
void Array::InvertMass()
{
 double temp;
   for(size_t i = 0; i < size / 2; i++)//делим пополам
     {
       temp = ptr[i];
       ptr[i] = ptr[size - i - 1];
       ptr[size - i - 1] = temp;//меняем половины местами
     }
}
 
int main()
{
system("chcp 1251 > nul");
 
 double d;
 int N =0,i = 0;
 
 Array Ar1(i); // создаем объект класса Ar1, используя конструктор аргументированный
 Array Ar(Ar1);  // создаем объект класса Ar, используя конструктор копирования
 Array Ar2;    // создаем объект класса Ar2, используя конструктор по умолчанию
 //выбираем как заполнять массив
  cout << "Как заполнить массив массив?  \n";
  cout << "Из файла-введите 0, с клавиатуры-введите 1.  \n";
  cin>>N;
 
 if (N == 1)
  {
    while (d!= 0)//заполняем перегруженным оператором += пока не введен 0
    {  cin>>d; if (d !=0) { Ar1 += d; i++; }}
       cout << "Начальный массив: \n";
       cout << Ar1; //вывод массива с помощью перегруженного оператора вывода <<
       Ar = Ar1; // присваиваем массиву Ar массив Ar1
       Ar.CopiMas(i,0);
       cout<< "Размер массива: " << Ar.PrintSize() << "\n";
       Ar.SortMass ();
       cout << "Сортированный массив: \n";
       cout << Ar; //вывод
  }
 if (N == 0)
  {
    cout << "Начальный массив: \n";
    Ar2.ReadFile("D:\\моя колликция\\символьная переменная\\мой файл.txt");
    Ar = Ar2; // присваиваем массиву Ar массив Ar2
    cout << Ar.CopiMas(Ar.PrintSize(),0)<< "Размер массива: " << Ar.PrintSize() << "\n";
  }
  cout <<"Макс элемент=  "<<Ar.MaxElement ()<<"    Мин элемент=   "<<Ar.MinElement ()<<"\n";
 
 int pos = 0;
    cout << " Введите число \n";
    cin >>d;
    if ((pos = Ar.Search(d)) != -1)//поиск элемента по значению
        cout << "Позиция искомого элемента: " << pos << "\n";
    else
        cout << "Искомый элемент не найден!\n";
 
    cout << "Инвертированный массив: \n";
    Ar.InvertMass ();//инверсия массива
    cout << Ar; //вывод
    cout << "Элемент массива = " << Ar[Ar.PrintSize() -2] << "\n";//поиск элемента по индексу
 
    cout << "Инвертированный массив: \n";
    Ar.InvertMass ();//инверсия массива
    cout << Ar; //вывод
 
 int min = Ar.IndMin (d);
 int max = Ar.IndMax (d);
 
    cout << "Минимальный индекс=   "<<min<<" Максимальный индекс=    "<<max<<"\n";
    Array Ar3(Ar); // 5-ти элементный объект класса Array
    cout << "Полученный массив: \n";
    Ar3.CopiMas(max,min);
    cout << "Размер массива: " << Ar3.PrintSize() << "\n";
    cout << Ar3; //вывод
    return 0;
}

Tulosba · 19.01.2014, 22:05

Из того, что бросилось в глаза:
1. using namespace std;
2. отсутствие в объявлении класса имен аргументов (только типы)
3. магические константы (size = 28)
4. странная проверка в 58 строке, учитывая, что тип беззнаковый
5. setArray можно реализовать через operator>>
6. строка 108. закрывать вручную не обязательно
7. в IndMin/IndMax выход за границы массива и снова магические константы
8. почему оператор= возвращает const ref&?
9. почему в Sort - swap, а в InvertMass нет?

Croessmah · 19.01.2014, 22:23

C++
1
2
Array temp(size);
temp = *this; // сохраняем текущий массив во временный объект

Зачем тут лишнее копирование? Не лучше ли просто сохранить указатель пока он нужен?

MrGluck · 19.01.2014, 22:43

Сообщение от Tulosba

6. строка 108. закрывать вручную не обязательно

а если захотим записать в тот же файл и еще раз считать? RAII разве не в конце работы программы файл закроет?

Советую использовать список инициализации в конструкторе.
Советовал бы также посмотреть в сторону идиомы copy-and-swap
В 189 строке неверно было бы завершить работу программы, уж лучше кинуть исключение std::out_of_range.

PrintSize я бы назвал getSize(). Потому как get - это не всегда print.

size_t определен в <cstddef>
А вообще, много букаф, нету разделения на определение и реализацию и форматирование не самое лучшее. (Критиковать так критиковать

)

Добавлено через 1 минуту
перегрузку операторов для работы с потоками можно и не делать friend-функциями, достаточно апперировать get-set методами.

Добавлено через 28 секунд
Конечно после вылизывания всего и вся, необходимо класс сделать шаблонным.

Croessmah · 19.01.2014, 22:45

Сообщение от MrGluck

RAII разве не в конце работы программы файл закроет?

в деструкторе объекта in, то бишь при выходе из функции

MrGluck · 19.01.2014, 22:55

Не по теме:

Croessmah, привык передавать ссылку на fstream в функцию

В 203 строке CopiMas. Думаю, сами поймете, что это неверно

@Genn55 · 19.01.2014, 23:11 **[ТС]**

Сообщение от Tulosba

Из того, что бросилось в глаза:
1. using namespace std;
2. отсутствие в объявлении класса имен аргументов (только типы)
3. магические константы (size = 28)
4. странная проверка в 58 строке, учитывая, что тип беззнаковый
5. setArray можно реализовать через operator>>
6. строка 108. закрывать вручную не обязательно
7. в IndMin/IndMax выход за границы массива и снова магические константы
8. почему оператор= возвращает const ref&?
9. почему в Sort - swap, а в InvertMass нет?

3. магические константы (size = 28) это размер по умолчанию в программе планируется его менять в настройках с сохранением в отдельном файле то же самое и с другими чисто упрощения.
4. странная проверка в 58 строке, учитывая, что тип беззнаковый.
это не проверка ,а переприсвоение для ввода вручную без определения начального размера.
5. setArray можно реализовать через operator>> . Попробую
1. using namespace std;
2. отсутствие в объявлении класса имен аргументов (только типы)
7. в IndMin/IndMax выход за границы массива и снова магические константы.Сейчас буду проверять.
6. строка 108. закрывать вручную не обязательно.
В нем могут быть пользовательские изменения которые нужно сохранить
9. почему в Sort - swap, а в InvertMass нет? Исправил.
8. почему оператор= возвращает const ref&? и
1. using namespace std;
2. отсутствие в объявлении класса имен аргументов (только типы).Если можно по подробнее.Пишут везде по разному.

Добавлено через 4 минуты

Сообщение от Croessmah

C++
1
2
Array temp(size);
temp = *this; // сохраняем текущий массив во временный объект

Зачем тут лишнее копирование? Не лучше ли просто сохранить указатель пока он нужен?

Извините с ходу не понял. Если можно подробнее

Croessmah · 19.01.2014, 23:19

Сообщение от Genn55

это размер по умолчанию

ну так и надо было сделать что-то вроде defaultSize, а не просто 28 писать

Сообщение от Genn55

это не проверка ,а переприсвоение для ввода вручную без определения начального размера.

size = (arraySize > 0 ? arraySize : 0);
false может тут быть только если arraySize == 0, и тогда получится size = 0
так зачем еще условие, если можно просто
size=arraySize?
ибо условие смысла не имеет.

Сообщение от Genn55

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

файл закроется при вызове деструктора, а он будет вызван при выходе из функции, то есть почти сразу после Вашего закрытия, поэтому эту строчку можно убрать.

Добавлено через 4 минуты

Сообщение от Genn55

Извините с ходу не понял. Если можно подробнее

что-то вроде этого:

C++
1
2
3
4
5
6
7
8
9
10
11
12
 Array &Array::CopiMas (const size_t &max,const size_t &min)//копируем и определяем размер нового массива
{
     double * temp_ptr = ptr;//Храним указатель на старую память (не создавая нового объекта и не копируя в него всё старое содержимое)
     size = max-min; // переопределяем размер
     ptr = new double [size];
 size_t i,len = 0;
    for ( i = min; i < max; i++ )//читаем в ptr
    for ( i = min; i < max; i++ )//переносим в temp
     {if (temp_ptr[i]!=0) ptr[len++]= temp_ptr[i];}//переприсваиваем из temp в ptr
     delete [] temp_ptr ;//Старая память более не нужна
     return *this;
   }

@Genn55 · 19.01.2014, 23:21 **[ТС]**

Сообщение от MrGluck

Советую использовать список инициализации в конструкторе.

Постарался,но наверное плохо.Если можно подскажите.

Сообщение от MrGluck

size_t определен в <cstddef> .

Но у меня работает в Code::Block

Сообщение от MrGluck

Конечно после вылизывания всего и вся, необходимо класс сделать шаблонным.

Это как.В Code::Block попытался создать файл h потерпел не удачу.Не знаю как делать и не нахожу инструкций на русском,а с английским туго.

Croessmah · 19.01.2014, 23:23

Сообщение от Genn55

Но у меня работает в Code::Block

ну попробуйте создать новый проект и вписать только этот код:

C++
1
2
3
int main () {
    size_t i ;
}

MrGluck · 19.01.2014, 23:32

Сообщение от Genn55

Но у меня работает в Code::Block

Писать надо не под компилятор (кстати IDE - среда разработки, часто поставляется с компилятором mingw) а под стандарт. А стандарт не гарантирует, что без использования cstddef(stddef.h) вы сможете получить объявление данного типа.

Сообщение от Genn55

Это как.В Code::Block попытался создать файл h потерпел не удачу.

шаблонный класс != разделение объявления и реализации.
Прочитайте и про то и про другое у Дейтелов, "как программировать на C++", там весьма подробно данный момент расписан.

@Genn55 · 19.01.2014, 23:53 **[ТС]**

Сообщение от Croessmah

ну попробуйте создать новый проект и вписать только этот код:

C++
1
2
3
int main () {
    size_t i ;
}

Попробовал.Выдает одинаковый варнинг i не является функцией.

Добавлено через 6 минут

Сообщение от MrGluck

шаблонный класс != разделение объявления и реализации.
Прочитайте и про то и про другое у Дейтелов, "как программировать на C++", там весьма подробно данный момент расписан.

Да спасибо конечно я с благодарностью пользуюсь вашими советами.Действительно,что работает у меня может не работать у других.
шаблонный класс != разделение объявления и реализации.С этим еще предстоит разбираться.Более простое получается с трудом!

Добавлено через 9 минут
Всем огромное спасибо.Размышлять есть над чем.Пока постараюсь все переварить.Еще раз огромное спасибо и надеюсь на вашу помощь.

MrGluck · 19.01.2014, 23:59

мануальчик по созданию проекта в CodeBlocks с картинками

@Genn55 · 22.01.2014, 01:38 **[ТС]**

Вот что у меня получилось

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
#include <ctime>
#include <cstdlib>
#include <algorithm>
#include <iostream>
#include <fstream>
#include <cmath>
#include <iomanip>
#include <cstring>
#include<cstddef>
using namespace std;
 
class Array
{
    friend istream &operator>> (istream &, Array &); // перегруженный оператор ввода
    friend ostream &operator<< (ostream &, const Array &); // перегруженный оператор вывода
private:
    double *ptr; // указатель на массив
    size_t size; // размер массива
public:
    Array(){}; // конструктор по умолчанию
    Array(const size_t new_size ); // конструктор с параметрами
    Array( const Array & ); // конструктор копии
    ~Array(); // деструктор
     //set методы
    void setArray(); // заполнение массива с клавиатуры
    bool ReadFile(const char *);//заполняем из файла
     //get методы
    size_t getSize() const; // возвратить количество элементов массива
    void PrintMass(); // вывод массива
    //перегруженные операторы
    bool operator== (const Array &) const; // оператор сравнения
    Array &operator= (const Array &); // оператор присваивания
    double &operator[] (size_t );//взятие индекса
    Array &operator+= (const double &); // оператор добавления элемента в конец массива
    Array &CopiMas (const size_t &,const size_t &);//копируем и определяем размер нового массива
    //поиск
    size_t Search(const double &) const;// поиск по ключу
    int IndMin (const double &)const;//минимальный индекс
    int IndMax (const double &)const;//максимальный индекс
    void SortMass ();// сортировка
    void InvertMass();//инверсия
    //вспомогательные ф-ции
    double MaxElement ();//макс элемент
    double MinElement ();//мин элемент
 
 
};
 
 
Array::Array(size_t arraySize) // конструктор с параметрами
{
    size = arraySize;
    ptr = new double [size]; // выделить место в памяти для массива
 
    for (size_t i = 0; i < size; i++) // обнуляем массив
        ptr[i] = 0;
}
Array::Array( const Array &arrayToCopy ) // конструктор копии
    :size(arrayToCopy.size)              // инициализатор размера массива
{
    ptr = new double [size]; // выделить место в памяти для массива
 
    for (size_t i = 0; i < size; i++)
        //ptr[i] = arrayToCopy.ptr[i]; // заполняем массив значениями массива arrayToCopy
        swap (this->ptr[i],arrayToCopy.ptr[i]);
}
Array::~Array() // деструктор класса Array
{
    delete  [] ptr; // освободить память, удалив массив
}
istream &operator>> (istream & input, Array &obj)// перегруженный оператор ввода с клавиатуры
{
    for (size_t i = 0; i < obj.size; i++)
        input >> obj.ptr[i]; // заполняем массив объекта obj
    return input; // позволяет множественный ввод
}
ostream &operator<< (ostream &output, const Array &obj)// перегруженный оператор вывода
{
    for (size_t i = 0; i < obj.size; i++)
    {
        output << setw(10)<< setiosflags(ios::left) // под каждое число выделяется 5 позиций
               << obj.ptr[i];
    }
 
    output << endl;
 
    return output; // позволяет множественный вывод
}
void Array::setArray() // заполнение массива
{
    for (size_t i = 0; i < size; i++)
        cin >> ptr[i]; // ввод элемента массива с клавиатуры
}
bool Array::ReadFile(const char *filename)//заполняем из файла
{
    ifstream in(filename);
    if (!in) return false;
        for (size_t i = 0;i< size; i++)  //чтение чисел
    {
    in >> ptr[i];
    //arr[i] = ((arr[i]/2)*(arr[i]/2))*3.14;             //     из файла
    }
    //in.close(); //Закрываем файл
  return true;
}
int Array::IndMin(const double &key)const//ищем минимальный индекс
{
 int min = -1;
    for (size_t i = 0; i < size; i++)
     {
        //пока оставляю magic number
        if (key > (ptr[0]- 0.021))
             {
                if (fabs(ptr[i]-key)<= fabs(ptr[i+1]-key))//поиск по условию
                return (i >= 2)?min = i - 2: min = 0;//нижняя граница
             }
     }
 return -1;
}
 size_t Array::Search(const double &key) const // поиск по ключу
 {
     for (size_t i = 0; i < size; i++)
         if ( key == ptr[i] ) // поиск по ключу
             return (i + 1);             // позиция искомого элемента
     return -1;
 }
double Array::MaxElement ()//вспомогательная ф-ция макс элемент
{
 
double max_el = ptr[0];
for (size_t i =0 ;i< size; i++)
{
    if (max_el < ptr[i])
    max_el= ptr[i];
    }
    return max_el;
}
double Array::MinElement ()//вспомогательная ф-ция min элемент
{
double min_el = ptr[0];
for (size_t i =0 ;i< size; i++)
{
    if (min_el > ptr[i])
    min_el= ptr[i];
    }
    return min_el;
}
int Array::IndMax (const double  &key)const//максимальный индекс
{
 int max = -1;
 
    for (size_t i = 0; i < size; i++)
      {
        if (key < (ptr[i]+ 0.021))//пока оставляю magic number
         {
           if (fabs(ptr[i]-key)<= fabs(ptr[i+1]-key))//поиск по условию
           //пока оставляю magic number
               return (i <= size-3)? max=i +3 : max = size;//верхняя граница
         }
       }
 return -1;
}
void Array::PrintMass() // вывод массива
{
    for (size_t i = 0; i < size; i++)
        cout << setw(10)<< setiosflags(ios::left)<< ptr[i]; // вывод элементов массива на экран
 
    cout << endl; // новая строка
}
size_t Array::getSize() const // возвратить количество элементов массива
{
    return size;
}
 Array &Array::operator= (const Array &mass) // оператор присваивания
{
 
    if (&mass != this) // чтобы не выполнялось самоприсваивание
    {
        if (size != mass.size)
        {
            delete [] ptr; // освободить пространство
            size = mass.size; // установить нужный размер массива
            ptr = new double [size]; // выделить память под копируемый массив
        }
        for (size_t i = 0; i < size; i++)
            //ptr[i] = mass.ptr[i]; // скопировать массив
            swap (this->ptr[i],mass.ptr[i]);
    }
 
    return *this; // множественное присваивание
}
 
double &Array::operator[] (size_t index)
{
    if(index < 0 || index >= size)
    {
        std::cerr << "\n Ошибка индекса: " << index << std::endl;
        exit(1); // завершить работу программы, неправильный индекс
    }
    return ptr[index]; // возврат ссылки на элемент массива
}
bool Array::operator== (const Array &mass) const// оператор сравнения
{
    if (size != mass.size)
        return false; // массивы с разным количеством элементов
    for (size_t i = 0; i < size; i++)
        if (ptr[i] != mass.ptr[i])
            return false; // массивы не равны
 
    return true; // массивы равны
}
Array &Array::CopiMas (const size_t &max,const size_t &min)//копируем и определяем размер нового массива
{
     double *temp_ptr = ptr ;//Храним указатель на старую память (не создавая нового объекта и не копируя в него всё старое содержимое)
     size = max-min; // переопределяем размер
     ptr = new double [size];
 size_t len = 0;
    for (size_t i = min; i < max; i++ )//читаем в ptr
    //for ( i = min; i < max; i++ )//переносим в temp
     //if (temp_ptr[i]!=0) ptr[len++]= temp_ptr[i];//переприсваиваем из temp в ptr
     swap (this->ptr[len++],temp_ptr[i]);//должен сработать деструктор
     //delete [] temp_ptr ;//Старая память более не нужна
     return *this;
   }
 Array &Array::operator+= (const double &num) // оператор добавления элемента в конец массива
{
    //Array result(size);
    //result = *this; // временно сохраним текущий массив
    //delete [] ptr; // освобождаем память
    double *result_ptr = ptr ;
    size = size + 1; // увеличиваем размер массива на 1
    ptr = new double [size]; // выделяем память
    for (size_t i = 0; i < (size - 1); i++)
    swap (this->ptr[i],result_ptr[i]);
        //ptr[i] = result.ptr[i]; // скопировать массив
        ptr[size - 1] = num; // добавляем число в конец массива
 
    return *this; // вызов перегруженного оператора
}
void Array::SortMass ()
{
 for (size_t i = 0; i < size; i++)
    {
        for (size_t j= i+ 1; j< size; j++)
           {
             if (ptr[j] < ptr[i]) swap (this->ptr[i],this-> ptr[j]);
           }
    }
}
void Array::InvertMass()
{
    for(size_t i = 0; i < size / 2; i++)//делим пополам
    swap (this->ptr[i],this->ptr[size - i - 1]);
}
 
int main()
{
system("chcp 1251 > nul");
 
 double d;
 int N =0,i = 0;
 
 Array Ar1(i); // создаем объект класса Ar1, используя конструктор аргументированный
 Array Ar(Ar1);  // создаем объект класса Ar, используя конструктор копирования
 Array Ar2(28);    // создаем объект класса Ar2, используя конструктор по умолчанию
 //выбираем как заполнять массив
  cout << "Как заполнить массив массив?  \n";
  cout << "Из файла-введите 0, с клавиатуры-введите 1.  \n";
  cin>>N;
 
 if (N == 1)
  {
    while (d!= 0)//заполняем перегруженным оператором += пока не введен 0
    {  cin>>d; if (d !=0) { Ar1 += d; i++; }}
       cout << "Начальный массив: \n";
       cout << Ar1; //вывод массива с помощью перегруженного оператора вывода <<
       Ar = Ar1; // присваиваем массиву Ar массив Ar1
       Ar.CopiMas(i,0);
       cout<< "Размер массива: " << Ar.getSize() << "\n";
       Ar.SortMass ();
       cout << "Сортированный массив: \n";
       cout << Ar; //вывод
  }
 if (N == 0)
  {
    cout << "Начальный массив: \n";
    Ar2.ReadFile("D:\\моя колликция\\символьная переменная\\мой файл.txt");
    Ar = Ar2; // присваиваем массиву Ar массив Ar2
    cout << Ar.CopiMas(Ar.getSize(),0)<< "Размер массива: " << Ar.getSize() << "\n";
 
  }
  cout <<"Макс элемент=  "<< Ar.MaxElement () <<"    Мин элемент=   "<<Ar.MinElement ()<<"\n";
 
 int pos = 0;
    cout << " Введите число \n";
    cin >>d;
    if ((pos = Ar.Search(d)) != -1)//поиск элемента по значению
        cout << "Позиция искомого элемента: " << pos << "\n";
    else
        cout << "Искомый элемент не найден!\n";
 
    cout << "Инвертированный массив: \n";
    Ar.InvertMass ();//инверсия массива
    cout << Ar; //вывод
    cout << "Элемент массива = " << Ar[Ar.getSize() -2] << "\n";//поиск элемента по индексу
 
    cout << "Инвертированный массив: \n";
    Ar.InvertMass ();//инверсия массива
    cout << Ar; //вывод
 
 int min = Ar.IndMin (d);
 int max = Ar.IndMax (d);
  if ((min != -1)&&(max != -1))
    {
            cout << "Минимальный индекс=   "<<min<<" Максимальный индекс=    "<<max<<"\n";
            Array Ar3(Ar); // 5-ти элементный объект класса Array
             cout << "Полученный массив: \n";
            Ar3.CopiMas(max,min);
            cout << "Размер массива: " << Ar3.getSize() << "\n";
             cout << Ar3; //вывод
    }else
    cout<<" Такого элемента нет в массиве!";
 
 
    return 0;
}

MrGluck · 22.01.2014, 02:03

Еще раз повторюсь - разделите объявление и реализацию, подтяните форматирование кода.

@Genn55 · 22.01.2014, 21:48 **[ТС]**

А переписал функции и конструктор копирования правильно?

Добавлено через 19 часов 36 минут
Доброго всем времени суток!
Переписал.Пожалуйста посмотрите получилось ли?Какие еще косяки или неточности?

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
//--------------------Заголовочный файл h----------array.h класса Array.------------------------------------------
#ifndef ARRAY_H
#define ARRAY_H
 
#include <istream>
#include <ostream>
using std::istream;
using std::ostream;
 
class Array
{
    friend istream &operator>> (istream &, Array &); // перегруженный оператор ввода
    friend ostream &operator<< (ostream &, const Array &); // перегруженный оператор вывода
private:
    double *ptr; // указатель на массив
    size_t size; // размер массива
public:
    Array(){}; // конструктор по умолчанию
    Array(const size_t new_size ); // конструктор с параметрами
    Array( const Array & ); // конструктор копии
    ~Array(); // деструктор
     //set методы
    void setArray(); // заполнение массива с клавиатуры
    bool ReadFile(const char *);//заполняем из файла
     //get методы
    size_t getSize() const; // возвратить количество элементов массива
    void PrintMass(); // вывод массива
    //перегруженные операторы
    bool operator== (const Array &) const; // оператор сравнения
    Array &operator= (const Array &); // оператор присваивания
    double &operator[] (size_t );//взятие индекса
    Array &operator+= (const double &); // оператор добавления элемента в конец массива
    Array &CopiMas (const size_t &,const size_t &);//копируем и определяем размер нового массива
    //поиск
    size_t Search(const double &) const;// поиск по ключу
    int IndMin (const double &)const;//минимальный индекс
    int IndMax (const double &)const;//максимальный индекс
    void SortMass ();// сортировка
    void InvertMass();//инверсия
    //вспомогательные ф-ции
    double MaxElement ();//макс элемент
    double MinElement ();//мин элемент
 
 
};
#endif // ARRAY_H
 
//-----------Исполняемый файл cpp---------------array.cpp класса Array------------------
#include "array.h"
 
#include <fstream>
#include <iostream>
using std::cout; // пространство имен  для cout
using std::cin; // пространство имен  для cin
using std::swap;// пространство имен  для swap
using std::ifstream;// пространство имен  для ifstream
 
#include <iomanip> // для манипулятора setw
using std::setw;   // пространство имен для setw
 
#include <cmath>
#include <cstdlib>
#include<cstddef>
 
Array::Array(size_t arraySize) // конструктор с параметрами
{
    size = arraySize;
    ptr = new double [size]; // выделить место в памяти для массива
 
    for (size_t i = 0; i < size; i++) // обнуляем массив
        ptr[i] = 0;
}
Array::Array( const Array &arrayToCopy ) // конструктор копии
    :size(arrayToCopy.size)              // инициализатор размера массива
{
    ptr = new double [size]; // выделить место в памяти для массива
 
    for (size_t i = 0; i < size; i++)
    swap (this->ptr[i],arrayToCopy.ptr[i]);// заполняем массив значениями массива arrayToCopy
}
Array::~Array() // деструктор класса Array
{
    delete  [] ptr; // освободить память, удалив массив
}
istream &operator>> (istream & input, Array &obj)// перегруженный оператор ввода с клавиатуры
{
    for (size_t i = 0; i < obj.size; i++)
        input >> obj.ptr[i]; // заполняем массив объекта obj
    return input; // позволяет множественный ввод
}
ostream &operator<< (ostream &output, const Array &obj)// перегруженный оператор вывода
{
    for (size_t i = 0; i < obj.size; i++)
    {
        output << setw(10)<<std::setiosflags(std::ios::left) // под каждое число выделяется 10 позиций
               << obj.ptr[i];
    }
 
    output << std::endl;
 
    return output; // позволяет множественный вывод
}
void Array::setArray() // заполнение массива
{
    for (size_t i = 0; i < size; i++)
        cin >> ptr[i]; // ввод элемента массива с клавиатуры
}
bool Array::ReadFile(const char *filename)//заполняем из файла
{
    ifstream in(filename);
    if (!in) return false;
        for (size_t i = 0;i< size; i++)  //чтение чисел
          {
            in >> ptr[i];
    //arr[i] = ((arr[i]/2)*(arr[i]/2))*3.14;             //     из файла
          }
  return true;
}
int Array::IndMin(const double &key)const//ищем минимальный индекс
{
 int min = -1;
    for (size_t i = 0; i < size; i++)
     {
        //пока оставляю magic number
        if (key > (ptr[0]- 0.021))//будет указатель на функцию
             {
                if (fabs(ptr[i]-key)<= fabs(ptr[i+1]-key))//поиск по условию
                     return (i >= 2)?min = i - 2: min = 0;//нижняя граница
             }
     }
 return -1;
}
 size_t Array::Search(const double &key) const // поиск по ключу
 {
     for (size_t i = 0; i < size; i++)
         if ( key == ptr[i] ) // поиск по ключу
             return (i + 1);             // позиция искомого элемента
     return -1;
 }
double Array::MaxElement ()//вспомогательная ф-ция макс элемент
{
 
 double max_el = ptr[0];
      for (size_t i =0 ;i< size; i++)
         {
           if (max_el < ptr[i])
               max_el= ptr[i];
         }
 return max_el;
}
double Array::MinElement ()//вспомогательная ф-ция min элемент
{
 double min_el = ptr[0];
       for (size_t i =0 ;i< size; i++)
           {
              if (min_el > ptr[i])
                  min_el= ptr[i];
           }
 return min_el;
}
int Array::IndMax (const double  &key)const//максимальный индекс
{
 int max = -1;
 
    for (size_t i = 0; i < size; i++)
      {
        if (key < (ptr[i]+ 0.021))//пока оставляю magic number
         {
           if (fabs(ptr[i]-key)<= fabs(ptr[i+1]-key))//поиск по условию
           //пока оставляю magic number
               return (i <= size-3)? max=i +3 : max = size;//верхняя граница
         }
       }
 return -1;
}
void Array::PrintMass() // вывод массива
{
    for (size_t i = 0; i < size; i++)
        cout << setw(10)<< std::setiosflags(std::ios::left)<< ptr[i]; // вывод элементов массива на экран
 
    cout << std::endl; // новая строка
}
size_t Array::getSize() const // возвратить количество элементов массива
{
    return size;
}
 Array &Array::operator= (const Array &mass) // оператор присваивания
{
 
 if (&mass != this) // чтобы не выполнялось самоприсваивание
    {
        if (size != mass.size)
        {
            delete [] ptr; // освободить пространство
            size = mass.size; // установить нужный размер массива
            ptr = new double [size]; // выделить память под копируемый массив
        }
        for (size_t i = 0; i < size; i++)
             swap (this->ptr[i],mass.ptr[i]);// скопировать массив
    }
 
    return *this; // множественное присваивание
}
 
double &Array::operator[] (size_t index)
{
    if(index < 0 || index >= size)
    {
        cout<< " Ошибка индекса    " << index << std::endl;
        return ptr [index] = -1;
    }
 return ptr[index]; // возврат ссылки на элемент массива
}
bool Array::operator== (const Array &mass) const// оператор сравнения
{
    if (size != mass.size)
        return false; // массивы с разным количеством элементов
    for (size_t i = 0; i < size; i++)
        if (ptr[i] != mass.ptr[i])
            return false; // массивы не равны
 
    return true; // массивы равны
}
Array &Array::CopiMas (const size_t &max,const size_t &min)//копируем и определяем размер нового массива
{
 double *temp_ptr = ptr ;//Храним указатель на старую память (не создавая нового объекта и не копируя в него всё старое содержимое)
 
         size = max-min; // переопределяем размер
         ptr = new double [size];
 
 size_t len = 0;
 
    for (size_t i = min; i < max; i++ )//читаем в ptr
         swap (this->ptr[len++],temp_ptr[i]);// скопировать массив
     //должен сработать деструктор
     return *this;
   }
 Array &Array::operator+= (const double &num) // оператор добавления элемента в конец массива
{
 double *result_ptr = ptr ;
 
       size = size + 1; // увеличиваем размер массива на 1
       ptr = new double [size]; // выделяем память
 
    for (size_t i = 0; i < (size - 1); i++)
         swap (this->ptr[i],result_ptr[i]);// скопировать массив
         ptr[size - 1] = num; // добавляем число в конец массива
 
    return *this; // вызов перегруженного оператора
}
void Array::SortMass ()
{
 for (size_t i = 0; i < size; i++)
    {
        for (size_t j= i+ 1; j< size; j++)
           {
             if (ptr[j] < ptr[i]) swap (this->ptr[i],this-> ptr[j]);
           }
    }
}
void Array::InvertMass()
{
    for(size_t i = 0; i < size / 2; i++)//делим пополам
        swap (this->ptr[i],this->ptr[size - i - 1]);
}
 
//-------------Главная функция main----Работа с классом--------------------------------------------------
 
#include <iostream>
using namespace std;
#include "array.h"
int main()
{
system("chcp 1251 > nul");
 
 double d;
 int N =0,i = 0;
 
 Array Ar1(i); // создаем объект класса Ar1, используя конструктор аргументированный
 Array Ar(Ar1);  // создаем объект класса Ar, используя конструктор копирования
 Array Ar2(28);    // создаем объект класса Ar2используя конструктор аргументированный
 //выбираем как заполнять массив
  cout << "Как заполнить массив массив?  \n";
  cout << "Из файла-введите 0, с клавиатуры-введите 1.  \n";
  cin>>N;
 
 if (N == 1)
  {
    while (d!= 0)//заполняем перегруженным оператором += пока не введен 0
    {  cin>>d; if (d !=0) { Ar1 += d; i++; }}
       cout << "Начальный массив: \n";
       cout << Ar1; //вывод массива с помощью перегруженного оператора вывода <<
       Ar = Ar1; // присваиваем массиву Ar массив Ar1
       Ar.CopiMas(i,0);
       cout<< "Размер массива: " << Ar.getSize() << "\n";
       Ar.SortMass ();
       cout << "Сортированный массив: \n";
       cout << Ar; //вывод
  }
 if (N == 0)
  {
    cout << "Начальный массив: \n";
    Ar2.ReadFile("D:\\моя колликция\\символьная переменная\\мой файл.txt");
    Ar = Ar2; // присваиваем массиву Ar массив Ar2
    cout << Ar.CopiMas(Ar.getSize(),0)<< "Размер массива: " << Ar.getSize() << "\n";
 
  }
  cout <<"Макс элемент=  "<< Ar.MaxElement () <<"    Мин элемент=   "<<Ar.MinElement ()<<"\n";
 
 int pos = 0;
    cout << " Введите число \n";
    cin >>d;
    if ((pos = Ar.Search(d)) != -1)//поиск элемента по значению
        cout << "Позиция искомого элемента: " << pos << "\n";
    else
        cout << "Искомый элемент не найден!\n";
 
    cout << "Инвертированный массив: \n";
    Ar.InvertMass ();//инверсия массива
    cout << Ar; //вывод
    if (Ar[Ar.getSize() -2]!= -1)
        cout << "Элемент массива = " << Ar[Ar.getSize() -2] << "\n";//поиск элемента по индексу
 
        cout << "Инвертированный массив: \n";
    Ar.InvertMass ();//инверсия массива
    cout << Ar; //вывод
 
 int min = Ar.IndMin (d);
 int max = Ar.IndMax (d);
  if ((min != -1)&&(max != -1))
    {
            cout << "Минимальный индекс=   "<<min<<" Максимальный индекс=    "<<max<<"\n";
            Array Ar3(Ar); // 5-ти элементный объект класса Array
             cout << "Полученный массив: \n";
            Ar3.CopiMas(max,min);
            cout << "Размер массива: " << Ar3.getSize() << "\n";
             cout << Ar3; //вывод
    }else
    cout<<" Такого элемента нет в массиве!";
 
 
    return 0;
}

Перегрузку операторов >> и << пока решил оставить.В следующем классе буду пробовать делать по другому.

MrGluck · 22.01.2014, 21:59

Сообщение от Genn55

using std::istream;
using std::ostream;

вот таких вещей в заголовочных файлах делать не стоит. Неминуемо кидает в стандартную область видимости все istream и ostream, существующие в проекте.
Далее, оформите каждый исходник в отдельном теге CPP.
Уберите всю реализацию в заголовочных файлах (я про ваш конструктор по-умолчанию).
С форматированием вы так и не разобрались. Сделайте хотя бы чтоб логические блоки (например тело одного цикла) имели один и тот же отступ.

@Genn55 · 22.01.2014, 23:07 **[ТС]**

оформите каждый исходник в отдельном теге CPP.
Извините,может это и глупо,но я не знаю как.
А с форматированием...да проблема еще та.Проверять коды не кому,а пишут все по разному. Если не трудно покажите на каком нибудь примере.Буду стараться.
Если все остальное верно,если не возражаете,покажу что получится в следующий раз.

Добавлено через 50 минут
Так правильно?

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
//--------------------Заголовочный файл h----------array.h класса Array.------------------------------------------
#ifndef ARRAY_H
#define ARRAY_H
 
#include <istream>
#include <ostream>
 
 
class Array
{
    friend std::istream &operator>> (std::istream &, Array &); // перегруженный оператор ввода
    friend std::ostream &operator<< (std::ostream &, const Array &); // перегруженный оператор вывода
private:
    double *ptr; // указатель на массив
    size_t size; // размер массива
public:
    Array(); // конструктор по умолчанию
    Array(const size_t new_size ); // конструктор с параметрами
    Array( const Array & ); // конструктор копии
    ~Array(); // деструктор
     //set методы
    void setArray(); // заполнение массива с клавиатуры
    bool ReadFile(const char *);//заполняем из файла
     //get методы
    size_t getSize() const; // возвратить количество элементов массива
    void PrintMass(); // вывод массива
    //перегруженные операторы
    bool operator== (const Array &) const; // оператор сравнения
    Array &operator= (const Array &); // оператор присваивания
    double &operator[] (size_t );//взятие индекса
    Array &operator+= (const double &); // оператор добавления элемента в конец массива
    Array &CopiMas (const size_t &,const size_t &);//копируем и определяем размер нового массива
    //поиск
    size_t Search(const double &) const;// поиск по ключу
    int IndMin (const double &)const;//минимальный индекс
    int IndMax (const double &)const;//максимальный индекс
    void SortMass ();// сортировка
    void InvertMass();//инверсия
    //вспомогательные ф-ции
    double MaxElement ();//макс элемент
    double MinElement ();//мин элемент
 
 
};
#endif // ARRAY_H
 
//-----------Исполняемый файл cpp---------------array.cpp класса Array------------------
//#include "array.h"
 
#include <fstream>
#include <iostream>
using std::cout; // пространство имен  для cout
using std::cin; // пространство имен  для cin
using std::swap;// пространство имен  для swap
using std::ifstream;// пространство имен  для ifstream
using std::istream;
using std::ostream;
 
#include <iomanip> // для манипулятора setw
using std::setw;   // пространство имен для setw
 
#include <cmath>
#include <cstdlib>
#include<cstddef>
 
Array::Array()
{
 
}

MrGluck · 23.01.2014, 01:58

Что исправлено:
- улучшено форматирование кода
- исходник разделен по файлам, реализация вынесена от объявления
- исправлены некоторые неверные комментарии
- исправлены ошибки в копировании в конструкторе копий и операторе присваиваний
- убраны ненужные ссылки в параметрах методов
- добавлен квалификатор const к некоторым параметрам функций
- некоторые методы стали константными (добавлен const в конце)
- добавлен конструктор по умолчанию
- инициализация в конструкторе использует список инициализации конструктора
- добавлен недостающий заголовочный файл, ввод вывод объединен в iostream
- изменен порядок следования методов в заголовочном файле (поделено по категориям)
- изменен порядок следования в файле реализаций (соответствует порядку следования в заголовочном файле
- добавлен using namespace std; использовать - так использовать. Лишние std:: убраны
- Copi поменял на Copy - смотреть невозможно
- переписан оператор += (избавление от утечки памяти)

Вообщем то тут много чего еще меня не устраивает - например я методы всегда с маленькой буквы называю, избегаю транслит(Mass), считаю, что setArray должен принимать указатель на массив, а не требовать ввод с клавиатуры, функция сортировки должна называться просто sort(), мы же итак с массивом работаем, и прочее и прочее...
Смысл работы функции CopyMass я так и не понял, поэтому тело оставил как есть.

Почти все делал на автомате, все-таки целый день работал, а время уже немалое. Наверняка что-нибудь оставил концептуально неверное. Основная задача ставилась показать пример правильного (на мой взгляд, разумеется) форматирования кода. А уж вышло что вышло. Проект для CB 10.05 (в котором работает ТС) прикрепляю.

Array.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
//--------------------Заголовочный файл класса Array.------------------------------------------
#ifndef ARRAY_H
#define ARRAY_H
 
#include <cstddef>
#include <iostream>
 
 
class Array
{
    double *ptr; // указатель на массив
    size_t size; // размер массива
public:
    Array();                      // конструктор по умолчанию
    Array(const size_t new_size); // конструктор с параметрами
    Array(const Array &);         // конструктор копии
    ~Array();                     // деструктор
 
    // перегруженные операторы
    Array&  operator=  (const Array &);       // оператор присваивания
    bool    operator== (const Array &) const; // оператор сравнения
    double& operator[] (const size_t);        // взятие индекса
    Array&  operator+= (const double );       // оператор добавления элемента в конец массива
 
    // set методы
    void setArray(); // заполнение массива с клавиатуры
 
    // get методы
    size_t getSize() const; // возвратить количество элементов массива
 
    // поиск
    size_t Search(const double) const; // поиск по ключу
    int    IndMin(const double) const; // минимальный индекс
    int    IndMax(const double) const; // максимальный индекс
 
    // прочие методы
    void SortMass();             // сортировка
    void InvertMass();           // инверсия
    bool ReadFile(const char *); // заполняем из файла
    void PrintMass() const;      // вывод массива
    Array& CopyMas(const size_t, const size_t); // копируем и определяем размер нового массива
 
    // вспомогательные ф-ции
    double MaxElement(); // макс элемент
    double MinElement(); // мин элемент
 
    friend std::istream &operator>> (std::istream &, Array &);       // перегруженный оператор ввода
    friend std::ostream &operator<< (std::ostream &, const Array &); // перегруженный оператор вывода
};
 
#endif // ARRAY_H

Array.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
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
//----------- Файл реализации класса Array------------------
#include <cmath>
#include <cstdlib>
#include <cstddef>
#include <fstream>
#include <iomanip> // для манипулятора setw
#include <iostream>
#include "Array.h"
 
using namespace std;
 
 
Array::Array() :
    ptr(NULL), size()
{}
 
// конструктор с параметрами
Array::Array(const size_t arraySize) :
    ptr(new double[arraySize]), size(arraySize)
{
    ptr = {0}; // обнуляем массив
}
 
// конструктор копий
Array::Array(const Array &arrayToCopy) :
    ptr(new double[arrayToCopy.size]), size(arrayToCopy.size) // инициализатор размера массива
{
    for (size_t i=0; i < size; i++)
        ptr[i] = arrayToCopy.ptr[i]; // заполняем массив значениями массива arrayToCopy
}
 
Array::~Array() // деструктор класса Array
{
    delete[] ptr; // освободить память, удалив массив
}
 
 
Array& Array::operator= (const Array &mass) // оператор присваивания
{
    if (&mass != this) // чтобы не выполнялась лишняя работа при самоприсваивании
    {
        if (size != mass.size)
        {
            delete[] ptr;            // освободить пространство
            size = mass.size;        // установить нужный размер массива
            ptr  = new double[size]; // выделить память под копируемый массив
        }
        for (size_t i=0; i < size; i++)
             ptr[i] = mass.ptr[i];   // скопировать массив
    }
 
    return *this; // возвращаем указатель на сформированный объект (на самого себя)
}
 
bool Array::operator== (const Array &mass) const // оператор сравнения
{
    if (size != mass.size)
        return false; // массивы с разным количеством элементов
 
    for (size_t i=0; i < size; i++)
        if (ptr[i] != mass.ptr[i])
            return false; // массивы не равны
 
    return true; // массивы равны
}
 
double& Array::operator[] (const size_t index)
{
    if (index >= size) // size_t всегда больше нуля
    {
        // тут надо бы исключение кинуть
        cout << " Ошибка индекса    " << index << endl;
        return ptr[index] = -1;
    }
    return ptr[index]; // возврат ссылки на элемент массива
}
 
Array& Array::operator+= (const double num) // оператор добавления элемента в конец массива
{
    size++;
    double *result_ptr = new double[size + 1];
 
    for (size_t i=0; i < size-1; i++)
        swap(this->ptr[i], result_ptr[i]); // скопировать массив
    result_ptr[size - 1] = num; // добавляем число в конец массива
 
    delete[] ptr;
    ptr = result_ptr;
 
    return *this; // возвращаем сформированный объект (себя)
}
 
 
void Array::setArray() // заполнение массива
{
    for (size_t i=0; i < size; i++)
        cin >> ptr[i]; // ввод элемента массива с клавиатуры
}
 
 
size_t Array::getSize() const // возвратить количество элементов массива
{
    return size;
}
 
size_t Array::Search(const double key) const // поиск по ключу
{
    for (size_t i=0; i < size; i++)
        if (key == ptr[i]) // поиск по ключу
            return i + 1; // позиция искомого элемента
 
    return -1;
}
 
int Array::IndMin(const double key) const // ищем минимальный индекс
{
    int min = -1;
    for (size_t i=0; i < size; i++)
    {
        // пока оставляю magic number
        if (key > (ptr[0]- 0.021)) // будет указатель на функцию
        {
            if (fabs(ptr[i] - key) <= fabs(ptr[i+1] - key)) // поиск по условию
                return (i >= 2) ? min = i - 2: min = 0;     // нижняя граница
        }
    }
 
    return -1;
}
 
int Array::IndMax(const double key) const // максимальный индекс
{
    int max = -1;
 
    for (size_t i=0; i < size; i++)
    {
        if (key < (ptr[i]+ 0.021))//пока оставляю magic number
        {
            if (fabs(ptr[i] - key) <= fabs(ptr[i+1] - key)) //поиск по условию
                // пока оставляю magic number
                return (i <= size-3) ? max = i+3 : max = size; //верхняя граница
        }
    }
 
    return -1;
}
 
void Array::SortMass()
{
    for (size_t i=0; i < size; i++)
    {
        for (size_t j=i+1; j < size; j++)
        {
            if (ptr[j] < ptr[i])
                swap (this->ptr[i], this-> ptr[j]);
        }
    }
}
 
void Array::InvertMass()
{
    for (size_t i = 0; i < size/2; i++) // меняем элементы до средины
        swap(this->ptr[i], this->ptr[size-i-1]);
}
 
bool Array::ReadFile(const char *filename) // заполняем из файла
{
    ifstream in(filename);
    if (!in) return false;
    for (size_t i=0; i < size; i++)  // чтение чисел
    {
        in >> ptr[i];
        //arr[i] = ((arr[i]/2)*(arr[i]/2))*3.14; // из файла
    }
 
    return true;
}
 
void Array::PrintMass() const // вывод массива
{
    for (size_t i=0; i < size; i++)
        cout << setw(10) << std::setiosflags(std::ios::left) << ptr[i]; // вывод элементов массива на экран
    cout << std::endl; // новая строка
}
 
Array& Array::CopyMas(const size_t max, const size_t min) // копируем и определяем размер нового массива
{
    double *temp_ptr = ptr ; // Храним указатель на старую память (не создавая нового объекта и не копируя в него всё старое содержимое)
    size = max - min;        // переопределяем размер
    ptr  = new double[size];
 
    size_t len = 0;
 
    for (size_t i=min; i < max; i++)          // читаем в ptr
         swap(this->ptr[len++], temp_ptr[i]); // скопировать массив
 
     // должен сработать деструктор
     return *this;
}
 
 
double Array::MaxElement() //вспомогательная ф-ция макс элемент
{
    double max_el = ptr[0];
    for (size_t i=0; i < size; i++)
    {
        if (max_el < ptr[i])
            max_el = ptr[i];
    }
 
    return max_el;
}
 
double Array::MinElement() //вспомогательная ф-ция min элемент
{
    double min_el = ptr[0];
    for (size_t i=0; i < size; i++)
    {
        if (min_el > ptr[i])
            min_el= ptr[i];
    }
 
    return min_el;
}
 
 
istream &operator>> (istream &input, Array &obj) // перегруженный оператор ввода с клавиатуры
{
    for (size_t i=0; i < obj.size; i++)
        input >> obj.ptr[i]; // заполняем массив объекта obj
    return input; // возвращаем поток
}
 
ostream &operator<< (ostream &output, const Array &obj)// перегруженный оператор вывода
{
    for (size_t i=0; i < obj.size; i++)
    {
        output << setw(10) << setiosflags(ios::left) // под каждое число выделяется 10 позиций
               << obj.ptr[i];
    }
    output << endl;
 
    return output; // возвращаем поток
}

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
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
//-------------Главная функция main----Работа с классом--------------------------------------------------
#include <cstdlib>
#include <iostream>
#include "Array.h"
using namespace std;
 
 
int main()
{
    system("chcp 1251 > nul");
    double d;
    int N = 0, i = 0;
 
    Array Ar1(i);  // создаем объект класса Ar1 используя конструктор аргументированный
    Array Ar(Ar1); // создаем объект класса Ar используя конструктор копирования
    Array Ar2(28); // создаем объект класса Ar2 используя конструктор аргументированный
 
    // выбираем как заполнять массив
    cout << "Как заполнить массив массив?  \n";
    cout << "Из файла-введите 0, с клавиатуры-введите 1.  \n";
    cin >> N;
 
    if (N == 1)
    {
        while (d != 0) // заполняем перегруженным оператором += пока не введен 0
        {
            cin >> d;
            if (d != 0)
            {
                Ar1 += d;
                i++;
            }
        }
 
        cout << "Начальный массив: \n";
        cout << Ar1; // вывод массива с помощью перегруженного оператора вывода <<
        Ar = Ar1;    // присваиваем массиву Ar массив Ar1
        Ar.CopyMas(i, 0);
        cout<< "Размер массива: " << Ar.getSize() << "\n";
        Ar.SortMass();
        cout << "Сортированный массив: \n";
        cout << Ar; //вывод
    }
 
    else if (N == 0)
    {
        cout << "Начальный массив: \n";
        Ar2.ReadFile("D:\\моя колликция\\символьная переменная\\мой файл.txt"); // использовать абсолютные пути, а уж тем более с русскими символами это очень плохо
        Ar = Ar2; // присваиваем массиву Ar массив Ar2
        cout << Ar.CopyMas(Ar.getSize(), 0) << "Размер массива: " << Ar.getSize() << "\n";
 
    }
 
    cout << "Макс элемент=  "     << Ar.MaxElement()
         << "    Мин элемент=   " << Ar.MinElement() << "\n";
 
    int pos = 0;
    cout << " Введите число \n";
    cin >> d;
 
    if ((pos = Ar.Search(d)) != -1) // поиск элемента по значению
        cout << "Позиция искомого элемента: " << pos << "\n";
    else
        cout << "Искомый элемент не найден!\n";
 
    cout << "Инвертированный массив: \n";
    Ar.InvertMass(); // инверсия массива
    cout << Ar;      // вывод
    if (Ar[Ar.getSize() - 2] != -1)
        cout << "Элемент массива = " << Ar[Ar.getSize() -2] << "\n"; // поиск элемента по индексу
 
    cout << "Инвертированный массив: \n";
    Ar.InvertMass(); // инверсия массива
    cout << Ar;      // вывод
 
    int min = Ar.IndMin (d);
    int max = Ar.IndMax (d);
    if (min != -1 && max != -1)
    {
        cout << "Минимальный индекс=   " << min << " Максимальный индекс=    " << max << "\n";
        Array Ar3(Ar); // 5-ти элементный объект класса Array
        cout << "Полученный массив: \n";
        Ar3.CopyMas(max,min);
        cout << "Размер массива: " << Ar3.getSize() << "\n";
        cout << Ar3; //вывод
    }
    else
        cout << " Такого элемента нет в массиве!";
 
    return 0;
}

MrGluck · 23.01.2014, 02:17

Еще надо добавить

C++
1
#include <algorithm>

в Array.cpp
Сам не проверил, а у вас его не было.

Новые блоги и статьи Все статьи Все блоги /
Модель заражения группы наркоманов alhaos 17.04.2026 Условия задачи сформулированы тут Суть: - Группа наркоманов из 10 человек. - Только один инфицирован ВИЧ. - Колются одной иглой. - Колются раз в день. - Колются последовательно через. . .	Мысли в слух. Про "навсегда". kumehtar 16.04.2026 Подумалось тут, что наверное очень глупо использовать во всяких своих установках понятие "навсегда". Это очень сильное понятие, и я только начинаю понимать край его смысла, не смотря на то что давно. . .	My Business CRM MaGz GoLd 16.04.2026 Всем привет, недавно возникла потребность создать CRM, для личных нужд. Собственно программа предоставляет из себя базу данных клиентов, в которой можно фиксировать звонки, стадии сделки, а также. . .	Знаешь почему 90% людей редко бывают счастливыми? kumehtar 14.04.2026 Потому что они ждут. Ждут выходных, ждут отпуска, ждут удачного момента. . . а удачный момент так и не приходит.
Фиксация колонок в отчете СКД Maks 14.04.2026 Фиксация колонок в СКД отчета типа Таблица. Задача: зафиксировать три левых колонки в отчете. Процедура ПриКомпоновкеРезультата(ДокументРезультат, ДанныеРасшифровки, СтандартнаяОбработка) / / . . .	Настройки VS Code Loafer 13.04.2026 { "cmake. configureOnOpen": false, "diffEditor. ignoreTrimWhitespace": true, "editor. guides. bracketPairs": "active", "extensions. ignoreRecommendations": true, . . .	Оптимизация кода на разграничение прав доступа к элементам формы Maks 13.04.2026 Алгоритм из решения ниже реализован на нетиповом документе, разработанного в конфигурации КА2. Задачи, как таковой, поставлено не было, проделанное ниже исключительно моя инициатива. Было так:. . .	Контроль заполнения и очистка дат в зависимости от значения перечислений Maks 12.04.2026 Алгоритм из решения ниже реализован на примере нетипового документа "ПланированиеПерсонала", разработанного в конфигурации КА2. Задача: реализовать контроль корректности заполнения дат назначения. . .

Tulosba :) 4773 / 3267 / 497 Регистрация: 19.02.2013 Сообщений: 9,046
	19.01.2014, 22:05
	Из того, что бросилось в глаза: 1. using namespace std; 2. отсутствие в объявлении класса имен аргументов (только типы) 3. магические константы (size = 28) 4. странная проверка в 58 строке, учитывая, что тип беззнаковый 5. setArray можно реализовать через operator>> 6. строка 108. закрывать вручную не обязательно 7. в IndMin/IndMax выход за границы массива и снова магические константы 8. почему оператор= возвращает const ref&? 9. почему в Sort - swap, а в InvertMass нет? 1

MrGluck Форумчанин 8216 / 5047 / 1437 Регистрация: 29.11.2010 Сообщений: 13,453
	19.01.2014, 22:55
	Не по теме: Croessmah, привык передавать ссылку на fstream в функцию В 203 строке CopiMas. Думаю, сами поймете, что это неверно 1

MrGluck Форумчанин 8216 / 5047 / 1437 Регистрация: 29.11.2010 Сообщений: 13,453
	19.01.2014, 23:59
	мануальчик по созданию проекта в CodeBlocks с картинками 1

MrGluck Форумчанин 8216 / 5047 / 1437 Регистрация: 29.11.2010 Сообщений: 13,453
	22.01.2014, 02:03
	Еще раз повторюсь - разделите объявление и реализацию, подтяните форматирование кода. 0