Класс Массив, описывающий одномерный массив

Уровень сложности:

Задание
Решение

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

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

CppStudio.com

    Размер массива myArray1: 10
Элементы массива myArray1, после его создания:
    0    0    0    0    0    0    0    0    0    0
Размер массива myArray2: 15
Элементы массива myArray2, после его создания:
    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0
Введите 10 чисел: 1 9 2 8 3 7 4 6 5 0
Введенный массив:     1    9    2    8    3    7    4    6    5    0
Введите 15 чисел: -2 -3 4 1 -5 0 0 9 12 34 5 16 17 11 22
Введенный массив:    -2   -3    4    1   -5    0    0    9   12   34    5   16   17   11   22
Размер массива myArray3: 10
    1    9    2    8    3    7    4    6    5    0
   -2   -3    4    1   -5    0    0    9   12   34    5   16   17   11   22
Массивы myArray1 и myArray2 не равны!
Элемент массива myArray1: 0
Массив myArray4:
   -4   -6    8    2  -10    0    0   18   24   68   10   32   34   22   44
Массив myArray4 + 8:
   -4   -6    8    2  -10    0    0   18   24   68   10   32   34   22   44  111  112  113
   -4   -6    8    2  -10    0    0   18   24   68   10   32   34   22   44
Искомый элемент не найден!
  -10   -6   -4    0    0    2    8   10   18   22   24   32   34   44   68

Заголовочный файл 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;
}

Следующие статьи помогут вам в решении данной задачи:

Классы в С++

Обсудить на форуме

Автор: Marienko L.

Дата: 14.11.2012

Виктор Столяров
23.11.2015
Кто может помочь? a3 = a1 + a2;
+ работает, после присвоения вызывается деструктор (для удаления врем массива) и программа зависает

http://vk.com/doc47557752_437053518?hash=103767f02d34e326a4&dl=163b88f8fc8a66ef4f
http://vk.com/doc47557752_437053519?hash=65b023ab9aa9301675&dl=d110c01b40d335e8f7
http://vk.com/doc47557752_437053520?hash=47ebcf73ee722a96cb&dl=fc5523bc8218bf34fe
http://vk.com/doc47557752_437053521?hash=0bbb72593e37945e49&dl=fcffff381daa21be90
http://vk.com/doc47557752_437053522?hash=11a852a93106c90060&dl=182140cf3c8846e207
Войдите, чтобы ответить

Arthur

10.08.2015

#include<iostream>
#include<cstdlib>
#include<iomanip>
#include"massiv.h"
using namespace std;

const int MAX = 20; //максимальная длина массива

int main()
{
    setlocale(LC_CTYPE,"rus");
    cin.unsetf(ios::skipws); //не игнорировать разделители

    int sz;                  //размер массива
    while(true)
    {
      cout<<"\nВведите размер массива(1-20): "; cin>>sz;
      if(cin.good() && (sz<1 || sz>MAX))
      {
          cout<<"\nНедопустимый размер массива.\n";
          cin.sync();
          continue;
      }

      if(cin.good())
      {
          cin.sync();
          break;
      }
      cout<<"\nНеправильный ввод данных"<<endl;
      cin.clear();
      cin.sync();
    }

    Massiv massiv1(sz);  //создание массива с использованием консруктора

    cout<<"Введите элементы массива:\n";
    massiv1.setMass();   //установка значений массива

    cout<<"\nМассив 1:\n\n";
    massiv1.getMass();   //показать массив

    char menu;
    Massiv rezult;
   while(true)
    {
    cin.sync();
    cout<<"\n\nВыберите действие:"
        <<"\n1 - суммирование массивов"// присвоение
        <<"\n2 - добавить элемент в конец массива"
        <<"\n3 - удалить элемент по ключу"
        <<"\n4 - найти элемент по ключу"
        <<"\n5 - сравнить по элементам"
        <<"\n6 - взять элемент с заданным индексом"
        <<"\n7 - рассортировать элементы массива по возрастанию"
        <<"\n0 - Выход"
        <<"\n>> ";
        cin>>menu;
        cin.sync();
     switch(menu)
     {
     case '1':
        {
            Massiv massiv2;
            massiv2.setSize(massiv1.getSize());  //использование set - метода
            cout<<"\nВведите элементы второго массива:"<<endl;
            cin>>massiv2;                       //используется перегруженная операция >>
            rezult = massiv1 + massiv2;
            cout<<"Результат сложения масссивов:"<<endl;
            cout<<rezult;
          break;
        }
     case '2':
        {
            if(massiv1.getSize()>=MAX)
            {
                cout<<"\nПревышен допустимый размер массива";
                break;
            }
            int numb;
            while(true)
            {
             cout<<"Введите число: "; cin>>numb;
             if(cin.good())
                break;
             cout<<"\nНедопустимый ввод\n";
             cin.clear();
             cin.sync();
            }
            cout<<"Массив с добавлением элемента \'"<<numb<<"\' :\n"<<endl;
            cout<< (massiv1 += numb);
            break;
        }
     case '3':
        {
            int numb;
            while(true)
            {
              cout<<"Введите число которое хотите удалить из массива: "; cin>>numb;
              if(cin.good())
                    break;
             cout<<"\nНедопустимый ввод\n";
             cin.clear();
             cin.sync();
            }
            cout<<"Массив без элемента "<<numb<<" :"<<endl;
               cout<<(massiv1 - numb);
           break;
        }
     case '4':
        {
            int numb;
            while(true)
            {
             cout<<"Веведите число, позицию которого хотите получить: ";
             cin>>numb;
              if(cin.good())
                break;
             cout<<"\nНедопустимый ввод\n";
             cin.clear();
             cin.sync();
            }

            int position = massiv1.positionElenent(numb);
            if(position != -1)
                cout<<"Позиция искомого элемента: "<<position + 1<<endl;
            else
                cout<<"Нет такого числа в массиве"<<endl;
            break;
        }
     case '5':
        {
            Massiv massiv2(massiv1.getSize());
            cout<<"\nВведите элементы второго массива:"<<endl;
            cin>>massiv2;
            if(massiv1 == massiv2)
                cout<<"Массивы равны";
            else
                cout<<"Массивы не равны";
            break;
        }
     case '6':
        {
            int i;
            while(true)
            {
             cout<<"Введите индекс массива( 0 - "<<massiv1.getSize()-1<<" ): ";  cin>>i;
             if(cin.good() && (i>=0 && i<massiv1.getSize()))
                break;
             cout<<"\nНедопустимый ввод\n";
             cin.clear();
             cin.sync();
            }

            cout<<"["<<i<<"] = "<<massiv1[i];
            break;
        }
     case '7':
        {
            massiv1.sortmass();
            cout<<massiv1;
            break;
        }
     case '0':
        {
          return 0;
        }
     default: cout<<"Недопустимый ввод!";
     }
    }

return 0;
}

Arthur

10.08.2015

#include "massiv.h"
#include<iostream>
#include<cstdlib>
#include<iomanip>
using namespace std;

    Massiv::Massiv() //конструктор без параметров
    {
    mass_size = 0;
    mass = NULL;
    }
//---------------------------------------------------------------------
    Massiv::Massiv(int s) //конструктор с одним параметром
    {
    mass_size = s;
    mass = new int[mass_size];
    for(int x = 0; x<mass_size; x++)
        mass[x] = 0;
    }
//---------------------------------------------------------------------
    Massiv::Massiv(Massiv& cop) //конструктор копии
    {
        mass = cop.mass;
        mass_size = cop.mass_size;
    }
//----------------------------------------------------------------------
    Massiv::~Massiv() //деструктор
    {
      delete []mass; //освобождение памяти
    }
//----------------------------------------------------------------------
    void Massiv:: setSize(int s)  //создание массива
    {
      mass_size = s;
      mass = new int[mass_size];
      for(int x = 0; x<mass_size; x++)
        mass[x] = 0;
    }
//----------------------------------------------------------------------
    void Massiv::setMass() //ввод элементов  массива пользователем
    {
     for(int x = 0; x<mass_size; x++)
     {
        cin>>mass[x];
        if(cin.good())
           cin.sync();
        else
          {
           cout<<"\nНеверный ввод\n\n";
           cin.clear();
           cin.sync();
           x--;
          }
     }
    }
//---------------------------------------------------------------
    void Massiv::getMass()   //вывод массива
    {
        for(int x = 0; x<mass_size; x++)
          cout<<setw(4)<<mass[x];
    }
//-----------------------------------------------------------------------
   int Massiv::getSize()   //вернуть размер массива
   {
       return mass_size;
   }
//------------------------------------------------------------------------
    Massiv& Massiv::operator=(const Massiv& ms) //перегрузка оператора присваивания
    {
        if(this == &ms)                 //если самоприсваивание
            return *this;
        if(mass)                        //удаляем предыдущий массив
          delete[]mass;

        mass = ms.mass;
        mass_size = ms.mass_size;
        return *this;
    }
//-----------------------------------------------------------------------
     Massiv Massiv::operator+(Massiv& ms) //перегрузка оператора +
    {
       if(mass_size == ms.mass_size)      //проверка размеров слагаемых массивов
       {
         Massiv rezult(mass_size);
         for(int x = 0; x<mass_size; x++ )
         rezult.mass[x] = mass[x] + ms.mass[x];
         return rezult;
       }
       else
       cout<<"\nМатрицы имеют разные размеры!\n";
       exit(1);
   }
//---------------------------------------------------------------------------
    Massiv& Massiv::operator+=(int i)//перегрузка оператора+=
    {
      Massiv temp(*this);    //создание временного массива

      delete []mass;

      mass_size = temp.mass_size+1;
      mass = new int[mass_size];

     for(int x = 0; x<mass_size-1; x++)
        mass[x] = temp.mass[x];
     mass[mass_size-1] = i;
      return *this;
    }
//---------------------------------------------------------------------------------------------
    Massiv& Massiv::operator-(int n)//перегрузка оператора-
    {
     int many_n = 0;

     for(int x = 0; x<mass_size; x++)
        if(mass[x] == n)
            many_n++;

     Massiv temp(*this);

     delete[]mass;

     mass_size = temp.mass_size - many_n;
     mass = new int[mass_size];

     for(int x = 0,y = 0; y<temp.mass_size; y++)
         if(temp.mass[y] != n)
           {
              mass[x] = temp.mass[y];
              x++;
           }

     return *this;
    }
//---------------------------------------------------------------------------------
    bool Massiv::operator==(const Massiv& m) const  //перегрузка оператора==
    {
        if(mass_size!=m.mass_size)         //если размеры массивов разные
            return false;
        for(int x = 0; x<mass_size; x++) //если элементы массивов не равны
            if(mass[x] != m.mass[x])
              return false;
        return true;
    }
//----------------------------------------------------------------------------------
     int& Massiv::operator[]( int i) const//перегрузка оператора[]
    {
     if(i<0 || i>=mass_size)
         exit(1);
     return mass[i];
    }
//---------------------------------------------------------------------------------
    int Massiv::positionElenent(int n) const   //поиск элемента по ключу
    {
       for(int x = 0; x<mass_size; x++)
         if(mass[x] == n)
           return x;
       return -1;
    }
//------------------------------------------------------------------------------------
    void Massiv::sortmass()  //сортировка массива вставкой по возрастанию
    {
    int temp, i;

    for(int x = 1; x<mass_size; x++)
      {
       temp = mass[x];
       for( i = x; temp < mass[i-1] && i!=0; i--)
            mass[i] = mass[i -1];

       mass[i] = temp;
      }
    }

///////////////////////////////////////////////////////////////////
ostream& operator<<(ostream& s, Massiv& ms) //перегрузка оператора <<
{
    for(int x = 0; x<ms.mass_size; x++)
        s<<setw(4)<<ms.mass[x];

    return s;
}
//-------------------------------------------------------------
istream& operator>>(istream& s, Massiv& ms) //перегрузка оератора >>
{
  for(int x = 0; x<ms.mass_size; x++)
  {
     s>>ms.mass[x];
        if(cin.good())
           cin.sync();
        else
          {
           cout<<"\nНеверный ввод\n\n";
           cin.clear();
           cin.sync();
           x--;
          }
  }
  return s;
}

Arthur

10.08.2015

#ifndef MASSIV_H
#define MASSIV_H

#include<iostream>
using namespace std;

class Massiv
{
private:
    int *mass;
    int mass_size;
public:
    Massiv();                             //конструктор без параметров
    Massiv(int );                         //конструктор с одним параметром
    Massiv(Massiv& );                     //конструктор копии
    ~Massiv();                            //деструктор
    void setSize(int );                   //создание массива
    void setMass();                       //установка массива пользователем
    void getMass() ;
    int  getSize() ;                                  //вернуть размер массива
    Massiv& operator=(const Massiv& );                //перегрузка оператора =
    Massiv operator+(Massiv& );                       //перегрузка оператора +
    Massiv& operator+=(int );                         //перегрузка оператора+=
    Massiv& operator-(int );                          //перегрузка оператора-
    bool operator==(const Massiv& ) const;            //перегрузка оператора==
    int& operator[](int ) const;                      //перегрузка оператора[]
    int positionElenent(int )  const;                 //поиск элемента по ключу
    void sortmass() ;                                 //сортировка массива вставкой по возрастанию
    friend ostream& operator<<(ostream& , Massiv& );
    friend istream& operator>>(istream& , Massiv& );
};

#endif // MASSIV_H

Arthur

03.05.2015

Без перегрузки операторов >> <<

#include<iostream>
using namespace std;

class Massiv
{
private:
    int *mass;
    int SZ;
public:
    Massiv() //конструктор без параметров
    {
       SZ = 1;
    mass = new int[SZ];
    for(int x = 0; x<SZ; x++)
        mass[x] = 0;
    }
    Massiv(int s) //конструктор с одним параметром
    {
       SZ = s;
    mass = new int[SZ];
    for(int x = 0; x<SZ; x++)
        mass[x] = 0;
    }
    ~Massiv() //деструктор
    {
        delete []mass; //освобождение памяти
    }
    int getsize() //возвращение размера массива
    {
        return SZ;
    }

    void getmass() //показать массив
    {
    for(int x = 0; x<SZ; x++)
        cout<<mass[x]<<"  ";
    }

    void setmass() //ввод пользователем элементов массива
    {
    cout<<"\n\nВведите "<<SZ<<" чисел через пробел :";
        for(int x = 0; x<SZ; x++)
            cin>>mass[x];
    }
    Massiv operator+(Massiv ms) //перегрузка оператора +
    {
       int maxSZ = (SZ>ms.SZ?SZ:ms.SZ);
       Massiv temp(maxSZ);
       for(int x = 0; x<maxSZ; x++ )
       temp.mass[x] = mass[x] + ms.mass[x];
      return temp;
    }

    void operator+=(int i)//перегрузка оператора+=
    {
      mass[SZ] = i; SZ++;
    }

    Massiv operator-(int n)//перегрузка оператора-
    {
        for(int i = 0; i<SZ; i++) //удаление элемента из массива
            if(mass[i] == n)
        {
            Massiv temp(SZ-1);//создание временного массива
        int x = 0;
        for( x; mass[x] != n; x++) //копируем во временный массив элементы из исходного массива
            temp.mass[x] = mass[x]; //до элемента равного n
        for(x; x<SZ; x++)           //копируем элементы во временный массив кроме элемента равного n
            temp.mass[x] = mass[x+1];
        return temp;
        }
         Massiv temp(0);
        cout<<"Нет такого элемента в массиве"<<endl;
        return temp;

    }

    bool operator==(Massiv m) //перегрузка оператора==
    {
        if(SZ!=m.SZ)         //если размеры массивов разные
            return false;
        for(int x = 0; x<SZ; x++) //если элементы массивов не равны
            if(mass[x] != m.mass[x])
              return false;
        return true;
    }

    int& operator[](int i) //перегрузка оператора[]
    {
        if(i<0||i>SZ) //если индекс выходит за пределы размера массива
            cout<<"Ошибочный индекс!"<<endl;
        return mass[i];
    }

    void sortmass() //сортировка массива по возрастанию
    {
     int temp; int x; // переменные для хранения мин-ного значения и индекса массива
     for(int i = 0; i<SZ; i++)
      {
       temp = mass[i]; //инициализируем врем. переменную
       for(x = i; x<SZ; x++)
          if(temp>mass[x])//находим минимальный элемент
            {
             temp = mass[x]; //делаем перестановку
             mass[x] = mass[i];
             mass[i] = temp;
            }
      }
   }
};
///////////////////////////////////////////////
int main()
{
    setlocale(LC_CTYPE,"rus");
    int sz;
    cout<<"Введите размер массива1: "; cin>>sz;
    Massiv massiv1(sz);
    cout<<"Введите размер массива2: "; cin>>sz;
    Massiv massiv2(sz);

    cout<<"\nЭлементы массива 1 после создания:"<<endl;
    massiv1.getmass();
    cout<<"\nЭлементы массива 2 после создания:"<<endl;
    massiv2.getmass();

    massiv1.setmass();
    cout<<"\nМассив 1:"<<endl;
    massiv1.getmass();

    massiv2.setmass();
    cout<<"\nМассив 2:"<<endl;
    massiv2.getmass();

    int menu; bool ex = 1;
   while(ex)
    {
       cout<<"\n\nВыберите действие:"
        <<"\n1 - сложить элементы массивов"// присвоение
        <<"\n2 - добавить элемент в конец массива"
        <<"\n3 - удалить элемент по ключу"
        <<"\n4 - сравнить по элементам"
        <<"\n5 - взять элемент с заданным индексом"
        <<"\n6 - рассортировать элементы массивов по возрастанию"
        <<"\n0 - Выход"
        <<"\n>> ";
        cin>>menu;
     switch(menu)
     {
     case 1:
        {
         if(massiv1.getsize() == massiv2.getsize() )
            {
            Massiv massiv3(sz);
            massiv3 = massiv1 + massiv2;
            cout<<"Результат сложения масссивов:"<<endl;
            massiv3.getmass();
            }
          else
             cout<<"Массивы не равны по размеру!";
          break;
        }
     case 2:
        {
            int numb;
            cout<<"Введите число: "; cin>>numb;
            massiv1 += numb;
            cout<<"Массив с добавлением элемента "<<numb<<" :"<<endl;
            massiv1.getmass();
            break;
        }
     case 3:
        {
            int numb;
            cout<<"Введите число которое хотите удалить из массива: "; cin>>numb;
            Massiv massiv3(sz);
            massiv3 = massiv1 - numb;
            if(massiv3.getsize()!=0)
            {
               cout<<"Массив без элемента "<<numb<<" :"<<endl;
               massiv3.getmass();
            }
           break;
        }
     case 4:
        {
            if(massiv1 == massiv2)
                cout<<"Массивы равны";
            else
                cout<<"Массивы не равны";
            break;
        }
     case 5:
        {
            int i;
            cout<<"Введите индекс массива: ";  cin>>i;
            if(i>0 && i<massiv1.getsize())
            cout<<"Элемент массива1 с индексом "<<i<<" равен: "<<massiv1[i];
            else
            cout<<"Ошибочный индекс!"<<endl;
            break;
        }
     case 6:
        {
            massiv1.sortmass();
            massiv1.getmass();
            break;
        }
     case 0:
        {
            ex=0; break;
        }
     default: cout<<"Недопустимый ввод!";
     }
    }

return 0;
}

Оставить комментарий

Вы должны войти, чтобы оставить комментарий.

Комментарии

Виктор Столяров

Arthur

Arthur

Arthur

Arthur

Оставить комментарий