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

🤔 Какие знаешь алгоритмы реализации коллизии? Существуют несколько алгоритмов для разрешения коллизий: метод цепочек, открытая адресация, двойное хеширование. Метод цепочек использует связные списки для хранения нескольких значений в одной ячейке. Открытая адресация хранит все элементы в хеш-таблице, перезаписывая при коллизиях в следующую свободную ячейку. Ставь 👍 если знал ответ, 🔥 если нет Забирай 📚Базу знаний

Не платите больше. Зафиксируйте цену сегодня Сколько клиентов вы уже упустили? Каждая просроченная заявка – это деньги вашим конкурентам. amoCRM помогает закрывать сделки, пока другие теряют лиды. Мы не делаем универсальных решений для всех. Только то, что работает в продажах. И одно из лучших решений, которое вы можете принять сейчас – это зафиксировать текущую цену. С 01 сентября amoCRM станет дороже. Но если подключитесь до этой даты, мы зафиксируем текущую цену для вас — и сейчас, и при продлении. ✨ Переходите по ссылке и успейте зафиксировать свою выгоду! Узнать больше #реклама 16+ amocrm.ru О рекламодателе

🤔 Какие есть еще умные указатели кроме auto_ptr и unique_ptr? Умные указатели – это классы-обёртки, которые автоматически управляют памятью и помогают избежать утечек памяти. В C++98 был только std::auto_ptr (сейчас устарел). В C++11 появились std::unique_ptr, std::shared_ptr, std::weak_ptr. В C++14 добавили std::make_unique, а в C++17 – **std::shared_ptr для массивов. 🟠`std::unique_ptr` (C++11) – единоличное владение Хранит указатель и удаляет его при выходе из области видимости. Нельзя копировать (deleted copy constructor). Можно передавать владение через std::move.

    
        #include <iostream>
#include <memory>

class Test {
public:
    Test() { std::cout << "Test создан\n"; }
    ~Test() { std::cout << "Test уничтожен\n"; }
};

int main() {
    std::unique_ptr<Test> ptr1 = std::make_unique<Test>();  // Создаём объект
    // std::unique_ptr<Test> ptr2 = ptr1; ❌ Ошибка! Нельзя копировать
    std::unique_ptr<Test> ptr2 = std::move(ptr1);  // ✅ Передаём владение
}{}
    

🟠`std::shared_ptr` (C++11) – совместное владение Можно копировать – несколько указателей указывают на один объект. Когда последний shared_ptr удаляется, объект уничтожается. Использует счётчик ссылок (reference counting).

    
        #include <iostream>
#include <memory>

class Test {
public:
    Test() { std::cout << "Test создан\n"; }
    ~Test() { std::cout << "Test уничтожен\n"; }
};

int main() {
    std::shared_ptr<Test> ptr1 = std::make_shared<Test>();  // Создаём объект
    std::shared_ptr<Test> ptr2 = ptr1;  // ptr2 тоже владеет объектом
    std::cout << "Счётчик ссылок: " << ptr1.use_count() << std::endl;
}{}
    

🟠`std::weak_ptr` (C++11) – слабая ссылка (не увеличивает счётчик) Работает вместе с std::shared_ptr, но не увеличивает счётчик ссылок. Используется для избежания циклических зависимостей.

    
        #include <iostream>
#include <memory>

struct B;  // Объявляем заранее

struct A {
    std::shared_ptr<B> bptr;
    ~A() { std::cout << "A уничтожен\n"; }
};

struct B {
    std::shared_ptr<A> aptr;
    ~B() { std::cout << "B уничтожен\n"; }
};

int main() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();

    a->bptr = b;  // Взаимная ссылка
    b->aptr = a;  // Взаимная ссылка

    // ❌ Оба объекта никогда не удалятся – утечка памяти!
}{}
    

Использование weak_ptr для предотвращения утечки

    
        struct A {
    std::weak_ptr<B> bptr;  // Слабая ссылка
    ~A() { std::cout << "A уничтожен\n"; }
};

struct B {
    std::shared_ptr<A> aptr;
    ~B() { std::cout << "B уничтожен\n"; }
};{}
    

🟠`std::scoped_ptr` (Boost) – как `unique_ptr`, но без `move` Устарел (заменён unique_ptr). Удаляет объект при выходе из области видимости. Нельзя передавать владение!

    
        #include <boost/scoped_ptr.hpp>
boost::scoped_ptr<int> p(new int(42));  // Нельзя передать другому указателю{}
    

🟠`std::intrusive_ptr` (Boost) – ручной счётчик ссылок Как shared_ptr, но счётчик ссылок внутри объекта. Требует явного вызова add_ref() / release().

    
        #include <boost/intrusive_ptr.hpp>

class RefCounted {
    int count = 0;
public:
    void add_ref() { ++count; }
    void release() { if (--count == 0) delete this; }
};

boost::intrusive_ptr<RefCounted> ptr(new RefCounted());{}
    

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

«Был такой кейс» — бизнес-подкаст с предпринимателями Задайте ваш бизнес-вопрос, опытные предприниматели разберут его в выпуске Перейти на сайт #реклама sberbusiness.live О рекламодателе

🤔 Какой контейнер используется в priority_queue? priority_queue в C++ обычно реализован на базе std::vector с использованием кучи (heap) для управления приоритетами. Ставь 👍 если знал ответ, 🔥 если нет Забирай 📚Базу знаний

Где вести задачи и проекты? Конечно, в Битрикс24 Бесплатный онлайн-сервис для бизнеса и совместной работы. — Удобный планировщик задач для всей команды с чек-листами и комментариями. — Популярные проектные методики: канбан, скрам, диаграмма ганта. — Видеозвонки в один клик из чата. — Календарь и слоты для совместного планирования. — Умный ИИ-помощник для постановки четких тз. Полный комплект для эффективности вашей команды. Ставьте первую задачу прямо сейчас. Начать #реклама 16+ task-24.bitrix24.ru О рекламодателе

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

    
        #include <vector>
#include <iostream>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    vec.push_back(6); // Добавление элемента в конец вектора
    std::cout << "Элемент по индексу 3: " << vec[3] << std::endl; // Быстрый доступ к элементам

    return 0;
}{}
    

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

    
        #include <list>
#include <iostream>

int main() {
    std::list<int> lst = {1, 2, 3, 4, 5};
    lst.push_front(0); // Быстрая вставка в начало списка
    lst.push_back(6);  // Быстрая вставка в конец списка

    for (auto it = lst.begin(); it != lst.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    return 0;
}{}
    

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

🤔 Что будет, если вызвать оператор delete на nullptr? Если вызвать оператор delete на nullptr, ничего не произойдет. Это безопасная операция, так как стандарт гарантирует, что освобождение nullptr не вызовет ошибок или исключений. Ставь 👍 если знал ответ, 🔥 если нет Забирай 📚Базу знаний

Укрепление кибербезопасности с Solar SIEM Борьба с угрозами при ограниченном бюджете На вебинаре 12 августа в 11:00 обсудим, как платформа Solar SIEM объединяет функции SIEM и SOAR/IRP, ускоряя поиск угроз в 3 раза и экономя до 40% бюджета. Узнайте, как автоматизация снижает нагрузку на команду и повышает уровень защиты. Сделайте работу ИБ-специалистов проще и эффективнее. Регистрируйтесь на вебинар! 🔐 Зарегистрироваться #реклама 16+ rt-solar.ru О рекламодателе

🤔 Как работает range based? Range-based for loop – это упрощённый цикл for, который позволяет перебирать элементы контейнера (std::vector, std::array, std::map, std::set и т. д.) без индексов и итераторов.

    
        for (auto element : container) {
    // Действие с element
}{}
    

🚩Как это работает внутри? Простой пример с std::vector

    
        #include <iostream>
#include <vector>

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

    for (int x : v) { // Перебираем все элементы вектора
        std::cout << x << " ";
    }
}{}
    

Вывод

    
        1 2 3 4 5{}
    

Как работает этот цикл? Компилятор превращает его в обычный for с итератором:

    
        for (auto it = v.begin(); it != v.end(); ++it) {
    int x = *it; // Копируем элемент
    std::cout << x << " ";
}{}
    

🚩Передача по ссылке (`&`) и по значению (`=`) Передача по значению (=) – создаёт копию элемента

    
        for (int x : v) { // x - копия элемента
    x = 100; // НЕ изменит вектор!
}{}
    

Передача по ссылке (&) – изменяет оригинал

    
        for (int& x : v) { // x - ссылка на элемент
    x *= 2; // Изменит оригинальный вектор!
}{}
    

🚩Работает со всеми контейнерами STL С std::map

    
        std::map<int, std::string> m = {{1, "one"}, {2, "two"}};
for (const auto& [key, value] : m) { // structured binding (C++17)
    std::cout << key << " -> " << value << "\n";
}{}
    

С std::set

    
        std::set<int> s = {1, 2, 3, 4};
for (int x : s) { std::cout << x << " "; }{}
    

🚩Работает с `std::initializer_list`

    
        for (int x : {10, 20, 30}) {
    std::cout << x << " ";
}{}
    

Вывод

    
        10 20 30{}
    

🚩Как работает range-based for с обычными массивами?

    
        int arr[] = {1, 2, 3};
for (int x : arr) { std::cout << x << " "; }{}
    

Работает так же, как и с `std::vector`! Работает с пользовательскими классами (если есть begin() и end())

    
        class MyContainer {
    int data[3] = {10, 20, 30};
public:
    int* begin() { return data; }
    int* end() { return data + 3; }
};

int main() {
    MyContainer c;
    for (int x : c) { std::cout << x << " "; }
}{}
    

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