C/C++ | Вопросы собесов

Всё, что вы любите, есть на Wildberries Все мы ищем разное, но всегда находим что-то своё на WB — со скидками и доставкой. Перейти на сайт #реклама wildberries.ru О рекламодателе

🤔 Какова суть принципа подстановки Барбары Лисков? Является одним из пяти принципов SOLID и был предложен Барбарой Лисков в 1987 году. Этот принцип гласит, что объекты базового (родительского) класса должны быть заменяемы объектами производного (дочернего) класса без нарушения правильности программы. Другими словами, если класс S является подтипом класса T, то объекты типа T должны быть заменяемы объектами типа S без изменения желаемых свойств программы. 🚩Почему это нужно? LSP помогает обеспечить правильное использование наследования и полиморфизма в объектно-ориентированном программировании. Если принцип подстановки нарушен, то полиморфизм может привести к неожиданным ошибкам и некорректному поведению программы. Следование LSP делает код более гибким, надежным и легким для сопровождения. 🚩Как это используется? 1⃣Поддерживали контракт, заданный базовым классом. 2⃣Не изменяли ожидаемое поведение базового класса. 3⃣Не ослабляли инварианты базового класса. 4⃣Не нарушали постусловия и предусловия базового класса. 🚩Пример использования 🟠Нарушение LSP Здесь класс Square нарушает LSP, потому что он изменяет поведение методов setWidth и setHeight, что может привести к неожиданным результатам при использовании объекта Square как Rectangle.

    
        class Rectangle {
protected:
    int width, height;
public:
    virtual void setWidth(int w) { width = w; }
    virtual void setHeight(int h) { height = h; }
    int getWidth() const { return width; }
    int getHeight() const { return height; }
    int area() const { return width * height; }
};

class Square : public Rectangle {
public:
    void setWidth(int w) override {
        width = w;
        height = w; // Изменяем и ширину, и высоту
    }

    void setHeight(int h) override {
        height = h;
        width = h; // Изменяем и высоту, и ширину
    }
};{}
    

🟠Соблюдение LSP Лучше всего избегать такого наследования, которое приводит к нарушению LSP. В этом случае можно использовать другой подход, например, композицию вместо наследования. Теперь Rectangle и Square наследуют от абстрактного класса Shape, и каждый класс реализует метод area согласно своей логике, не нарушая LSP.

    
        class Shape {
public:
    virtual int area() const = 0;
    virtual ~Shape() = default;
};

class Rectangle : public Shape {
protected:
    int width, height;
public:
    Rectangle(int w, int h) : width(w), height(h) {}
    void setWidth(int w) { width = w; }
    void setHeight(int h) { height = h; }
    int getWidth() const { return width; }
    int getHeight() const { return height; }
    int area() const override { return width * height; }
};

class Square : public Shape {
    int side;
public:
    Square(int s) : side(s) {}
    void setSide(int s) { side = s; }
    int getSide() const { return side; }
    int area() const override { return side * side; }
};{}
    

Ставь 👍 и забирай 📚 Базу знаний

🤔 Какая сложность работы с кучей? Работа с кучей (heap) в алгоритмах обычно имеет временную сложность O(log n) для операций вставки и удаления, т.к. элементы необходимо сравнивать и переставлять для поддержания свойств кучи. Ставь 👍 если знал ответ, 🔥 если нет Забирай 📚Базу знаний

🤔 Что такое процессы, потоки? Это независимые программы, выполняющиеся в операционной системе, каждая со своим адресным пространством. Потоки – это единицы выполнения внутри процесса, которые делят общее адресное пространство. Потоки легче создавать и переключать, чем процессы, поэтому они используются для параллельной обработки. 🚩Процессы Это экземпляр выполняемой программы, который включает в себя программу кода, данные и состояния. Каждый процесс имеет свое собственное адресное пространство и системные ресурсы (например, файлы, память и устройства ввода-вывода). 🟠Изоляция Процессы изолированы друг от друга. Один процесс не может напрямую изменить данные другого процесса. 🟠Ресурсы Каждый процесс имеет свое собственное адресное пространство, дескрипторы файлов и т. д. 🟠Создание Создание нового процесса может быть дорогостоящим по времени и ресурсам, так как включает выделение памяти и инициализацию ресурсов.

    
        #include <iostream>
#include <unistd.h>

int main() {
    pid_t pid = fork(); // Создание нового процесса

    if (pid == 0) {
        // Дочерний процесс
        std::cout << "Это дочерний процесс" << std::endl;
    } else {
        // Родительский процесс
        std::cout << "Это родительский процесс, PID дочернего процесса: " << pid << std::endl;
    }

    return 0;
}{}
    

🚩Потоки Это наименьшая единица выполнения в рамках процесса. Потоки одного процесса разделяют одно адресное пространство и ресурсы, такие как память и дескрипторы файлов. 🟠Разделение ресурсов Потоки разделяют память и ресурсы процесса, что делает межпоточное взаимодействие более эффективным. 🟠Создание Создание потоков обычно быстрее и менее ресурсозатратно по сравнению с процессами. 🟠Параллелизм Потоки позволяют выполнять несколько частей программы параллельно, что улучшает производительность на многоядерных системах.

    
        #include <iostream>
#include <thread>

void printMessage(const std::string& message) {
    std::cout << message << std::endl;
}

int main() {
    std::thread t1(printMessage, "Привет из потока 1");
    std::thread t2(printMessage, "Привет из потока 2");

    t1.join(); // Ожидание завершения потока
    t2.join();

    return 0;
}{}
    

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что известно о истории умных указателей? - Первым в стандарт попал auto_ptr в C++98 — оказался неудобным и небезопасным. - Затем Boost предложил shared_ptr, scoped_ptr, weak_ptr. - С выходом C++11 появились современные unique_ptr, shared_ptr, weak_ptr. - auto_ptr был объявлен устаревшим и позже удалён (в C++17). - Современные умные указатели активно используются для автоматического управления памятью и соблюдения RAII. Ставь 👍 если знал ответ, 🔥 если нет Забирай 📚Базу знаний

🤔 Расскажите про ключевое слово _fastcall? Это соглашение о вызове функций, используемое в некоторых компиляторах C и C++ (например, Microsoft Visual C++), которое указывает, что параметры функции должны передаваться через регистры, а не через стек. Это может привести к более быстрой работе программы, так как доступ к регистрами обычно быстрее, чем доступ к стеку. 🚩Основные характеристики 🟠Передача аргументов через регистры _fastcall передает первые два целочисленных аргумента (например, int, char, long) через регистры ECX и EDX на архитектуре x86. Остальные аргументы передаются через стек. 🟠Обратная совместимость _fastcall обеспечивает совместимость с другими соглашениями о вызове, но это может потребовать дополнительных усилий для обеспечения совместимости при смешивании разных соглашений о вызове в одном проекте. 🟠Оптимизация производительности Передача аргументов через регистры уменьшает накладные расходы, связанные с использованием стека, что может улучшить производительность в функциях, которые вызываются часто или требуют высокой производительности.

    
        #include <iostream>

// Функция, использующая соглашение о вызове _fastcall
int __fastcall add(int a, int b) {
    return a + b;
}

int main() {
    int result = add(5, 3);
    std::cout << "Result: " << result << std::endl; // Вывод: Result: 8
    return 0;
}{}
    

🚩Примечания и ограничения 🟠Платформенная зависимость _fastcall специфичен для архитектуры x86 и поддерживается не всеми компиляторами. На x64 используется другое соглашение о вызове, и _fastcall не применим. 🟠Совместимость с другими соглашениями о вызове Если вы используете _fastcall вместе с другими соглашениями о вызове (например, __cdecl, __stdcall), нужно быть осторожным, чтобы избежать ошибок при вызове функций с разными соглашениями о вызове. 🟠Использование в современных проектах В современных проектах использование _fastcall редко необходимо, так как современные компиляторы достаточно умны, чтобы автоматически оптимизировать вызовы функций, используя подходящие соглашения о вызове. В большинстве случаев вручную указывать _fastcall нет необходимости.

    
        #include <iostream>

// Проверка платформы
#ifdef _M_IX86 // Если используется компилятор для архитектуры x86
int __fastcall add(int a, int b) {
    return a + b;
}
#else
int add(int a, int b) {
    return a + b;
}
#endif

int main() {
    int result = add(5, 3);
    std::cout << "Result: " << result << std::endl; // Вывод: Result: 8
    return 0;
}{}
    

Ставь 👍 и забирай 📚 Базу знаний

🤔 Какая будет сложность удаления элемента с начала в vector? Удаление элемента с начала вектора в C++ имеет временную сложность O(n), так как все элементы после удаляемого необходимо переместить ближе к началу вектора. Ставь 👍 если знал ответ, 🔥 если нет Забирай 📚Базу знаний

🤔 Что такое back_inserter, зачем он нужен? std::back_inserter — это адаптер итератора из библиотеки STL, который позволяет удобно добавлять элементы в конец контейнера при использовании алгоритмов стандартной библиотеки (например, std::copy, std::transform и т. д.). Он создает итератор-вставку (inserter iterator), который при попытке записи нового элемента фактически вызывает метод push_back() у контейнера. 🚩Почему он нужен? Обычно алгоритмы STL работают с итераторами и требуют, чтобы целевой контейнер уже содержал достаточно места для копирования или вставки элементов. back_inserter позволяет избежать этого ограничения, автоматически расширяя контейнер по мере необходимости. 🚩Пример использования Без back_inserter (приведет к ошибке!)

    
        #include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> source = {1, 2, 3, 4, 5};
    std::vector<int> destination; // Пустой контейнер

    // Ошибка! У destination нет места для элементов
    std::copy(source.begin(), source.end(), destination.begin());

    return 0;
}{}
    

Используем back_inserter (правильный вариант)

    
        #include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>

int main() {
    std::vector<int> source = {1, 2, 3, 4, 5};
    std::vector<int> destination; // Начинаем с пустого контейнера

    // Используем back_inserter
    std::copy(source.begin(), source.end(), std::back_inserter(destination));

    // Вывод результата
    for (int num : destination) {
        std::cout << num << " ";
    }

    return 0;
}{}
    

Вывод

    
        1 2 3 4 5{}
    

🚩Где используется `back_inserter`? 🟠**std::transform – Преобразование элементов** Применяем функцию ко всем элементам и добавляем результат в новый контейнер

    
        #include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>

int main() {
    std::vector<int> nums = {1, 2, 3, 4, 5};
    std::vector<int> squared;

    std::transform(nums.begin(), nums.end(), std::back_inserter(squared), 
                   [](int x) { return x * x; });

    for (int num : squared) {
        std::cout << num << " ";
    }

    return 0;
}{}
    

Вывод:

    
        1 4 9 16 25{}
    

std::unique_copy – Удаление дубликатов

    
        #include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>

int main() {
    std::vector<int> nums = {1, 2, 2, 3, 4, 4, 5};
    std::vector<int> unique_nums;

    std::unique_copy(nums.begin(), nums.end(), std::back_inserter(unique_nums));

    for (int num : unique_nums) {
        std::cout << num << " ";
    }

    return 0;
}{}
    

Вывод:

    
        1 2 3 4 5{}
    

Ставь 👍 и забирай 📚 Базу знаний

🤔 Зачем нужен виртуальный деструктор? Виртуальный деструктор необходим, когда класс предполагает полиморфное использование, то есть когда объекты базового класса могут быть удалены через указатель на производный класс. Без виртуального деструктора вызов `delete` на указатель базового типа приведет к вызову только деструктора базового класса, что может вызвать утечку памяти для производных классов. Виртуальный деструктор гарантирует, что будет вызван правильный деструктор для производного класса, обеспечивая корректное освобождение всех ресурсов. Ставь 👍 если знал ответ, 🔥 если нет Забирай 📚Базу знаний

🤔 Что такое deque? Deque (double-ended queue, двусторонняя очередь) — это последовательный контейнер в C++, который позволяет добавлять и удалять элементы как с начала, так и с конца очереди с постоянной временной сложностью O(1). Контейнер deque является частью стандартной библиотеки шаблонов (STL) и объявляется в заголовочном файле <deque>. 🚩Основные характеристики: 🟠Быстрый доступ к элементам: deque обеспечивает доступ к элементам по индексу с амортизированной временной сложностью O(1). 🟠Двусторонняя очередь: Позволяет эффективно добавлять и удалять элементы как с начала, так и с конца очереди. 🟠Динамический размер: deque автоматически изменяет свой размер по мере добавления или удаления элементов, подобно vector. 🟠Не требует смежного хранения: В отличие от vector, элементы deque могут быть размещены в различных сегментах памяти, что делает его более гибким для частых операций вставки и удаления. 🚩Основные операции: 🟠Добавление элементов: push_back(), push_front() 🟠Удаление элементов: pop_back(), pop_front() 🟠Доступ к элементам: operator[], at(), front(), back() 🟠Размер и емкость: size(), empty(), resize() 🟠Итераторы: Поддержка итераторов для прохода по элементам

    
        #include <iostream>
#include <deque>

int main() {
    std::deque<int> dq;

    // Добавление элементов в конец
    dq.push_back(1);
    dq.push_back(2);
    dq.push_back(3);

    // Добавление элементов в начало
    dq.push_front(0);

    std::cout << "Deque elements: ";
    for (int elem : dq) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;

    // Удаление элемента с конца
    dq.pop_back();

    // Удаление элемента с начала
    dq.pop_front();

    std::cout << "Deque elements after pop operations: ";
    for (int elem : dq) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;

    return 0;
}{}
    

Ставь 👍 и забирай 📚 Базу знаний