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

🤔 Как устроена хеш таблица в unordered_map?

std::unordered_map в C++ реализован на основе хеш-таблицы. Это структура данных, обеспечивающая O(1) доступ к элементам в среднем случае.

🚩Основные компоненты хеш-таблицы

🟠Массив "бакетов" (buckets)
Хеш-таблица состоит из массива бакетов, где каждый бакет содержит список элементов с одинаковым хеш-кодом.
🟠Функция хеширования (`std::hash`)
Для определения, в какой бакет попадёт ключ, используется функция хеширования (std::hash).
🟠Проверка коллизий
Если два разных ключа попадают в один бакет (коллизия), элементы сохраняются в связанном списке (чаще всего).
🟠Рехеширование
При переполнении таблицы (load_factor > порогового значения) количество бакетов увеличивается, и все элементы перераспределяются.

🚩Как работает поиск и вставка в `unordered_map`

Хеш-функция вычисляет хеш-код ключа
std::hash hash_fn;
size_t hash_value = hash_fn(42); // Например, 23145123

Определяется индекс бакета
size_t bucket_index = hash_value % bucket_count;

🚩Разрешение коллизий

Когда два ключа попадают в один бакет, возникают коллизии. std::unordered_map использует метод цепочек (separate chaining):
В каждом бакете хранится связанный список (или другой контейнер).
Если несколько элементов имеют одинаковый хеш, они добавляются в этот список.
#include
#include

int main() {
std::unordered_map myMap;

myMap[1] = "One"; // Хеш-функция определит бакет
myMap[2] = "Two"; // Если попадает в тот же бакет, создаётся список

for (const auto& [key, value] : myMap) {
std::cout

🤔 Что знаешь про гарантии безопасности исключений?

Гарантии безопасности исключений (Exception Safety Guarantees) — это концепция, связанная с корректным поведением программы при возникновении исключений. Она определяет, насколько безопасно может завершиться выполнение функции или блока кода в случае выбрасывания исключения.

🚩Никаких гарантий (No Guarantee)

Этот уровень означает, что при возникновении исключения состояние программы может быть непредсказуемым. Объекты могут остаться в недопустимом состоянии, и поведение программы после выброса исключения неопределено.
void unsafeFunction(std::vector& vec, int value) {
vec.push_back(value); // Если здесь выбросится исключение, состояние vec не определено
// ...
}

🚩Базовая гарантия (Basic Guarantee)

Этот уровень гарантирует, что не произойдёт утечек ресурсов или нарушений инвариантов объектов. После выброса исключения все объекты остаются в допустимом состоянии, однако состояние программы может быть частично изменено.
void safeFunction(std::vector& vec, int value) {
try {
vec.push_back(value); // Если исключение, состояние vec остаётся корректным
} catch (...) {
// Обработка исключения
std::cerr

🤔 Когда нужно объявлять деструктор виртуальным?

Виртуальный деструктор нужен всегда, когда класс предполагается использовать в качестве базового и поддерживает полиморфизм (наследование и динамическое связывание).

🚩Зачем нужен виртуальный деструктор?

Если у базового класса деструктор не виртуальный, а удаление происходит через указатель на базовый класс, деструктор производного класса не вызовется! Это приведёт к утечке памяти или некорректному освобождению ресурсов.
Пример проблемы без виртуального деструктора
#include

class Base {
public:
~Base() { std::cout

🤔 Что такое deque?

Deque (double-ended queue, двусторонняя очередь) — это последовательный контейнер в C++, который позволяет добавлять и удалять элементы как с начала, так и с конца очереди с постоянной временной сложностью O(1). Контейнер deque является частью стандартной библиотеки шаблонов (STL) и объявляется в заголовочном файле .

🚩Основные характеристики:

🟠Быстрый доступ к элементам:
deque обеспечивает доступ к элементам по индексу с амортизированной временной сложностью O(1).
🟠Двусторонняя очередь:
Позволяет эффективно добавлять и удалять элементы как с начала, так и с конца очереди.
🟠Динамический размер:
deque автоматически изменяет свой размер по мере добавления или удаления элементов, подобно vector.
🟠Не требует смежного хранения:
В отличие от vector, элементы deque могут быть размещены в различных сегментах памяти, что делает его более гибким для частых операций вставки и удаления.

🚩Основные операции:

🟠Добавление элементов:
push_back(), push_front()
🟠Удаление элементов:
pop_back(), pop_front()
🟠Доступ к элементам:
operator[], at(), front(), back()
🟠Размер и емкость:
size(), empty(), resize()
🟠Итераторы:
Поддержка итераторов для прохода по элементам
#include
#include

int main() {
std::deque dq;

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

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

std::cout

🤔 Что такое наследование?

Наследование — это механизм ООП, позволяющий одному классу (наследнику) унаследовать свойства и методы другого класса (родителя) для повторного использования и расширения.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚Базу знаний

🤔 Что такое placement new?

placement new – это специальная форма оператора new, которая размещает объект в уже выделенной памяти вместо того, чтобы выделять её заново.
placement new
НЕ выделяет память (мы сами передаём адрес).
Просто вызывает конструктор в указанном месте.
void* ptr = malloc(sizeof(int)); // Выделяем память вручную
int* num = new(ptr) int(42); // Размещаем объект в этой памяти

Синтаксис placement new
new (адрес) Type(аргументы конструктора);

адрес – указатель на уже выделенную память.
Type(аргументы конструктора) – объект создаётся в этом месте.
#include

int main() {
char buffer[sizeof(int)]; // Буфер памяти (размер как у int)

int* p = new (buffer) int(123); // Размещаем int в этом буфере

std::cout

🤔 Какие виды конструкторов могут быть у класса?

🟠Конструктор по умолчанию (Default Constructor)
Без параметров, создается автоматически компилятором, если не задан.
class MyClass {
public:
MyClass() {}
};

🟠Параметризованный конструктор (Parameterized Constructor)
Принимает параметры для инициализации объекта.
class MyClass {
private:
int x;
public:
MyClass(int value) : x(value) {}
};

🟠Конструктор копирования (Copy Constructor)
Создает копию существующего объекта.
class MyClass {
private:
int x;
public:
MyClass(const MyClass &other) : x(other.x) {}
};

🟠Конструктор перемещения (Move Constructor)
Перемещает ресурсы из временного объекта.
class MyClass {
private:
int* data;
public:
MyClass(MyClass&& other) noexcept : data(other.data) {
other.data = nullptr;
}
};

🟠Делегирующий конструктор (Delegating Constructor)
Вызывает другой конструктор того же класса.
class MyClass {
private:
int x, y;
public:
MyClass(int value) : MyClass(value, 0) {}
MyClass(int value1, int value2) : x(value1), y(value2) {}
};

🟠Явный конструктор (Explicit Constructor)
Помечен explicit для предотвращения неявных преобразований.
class MyClass {
public:
explicit MyClass(int value) {}
};

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

🤔 В каких STL контейнерах внутри находится хеш таблица?

🚩В стандартной библиотеке шаблонов (STL) C++ хеш-таблица используется для реализации следующих контейнеров

🟠std::unordered_map
Ассоциативный контейнер, который хранит пары ключ-значение, с уникальными ключами. Обеспечивает амортизированное среднее время доступа, вставки и удаления за O(1).

🟠std::unordered_multimap
Ассоциативный контейнер, который хранит пары ключ-значение, где ключи могут повторяться. Обеспечивает амортизированное среднее время для основных операций за O(1), несмотря на дублирование ключей.

🟠std::unordered_set
Ассоциативный контейнер, который хранит уникальные элементы, неупорядоченные. Обеспечивает амортизированное среднее время для основных операций за O(1).

🟠std::unordered_multiset
Ассоциативный контейнер, который хранит элементы, где значения могут повторяться, неупорядоченные. Обеспечивает амортизированное среднее время для основных операций за O(1), несмотря на дублирование элементов.

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

🤔 Как работает range based?

Range-based for loop – это упрощённый цикл for, который позволяет перебирать элементы контейнера (std::vector, std::array, std::map, std::set и т. д.) без индексов и итераторов.
for (auto element : container) {
// Действие с element
}

🚩Как это работает внутри?

Простой пример с std::vector
#include
#include

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

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

🤔 Что известно о истории умных указателей?

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

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚Базу знаний

🤔 Как вы будете реализовывать Singletone ?

Это шаблон проектирования, который гарантирует, что класс имеет только один экземпляр, и предоставляет глобальную точку доступа к этому экземпляру. Существует несколько способов реализации Singleton, включая ленивую инициализацию, использование static и многопоточную безопасность.

🚩Основные методы реализации

🟠Ленивая инициализация (Lazy Initialization)
При ленивой инициализации объект создается только при первом обращении к нему.
class Singleton {
public:
static Singleton& getInstance() {
static Singleton instance;
return instance;
}

// Удаляем конструкторы копирования и присваивания
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;

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

🟠Инициализация при запуске (Eager Initialization)
При инициализации при запуске объект создается сразу при загрузке программы.
class Singleton {
public:
static Singleton& getInstance() {
return instance;
}

Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;

private:
Singleton() {}
static Singleton instance; // Статический экземпляр
};

Singleton Singleton::instance;

🟠Многопоточная безопасность (Thread-safe Singleton)
Используя std::call_once и std::once_flag, можно обеспечить безопасность при доступе из нескольких потоков.
#include

class Singleton {
public:
static Singleton& getInstance() {
std::call_once(initInstanceFlag, &Singleton::initSingleton);
return *instance;
}

Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;

private:
Singleton() {}
static void initSingleton() {
instance = new Singleton();
}
static Singleton* instance;
static std::once_flag initInstanceFlag;
};

Singleton* Singleton::instance = nullptr;
std::once_flag Singleton::initInstanceFlag;

🚩Плюсы

➕Ленивая инициализация
Экономит ресурсы, так как объект создается только при необходимости.
➕Инициализация при запуске
Простая реализация, не требует дополнительных проверок, но объект создается даже если не используется.
➕Многопоточная безопасность
Обеспечивает корректное создание объекта в многопоточной среде, но сложнее в реализации.

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

🤔 Какие есть тонкости при вызове виртуальной функции из конструктора или деструктора?

Вызов виртуальных функций из конструктора или деструктора в C++ может привести к неожиданным результатам, поскольку полиморфизм в этих контекстах работает иначе. Рассмотрим эти тонкости подробнее.

🚩Поведение виртуальных функций в конструкторах и деструкторах

🟠Конструкторы
Виртуальные функции в конструкторах вызываются в контексте текущего класса, а не в контексте производного класса. Когда конструктор базового класса вызывает виртуальную функцию, будет вызвана версия этой функции из самого базового класса, даже если объект принадлежит производному классу. Это связано с тем, что в момент вызова конструктора объект еще не полностью сконструирован как объект производного класса.

🟠Деструкторы
Виртуальные функции в деструкторах также вызываются в контексте текущего класса. Когда деструктор базового класса вызывает виртуальную функцию, будет вызвана версия этой функции из самого базового класса, поскольку деструкторы вызываются в порядке от производного к базовому, и в момент вызова деструктора базового класса объект уже не является объектом производного класса.

🚩Пример для иллюстрации

#include

class Base {
public:
Base() {
std::cout virtualFunction();
}

virtual ~Base() {
std::cout virtualFunction();
}

virtual void virtualFunction() {
std::cout

🤔 Что известно об умных указателях?

Обёртки над обычными указателями, автоматически управляющие временем жизни объекта.
- std::unique_ptr — единственный владелец, нельзя копировать.
- std::shared_ptr — подсчёт ссылок, разделённое владение.
- std::weak_ptr — не влияет на счётчик shared_ptr, нужен для избежания циклов.
Плюсы:
- Безопасное управление памятью.
- Нет утечек при правильном использовании.
- Легче соблюдать RAII.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚Базу знаний

🤔 Расскажи о истории умных указателей

История умных указателей (smart pointers) в C++ связана с необходимостью управления динамической памятью и улучшением безопасности работы с указателями. Они появились как способ автоматизировать управление памятью и избежать ошибок, таких как утечки памяти, двойное освобождение или использование освобожденной памяти.

🚩Основные этапы развития умных указателей

🟠Классические проблемы обычных указателей
В языке C++ динамическая память выделяется с помощью new и освобождается с помощью delete. Однако ручное управление памятью приводит к ошибкам:
Утечки памяти: забыли вызвать delete, и память остаётся занятой.
Двойное освобождение: дважды вызвали delete на одном указателе.
Использование освобождённой памяти: доступ к указателю после delete.
Эти проблемы стали мотиватором для появления решений, которые бы автоматически управляли памятью.


🟠Ручная реализация умных указателей в C++98
До стандартизации разработчики часто писали свои собственные классы для управления динамической памятью. Такой класс оборачивал указатель и вызывал delete в своём деструкторе:
class SmartPointer {
int* ptr;
public:
explicit SmartPointer(int* p = nullptr) : ptr(p) {}
~SmartPointer() { delete ptr; }

int& operator*() { return *ptr; }
int* operator->() { return ptr; }
};

🟠Boost и развитие библиотеки умных указателей
В библиотеке Boost появились первые стандартизированные умные указатели:
boost::shared_ptr: реализует совместное владение указателем (reference counting).
boost::scoped_ptr: уникальное владение (аналог будущего std::unique_ptr).
boost::weak_ptr: слабая ссылка для работы с циклическими зависимостями.
Boost сыграл огромную роль в стандартизации умных указателей, так как многие из них легли в основу C++11.

🟠C++11: стандартные умные указатели
Стандарт C++11 ввёл библиотеку , которая предоставляет три типа умных указателей:
std::unique_ptr:
Гарантирует уникальное владение ресурсом.
Замена для обычных указателей с более строгими гарантиями.
Не поддерживает копирование, только перемещение.

std::unique_ptr ptr(new int(5));


std::shared_ptr:
Совместное владение ресурсом через подсчёт ссылок.
Освобождает память, когда последний shared_ptr указывает на объект.

std::shared_ptr sp1 = std::make_shared(10);


std::weak_ptr:
Не увеличивает счётчик ссылок в std::shared_ptr.
Используется для работы с циклическими зависимостями.

std::weak_ptr wp = sp1;


🟠Современное использование умных указателей
С выходом C++14, C++17 и C++20 умные указатели остаются важной частью языка. Они используются для:
Ресурсного управления (RAII).
Устранения утечек памяти.
Упрощения кода.

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

🤔 Какое присваивание разрешает unique_ptr?

unique_ptr поддерживает только перемещение (move assignment), чтобы гарантировать уникальное владение объектом, но не копирование.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚Базу знаний

🤔 Как можно взвести бит используя побитовую операцию ИЛИ?

Чтобы взвести (установить) бит в определённое значение (1) в числе, можно использовать побитовую операцию ИЛИ (|). Эта операция позволяет установить конкретный бит в 1, не изменяя остальные биты числа.

🚩Как это работает

Операция ИЛИ (|) сравнивает каждый бит двух чисел. Если хотя бы один из битов в соответствующей позиции равен 1, результат в этой позиции будет 1. Иначе, результат будет 0.

🚩Шаги

1⃣Создаём маску, которая имеет единицу в позиции n и нули в остальных позициях. Это можно сделать с помощью выражения 1

🤔 Принцип Open/Closed (открытости/закрытости)?

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

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚Базу знаний