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

🤔 Принцип Open/Closed (открытости/закрытости)? Принцип открытости/закрытости гласит, что классы должны быть открыты для расширения, но закрыты для модификации. Это достигается за счёт использования абстракций, чтобы добавлять функциональность через наследование или композицию, не изменяя исходный код. Ставь 👍 если знал ответ, 🔥 если нет Забирай 📚Базу знаний

🤔 Что необходимо иметь классу, что бы использовать его в качестве ключа к ассоциативным контейнерам? Чтобы класс мог использоваться в качестве ключа в ассоциативных контейнерах (например, в std::map или std::unordered_map), он должен удовлетворять определённым требованиям. 🚩Ассоциативные контейнеры на основе дерева 🟠Оператор сравнения Класс должен иметь определённый оператор сравнения. По умолчанию, std::map и std::set используют оператор operator< для сравнения ключей. Это необходимо, чтобы контейнер мог упорядочивать ключи. В этом примере класс MyKey имеет перегруженный оператор operator<, что позволяет использовать его в качестве ключа в std::map.

    
        #include <iostream>
#include <map>

class MyKey {
public:
    int value;
    
    MyKey(int v) : value(v) {}
    
    bool operator<(const MyKey& other) const {
        return value < other.value;
    }
};

int main() {
    std::map<MyKey, std::string> myMap;
    myMap[MyKey(1)] = "one";
    myMap[MyKey(2)] = "two";
    
    for (const auto& pair : myMap) {
        std::cout << pair.first.value << ": " << pair.second << std::endl;
    }
    
    return 0;
}{}
    

🚩Неупорядоченные ассоциативные контейнеры 🟠Функция хэширования Класс должен быть хэшируемым. Это означает, что для него должна быть определена функция хэширования. В стандартной библиотеке C++ можно определить специализированный шаблон std::hash для вашего класса. 🟠Операторы сравнения на равенство Класс должен иметь определённый оператор operator==. В этом примере для класса MyKey определён оператор operator== и специализированный шаблон std::hash, что позволяет использовать его в качестве ключа в std::unordered_map.

    
        #include <iostream>
#include <unordered_map>
#include <functional>

class MyKey {
public:
    int value;
    
    MyKey(int v) : value(v) {}
    
    bool operator==(const MyKey& other) const {
        return value == other.value;
    }
};

namespace std {
    template <>
    struct hash<MyKey> {
        std::size_t operator()(const MyKey& k) const {
            return std::hash<int>()(k.value);
        }
    };
}

int main() {
    std::unordered_map<MyKey, std::string> myMap;
    myMap[MyKey(1)] = "one";
    myMap[MyKey(2)] = "two";
    
    for (const auto& pair : myMap) {
        std::cout << pair.first.value << ": " << pair.second << std::endl;
    }
    
    return 0;
}{}
    

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

🤔 Как можно проверить, что нет double exception? Используйте функцию std::uncaught_exceptions() (C++17) или std::uncaught_exception() (до C++17) для проверки активного исключения. Ставь 👍 если знал ответ, 🔥 если нет Забирай 📚Базу знаний

🔥 Записал видос "Как за 3 минуты настроить Автоотклики на вакансии HeadHunter" больше не придется заниматься этой унылой рутиной 📺 Видео: https://youtu.be/G_FOwEGPwlw

🤔 Для чего используется ключевое слово volatile? Используется для обозначения переменных, значение которых может изменяться неожиданно для компилятора. Это может происходить, например, из-за внешних факторов вне контроля программы, таких как аппаратные регистры, прерывания или многопоточные среды. volatile говорит компилятору, что он не должен оптимизировать код, касающийся этих переменных, и всегда должен считывать их значения непосредственно из памяти. 🚩Основные применения 🟠Аппаратные регистры Переменные, связанные с аппаратными устройствами, такими как порты ввода-вывода, часто меняются вне контроля программы. Использование volatile предотвращает оптимизации, которые могли бы кэшировать значение регистров.

    
        volatile int* port = reinterpret_cast<int*>(0x400);
*port = 42; // Запись в аппаратный регистр   {}
    

🟠Переменные, изменяемые прерываниями В системах реального времени и встроенных системах значения переменных могут изменяться в обработчиках прерываний. volatile гарантирует, что каждое обращение к такой переменной будет действительным.

    
        volatile bool interruptFlag = false;

void interruptHandler() {
    interruptFlag = true; // Устанавливается в обработчике прерывания
}

void mainFunction() {
    while (!interruptFlag) {
        // Ожидание установки флага прерывания
    }
    // Обработка прерывания
}   {}
    

🟠Многопоточные приложения Переменные, которые могут изменяться из других потоков, также могут быть помечены как volatile. Однако следует отметить, что volatile не обеспечивает защиту от гонок данных и не заменяет средства синхронизации, такие как мьютексы или атомарные операции.

    
        volatile bool stopThread = false;

void workerThread() {
    while (!stopThread) {
        // Выполнение работы
    }
}

int main() {
    std::thread t(workerThread);
    // ...
    stopThread = true; // Остановка рабочего потока
    t.join();
    return 0;
}   {}
    

🚩Особенности и ограничения 🟠Оптимизация компиляции volatile предотвращает оптимизации компилятором, которые могли бы удалить или кэшировать доступы к переменной. 🟠Не потокобезопасность volatile не обеспечивает потокобезопасность. Для обеспечения корректной работы в многопоточной среде следует использовать мьютексы, атомарные операции или другие механизмы синхронизации. 🟠Совместное использование с `const` Переменные могут быть как const volatile, если они не должны изменяться программой, но могут изменяться внешними факторами. 🚩Пример: Аппаратные регистры

    
        #include <iostream>

volatile int* hardwareRegister = reinterpret_cast<int*>(0x400);

void writeToRegister(int value) {
    *hardwareRegister = value; // Запись в регистр
}

int readFromRegister() {
    return *hardwareRegister; // Чтение из регистра
}

int main() {
    writeToRegister(100);
    std::cout << "Register value: " << readFromRegister() << std::endl;
    return 0;
}{}
    

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

🤔 Что происходит, когда случается коллизия при получении ключа для контейнера? 1. При коллизии несколько ключей имеют одинаковый хеш-код. 2. Контейнер использует методы разрешения коллизий: o Связанные списки (chaining): все элементы с одним хешем добавляются в связанный список внутри одного bucket'а. o Открытая адресация: поиск свободной ячейки для хранения данных. 3. После нахождения bucket'а выполняется проверка на равенство ключей с помощью метода equals. Ставь 👍 если знал ответ, 🔥 если нет Забирай 📚Базу знаний

🤔 Как можно взвести бит используя побитовую операцию ИЛИ? Чтобы взвести (установить) бит в определённое значение (1) в числе, можно использовать побитовую операцию ИЛИ (|). Эта операция позволяет установить конкретный бит в 1, не изменяя остальные биты числа. 🚩Как это работает Операция ИЛИ (|) сравнивает каждый бит двух чисел. Если хотя бы один из битов в соответствующей позиции равен 1, результат в этой позиции будет 1. Иначе, результат будет 0. 🚩Шаги 1⃣Создаём маску, которая имеет единицу в позиции n и нули в остальных позициях. Это можно сделать с помощью выражения 1 << n. 2⃣Применяем операцию ИЛИ между числом x и маской.

    
        #include <iostream>

int main() {
    int x = 0b00001010; // Число, с которым работаем (10 в десятичной системе)
    int n = 3;          // Позиция бита, которую хотим установить (начиная с 0)

    // Создаём маску с единицей в позиции n
    int mask = 1 << n;

    // Устанавливаем бит в позиции n
    x = x | mask;

    // Вывод результата
    std::cout << "Результат: " << std::bitset<8>(x) << std::endl; // Двоичный вывод
    std::cout << "Результат: " << x << std::endl; // Десятичный вывод

    return 0;
}{}
    

1 << n создает маску, сдвигая 1 влево на n позиций. Например, если n = 3, результат будет 0b00001000. Операция x | mask устанавливает бит в x на позиции n в 1. Если бит в x на позиции n уже был 1, он останется 1, если он был 0, то станет 1. 🚩Пример вывода Если x было 0b00001010 и n = 3, результат будет: Маска: 0b00001000 x | mask: 0b00001010 | 0b00001000 = 0b00001010 В результате бит в позиции 3 установлен в 1, и итоговое значение числа в двоичном формате 0b00001010 (десятичное 10). Ставь 👍 и забирай 📚 Базу знаний

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

🤔 Какая есть оптимизация в строках С++? Стандартный класс std::string в C++ имеет несколько механизмов оптимизации для повышения производительности и уменьшения расхода памяти. Рассмотрим основные из них. 🟠Small String Optimization (SSO) – Оптимизация малых строк Если строка маленькая (обычно до 15-23 байт, зависит от реализации), std::string не выделяет динамическую память, а хранит символы прямо внутри объекта std::string. Обычно std::string содержит: - Указатель на динамическую память - Размер строки - Вместимость (capacity) Но если строка короткая, память не выделяется в куче (heap), а данные хранятся прямо внутри объекта std::string.

    
        #include <iostream>
#include <string>

int main() {
    std::string small = "Hello"; // Использует SSO
    std::string large = "This is a very long string that will not fit SSO"; // Динамическая память

    std::cout << "Small string: " << small << "\n";
    std::cout << "Large string: " << large << "\n";
}{}
    

🟠Copy-on-Write (COW) – Оптимизация копирования (устарела) Раньше (до C++11) std::string использовал технику Copy-on-Write (COW), где несколько строк могли разделять одну и ту же память, пока одна из них не изменялась. Почему отказались? Не потокобезопасно (если один поток меняет строку, другой может получить неожиданные данные). В C++11 было добавлено std::move, которое делает копирование дешевле. SSO делает COW менее нужной.

    
        std::string a = "Hello";
std::string b = a; // Копия не создается, оба указывают на одну память
b[0] = 'X'; // Теперь создаётся отдельная копия{}
    

🟠Move Semantics – Семантика перемещения (C++11) Вместо дорогостоящего копирования std::string теперь можно перемещать с помощью std::move(), передавая владение ресурсом без копирования.

    
        #include <iostream>
#include <string>

int main() {
    std::string a = "Hello, world!";
    std::string b = std::move(a); // Перемещение, a становится пустой
    std::cout << "b: " << b << "\n"; // "Hello, world!"
}{}
    

🟠Reserve() – Избегание частых выделений памяти Если заранее известно, сколько символов потребуется, можно использовать .reserve(size), чтобы избежать многократных перевыделений памяти.

    
        std::string str;
str.reserve(100); // Сразу выделяет память на 100 символов
for (int i = 0; i < 100; i++) {
    str += 'a'; // Не перевыделяет память 100 раз
}{}
    

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

🤔 Можно ли бросить исключение из деструктора и перехватить его? Бросать исключение из деструктора можно, однако это крайне не рекомендуется, так как если исключение будет выброшено во время обработки другого исключения, произойдет вызов `std::terminate()`, что приведет к завершению программы. Тем не менее, исключение из деструктора можно перехватить внутри самого деструктора или в другом месте программы. Хорошей практикой является либо избежание выбрасывания исключений из деструкторов, либо использование механизма `noexcept` для предотвращения исключений. Ставь 👍 если знал ответ, 🔥 если нет Забирай 📚Базу знаний