Написать класс «массив». Реализовать в классе такие методы:

конструктор по умолчанию, конструктор с параметрами, конструктор копии;
деструктор;

поиск элемента в массиве по ключу;

сортировка элементов по возрастанию;

ввод с клавиатуры и вывод на экран (в виде методов класса и при помощи
перегруженных операций потокового ввода и вывода);

перегрузить следующие операции:
+ (поэлементное сложение);
+= (добавление элемента в конец массива);
– (удаление элемента по ключу);
= (присвоение);
== (сравнение по элементам);
[] (взятие элемента с заданным индексом).



Заголовочный файл 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:
    int *ptr; // указатель на массив
    int size; // размер массива
public:
    Array(); // конструктор по умолчанию
    Array(int ); // конструктор с параметрами
    Array( const Array & ); // конструктор копии
    ~Array(); // десструктор
 
    int getSize() const; // возвратить количество элементов массива
    void setArray(); // заполнение массива
    void getArray(); // вывод массива
    const Array &operator= (const Array &); // оператор присваивания
    bool operator== (const Array &) const; // оператор сравнения
    int &operator[] (int );
    Array operator+ (const Array &);
    Array &operator+= (const int &); // оператор добавления элемента в конец массива
    Array &operator- (const int &); // оператор удаления элемента по ключу
    int search(const int ) const;
    void choicesSort(); // сортировка выбором
 
};
 
#endif // ARRAY_H

Исполняемый файл array.cpp класса Array.

#include "array.h"
 
#include <iostream>
using std::cout; // пространство имен std для cout
using std::cin; // пространство имен std для cin
 
#include <iomanip> // для манипулятора setw
using std::setw;   // пространство имен std для setw
 
#include <cstdlib>
 
Array::Array() // конструктор по умолчанию, без параметров
{
    size = 10; // по умолчанию размер массива = 10 элементов
    ptr = new int [size]; // выделить место в памяти для массива
    for (int ix = 0; ix < size; ix++) // обнуляем массив
        ptr[ix] = 0;
}
 
Array::Array(int arraySize) // конструктор с параметрами
{
    // если значение параметра больше 0, присвоить size значение arraySize, иначе - 10
    size = (arraySize > 0 ? arraySize : 10);
    ptr = new int [size]; // выделить место в памяти для массива
 
    for (int ix = 0; ix < size; ix++) // обнуляем массив
        ptr[ix] = 0;
}
 
Array::Array( const Array &arrayToCopy ) // конструктор копии
    :size(arrayToCopy.size)              // инициализатор размера массива
{
    ptr = new int [size]; // выделить место в памяти для массива
 
    for (int ix = 0; ix < size; ix++)
        ptr[ix] = arrayToCopy.ptr[ix]; // заполняем массив значениями массива arrayToCopy
}
 
Array::~Array() // десструктор класса Array
{
    delete  [] ptr; // освободить память, удалив массив
}
 
int Array::getSize() const // возвратить количество элементов массива
{
    return size;
}
 
// перегруженный оператор ввода, для ввода значений массива с клавиатуры
istream &operator>> (istream & input, Array &obj)
{
    for (int ix = 0; ix < obj.size; ix++)
        input >> obj.ptr[ix]; // заполняем массив объекта obj
    return input; // позволяет множественный ввод, типа cin >> x >> y >> z >> ...
}
 
// перегруженный оператор вывода для класса Array (вывод элементов массива на экран)
ostream &operator<< (ostream &output, const Array &obj)
{
    for (int ix = 0; ix < obj.size; ix++)
    {
        output << setw(5) // под каждое число выделяется 5 позиций
               << obj.ptr[ix];
    }
 
    output << std::endl; // перенос маркера на новую строку
 
    return output; // позволяет множественный вывод, типа cout << x << y << z << ...
}
 
void Array::setArray() // заполнение массива
{
    for (int ix = 0; ix < size; ix++)
        cin >> ptr[ix]; // ввод элемента массива с клавиатуры
}
 
void Array::getArray() // вывод массива
{
    for (int ix = 0; ix < size; ix++)
        cout << setw(5) << ptr[ix]; // вывод элементов массива на экран
 
    cout << std::endl; // новая строка
}
 
const Array &Array::operator= (const Array &right) // оператор присваивания
{
    if (&right != this) // чтобы не выполнялось самоприсваивание
    {
        if (size != right.size)
        {
            delete [] ptr; // освободить пространство
            size = right.size; // установить нужный размер массива
            ptr = new int [size]; // выделить память под копируемый массив
        }
 
        for (int ix = 0; ix < size; ix++)
            ptr[ix] = right.ptr[ix]; // скопировать массив
    }
 
    return *this; // разрешает множественное присваивание, например x = t = e
}
 
bool Array::operator== (const Array &right) const// оператор сравнения
{
    if (size != right.size)
        return false; // массивы с разным количеством элементов
    for (int ix = 0; ix < size; ix++)
        if (ptr[ix] != right.ptr[ix])
            return false; // массивы не равны
 
    return true; // массивы равны
}
 
int &Array::operator[] (int subscript)
{
    if(subscript < 0 || subscript >= size)
    {
        std::cerr << "\n Ошибка индекса: " << subscript << std::endl;
        exit(1); // завершить работу программы, неправильный индекс
    }
    return ptr[subscript]; // возврат ссылки на элемент массива
}
 
Array Array::operator+ (const Array &right)
{
    if (size != right.size)
    {
        cout << "Массивы разного размера!\n";
        exit(1); // завершить работу программы
    }
 
    Array result(size);
    for (int ix = 0; ix < size; ix++)
        result.ptr[ix] = ptr[ix] + right.ptr[ix];
 
    return result; // вернуть сумму
}
 
 Array &Array::operator+= (const int &number) // оператор добавления элемента в конец массива
{
    Array result(size);
    result = *this; // временно сохраним текущий массив
 
    delete [] ptr; // освобождаем память
 
    size = size + 1; // увеличиваем размер массива на 1
    ptr = new int [size]; // выделяем память
 
    for (int ix = 0; ix < (size - 1); ix++)
        ptr[ix] = result.ptr[ix]; // скопировать массив
 
    ptr[size - 1] = number; // добавляем число в конец массива
 
    return *this; // каскадный вызов перегруженного оператора
}
 
 Array &Array::operator- (const int & key) // оператор удаления элемента по ключу
 {
     int counterKey = 0; // счетчик найденных ключевых элементов
     // определяем количество элементов, которые необходимо удалить
     for (int ix = 0; ix < size; ix++)
     {
         if (ptr[ix] == key)
             counterKey++;
     }
 
     Array temp(size);
     temp = *this; // сохраняем текущий массив во временный объект
 
     delete [] ptr; // jосвобождае память
     size = size - counterKey; // переопределяем размер
 
     ptr = new int [size];
     int counter = 0, ix = 0;
     while (counter < size)
     {
         if (temp[counter] != key)
         {
             ptr[ix] = temp.ptr[counter]; // скопировать массив
             ix++;
         }
         counter++;
     }
 
     return *this;
 }
 
 int Array::search(const int key) const // поиск по ключу
 {
     for (int ix = 0; ix < size; ix++)
         if ( key == ptr[ix] ) // поиск по ключу
             return (ix + 1);             // позиция искомого элемента
 
     return -1;
 }
 
 void Array::choicesSort() // сортировка выбором
 {
     for (int repeat_counter = 0; repeat_counter < size; repeat_counter++)
     {
         int temp = ptr[0]; // временная переменная для хранения значения перестановки
         for (int element_counter = repeat_counter + 1; element_counter < size; element_counter++)
         {
             if (ptr[repeat_counter] > ptr[element_counter])
             {
                 temp = ptr[repeat_counter];
                 ptr[repeat_counter] = ptr[element_counter];
                 ptr[element_counter] = temp;
             }
         }
     }
 }

Файл с функцией main(). В этом файле я постарался протестировать все возможности класса.

#include <iostream>
using namespace std;
#include "array.h"
 
int main()
{
 
    Array myArray1;     // 10-ти элементный объект класса Array, по умолчанию
    Array myArray2(15); // 15-ти элементный объект класса Array
 
    cout << "Размер массива myArray1: " << myArray1.getSize() << endl;
    cout << "Элементы массива myArray1, после его создания:\n";
    myArray1.getArray(); // вывод элементов массива с помощью метода класса Array
 
    cout << "Размер массива myArray2: " << myArray2.getSize() << endl;
    cout << "Элементы массива myArray2, после его создания:\n";
    cout << myArray2; // вывод элементов массива с помощью перегруженного оператора вывода
 
    cout << "Введите 10 чисел: ";
    myArray1.setArray(); // заполнение массива с помощью метода класса Array
 
    // введенный массив
    cout << "Введенный массив: " << myArray1;
 
    cout << "Введите 15 чисел: ";
    cin >> myArray2; // заполнение массива с помощью перегруженного оператора ввода
 
    // введенный массив
    cout << "Введенный массив: " << myArray2;
 
    Array myArray3(myArray1);  // создаем объект класса Array, используя конструктор копирования
 
    cout << "Размер массива myArray3: " << myArray1.getSize() << endl;
    cout << myArray3; // вывод элементов массива
 
    myArray3 = myArray2; // присваиваем массиву myArray3 массив myArray2
    cout << myArray3; // вывод элементов массива myArray3
 
    if (myArray1 == myArray2)
        cout << "Массивы myArray1 и myArray2 равны!\n";
    else
        cout << "Массивы myArray1 и myArray2 не равны!\n";
 
    // вывод элемента массива, используя перегруженную операцию взятия индекса
    cout << "Элемент массива myArray1: " << myArray1[myArray1.getSize() -1] << endl;
 
    Array myArray4 = myArray2 + myArray3; // перегруженная операция сложения
 
    cout << "Массив myArray4:\n" << myArray4;
 
    myArray4 += 111; // добавление элемента 111 в конец массива
    cout << "Массив myArray4 + 8:\n" << ((myArray4 += 112) += 113);
 
    // удаляем элементы массива myArray4: 111 112 113 посредством перегруженной операции минус
    cout << (myArray4 - 111 - 112 - 113);
 
    int pos = 0;
    if ((pos = myArray4.search(30)) != -1)
        cout << "Позиция искомого элемента: " << pos << endl;
    else
        cout << "Искомый элемент не найден!\n";
 
    myArray4.choicesSort(); // сортировка по возрастанию
    cout << myArray4;
 
    return 0;
}

Добавлено: 19 Июня 2015 18:23:50 Добавил: Андрей Ковальчук Нравится 0

Добавить