👉 map — это контейнер, реализующий ассоциативный массив, где каждый элемент представлен парой "ключ-значение". Ключи уникальны и автоматически сортируются.

👉 map основан на сбалансированном дереве поиска (обычно красно-черное дерево), что обеспечивает логарифмическое время доступа, вставки и удаления.

#include <iostream>
#include <map>

int main() {
    std::map<int, std::string> m;
    m[1] = "one"; // Вставка пары ключ-значение
    m[2] = "two";

    for (const auto& pair : m) {
        std::cout << pair.first << ": " << pair.second << std::endl; // Вывод ключа и значения
    }
}

map автоматически сортирует элементы по ключам.

Ставь 👍, если было полезно!
Больше ответов на сайте 👈

✈️ С++ собеседования

▶️ Union — это специальный тип данных, который позволяет хранить разные типы данных в одном и том же месте памяти. Все члены union используют одну и ту же область памяти, и в каждый момент времени может быть активно только одно значение.

#include <iostream>

union Data {
    int intValue;
    float floatValue;
    char charValue;
};

int main() {
    Data data;
    data.intValue = 10; // Устанавливаем значение int
    std::cout << "Int: " << data.intValue << std::endl;

    data.floatValue = 3.14f; // Перезаписываем значение float
    std::cout << "Float: " << data.floatValue << std::endl;

    return 0;
}

Union полезен для экономии памяти, но требует осторожности, так как изменение одного члена может затронуть другие.

Ставь 👍, если было полезно!
Больше ответов на сайте 👈

✈️ С++ собеседования

✅ Type traits — это шаблонные классы, предоставляющие информацию о типах во время компиляции. Они позволяют определять свойства типов, такие как принадлежность к числовым типам, возможность копирования и т.д. Используются для метапрограммирования и оптимизации.

#include <type_traits>

template<typename T>
void check() {
    // Проверка, является ли тип целочисленным
    if (std::is_integral<T>::value) {
        // Логика для целочисленных типов
    }
}

Ставь 👍, если было полезно!
Больше ответов на сайте 👈

✈️ С++ собеседования

➡️ Inline функции позволяют компилятору вставлять код функции непосредственно в место её вызова, что может уменьшить накладные расходы на вызов функции и повысить производительность. Однако компилятор может проигнорировать запрос на inline, если функция слишком сложная или если её использование нецелесообразно.

#include <iostream>

inline int add(int a, int b) {
    // Простая inline функция для сложения двух чисел
    return a + b;
}

int main() {
    int result = add(3, 4);
    std::cout << "Result: " << result << std::endl;
}

Inline функции полезны для небольших, часто вызываемых функций.

Ставь 👍, если было полезно!
Больше ответов на сайте 👈

✈️ С++ собеседования

❗️Основное отличие между массивами и векторами заключается в управлении памятью и гибкости.

Массив — это статический контейнер с фиксированным размером, который задаётся при создании. Размер массива не может изменяться в процессе выполнения программы.

int arr[5] = {1, 2, 3, 4, 5}; // Статический массив из 5 элементов

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

#include <vector>
std::vector<int> vec; // Инициализация вектора
vec.push_back(1); // Добавление элемента
vec.push_back(2); // Вектор автоматически увеличивает размер

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

Ставь 👍, если было полезно!
Больше ответов на сайте 👈

✈️ С++ собеседования

std::thread::hardware_concurrency — это статическая функция, которая возвращает количество потоков, которые могут быть выполнены одновременно на текущем оборудовании. Это значение обычно соответствует количеству логических процессоров (ядер) в системе.

Функция полезна для оптимизации многопоточных программ, так как позволяет определить оптимальное количество потоков для выполнения задач. Если функция не может определить количество ядер, она возвращает 0.

#include <iostream>
#include <thread>

int main() {
    unsigned int numThreads = std::thread::hardware_concurrency();
    std::cout << "Number of concurrent threads supported: " << numThreads << std::endl;
    return 0;
}

Использование hardware_concurrency помогает избежать создания избыточного количества потоков, что может привести к снижению производительности из-за накладных расходов на переключение контекста.

Ставь 👍, если было полезно!
Больше ответов на сайте 👈

✈️ С++ собеседования

std::array — это контейнер из стандартной библиотеки, представляющий статический массив фиксированного размера. В отличие от обычных массивов, std::array предоставляет дополнительные методы, такие как size(), begin(), end(), и поддерживает итераторы, что делает его более удобным и безопасным в использовании.

Пример:

#include <array>
#include <iostream>

int main() {
    std::array<int, 3> arr = {1, 2, 3}; // Создание массива из 3 элементов
    std::cout << "Size: " << arr.size() << std::endl; // Размер массива
}

std::array хранит данные на стеке, что обеспечивает высокую производительность, и гарантирует отсутствие утечек памяти.

Ставь 👍, если было полезно!
Больше ответов на сайте 👈

✈️ С++ собеседования

😎std::unique_lock — это класс из стандартной библиотеки, предоставляющий более гибкий способ управления мьютексами по сравнению с std::lock_guard. Он позволяет захватывать и освобождать мьютекс вручную, поддерживает отложенную блокировку, а также может быть перемещён или передан в другие функции.

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;

void task() {
    std::unique_lock<std::mutex> lock(mtx, std::defer_lock); // Отложенная блокировка
    lock.lock(); // Захват мьютекса
    std::cout << "Critical section\n";
    lock.unlock(); // Освобождение мьютекса
}

std::unique_lock полезен в сценариях, где требуется более тонкий контроль над блокировками, например, при использовании условных переменных.

Ставь 👍, если было полезно!
Больше ответов на сайте 👈

✈️ С++ собеседования

✔️ Функция sort в STL (Standard Template Library) сортирует элементы в диапазоне, заданном итераторами. По умолчанию используется оператор <, но можно передать пользовательский компаратор для определения порядка сортировки.

#include <algorithm>
#include <vector>

std::vector<int> vec = {4, 2, 5, 1, 3};
std::sort(vec.begin(), vec.end()); // Сортировка по возрастанию

Для сортировки по убыванию можно использовать std::greater:

std::sort(vec.begin(), vec.end(), std::greater<int>());

Функция sort работает за время O(N log N) и использует гибридный алгоритм (обычно Introsort), сочетающий QuickSort, HeapSort и InsertionSort. Это делает её эффективной для большинства случаев.

Ставь 👍, если было полезно!
Больше ответов на сайте 👈

✈️ С++ собеседования

▶️ std::is_same — это шаблонный метафункция из библиотеки <type_traits>, которая проверяет, являются ли два типа одинаковыми. Возвращает std::true_type, если типы идентичны, и std::false_type в противном случае.

#include <type_traits>

bool result1 = std::is_same<int, int>::value; // true
bool result2 = std::is_same<int, double>::value; // false

std::is_same часто используется в шаблонном программировании для проверки типов на этапе компиляции. Это позволяет создавать специализированные реализации функций или классов в зависимости от типов.

Ставь 👍, если было полезно!
Больше ответов на сайте 👈

✈️ С++ собеседования

✅ STL (Standard Template Library) — это библиотека, предоставляющая набор шаблонных классов и функций для работы с контейнерами, алгоритмами и итераторами. Она является частью стандартной библиотеки и широко используется для упрощения работы с данными.

Основные компоненты STL:
- Контейнеры: vector, list, map, set и другие структуры для хранения данных.
- Алгоритмы: sort, find, copy и другие операции над данными.
- Итераторы: обеспечивают доступ к элементам контейнеров.

Пример:

#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec = {5, 3, 1, 4, 2};
    std::sort(vec.begin(), vec.end()); // Сортировка вектора
    return 0;
}

STL позволяет писать эффективный и читаемый код, минимизируя ручное управление памятью и дублирование кода.

Ставь 👍, если было полезно!
Больше ответов на сайте 👈

✈️ С++ собеседования

std::packaged_task — это шаблонный класс, который оборачивает вызываемый объект (функцию, лямбду или функтор) и позволяет асинхронно получить результат его выполнения через std::future. Используется для выполнения задач в отдельном потоке с последующим получением результата.

Пример:

#include <future>
#include <iostream>

int main() {
    std::packaged_task<int()> task([](){ return 42; });
    std::future<int> result = task.get_future();
    
    std::thread t(std::move(task)); // Запуск задачи в отдельном потоке
    t.join();
    
    std::cout << result.get(); // Получение результата: 42
    return 0;
}

std::packaged_task полезен для управления асинхронными операциями и синхронизации результатов между потоками.

Ставь 👍, если было полезно!
Больше ответов на сайте 👈

✈️ С++ собеседования

std::array — это контейнер STL, предоставляющий статический массив фиксированного размера с дополнительными методами для удобства работы. Для использования необходимо подключить заголовочный файл <array>.

#include <array>
#include <iostream>

int main() {
    std::array<int, 5> arr = {1, 2, 3, 4, 5};  // Создание массива на 5 элементов

    arr[0] = 10;  // Доступ к элементам по индексу
    std::cout << "First element: " << arr.front() << "\n";  // Первый элемент
    std::cout << "Last element: " << arr.back() << "\n";  // Последний элемент
    std::cout << "Size: " << arr.size() << "\n";  // Размер массива

    for (int i : arr) {
        std::cout << i << " ";  // Итерация по массиву
    }
    return 0;
}

std::array сочетает в себе безопасность и удобство STL с производительностью обычных массивов.

Ставь 👍, если было полезно!
Больше ответов на сайте 👈

✈️ С++ собеседования