Skip to content
TheChatArchiveThe Chat Archive
gpt-4.1-mini-2025-04-14· OpenAIAi2 WildChat-4.8M (AI2)

дарова, мне надо подготовиться к экзамену по программированию, я дам тебе список…

  1. User

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

  2. Assistant

    Дарова! Конечно, присылай свои вопросы по программированию — помогу с ответами и кодом. Жду список!

  3. User
    1. С++. Строки

    2. С++. Указатели. Ссылки

    3. Случайные числа в языке программирования С++.

    4. Событийно-управляемая модель программирования. Компонентно-ориентированный подход

    5. События компонентов (элементов управления), их сущность и назначение. Создание процедур на основе событий

    6. Сортировка массива методом вставки

    7. Сортировка массива методом выбора.

    8. Структура if, классификация в С++.

    9. Структура switch(выбор) и ее программирование в С++.

    10. Структура программы. Команда присваивания в С++.

    11. ООП. Классы. Объекты. Конструкторы. Деструкторы. Инициализация.

    12. Принципы ООП. Абстракция данных. Инкапсуляция. Наследование. Полиморфизм.

    13. Ограничение доступа к данным и методам класса. Типы наследования

    14. Виртуальный метод (виртуальная функция)

    15. Дружественные классы. Вложенные классы.

  4. Assistant

    Отличный список! Отвечу по каждому пункту с примерами кода, чтобы было понятно.


    17. C++. Строки

    В C++ существуют два основных способа работы со строками: старый стиль — массивы символов и новый — класс std::string.

    Пример со строкой std::string:

    #include <iostream>
    #include <string>
    
    int main() {
        std::string s = "Привет, мир!";
        std::cout << s << std::endl;
    
        s += " Как дела?";
        std::cout << s << std::endl;
    
        // Длина строки
        std::cout << "Длина строки: " << s.size() << std::endl;
    
        // Доступ к символам
        for (char c : s) {
            std::cout << c << ' ';
        }
        std::cout << std::endl;
    
        return 0;
    }
    

    18. C++. Указатели. Ссылки

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

    Пример:

    #include <iostream>
    
    int main() {
        int a = 10;
    
        int* p = &a;    // указатель, p хранит адрес a
        std::cout << "a = " << a << ", *p = " << *p << std::endl;
    
        *p = 20;        // изменяем значение a через указатель
        std::cout << "a = " << a << std::endl;
    
        int& ref = a;   // ссылка на a
        ref = 30;       // меняем a через ссылку
        std::cout << "a = " << a << std::endl;
    
        return 0;
    }
    

    19. Случайные числа в языке программирования C++

    Для генерации случайных чисел используется <cstdlib> и функция rand(), но с C++11 появился более удобный <random>.

    Пример с rand():

    #include <iostream>
    #include <cstdlib>
    #include <ctime>
    
    int main() {
        std::srand(std::time(nullptr));  // инициализация генератора
    
        for(int i = 0; i < 5; i++) {
            int r = std::rand() % 100;  // случайное число от 0 до 99
            std::cout << r << " ";
        }
        std::cout << std::endl;
        return 0;
    }
    

    Пример с <random>:

    #include <iostream>
    #include <random>
    
    int main() {
        std::random_device rd;
        std::mt19937 gen(rd()); // генератор случайных чисел
        std::uniform_int_distribution<> distr(0, 99);
    
        for (int i = 0; i < 5; ++i) {
            std::cout << distr(gen) << " ";
        }
        std::cout << std::endl;
    
        return 0;
    }
    

    20. Событийно-управляемая модель программирования. Компонентно-ориентированный подход

    Событийно-управляемая модель — когда программа реагирует на события (нажатия кнопок, движение мышки и т.п.), а не выполняется линейно.

    Компонентно-ориентированный подход — разработка программ из взаимосвязанных компонент (элементов управления, модулей), которые обрабатывают события.

    Например, графический интерфейс: кнопка — компонент, при клике генерирует событие, которое обрабатывает процедура (слот).


    21. События компонентов (элементов управления), их сущность и назначение. Создание процедур на основе событий

    События — это сигналы от компонента, что произошло действие (например, нажата кнопка). Процедуры, которые обрабатывают события — это обработчики событий.

    На С++ с GUI фреймворками (Qt, wxWidgets) обычно пишутся функции-слоты и связываются с сигналами.


    22. Сортировка массива методом вставки

    Идея: проход по массиву, каждый элемент вставляется в отсортированную часть слева.

    #include <iostream>
    
    void insertionSort(int arr[], int n) {
        for (int i = 1; i < n; i++) {
            int key = arr[i];
            int j = i - 1;
    
            // Сдвигаем элементы вправо для освобождения места
            while (j >= 0 && arr[j] > key) {
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j + 1] = key;
        }
    }
    
    int main() {
        int arr[] = {5, 2, 4, 6, 1, 3};
        int n = sizeof(arr) / sizeof(arr[0]);
    
        insertionSort(arr, n);
    
        for (int x : arr)
            std::cout << x << " ";
    
        std::cout << std::endl;
        return 0;
    }
    

    23. Сортировка массива методом выбора

    Идея: на каждом шаге выбирается минимальный элемент из неотсортированной части и ставится на своё место.

    #include <iostream>
    
    void selectionSort(int arr[], int n) {
        for (int i = 0; i < n - 1; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++)
                if (arr[j] < arr[minIdx]) minIdx = j;
    
            std::swap(arr[i], arr[minIdx]);
        }
    }
    
    int main() {
        int arr[] = {64, 25, 12, 22, 11};
        int n = sizeof(arr) / sizeof(arr[0]);
    
        selectionSort(arr, n);
    
        for (int x : arr)
            std::cout << x << " ";
        std::cout << std::endl;
    
        return 0;
    }
    

    24. Структура if, классификация в C++

    if — условная конструкция для ветвления.

    Виды if:

    • Простое if:
    if (условие) {
        // действия, если условие true
    }
    
    • if-else:
    if (условие) {
        // если true
    } else {
        // если false
    }
    
    • if-else if-else (многоступенчатое):
    if (условие1) {
        // ...
    } else if (условие2) {
        // ...
    } else {
        // ...
    }
    

    25. Структура switch(выбор) и ее программирование в C++

    switch — конструкция для выбора одного из нескольких вариантов по значению целочисленного (или enum) выражения.

    #include <iostream>
    
    int main() {
        int day = 3;
    
        switch(day) {
            case 1:
                std::cout << "Понедельник\n";
                break;
            case 2:
                std::cout << "Вторник\n";
                break;
            case 3:
                std::cout << "Среда\n";
                break;
            default:
                std::cout << "Другой день\n";
        }
    
        return 0;
    }
    

    26. Структура программы. Команда присваивания в C++

    Структура программы:

    #include <iostream>   // подключение библиотек
    
    int main() {           // точка входа программы
        // тело программы
        int a = 5;
        a = 10;            // команда присваивания: переменной a присвоить значение 10
    
        std::cout << a << std::endl;
    
        return 0;
    }
    

    Присваивание — операция установки значения переменной:

    переменная = значение;
    

    27. ООП. Классы. Объекты. Конструкторы. Деструкторы. Инициализация.

    ООП — парадигма, в которой данные и функции объединены в классы.

    • Класс — шаблон (тип) для создания объектов (экземпляров).
    • Объект — экземпляр класса.
    • Конструктор — специальный метод для инициализации объекта.
    • Деструктор — метод для освобождения ресурсов объекта.
    #include <iostream>
    #include <string>
    
    class Person {
    private:
        std::string name;
        int age;
    
    public:
        // Конструктор
        Person(std::string n, int a) : name(n), age(a) {
            std::cout << "Конструктор вызван\n";
        }
    
        void greet() {
            std::cout << "Привет, меня зовут " << name << ", мне " << age << " лет.\n";
        }
    
        // Деструктор
        ~Person() {
            std::cout << "Деструктор вызван для " << name << "\n";
        }
    };
    
    int main() {
        Person p("Иван", 25);
        p.greet();
    
        // Деструктор вызовется автоматически при выходе из main
        return 0;
    }
    

    28. Принципы ООП. Абстракция данных. Инкапсуляция. Наследование. Полиморфизм.

    • Абстракция — выделение значимых характеристик и сокрытие деталей реализации.
    • Инкапсуляция — сокрытие данных (через private) и открытие интерфейса через методы.
    • Наследование — создание нового класса на основе существующего.
    • Полиморфизм — возможность применять один интерфейс к объектам разных типов (например, виртуальные функции).

    29. Ограничение доступа к данным и методам класса. Типы наследования

    В C++ уровни доступа:

    • private — доступ только внутри класса
    • protected — внутри класса и наследников
    • public — доступ всем

    Наследование:

    class Base { };
    class Derived : public Base { };   // public наследование
    class Derived2 : protected Base { }; // protected наследование
    class Derived3 : private Base { }; // private наследование
    

    30. Виртуальный метод (виртуальная функция)

    Виртуальная функция — метод, который может быть переопределён в наследниках и вызывается в зависимости от типа объекта во время выполнения.

    #include <iostream>
    
    class Base {
    public:
        virtual void show() { std::cout << "Base\n"; }
    };
    
    class Derived : public Base {
    public:
        void show() override { std::cout << "Derived\n"; }
    };
    
    int main() {
        Base* b = new Derived();
        b->show(); // Выведет "Derived" благодаря виртуальному методу
    
        delete b;
        return 0;
    }
    

    31. Дружественные классы. Вложенные классы.

    • Дружественные классы — классы, которые имеют доступ к private и protected членам другого класса.
    class B; // объявление вперед
    
    class A {
        int x = 10;
        friend class B; // B является дружественным классом
    };
    
    class B {
    public:
        void show(A& a) {
            std::cout << a.x << std::endl; // имеет доступ к private A
        }
    };
    
    • Вложенные классы — класс, объявленный внутри другого класса.
    class Outer {
    public:
        class Inner {
        public:
            void f() { std::cout << "Внутренний класс\n"; }
        };
    };
    
    int main() {
        Outer::Inner innerObj;
        innerObj.f();
    
        return 0;
    }
    

    Если нужна помощь с каким-то конкретным вопросом более подробно — пиши!