---

#include <iostream>
#include <cstring>

using namespace std;

// ==================== ФУНКЦИЯ ДЛЯ ВВОДА ЦЕЛЫХ ЧИСЕЛ С ПРОВЕРКОЙ ====================
int inputInt(const char* prompt, bool allowZero = false) {
    int value;
    bool validInput = false;
        
    cout << prompt;
        
    for (int attempt = 0; attempt < 3 && !validInput; attempt++) {
        if (attempt > 0) {
            cout << "Oshibka! Vvedite chislo: ";
        }
            
        if (cin >> value) {
            if (value > 0) {
                validInput = true;
            } else if (allowZero && value == 0) {
                validInput = true;
            } else {
                cout << "Chislo dolzhno byt' polozhitel'nym. ";
                cin.clear();
                cin.ignore(10000, '\n');
            }
        } else {
            cin.clear();
            cin.ignore(10000, '\n');
            cout << "Nekorrektnyy vvod. ";
        }
    }
        
    if (!validInput) {
        cout << "Prekratnyy vvod. Ustanovleno znachenie 5." << endl;
        value = 5;
    }
    return value;
}

// ==================== СТРУКТУРА ФИЛЬМ ====================
struct film {
    char* nazvanie;   // название фильма
    int stoimost;     // стоимость
    char* rezhisser;  // режиссер
    film* next;       // указатель на следующий элемент
};

// ==================== КЛАСС LIST ====================
class list {
private:
    int size;     // количество элементов
    film* h;      // голова списка

public:
    // Конструктор
    list() {
        h = 0;
        size = 0;
    }

    // Деструктор
    ~list() {
        release();
    }

    // ДОБАВЛЕНИЕ ЭЛЕМЕНТА В НАЧАЛО СПИСКА
    void pred() {
        film* temp = new film;
        char str[80];

        cout << "Nazvanie filma: ";
        cin >> str;
        temp->nazvanie = new char[strlen(str) + 1];
        strcpy(temp->nazvanie, str);

        // Ввод стоимости с проверкой
        temp->stoimost = inputInt("Stoimost': ");

        cout << "Rezhisser: ";
        cin >> str;
        temp->rezhisser = new char[strlen(str) + 1];
        strcpy(temp->rezhisser, str);

        temp->next = h;
        h = temp;
        size++;
    }

    // УДАЛЕНИЕ ПЕРВОГО ЭЛЕМЕНТА
    void del() {
        if (h == 0) return;
        film* temp = h;
        h = h->next;
        delete[] temp->nazvanie;
        delete[] temp->rezhisser;
        delete temp;
        size--;
    }

    // ОЧИСТКА ВСЕГО СПИСКА
    void release() {
        while (h != 0) {
            del();
        }
    }

    // ВЫВОД ВСЕГО СПИСКА
    void print() {
        if (h == 0) {
            cout << "Spisok pust.\n";
            return;
        }
        int num = 1;
        for (film* temp = h; temp != 0; temp = temp->next) {
            cout << "===== Film #" << num++ << " =====\n";
            cout << "Nazvanie: " << temp->nazvanie << "\n";
            cout << "Stoimost': " << temp->stoimost << "\n";
            cout << "Rezhisser: " << temp->rezhisser << "\n\n";
        }
    }

    // ПОИСК i-ГО ЭЛЕМЕНТА (0‑базовый индекс)
    film* elem(int i) {
        if (i < 0 || i >= size) return 0;
        film* temp = h;
        for (int j = 0; j < i; j++) {
            temp = temp->next;
        }
        return temp;
    }

    // ВЫВОД ФИЛЬМОВ ЗАДАННОГО РЕЖИССЁРА
    void printByRezhisser(const char* rezh) {
        if (h == 0) {
            cout << "Spisok pust.\n";
            return;
        }
        int count = 0;
        for (film* temp = h; temp != 0; temp = temp->next) {
            if (strcmp(temp->rezhisser, rezh) == 0) {
                cout << "Nazvanie: " << temp->nazvanie << ", Stoimost': " << temp->stoimost << "\n";
                count++;
            }
        }
        if (count == 0) {
            cout << "Filmow rezhissera \"" << rezh << "\" ne naydeno.\n";
        } else {
            cout << "Vsego nashli " << count << " filmow.\n";
        }
    }

};

// ==================== ГЛАВНАЯ ФУНКЦИЯ ====================
int main() {
    list videoteka;
    int n;

    // Ввод количества фильмов с проверкой
    n = inputInt("Skolko filmov vvesti? ");

    // Ввод информации о фильмах
    for (int i = 0; i < n; i++) {
        cout << "\n--- Film #" << i + 1 << " ---\n";
        videoteka.pred();   // добавляем в начало
    }

    // Вывод всей видеотеки
    cout << "\n========== VSYa VIDEOTEKA ==========\n";
    videoteka.print();

    // Запрос режиссёра для поиска
    char searchRezh[80];
    cout << "\nVvedite familiyu rezhissera: ";
    cin >> searchRezh;

    // Вывод фильмов указанного режиссёра
    cout << "\n========== FIL'MY REZhISSERA \"" << searchRezh << "\" ==========\n";
    videoteka.printByRezhisser(searchRezh);

    return 0;
}




ЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫЫ




#include <iostream>
using namespace std;

// ==================== ФУНКЦИЯ ДЛЯ ВВОДА ЦЕЛЫХ ЧИСЕЛ С ПРОВЕРКОЙ ====================
int inputInt(const char* prompt, bool allowZero = false) {
    int value;
    bool validInput = false;
        
    cout << prompt;
        
    for (int attempt = 0; attempt < 3 && !validInput; attempt++) {
        if (attempt > 0) {
            cout << "Oshibka! Vvedite chislo: ";
        }
            
        if (cin >> value) {
            if (value > 0) {
                validInput = true;
            } else if (allowZero && value == 0) {
                validInput = true;
            } else {
                cout << "Chislo dolzhno byt' polozhitel'nym. ";
                cin.clear();
                cin.ignore(10000, '\n');
            }
        } else {
            cin.clear();
            cin.ignore(10000, '\n');
            cout << "Nekorrektnyy vvod. ";
        }
    }
        
    if (!validInput) {
        cout << "Prekratnyy vvod. Ustanovleno znachenie 5." << endl;
        value = 5;
    }
    return value;
}

// ==================== КЛАСС VECT (ХРАНИТ ОДИН СТОЛБЕЦ) ====================
class vect {
private:
    int* base;   // массив элементов столбца
    int size;    // количество строк в столбце

public:
    // Конструктор
    vect(int n) {
        size = n;
        base = new int[size];
    }

    // Конструктор копирования
    vect(const vect& v) {
        size = v.size;
        base = new int[size];
        for (int i = 0; i < size; i++) {
            base[i] = v.base[i];
        }
    }

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

    // Ввод столбца (с проверкой)
    void inputColumn(int colNum) {
        cout << "Stolbec " << colNum + 1 << ":" << endl;
        for (int i = 0; i < size; i++) {
            char prompt[100];
            sprintf(prompt, "  Element [%d]: ", i);
            base[i] = inputInt(prompt);
        }
    }

    // Вывод столбца
    void printColumn() {
        for (int i = 0; i < size; i++) {
            cout << base[i] << " ";
        }
    }

    // Геттеры
    int getSize() { return size; }
    int getElement(int index) {
        if (index >= 0 && index < size) return base[index];
        return 0;
    }

    // Сумма элементов столбца
    int sum() {
        int s = 0;
        for (int i = 0; i < size; i++) {
            s += base[i];
        }
        return s;
    }
};

// ==================== КЛАСС MATRIX (СОДЕРЖИТ МАССИВ СТОЛБЦОВ) ====================
class matrix {
private:
    vect** columns;   // массив указателей на столбцы
    int rows;         // количество строк (2)
    int cols;         // количество столбцов (30)

public:
    // Конструктор
    matrix(int r, int c) {
        rows = r;
        cols = c;
        columns = new vect*[cols];
        for (int j = 0; j < cols; j++) {
            columns[j] = new vect(rows);  // каждый столбец имеет rows элементов
        }
    }

    // Деструктор
    ~matrix() {
        for (int j = 0; j < cols; j++) {
            delete columns[j];
        }
        delete[] columns;
    }

    // Ввод всей матрицы
    void input() {
        cout << "Vvod matricy " << rows << "x" << cols << ":" << endl;
        for (int j = 0; j < cols; j++) {
            columns[j]->inputColumn(j);
        }
    }

    // Вывод всей матрицы
    void print() {
        cout << "\nMatrica:" << endl;
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                cout << columns[j]->getElement(i) << "\t";
            }
            cout << endl;
        }
    }

    // Поиск столбцов, у которых сумма > P и < T
    void findColumns(int P, int T) {
        cout << "\nStolbcy, u kotoryh summa elementov bol'she " << P 
             << " i men'she " << T << ":" << endl;
        
        bool found = false;
        for (int j = 0; j < cols; j++) {
            int s = columns[j]->sum();
            if (s > P && s < T) {
                cout << "Stolec #" << j + 1 << " (summa = " << s << ")" << endl;
                found = true;
            }
        }
        
        if (!found) {
            cout << "Takih stolbcov net." << endl;
        }
    }
};

// ==================== ГЛАВНАЯ ФУНКЦИЯ ====================
int main() {
    int P, T;
    
    // Ввод P и T с проверкой
    P = inputInt("Vvedite P: ");
    T = inputInt("Vvedite T: ");
    
    // Создаём матрицу 2x30
    matrix A(2, 30);
    
    // Ввод матрицы
    A.input();
    
    // Вывод матрицы
    A.print();
    
    // Поиск столбцов
    A.findColumns(P, T);
    
    return 0;
}


------------------------------------

#include <iostream>
using namespace std;

// ==================== ФУНКЦИЯ ДЛЯ ВВОДА ЦЕЛЫХ ЧИСЕЛ С ПРОВЕРКОЙ ====================
int inputInt(const char* prompt, bool allowZero = false) {
    int value;
    bool validInput = false;
        
    cout << prompt;
        
    for (int attempt = 0; attempt < 3 && !validInput; attempt++) {
        if (attempt > 0) {
            cout << "Oshibka! Vvedite chislo: ";
        }
            
        if (cin >> value) {
            if (value > 0) {
                validInput = true;
            } else if (allowZero && value == 0) {
                validInput = true;
            } else {
                cout << "Chislo dolzhno byt' polozhitel'nym. ";
                cin.clear();
                cin.ignore(10000, '\n');
            }
        } else {
            cin.clear();
            cin.ignore(10000, '\n');
            cout << "Nekorrektnyy vvod. ";
        }
    }
        
    if (!validInput) {
        cout << "Prekratnyy vvod. Ustanovleno znachenie 5." << endl;
        value = 5;
    }
    return value;
}

// ==================== КЛАСС VECT (ПОЛЯ PROTECTED) ====================
class vect {
protected:
    int* base;   // массив элементов столбца
    int size;    // количество строк в столбце

public:
    // Конструктор
    vect(int n) {
        size = n;
        base = new int[size];
    }

    // Конструктор копирования
    vect(const vect& v) {
        size = v.size;
        base = new int[size];
        for (int i = 0; i < size; i++) {
            base[i] = v.base[i];
        }
    }

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

    // Ввод столбца (с проверкой)
    void inputColumn(int colNum) {
        cout << "Stolbec " << colNum + 1 << ":" << endl;
        for (int i = 0; i < size; i++) {
            char prompt[100];
            sprintf(prompt, "  Element [%d]: ", i);
            base[i] = inputInt(prompt);
        }
    }

    // Вывод столбца
    void printColumn() {
        for (int i = 0; i < size; i++) {
            cout << base[i] << " ";
        }
    }

    // Сумма элементов столбца
    int sum() {
        int s = 0;
        for (int i = 0; i < size; i++) {
            s += base[i];
        }
        return s;
    }
    
    // Геттер для доступа извне (если нужен)
    int getSize() { return size; }
    int getElement(int index) {
        if (index >= 0 && index < size) return base[index];
        return 0;
    }
};

// ==================== КЛАСС MATRIX (НАСЛЕДУЕТ VECT) ====================
class matrix : public vect {
private:
    int rows;         // количество строк (2)
    int cols;         // количество столбцов (30)
    vect** columns;   // массив указателей на столбцы

public:
    // Конструктор
    matrix(int r, int c) : vect(r) {  // vect(r) — не используется, т.к. нужно хранить столбцы
        rows = r;
        cols = c;
        columns = new vect*[cols];
        for (int j = 0; j < cols; j++) {
            columns[j] = new vect(rows);
        }
    }

    // Деструктор
    ~matrix() {
        for (int j = 0; j < cols; j++) {
            delete columns[j];
        }
        delete[] columns;
    }

    // Ввод всей матрицы
    void input() {
        cout << "Vvod matricy " << rows << "x" << cols << ":" << endl;
        for (int j = 0; j < cols; j++) {
            columns[j]->inputColumn(j);
        }
    }

    // Вывод всей матрицы
    void print() {
        cout << "\nMatrica:" << endl;
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                // Так как поля base и size у vect protected,
                // но columns[j] — это указатель на vect,
                // доступ к base возможен только через методы
                cout << columns[j]->getElement(i) << "\t";
            }
            cout << endl;
        }
    }

    // Поиск столбцов, у которых сумма > P и < T
    void findColumns(int P, int T) {
        cout << "\nStolbcy, u kotoryh summa elementov bol'she " << P 
             << " i men'she " << T << ":" << endl;
        
        bool found = false;
        for (int j = 0; j < cols; j++) {
            int s = columns[j]->sum();
            if (s > P && s < T) {
                cout << "Stolec #" << j + 1 << " (summa = " << s << ")" << endl;
                found = true;
            }
        }
        
        if (!found) {
            cout << "Takih stolbcov net." << endl;
        }
    }
};

// ==================== ГЛАВНАЯ ФУНКЦИЯ ====================
int main() {
    int P, T;
    
    // Ввод P и T с проверкой
    P = inputInt("Vvedite P: ");
    T = inputInt("Vvedite T: ");
    
    matrix A(2, 30);
    A.input();
    A.print();
    A.findColumns(P, T);
    
    return 0;
}



ыыыыыыыыыыыыыыыыыыыыыыыыыыыыыыыыыыыыыыыыыыыыыыыыыыыыыыыыыыыыы

#include <iostream>
#include <cmath>

using namespace std;

// ==================== ФУНКЦИЯ ДЛЯ ВВОДА ЦЕЛЫХ ЧИСЕЛ (ТОЛЬКО > 0) ====================
int inputInt(const char* prompt) {
    int value;
    bool validInput = false;
        
    cout << prompt;
        
    for (int attempt = 0; attempt < 3 && !validInput; attempt++) {
        if (attempt > 0) {
            cout << "Oshibka! Vvedite chislo: ";
        }
            
        if (cin >> value) {
            if (value > 0) {
                validInput = true;          // число положительное
            } else {
                cout << "Chislo dolzhno byt' bol'she 0. ";
                cin.clear();
                cin.ignore(10000, '\n');
            }
        } else {
            cin.clear();
            cin.ignore(10000, '\n');
            cout << "Nekorrektnyy vvod. ";
        }
    }
        
    if (!validInput) {
        cout << "Prekratnyy vvod. Ustanovleno znachenie 1." << endl;
        value = 1;
    }
    return value;
}

// ==================== АБСТРАКТНЫЙ БАЗОВЫЙ КЛАСС ====================
class geom {
public:
    virtual double area() const = 0;     // чисто виртуальная для площади
    virtual double volume() const = 0;   // чисто виртуальная для объёма
    virtual ~geom() {}
};

// ==================== КЛАССЫ ДЛЯ ПЛОЩАДЕЙ ====================

// Прямоугольник
class Rectangle : public geom {
private:
    double width, height;
public:
    Rectangle(double w, double h) : width(w), height(h) {}
    double area() const override {
        return width * height;
    }
    double volume() const override {
        return 0;
    }
    double getWidth() const { return width; }
    double getHeight() const { return height; }
};

// Круг
class Circle : public geom {
private:
    double radius;
public:
    Circle(double r) : radius(r) {}
    double area() const override {
        return M_PI * radius * radius;
    }
    double volume() const override {
        return 0;
    }
    double getRadius() const { return radius; }
};

// Квадрат
class Square : public geom {
private:
    double side;
public:
    Square(double s) : side(s) {}
    double area() const override {
        return side * side;
    }
    double volume() const override {
        return 0;
    }
    double getSide() const { return side; }
};

// ==================== ЗАДАЧА 1 ====================
double remainingAreaAfterSubtraction(const Rectangle& rect, const Circle& circle, const Square& square) {
    double rectArea = rect.area();
    double circleArea = circle.area();
    double squareArea = square.area();

    double remaining = rectArea - circleArea - squareArea;
    return (remaining > 0) ? remaining : 0;
}

// ==================== КЛАССЫ ДЛЯ ОБЪЁМОВ ====================

// Параллелепипед (прямоугольный)
class Cuboid : public geom {
private:
    double length, width, height;
public:
    Cuboid(double l, double w, double h) : length(l), width(w), height(h) {}
    double volume() const override {
        return length * width * height;
    }
    double area() const override {
        return 0;
    }
};

// Треугольная призма (основание – прямоугольный треугольник)
class TriPrism : public geom {
private:
    double a, b, h;  // a, b – катеты основания, h – высота призмы
public:
    TriPrism(double a_, double b_, double h_) : a(a_), b(b_), h(h_) {}
    double volume() const override {
        double baseArea = 0.5 * a * b;
        return baseArea * h;
    }
    double area() const override {
        return 0;
    }
};

// ==================== ЗАДАЧА 2 (БЕЗ VECTOR) ====================
double totalVolume(geom** shapes, int count) {
    double sum = 0;
    for (int i = 0; i < count; i++) {
        sum += shapes[i]->volume();
    }
    return sum;
}

// ==================== ТЕСТИРОВАНИЕ С ВВОДОМ ПОЛЬЗОВАТЕЛЯ ====================
int main() {
    double a, b, c, d, e, f, g, h, i, j;
    
    cout << "========== ZADACHA 1 ==========" << endl;
    
    // Ввод данных для прямоугольника
    cout << "\nVvedite dannye dlya pryamougol'nika:" << endl;
    a = inputInt("  Shirina (width): ");
    b = inputInt("  Vysota (height): ");
    Rectangle rect(a, b);
    
    // Ввод данных для круга
    cout << "\nVvedite dannye dlya kruga:" << endl;
    c = inputInt("  Radius: ");
    Circle circ(c);
    
    // Ввод данных для квадрата
    cout << "\nVvedite dannye dlya kvadrata:" << endl;
    d = inputInt("  Storona (side): ");
    Square sq(d);
    
    // Вычисление и вывод результата
    double remaining = remainingAreaAfterSubtraction(rect, circ, sq);
    cout << "\nRezul'taty:" << endl;
    cout << "  Ploshad' pryamougol'nika: " << rect.area() << endl;
    cout << "  Ploshad' kruga: " << circ.area() << endl;
    cout << "  Ploshad' kvadrata: " << sq.area() << endl;
    cout << "  Ostatok ploshadi: " << remaining << endl;
    
    cout << "\n========== ZADACHA 2 ==========" << endl;
    
    // Ввод данных для параллелепипеда
    cout << "\nVvedite dannye dlya parallelepipeda:" << endl;
    e = inputInt("  Dlina (length): ");
    f = inputInt("  Shirina (width): ");
    g = inputInt("  Vysota (height): ");
    Cuboid box(e, f, g);
    
    // Ввод данных для треугольной призмы
    cout << "\nVvedite dannye dlya treugol'noy prizmy:" << endl;
    cout << "  (osnovanie - pryamougol'nyy treugol'nik)" << endl;
    h = inputInt("  Katuet a: ");
    i = inputInt("  Katuet b: ");
    j = inputInt("  Vysota prizmy h: ");
    TriPrism prism(h, i, j);
    
    // Массив указателей на geom
    geom* shapes[2];
    shapes[0] = &box;
    shapes[1] = &prism;
    
    // Вычисление и вывод результата
    double sumVol = totalVolume(shapes, 2);
    cout << "\nRezul'taty:" << endl;
    cout << "  Ob" << char(39) << "em parallelepipeda: " << box.volume() << endl;
    cout << "  Ob" << char(39) << "em prizmy: " << prism.volume() << endl;
    cout << "  Summa ob" << char(39) << "emov: " << sumVol << endl;
    
    return 0;
}