Class16-2

#include <iostream>
#include <cstdlib>
#include <cstring>
#include <climits>

// Класс Вектор, хранит элементы типа int
class Vector {
private:
    unsigned m_size; // размер вектора
    int* m_start;    // указатель на начало

public:
    // Конструктор по-умолчанию, задает размер=0 и m_start равным нулевому указателю
    Vector(): m_size(0), m_start(nullptr) {}

    // Конструктор из массива. Принимает указатель на массив и его размер
    Vector(int* array, unsigned size) {
        // Задаем размер
        m_size = size;

        // Выделяем память
        m_start = new int[m_size];

        // Копируем элементы из массива
        for (int i = 0; i < m_size; ++i)
            m_start[i] = array[i];
    }

    // Перегрузка оператора присваивания
    Vector& operator= (const Vector& vec) {
        // Копируем размер вектора
        m_size = vec.m_size;

        // Выделяем память под элементы вектора
        int* new_start = new int[m_size];

        // Копируем элементы в новую память
        for (int i = 0; i < m_size; ++i)
            new_start[i] = vec.m_start[i];

        // Освобождаем старую память под элементы
        delete [] m_start;
        m_start = new_start; // Присваиваем переменной m_start значение нового указателя на элементы

        return *this;
    }

    // Деструктор
    ~Vector() {
        // Освобождаем память
        delete [] m_start;
    }

    // Метод для добавления значения в вектор. Принимает значение и его кол-во (для задания важно именно кол-во значений)
    // По-умолчанию добавляет одно значение
    void add(int value, unsigned count = 1) {
        unsigned new_size = m_size + count; // находим новый размер вектора

        int* new_start = new int[count]; // Выделяем новую память под элементы вектора

        // Если m_start не нулевой указатель - копируем из него все значения в новую память
        if (m_start) {
            for (int i = 0; i < m_size; ++i)
                new_start[i] = m_start[i];
        }

        // Добавляем значение в конец столько раз, сколько задано в переменной count
        for (int i = m_size; i < new_size; ++i)
            new_start[i] = value;

        // Освобождаем память от старых элементов вектора, перезаписываем переменные
        delete [] m_start;
        m_start = new_start;
        m_size = new_size;
    }

    // Метод для удаления элементов вектора с конца. Принимает кол-во элементов, которые надо удалить
    void erase(unsigned count) {
        // Если хотим удалить больше чем есть - устанавливаем размер в 0
        if (m_size < count)
            m_size = 0;
        else
            // Если нет - уменьшаем на кол-во элементов, которые надо удалить
            m_size -= count;
    }

    // Метод возвращает кол-во элементов в векторе
    unsigned getSize() {
        return m_size;
    }

    // Метод возвращает наибольшее значения элемента в векторе. Если вектор пуст, то возвратит самый маленький int
    int findMax() {
        int max = INT_MIN; // Инициализируем переменную max значением самого маленького int

        // Находим в цикле наибольшее значение в векторе
        for (int i = 0; i < m_size; ++i) {
            if(max < m_start[i])
                max = m_start[i];
        }

        // Возвращаем его
        return max;
    }

    void print() {
        for (int i = 0; i < m_size; ++i)
            std::cout << m_start[i] << "  ";
        std::cout << std::endl;
    }
};

// Функция генерирует вектор случайного размера (от 10 до 30) со случайными элементами (от 1 до 1001)
Vector generateRandomVector() {
    unsigned size = rand() % 20 + 10; // Генерируем случайный размер

    int* a = new int[size]; // Выделяем память под массив этого размера

    // Заполняем массив случайными значениями
    for (int i = 0; i < size; ++i)
        a[i] = rand() % 1000 + 1;

    // Инициализируем вектор массивом
    Vector result(a, size);

    delete [] a; // Освобождаем память массива

    return result; // Возвращаем вектор
}

int main() {
    setlocale(LC_CTYPE, "rus");

    srand(clock()); // Инициализируем рандом текущим временем (чтобы при каждом запуске программа работала по-разному)

    unsigned size = rand() % 20 + 10; // Генерируем случайный размер массива векторов (от 10 до 30)
    Vector* vectors = new Vector[size]; // Выделяем память под массив векторов

    // Генерируем случайные вектора в цикле
    for (int i = 0; i < size; ++i)
        vectors[i] = generateRandomVector();

    // Выводим на экран
    std::cout << "Сгенерированные вектора: " << std::endl;
    for (int i = 0; i < size; ++i)
        vectors[i].print();

    // Находим самое большое значение из всех векторов
    int max = INT_MIN;
    for (int i = 0; i < size; ++i) {
        int imax = vectors[i].findMax();

        if (imax > max)
            max = imax;
    }
    std::cout << "Наибольшее значение: " << max << std::endl;

    // Находим самый длинный вектор
    int maxlen = vectors[0].getSize();
    int maxlen_index = 0;

    for (int i = 1; i < size; ++i) {
        int len = vectors[i].getSize();
        if (len > maxlen) {
            maxlen = len;
            maxlen_index = i;
        }
    }
    std::cout << "\nСамый длинный вектор (" << maxlen << " элементов): " << std::endl;
    vectors[maxlen_index].print();
    std::cout << std::endl;


    // Выводим первые 3 вектора
    std::cout << "Первые 3 вектора: " << std::endl;
    vectors[0].print();
    vectors[1].print();
    vectors[2].print();

    // Укорачиваем 2 вектора, удлиняем 1
    vectors[0].erase(10);
    vectors[1].erase(5);
    vectors[2].add(228, 10);

    // Выводим первые 3 вектора
    std::cout << "Первые 3 вектора (сокращаем первый и второй, удлиняем третий)" << std::endl;
    vectors[0].print();
    vectors[1].print();
    vectors[2].print();

    return 0;
}