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

Завтра последний день! Успей купить пожизненный easyoffer PRO - по цене 1 года Покупаешь один раз — пользуешься всю жизнь. 👉 Акция до 31 марта: https://easyoffer.ru/pro

🤔 В каком порядке элементы списка инициализируются в конструкторе после двоеточия? Порядок инициализации элементов списка инициализации конструктора (initializer list) определяется порядком объявления членов класса, а не порядком, указанным в списке инициализации. Это важно понимать, так как неправильный порядок может привести к неожиданным ошибкам, особенно при инициализации зависимых членов.

    
        #include <iostream>

class MyClass {
private:
    int a;
    int b;
    int c;

public:
    MyClass(int x, int y, int z) : c(z), b(y), a(x) {
        std::cout << "a: " << a << ", b: " << b << ", c: " << c << std::endl;
    }
};

int main() {
    MyClass obj(1, 2, 3);
    return 0;
}{}
    

🚩Список инициализации конструктора В конструкторе MyClass список инициализации указан в порядке c(z), b(y), a(x). Однако это не влияет на порядок инициализации членов класса. Члены класса будут инициализированы в порядке их объявления: a, затем b, затем c. 🚩Порядок инициализации 1⃣a инициализируется первым (значение x). 2⃣b инициализируется вторым (значение y). 3⃣c инициализируется третьим (значение z). 🚩Вывод программы Программа выведет

    
        a: 1, b: 2, c: 3{}
    

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

    
        class MyClass {
private:
    int a;
    int& ref;

public:
    MyClass(int x) : ref(a), a(x) { // Неправильный порядок: ref инициализируется до a
        std::cout << "a: " << a << ", ref: " << ref << std::endl;
    }
};{}
    

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

🤔 Когда начинают жить и умирают глобальные и локальные переменные в С++? Глобальные переменные живут на протяжении всей программы, начиная с инициализации до завершения. Локальные переменные живут с момента входа в блок кода до выхода из него. Ставь 👍 если знал ответ, 🔥 если нет Забирай 📚Базу знаний

🤔 Что знаешь про гарантии безопасности исключений? Гарантии безопасности исключений (Exception Safety Guarantees) — это концепция, связанная с корректным поведением программы при возникновении исключений. Она определяет, насколько безопасно может завершиться выполнение функции или блока кода в случае выбрасывания исключения. 🚩Никаких гарантий (No Guarantee) Этот уровень означает, что при возникновении исключения состояние программы может быть непредсказуемым. Объекты могут остаться в недопустимом состоянии, и поведение программы после выброса исключения неопределено.

    
        void unsafeFunction(std::vector<int>& vec, int value) {
    vec.push_back(value); // Если здесь выбросится исключение, состояние vec не определено
    // ...
}{}
    

🚩Базовая гарантия (Basic Guarantee) Этот уровень гарантирует, что не произойдёт утечек ресурсов или нарушений инвариантов объектов. После выброса исключения все объекты остаются в допустимом состоянии, однако состояние программы может быть частично изменено.

    
        void safeFunction(std::vector<int>& vec, int value) {
    try {
        vec.push_back(value); // Если исключение, состояние vec остаётся корректным
    } catch (...) {
        // Обработка исключения
        std::cerr << "Ошибка при добавлении элемента!" << std::endl;
    }
}{}
    

🚩Сильная гарантия (Strong Guarantee) Этот уровень гарантирует, что в случае возникновения исключения программа останется в исходном состоянии, как будто вызов функции никогда не происходил. Состояние откатывается до того, что было до вызова функции.

    
        void addValue(std::vector<int>& vec, int value) {
    std::vector<int> temp = vec; // Создаём копию
    temp.push_back(value);       // Работаем с копией
    vec = temp;                  // Замена содержимого
}{}
    

🚩Гарантия отсутствия исключений (No-Throw Guarantee) Этот уровень гарантирует, что функция никогда не выбрасывает исключений. Обычно применяется к ключевым операциям (например, деструкторам, перемещениям).

    
        void safeSwap(std::vector<int>& a, std::vector<int>& b) noexcept {
    a.swap(b); // std::vector::swap гарантирует отсутствие исключений
}{}
    

🚩Как достигаются гарантии безопасности исключений? 🟠RAII (Resource Acquisition Is Initialization) Использование классов, где ресурсы освобождаются в деструкторах. Например, std::unique_ptr или std::lock_guard. 🟠Копирование перед изменением Применение принципа работы с временными копиями (как в примере сильной гарантии). 🟠Использование стандартных контейнеров Библиотека STL предоставляет базовую гарантию безопасности исключений для большинства операций. Ставь 👍 и забирай 📚 Базу знаний

🤔 Какая сложность поиска в set и unordered_set? В set поиск имеет сложность O(log n), так как он реализован как сбалансированное бинарное дерево. В unordered_set сложность поиска в среднем O(1), но в худшем случае (при большом количестве коллизий) может достигать O(n). Ставь 👍 если знал ответ, 🔥 если нет Забирай 📚Базу знаний

🤔 Какое преимущество у list перед vector? List обеспечивает быстрые вставки и удаления за \(O(1)\) в произвольной позиции, благодаря двусвязной структуре. В отличие от vector, list не требует перераспределения памяти при добавлении элементов. Однако доступ к элементам в list медленнее, так как отсутствует прямой индексированный доступ. 🚩Основные преимущества `std::list` 🟠Эффективные вставка и удаление элементов в середине контейнера std::list реализован как двусвязный список, что позволяет эффективно вставлять и удалять элементы в любом месте контейнера за постоянное время O(1), если у вас уже есть итератор на нужное место.

    
        #include <list>
#include <iostream>

int main() {
    std::list<int> myList = {1, 2, 3, 4, 5};
    auto it = myList.begin();
    std::advance(it, 2); // Переместить итератор на третий элемент

    myList.insert(it, 10); // Вставка за O(1)
    myList.erase(it);      // Удаление за O(1)

    for (int n : myList) {
        std::cout << n << " ";
    }

    return 0;
}   {}
    

🟠Нет необходимости в перемещении элементов при вставке или удалении В std::vector при вставке или удалении элементов в середине контейнера происходит сдвиг элементов, что может быть дорогостоящей операцией (сложность O(n)). В std::list этого не происходит, так как элементы не хранятся в смежных блоках памяти. 🟠Постоянное время для операций вставки и удаления в произвольной позиции Операции вставки и удаления в произвольной позиции в std::list всегда выполняются за O(1) (при условии, что у вас есть итератор на эту позицию), в то время как в std::vector они могут занимать до O(n) из-за необходимости сдвига элементов. 🟠Итераторы не инвалидируются при вставке или удалении элементов В std::vector итераторы могут быть инвалидированы (становятся недействительными) при вставке или удалении элементов. В std::list итераторы остаются валидными, что делает работу с итераторами более безопасной и предсказуемой. 🚩Примеры, когда `std::list` предпочтительнее 🟠Частые вставки и удаления в середине контейнера Если ваша задача предполагает частые операции вставки и удаления в середине контейнера, std::list будет предпочтительнее из-за своей эффективности в этих операциях. 🟠Работа с большим количеством итераторов Если вам нужно работать с множеством итераторов, которые должны оставаться валидными даже после вставки или удаления элементов, std::list будет лучше подходить для таких задач. 🚩Ограничения `std::list` 🟠Доступ по индексу В отличие от std::vector, в std::list нет возможности быстрого доступа к элементам по индексу. Для доступа к элементу необходимо пройти весь список от начала до нужного элемента (сложность O(n)). 🟠Высокие накладные расходы на память std::list требует больше памяти на хранение элементов, так как для каждого элемента хранится два дополнительных указателя (на следующий и предыдущий элементы). Ставь 👍 и забирай 📚 Базу знаний

🤔 Как называется возможность вызова функции без явного указания namespace? Такую возможность называют ADL (Argument-Dependent Lookup) или Koenig Lookup. Компилятор автоматически ищет функцию в пространстве имен аргумента, если оно не указано явно. Ставь 👍 если знал ответ, 🔥 если нет Забирай 📚Базу знаний

🤔 Расскажи как запретить от него наследоваться В C++ можно запретить наследование от класса несколькими способами. 🟠Использование `final` (C++11 и новее) Ключевое слово final запрещает наследование от класса.

    
        class Base final {
public:
    void show() { std::cout << "Base class\n"; }
};

// Ошибка! Наследование запрещено
class Derived : public Base {
};{}
    

🟠Закрытый или удалённый конструктор копирования и операторы присваивания Можно сделать так, чтобы класс нельзя было создать или скопировать в унаследованных классах.

    
        class Base {
private:
    Base() = default;  // Приватный конструктор
};{}
    

Можно сделать конструктор protected, если хотим создать объекты внутри класса, но не разрешать наследование снаружи.

    
        class Base {
protected:
    ~Base() = default; // Деструктор защищённый
};{}
    

🟠Закрытый (private) деструктор Если сделать деструктор private, то класс нельзя будет корректно удалить через указатель.

    
        class Base {
private:
    ~Base() = default;  // Закрытый деструктор
};{}
    

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

🤔 В unordered_set поиск — константа? Поиск в unordered_set имеет среднюю сложность O(1), но в худшем случае при хеш-коллизиях может быть O(n). Ставь 👍 если знал ответ, 🔥 если нет Забирай 📚Базу знаний

Пожизненный PRO доступ на easyoffer — по цене одного года! До 31 марта вы можете купить PRO навсегда. Запускаем акцию, чтобы ускорить развитие сервиса. Что добавим в PRO в ближайшие полгода: – Автоотклики – Агрегатор вакансий – Проход ATS без отсева – Уникальные резюме и письма под каждую вакансию Покупаешь один раз — пользуешься всю жизнь. 👉 Купить PRO со скидкой 70%: https://easyoffer.ru/pro