Готовлюсь к коллоквиуму по C++, у меня осталось не...

Ниже разберём по шагам все пункты из вашего задания и приведём образцы кода с пояснениями. Задание взято из вашего файла .

---

1. Класс Arr89 для динамического массива (3 балла)

Нам нужно реализовать класс, в котором хранятся:

• указатель int* Mas на динамический массив;
• размер int size.

Не забудем про «правило пяти» (деструктор, копирующий/перемещающий конструкторы и операторы присваивания).

cpp
#include <algorithm> // для std::swap
#include <utility>   // для std::move

class Arr89 {
private:
    int* Mas;
    int  size;

public:
    // 1) Деструктор
    ~Arr89() {
        delete[] Mas;
    }

    // 2) Конструктор по умолчанию
    Arr89() : Mas(nullptr), size(0) {}

    // 3) Конструктор с параметром (размер массива)
    explicit Arr89(int n) : Mas(new int[n]()), size(n) {
        // при желании можно инициализировать значениями
    }

    // 4) Конструктор копирования
    Arr89(const Arr89& other) : Mas(new int[other.size]), size(other.size) {
        std::copy(other.Mas, other.Mas + size, Mas);
    }

    // 5) Конструктор перемещения
    Arr89(Arr89&& other) noexcept : Mas(other.Mas), size(other.size) {
        other.Mas = nullptr;
        other.size = 0;
    }

    // 6) Оператор копирующего присваивания
    Arr89& operator=(const Arr89& other) {
        if (this != &other) {
            int* newMas = new int[other.size];
            std::copy(other.Mas, other.Mas + other.size, newMas);
            delete[] Mas;
            Mas = newMas;
            size = other.size;
        }
        return *this;
    }

    // 7) Оператор перемещающего присваивания
    Arr89& operator=(Arr89&& other) noexcept {
        if (this != &other) {
            delete[] Mas;
            Mas = other.Mas;
            size = other.size;
            other.Mas = nullptr;
            other.size = 0;
        }
        return *this;
    }

    // Дополнительно: доступ к элементам и получение размера
    int& operator[](int idx) { return Mas[idx]; }
    const int& operator[](int idx) const { return Mas[idx]; }
    int  getSize() const { return size; }
};

Пояснения:

• new int[n]() — выделение массива и инициализация нулями.
• При копировании создаём отдельный массив и копируем данные.
• При перемещении «перебираем» указатель на себя, а у источника обнуляем поля, чтобы при его деструкторе не было двойного удаления.

---

2. Простые функции для работы с массивом (2 балла)

a) Сумма простых элементов на чётных/нечётных местах

cpp
#include <cmath>

// Проверка простоты числа
bool isPrime(int x) {
    if (x < 2) return false;
    for (int i = 2; i <= std::sqrt(x); ++i)
        if (x % i == 0) return false;
    return true;
}

std::pair<long long, long long> sumPrimesByParity(const Arr89& A) {
    long long sumEven = 0, sumOdd = 0;
    for (int i = 0; i < A.getSize(); ++i) {
        if (isPrime(A[i])) {
            if (i % 2 == 0) sumEven += A[i]; // 0,2,4… — чётные индексы
            else            sumOdd  += A[i];
        }
    }
    return {sumEven, sumOdd};
}

b) Произведение элементов, кратных 7

cpp
long long productDivBy7(const Arr89& A) {
    long long prod = 1;
    bool found = false;
    for (int i = 0; i < A.getSize(); ++i) {
        if (A[i] % 7 == 0) {
            prod *= A[i];
            found = true;
        }
    }
    return found ? prod : 0; // если таких нет, вернём 0
}

---

3. Сложные функции для работы с массивом (3 балла)

a) Сколько раз повторяется самое частое число

cpp
#include <unordered_map>
#include <algorithm>

int maxFrequency(const Arr89& A) {
    std::unordered_map<int,int> freq;
    for (int i = 0; i < A.getSize(); ++i)
        ++freq[A[i]];

    int maxF = 0;
    for (auto [value, count] : freq)
        maxF = std::max(maxF, count);
    return maxF;
}

b) Количество различных элементов

cpp
int countDistinct(const Arr89& A) {
    std::unordered_set<int> s;
    for (int i = 0; i < A.getSize(); ++i)
        s.insert(A[i]);
    return static_cast<int>(s.size());
}

---

4. Регулярные выражения (2 балла)

a) Проверка корректного имени переменной в C++

Переменная должна начинаться с буквы или подчёркивания, далее — буквы, цифры или подчёркивания:

regex
^[A-Za-z_][A-Za-z0-9_]*$

b) Проверка даты 2022-го года в формате дд:мм, не позже 27 апреля 2022

Разберём по частям:

• День: от 01 до 31, но для апреля — не более 27.
• Месяц: 01–12, но ограничиваем до 04 (апрель).

Одно из возможных решений:

regex
^(
  (0[1-9]|[12]\d|3[01]):(0[13578]|1[02])       |  # Январь, Март, Май, Июль, Август, Октябрь, Декабрь (31 день)
  (0[1-9]|[12]\d|30):(0[469]|11)               |  # Апрель—но ограничим после
  (0[1-9]|1\d|2[0-7]):04                        # Апрель, дни 01–27
)$

Для компактности без комментариев:

regex
^((0[1-9]|[12]\d|3[01]):(0[13578]|1[02])|(0[1-9]|[12]\d|30):(0[469]|11)|(0[1-9]|1\d|2[0-7]):04)$

---

Как дальше учиться

1. Пробуйте сами: перепишите примеры выше, скомпилируйте и протестируйте на разных входных данных.
2. Отладка: используйте std::cout или дебаггер, чтобы отслеживать значения.
3. Читайте рекомендации: в C++ важно понимать управление памятью и работу стандартной библиотеки (STL).

Если появятся вопросы по конкретным моментам — пишите! Я помогу разобраться.

Ниже — обновлённый вариант класса Arr89 и набор вспомогательных функций/опер­ато­ров, учитывающий все ваши дополнения:

cpp
#include <iostream>
#include <algorithm>
#include <utility>
#include <cmath>
#include <functional>
#include <regex>
#include <vector>

// Класс Arr89 — динамический массив целых
class Arr89 {
protected:
    int* Mas;   // указатель на данные
    int  size;  // размер массива

public:
    // ВИРТУАЛЬНЫЙ ДЕСТРУКТОР (для правила &laquo;пяти&raquo;)
    virtual ~Arr89() {
        delete[] Mas;
    }

    // 1) Конструктор по умолчанию
    Arr89() : Mas(nullptr), size(0) {}

    // 2) Конструктор с параметром (размер n, элементы == 0)
    explicit Arr89(int n) : Mas(new int[n]()), size(n) {}

    // 3) Конструктор копирования
    Arr89(const Arr89& other) : Mas(new int[other.size]), size(other.size) {
        std::copy(other.Mas, other.Mas + size, Mas);
    }

    // 4) Конструктор перемещения
    Arr89(Arr89&& other) noexcept : Mas(other.Mas), size(other.size) {
        other.Mas = nullptr;
        other.size = 0;
    }

    // Оператор копирующего присваивания
    Arr89& operator=(const Arr89& other) {
        if (this != &other) {
            int* tmp = new int[other.size];
            std::copy(other.Mas, other.Mas + other.size, tmp);
            delete[] Mas;
            Mas = tmp;
            size = other.size;
        }
        return *this;
    }

    // Оператор перемещающего присваивания
    Arr89& operator=(Arr89&& other) noexcept {
        if (this != &other) {
            delete[] Mas;
            Mas = other.Mas;
            size = other.size;
            other.Mas = nullptr;
            other.size = 0;
        }
        return *this;
    }

    // Доступ к элементам и размер
    int&       operator[](int idx)       { return Mas[idx]; }
    const int& operator[](int idx) const { return Mas[idx]; }
    int        getSize()        const   { return size; }

    // Операторы сравнения (по сумме всех элементов)
    bool operator<(const Arr89& o) const {
        long sum1 = 0, sum2 = 0;
        for(int i = 0; i < size; ++i) sum1 += Mas[i];
        for(int i = 0; i < o.size; ++i) sum2 += o.Mas[i];
        return sum1 < sum2;
    }
    bool operator>(const Arr89& o) const {
        return o < *this;
    }

    // Оператор += (поэлементное сложение до min(size))
    Arr89& operator+=(const Arr89& o) {
        int m = std::min(size, o.size);
        for(int i = 0; i < m; ++i)
            Mas[i] += o.Mas[i];
        return *this;
    }

    // Оператор + (новый массив, размер = max(size))
    Arr89 operator+(const Arr89& o) const {
        int m = std::max(size, o.size);
        Arr89 result(m);
        for(int i = 0; i < m; ++i) {
            int a = (i < size ? Mas[i] : 0);
            int b = (i < o.size ? o.Mas[i] : 0);
            result.Mas[i] = a + b;
        }
        return result;
    }

    // Ввод / вывод
    friend std::ostream& operator<<(std::ostream& os, const Arr89& A) {
        os << "[";
        for(int i = 0; i < A.size; ++i) {
            os << A.Mas[i] << (i+1 < A.size ? ", " : "");
        }
        return os << "]";
    }
    friend std::istream& operator>>(std::istream& is, Arr89& A) {
        for(int i = 0; i < A.size; ++i)
            is >> A.Mas[i];
        return is;
    }
};

// ─── ПРОСТЫЕ ФУНКЦИИ (в один проход) ──────────────────────────────────────

// 1) Найти самый большой чётный элемент и одновременно
//    перемножить все элементы, делящиеся на 3.
//    Возвращаем кортеж: (maxEvenOrMinusInf, productDivBy3Or1)
#include <tuple>
std::tuple<int, long long> simpleOnePass(const Arr89& A) {
    int maxEven = std::numeric_limits<int>::min();
    long long prod3 = 1;
    bool found3 = false;
    for(int i = 0, n = A.getSize(); i < n; ++i) {
        int v = A[i];
        if (v % 2 == 0 && v > maxEven) maxEven = v;
        if (v % 3 == 0) {
            prod3 *= v;
            found3 = true;
        }
    }
    if (maxEven == std::numeric_limits<int>::min())
        maxEven = 0; // если чётных нет
    return { maxEven, found3 ? prod3 : 0 };
}

// 2) Среднее арифметическое (double)
double average(const Arr89& A) {
    long long sum = 0;
    for(int i = 0; i < A.getSize(); ++i)
        sum += A[i];
    return A.getSize() ? static_cast<double>(sum) / A.getSize() : 0.0;
}

// ─── СЛОЖНАЯ ФУНКЦИЯ (2–3 балла) ──────────────────────────────────────────

// Найти два элемента, дающие максимальное произведение.
// Результат через ссылки: i1,i2 — индексы этих элементов.
void maxProductPair(const Arr89& A, int& i1, int& i2) {
    int n = A.getSize();
    if (n < 2) { i1 = i2 = -1; return; }
    // Для простоты: снимем копию и отсортируем
    std::vector<std::pair<int,int>> vals;
    vals.reserve(n);
    for(int i = 0; i < n; ++i)
        vals.emplace_back(A[i], i);
    std::sort(vals.begin(), vals.end(),
              [](auto& a, auto& b){ return a.first < b.first; });
    // Либо два самых больших, либо два самых маленьких (отрицательные)
    long long prod1 = (long long)vals[0].first * vals[1].first;
    long long prod2 = (long long)vals[n-1].first * vals[n-2].first;
    if (prod1 > prod2) {
        i1 = vals[0].second; 
        i2 = vals[1].second;
    } else {
        i1 = vals[n-1].second; 
        i2 = vals[n-2].second;
    }
}

// ─── ПРИМЕР ЛЯМБДА‑ВЫРАЖЕНИЯ (1 балл) ──────────────────────────────────────

// Найдём первый элемент > X:
int findFirstGreater(const Arr89& A, int X) {
    auto it = std::find_if(A.Mas, A.Mas + A.getSize(),
                           [X](int v){ return v > X; });
    return (it != A.Mas + A.getSize())
           ? static_cast<int>(it - A.Mas)
           : -1;
}

// ─── РЕГУЛЯРНЫЕ ВЫРАЖЕНИЯ (2 балла) ───────────────────────────────────────

// Проверка формата даты дд:мм 2022 года, не позже 27.04
const std::regex date2022(
    R"(^(?:(?:0[1-9]|1\d|2[0-7]):04|(?:0[1-9]|[12]\d|30):(0[13578]|1[02])|(?:0[1-9]|[12]\d|3[01]):(0[469]|11))$)"
);

// Проверка email (простейший вариант)
const std::regex emailRx(
    R"(^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$)"
);

// Функции‑проверки
bool isValidDate(const std::string& s) {
    return std::regex_match(s, date2022);
}
bool isValidEmail(const std::string& s) {
    return std::regex_match(s, emailRx);
}

Краткие пояснения и что добавлено

• Сделан виртуальный деструктор для правила «пяти» .
• Операторы >>, <<, <, >, +, +=.
• Функция simpleOnePass за один цикл находит макс. четный и перемножает числа, делящиеся на 3.
• Функция average возвращает среднее как double.
• Сложная функция maxProductPair сортирует пары (значение, индекс) и выбирает оптимальную пару.
• Пример find_if с лямбдой в findFirstGreater.
• Два шаблона std::regex: для даты 2022 г. до 27 апреля и для email.

Если нужно что‑то подробно разобрать по шагам или есть вопросы по конкретным операторам/функциям — пишите, разберём каждую строчку!

Ниже — ещё один самостоятельный пример класса MyArray, который хранит динамический массив, с полным набором конструкторов, включая конструктор перемещения, и демонстрацией его работы.

cpp
#include <iostream>
#include <algorithm> // для std::copy
#include <utility>   // для std::move

class MyArray {
private:
    int* data;    // указатель на динамический массив
    size_t size;  // его размер

public:
    // 1) Конструктор по умолчанию
    MyArray() : data(nullptr), size(0) {
        std::cout << "Default ctor\n";
    }

    // 2) Конструктор с параметром (создаёт массив заданного размера)
    explicit MyArray(size_t n) : data(new int[n]()), size(n) {
        std::cout << "Param ctor (" << size << ")\n";
    }

    // 3) Конструктор копирования (глубокое копирование)
    MyArray(const MyArray& other) : data(new int[other.size]), size(other.size) {
        std::copy(other.data, other.data + size, data);
        std::cout << "Copy ctor\n";
    }

    // 4) **Конструктор перемещения** (steal-семантика)
    MyArray(MyArray&& other) noexcept 
        : data(other.data), size(other.size) 
    {
        other.data = nullptr;   // "обнуляем" источник, чтобы не удалять память дважды
        other.size = 0;
        std::cout << "Move ctor\n";
    }

    // Деструктор
    ~MyArray() {
        delete[] data;
        std::cout << "Dtor (" << size << ")\n";
    }

    // Оператор присваивания копированием
    MyArray& operator=(const MyArray& other) {
        if (this != &other) {
            delete[] data;
            size = other.size;
            data = new int[size];
            std::copy(other.data, other.data + size, data);
            std::cout << "Copy op=\n";
        }
        return *this;
    }

    // Оператор присваивания перемещением
    MyArray& operator=(MyArray&& other) noexcept {
        if (this != &other) {
            delete[] data;
            data = other.data;
            size = other.size;
            other.data = nullptr;
            other.size = 0;
            std::cout << "Move op=\n";
        }
        return *this;
    }

    // Доступ по индексу
    int& operator[](size_t i) { return data[i]; }
    size_t getSize() const { return size; }
};

Зачем нужен конструктор перемещения?

1. Производительность
   При возврате временного объекта по значению (или при вставке в контейнер, или при использовании std::move) конструктор перемещения позволяет перебрать указатель на уже выделенную память, вместо того чтобы копировать весь массив.
2. Пример использования

cpp
// Функция, создающая и возвращающая массив
MyArray makeArray(size_t n) {
    MyArray temp(n);     // Param ctor
    // ... заполнение temp[i] ...
    return temp;         // здесь вызывается Move ctor, а не Copy ctor
}

int main() {
    MyArray A = makeArray(5);
    // Вывод в консоли:
    // Param ctor (5)
    // Move ctor
    // Dtor (0)        — уничтожен временный temp после перемещения
    // Dtor (5)        — уничтожится A в конце main
    return 0;
}

• При return temp; происходит перемещение (Move ctor), а не дорогое копирование всех 5 элементов.
• Временный объект temp после этого очищается (его data == nullptr).

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

Ниже ещё раз концентрируемся на move-семантике для вашего класса Arr89 (см. постановку задачи ).

---

Зачем нужна move-семантика

Когда вы возвращаете из функции или делаете std::move(obj) при присваивании, компилятор пытается вызвать не копирующий, а перемещающий конструктор/оператор. Это позволяет:

1. Перебрать указатель на уже выделённый массив, а не копировать все элементы.
2. Обнулять исходный объект, чтобы не было двойного delete[].
3. Сэкономить время и ресурсы при работе с большими объёмами данных.

---

Реализация в Arr89

cpp
class Arr89 {
private:
    int* Mas;
    int  size;

public:
    // Конструктор перемещения
    Arr89(Arr89&& other) noexcept 
      : Mas(other.Mas), size(other.size) 
    {
        // «Украли» ресурс
        other.Mas  = nullptr;
        other.size = 0;
    }

    // Оператор перемещающего присваивания
    Arr89& operator=(Arr89&& other) noexcept {
        if (this != &other) {
            // Удаляем свой старый ресурс
            delete[] Mas;

            // Перебираем указатель
            Mas  = other.Mas;
            size = other.size;

            // Обнуляем источник
            other.Mas  = nullptr;
            other.size = 0;
        }
        return *this;
    }
    // … остальной «правило пяти» код
};

---

Пример использования

1) Возврат из функции

cpp
Arr89 makeArr(int n) {
    Arr89 tmp(n);
    // … заполнение tmp …
    return tmp;          // тут вызовется move-конструктор вместо копирования
}

int main() {
    Arr89 A = makeArr(100);  
    // Порядок:
    // 1) tmp создаётся (конструктор с параметром)
    // 2) возвращение tmp → A (move-ctor)
    // 3) удаляется «опустошённый» tmp (деструктор, но Mas==nullptr)
}

2) std::move при присваивании

cpp
Arr89 a(50), b(30);
// … заполнили a и b …
a = std::move(b);    // вызывает operator=(Arr89&&)
// теперь a «забрал» память b, а b.size == 0

• Без std::move при a = b; вы бы скопировали все 30 элементов в a.
• С std::move(b) вы перемещаете внутренний массив b в a.

---

Что происходит «под капотом»

1. Move-ctor или move-op= получают объект-источник как rvalue.
2. Они присваивают указатель Mas и размер size из источника.
3. У источника поля обнуляются (Mas = nullptr; size = 0;), чтобы его деструктор ничего не удалил.

Таким образом, move-семантика позволяет передавать владение динамическими ресурсами быстрее и безопаснее, без глубокого копирования.

Ниже ваш класс Ar2020 с добавленным конструктором перемещения и примером его использования в main. Я пометил его комментарием // конструктор перемещения и добавил вызов через std::move, чтобы продемонстрировать, как он работает:

cpp
#include <iostream>
#include <utility>   // для std::move
#include <climits>   // для INT_MIN
#include <stdexcept> // для std::out_of_range

class Ar2020
{
public:
    int* M;
    int  count;

    // 1) Конструктор по умолчанию
    Ar2020() : count(5), M(new int[count])
    {
        for (int i = 0; i < count; ++i) M[i] = 0;
    }

    // 2) Конструктор копирования
    Ar2020(const Ar2020& copy) : count(copy.count), M(new int[copy.count])
    {
        for (int i = 0; i < count; ++i)
            M[i] = copy.M[i];
    }

    // 3) Конструктор с параметром
    Ar2020(int count) : count(count), M(new int[count])
    {
        for (int i = 0; i < count; ++i) M[i] = 1;
    }

    // 4) **Конструктор перемещения**  
    Ar2020(Ar2020&& other) noexcept  // конструктор перемещения
        : M(other.M), count(other.count)
    {
        other.M = nullptr;
        other.count = 0;
        std::cout << "Move ctor called\n";
    }

    // Деструктор
    ~Ar2020() {
        delete[] M;
    }

    // Оператор присваивания копированием
    Ar2020& operator=(const Ar2020& left) {
        if (this != &left) {
            delete[] M;
            count = left.count;
            M = new int[count];
            for (int i = 0; i < count; ++i)
                M[i] = left.M[i];
        }
        return *this;
    }

    // Оператор присваивания перемещением
    Ar2020& operator=(Ar2020&& other) noexcept {
        if (this != &other) {
            delete[] M;
            M = other.M;
            count = other.count;
            other.M = nullptr;
            other.count = 0;
            std::cout << "Move op= called\n";
        }
        return *this;
    }

    // Оператор []
    int& operator[](int index) {
        if (index < 0 || index >= count)
            throw std::out_of_range("Index out of range");
        return M[index];
    }

    // Оператор вывода
    friend std::ostream& operator<<(std::ostream& out, const Ar2020& Ar) {
        for (int i = 0; i < Ar.count; ++i)
            out << Ar.M[i] << ' ';
        return out;
    }

    // Оператор ввода
    friend std::istream& operator>>(std::istream& in, Ar2020& Ar) {
        for (int i = 0; i < Ar.count; ++i)
            in >> Ar.M[i];
        return in;
    }

    // Пример простой функции: сумма элементов меньше среднего
    int SrSum() {
        int sum = 0;
        for (int i = 0; i < count; ++i) sum += M[i];
        int sr = sum / count;
        sum = 0;
        for (int i = 0; i < count; ++i)
            if (M[i] < sr) sum += M[i];
        return sum;
    }

    // Пример сложной функции: два индекса максимального
    void TwoIndex() {
        int max = INT_MIN, idx1 = 0, idx2 = 0;
        for (int i = 0; i < count; ++i) {
            if (M[i] >= max) {
                idx2 = idx1;
                idx1 = i;
                max = M[i];
            }
        }
        std::cout << "Indexes: " << idx2 << ' ' << idx1 << std::endl;
    }
};

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

    // Создаём массив по умолчанию
    Ar2020 a1;            // default ctor
    for (int i = 0; i < a1.count; ++i) a1.M[i] = i + 1;
    std::cout << "a1: " << a1 << std::endl;

    // Используем конструктор перемещения при возврате из lambda
    auto makeArr = []() -> Ar2020 {
        Ar2020 tmp(5);    // param ctor
        for (int i = 0; i < 5; ++i) tmp.M[i] = (i + 1) * 10;
        return tmp;       // здесь вызовется move ctor
    };
    Ar2020 a2 = makeArr();
    std::cout << "a2 (moved): " << a2 << std::endl;

    // Или явно через std::move
    Ar2020 a3(5);
    for (int i = 0; i < 5; ++i) a3.M[i] = i * 2;
    std::cout << "a3 before move: " << a3 << std::endl;
    Ar2020 a4 = std::move(a3);  // конструктор перемещения
    std::cout << "a4 after move: " << a4 << std::endl;
    std::cout << "a3 after move (empty): " << a3 << std::endl;

    return 0;
}

• Конструктор перемещения (Ar2020(Ar2020&& other) noexcept) «перехватывает» указатель M и значение count из временного объекта, обнуляя его, чтобы не было двойного освобождения памяти.
• В main показаны два сценария: возврат через лямбду (makeArr) и явный std::move — в обоих случаях вы увидите строку Move ctor called.

В задании «повторить сортировку» обычно подразумевается, что вам нужно:

1. Напомнить себе (повторить) работу алгоритма std::sort из <algorithm>.
2. Показать, как внутри вызова std::sort можно передать лямбда-выражение в качестве компаратора, чтобы сортировать по разным критериям.

---

1. Базовая сортировка

Допустим, у вас есть массив Mas длины size внутри класса. Чтобы отсортировать его по возрастанию, достаточно:

cpp
#include <algorithm>

// где-то в методах класса Arr89 (или вне, получив доступ к Mas и size):
std::sort(Mas, Mas + size);

Это эквивалентно «повторению» того, что вы учили: алгоритм быстрой сортировки (обычно) применится к вашему динамическому массиву.

---

2. Лямбды как компараторы

Иногда нужно необычное упорядочение:

• По убыванию
• По абсолютному значению
• По чётности, по остаткам от деления и т.д.

Вместо того, чтобы писать отдельную функцию-компаратор, вы можете сразу в std::sort описать лямбду:

cpp
// 1) Сортировка по убыванию:
std::sort(Mas, Mas + size,
          [](int a, int b) {
              return a > b; // "true", если a должно стоять раньше b
          });

// 2) По абсолютному значению (возрастание):
std::sort(Mas, Mas + size,
          [](int a, int b) {
              return std::abs(a) < std::abs(b);
          });

// 3) Сначала чётные, потом нечётные:
std::sort(Mas, Mas + size,
          [](int a, int b) {
              // если один чётный, другой нечётный — чётный вперёд
              if ((a % 2 == 0) != (b % 2 == 0))
                  return (a % 2 == 0);
              // иначе обычный порядок
              return a < b;
          });

Каждая лямбда имеет вид

cpp
[ /*(захваты)*/ ](параметры) -> возвращаемый_тип { тело; }

но в простых случаях тип возвращаемого значения можно не указывать — компилятор выведет его сам.

---

3. Пример внутри класса Arr89

Добавим в ваш класс метод sortAsc() и sortDesc():

cpp
#include <algorithm>
#include <cmath>

class Arr89 {
    int* Mas;
    int  size;
public:
    // ... все ваши конструкторы, деструктор и т.п.

    // Сортировка по возрастанию
    void sortAsc() {
        std::sort(Mas, Mas + size);
    }

    // Сортировка по убыванию через лямбду
    void sortDesc() {
        std::sort(Mas, Mas + size,
                  [](int a, int b) {
                      return a > b;
                  });
    }

    // Сортировка по абсолютному значению
    void sortByAbs() {
        std::sort(Mas, Mas + size,
                  [](int a, int b) {
                      return std::abs(a) < std::abs(b);
                  });
    }
};

И в main можно увидеть:

cpp
int main() {
    Arr89 A(8);
    // заполним чем-нибудь
    for (int i = 0; i < A.getSize(); ++i)
        A[i] = (i % 2 == 0 ? i : -i*2);

    std::cout << "Исходный: " << A << "\n";

    A.sortAsc();
    std::cout << "По возрастанию: " << A << "\n";

    A.sortDesc();
    std::cout << "По убыванию:  " << A << "\n";

    A.sortByAbs();
    std::cout << "По |value|:    " << A << "\n";

    return 0;
}

Что происходит:

• При первом std::sort без третьего аргумента используется < для int.
• При втором — наша лямбда [](int a,int b){ return a>b; } «переворачивает» порядок.
• При третьем — лямбда сравнивает по абсолютным значениям.

Таким образом, «повторить сортировку» означает вспомнить вызов std::sort, а «использовать лямбда-выражения» — это дать внутрь std::sort анонимную функцию-компаратор, не выносить её в отдельный bool cmp(int,int). Соответственно, вы показываете гибкость и знание стандартных алгоритмов и лямбд в C++.

Ниже показано, как добавить в ваш код вызов std::sort с лямбда-компаратором прямо в main. В качестве примера я отсортирую массив a4 по убыванию (от большего к меньшему).

cpp
#include <iostream>
#include <utility>
#include <climits>
#include <stdexcept>
#include <algorithm> // для std::sort
#include <cmath>     // если понадобятся функции из <cmath>

class Ar2020
{
public:
    int* M;
    int  count;

    // ПО УМОЛЧАНИЮ
    Ar2020() : count(5), M(new int[count]) {
        for (int i = 0; i < count; ++i) M[i] = 0;
    }

    // КОПИРОВАНИЯ
    Ar2020(const Ar2020& copy) : count(copy.count), M(new int[count]) {
        for (int i = 0; i < count; ++i)
            M[i] = copy.M[i];
    }

    // С ПАРАМЕТРОМ
    Ar2020(int count) : count(count), M(new int[count]) {
        for (int i = 0; i < count; ++i)
            M[i] = 1;
    }

    // ПЕРЕМЕЩЕНИЯ
    Ar2020(Ar2020&& other) noexcept
        : M(other.M), count(other.count)
    {
        other.M = nullptr;
        other.count = 0;
        std::cout << "Move ctor called\n";
    }

    ~Ar2020() {
        delete[] M;
    }

    Ar2020& operator=(const Ar2020& left) {
        if (this != &left) {
            delete[] M;
            count = left.count;
            M = new int[count];
            for (int i = 0; i < count; ++i)
                M[i] = left.M[i];
        }
        return *this;
    }

    Ar2020& operator=(Ar2020&& other) noexcept {
        if (this != &other) {
            delete[] M;
            M = other.M;
            count = other.count;
            other.M = nullptr;
            other.count = 0;
            std::cout << "Move op= called\n";
        }
        return *this;
    }

    int& operator[](int index) {
        if (index < 0 || index >= count)
            throw std::out_of_range("Index out of range");
        return M[index];
    }

    friend std::ostream& operator<<(std::ostream& out, const Ar2020& Ar) {
        for (int i = 0; i < Ar.count; ++i)
            out << Ar.M[i] << ' ';
        return out;
    }

    friend std::istream& operator>>(std::istream& in, Ar2020& Ar) {
        for (int i = 0; i < Ar.count; ++i)
            in >> Ar.M[i];
        return in;
    }

    // ... SrSum(), TwoIndex() и т.п.
};

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

    // Демонстрация move-семантики
    Ar2020 a3(5);
    for (int i = 0; i < 5; ++i) a3.M[i] = i * 2;
    std::cout << "a3 before move: " << a3 << std::endl;

    Ar2020 a4 = std::move(a3);  // конструктор перемещения
    std::cout << "a4 after move:  " << a4 << std::endl;
    std::cout << "a3 after move:  " << a3 << std::endl; // пустой

    // ─── ВСТАВЛЯЕМ СОРТИРОВКУ ────────────────────────────────────────────────
    // Отсортируем a4 по убыванию с помощью лямбда-выражения:
    // лямбда [](int x, int y){ return x > y; } возвращает true,
    // если x должен стоять перед y &rarr; будем получать порядок от большего к меньшему.
    std::sort(a4.M, a4.M + a4.count,
              [](int x, int y) {
                  return x > y;
              });

    std::cout << "a4 sorted descending: " << a4 << std::endl;

    return 0;
}

Объяснение

1. Подключили <algorithm> для std::sort.
2. Вызвали

   cpp
   std::sort(a4.M, a4.M + a4.count,
             [](int x, int y) { return x > y; });

   Лямбда-выражение здесь — это анонимная функция, которая говорит «поместить элемент x перед элементом y, если x > y». Таким образом, массив сортируется в убывающем порядке.
3. Аналогично вы можете писать любые лямбды, например:
   • По возрастанию: [](int x,int y){ return x < y; }
   • По абсолютному значению: [](int x,int y){ return std::abs(x) < std::abs(y); }
   • Сначала чётные, потом нечётные и т.д.

Это и есть «повторить сортировку» и «использовать лямбда-выражения» в вашем задании.

Ниже кратко о том, как в C++ работать с регулярными выражениями (<regex>), и два готовых шаблона — для даты (формат дд:мм, 2022-й год, до 27 апреля включительно) и для email.

---

1. Основы работы с std::regex

cpp
#include <iostream>
#include <regex>
#include <string>

bool match(const std::string& s, const std::regex& rx) {
    return std::regex_match(s, rx);
}

int main() {
    std::regex rx("\\d{2}:\\d{2}");  // простой пример
    std::string test = "28:02";
    if (match(test, rx)) {
        std::cout << test << " — OK\n";
    } else {
        std::cout << test << " — NOT OK\n";
    }
    return 0;
}

• std::regex rx("PATTERN"); — компилирует шаблон.
• std::regex_match(str, rx) — проверяет, что вся строка целиком соответствует шаблону.
• Можно указывать флаги (например, std::regex_constants::icase для нечувствительности к регистру).

---

2. Регулярное выражение для даты дд:мм 2022 года, не позже 27 апреля

cpp
// шаблон (обратите внимание на экранирование слэшей в строке C++)
const std::regex dateRx(
    R"(^(?:(?:0[1-9]|1\d|2[0-7]):04|(?:0[1-9]|[12]\d|30):(0[13578]|1[02])|(?:0[1-9]|[12]\d|3[01]):(0[469]|11))$)"
);

Пояснение :

1. (?:0[1-9]|1\d|2[0-7]):04 — дни 01–27 апреля.
2. (?:0[1-9]|[12]\d|30):(0[13578]|1[02]) — месяцы с 31 днём (янв, мар, май, …) до 30-го.
3. (?:0[1-9]|[12]\d|3[01]):(0[469]|11) — месяцы с 30 днём (апрель уже ограничили выше, но здесь май нет — тк 31 день).

---

3. Регулярное выражение для Email

cpp
const std::regex emailRx(
    R"(^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$)"
);

• [A-Za-z0-9._%+-]+ — локальная часть (до @), хотя в реальности может быть сложнее.
• @[A-Za-z0-9.-]+ — домен (буквы, цифры, точки и дефисы).
• \.[A-Za-z]{2,} — точка и доменная зона из 2+ букв.

---

4. Пример проверки в main()

cpp
#include <iostream>
#include <regex>
#include <string>

int main() {
    std::regex dateRx(
        R"(^(?:(?:0[1-9]|1\d|2[0-7]):04|(?:0[1-9]|[12]\d|30):(0[13578]|1[02])|(?:0[1-9]|[12]\d|3[01]):(0[469]|11))$)"
    );
    std::regex emailRx(
        R"(^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$)"
    );

    std::string s1 = "27:04";
    std::string s2 = "31:02";
    std::string e1 = "[email protected]";
    std::string e2 = "[email protected]";

    std::cout << s1 << ": " 
              << (std::regex_match(s1, dateRx) ? "valid\n" : "invalid\n");
    std::cout << s2 << ": " 
              << (std::regex_match(s2, dateRx) ? "valid\n" : "invalid\n");

    std::cout << e1 << ": " 
              << (std::regex_match(e1, emailRx) ? "valid\n" : "invalid\n");
    std::cout << e2 << ": " 
              << (std::regex_match(e2, emailRx) ? "valid\n" : "invalid\n");

    return 0;
}

Вывод будет примерно:

text
27:04: valid
31:02: invalid
[email protected]: valid
[email protected]: invalid

---

Таким образом, вы получаете готовые C++-шаблоны и демонстрацию их использования в коде. Надеюсь, это поможет!