Скрининг на middle-senior C/C++ Разработчик в Лаборатория Касперского

1. Что такое идиома RAII (Resource Acquisition Is Initialization)?

2. Какая техника есть и что делает lock_guard?

3. Помимо lock_guard, что ещё есть?

4. Какие есть объекты, которые во время инициализации что-то делают, а во время деинициализации разрушаются или вызывается деструктор?

5. Как работают умные указатели, где используются и зачем нужны?

6. Зачем нужны weak_ptr и как они работают?

7. Чем unique_ptr отличается от shared_ptr?

8. В каких случаях unique_ptr предпочтительней shared_ptr?

9. Когда нужно организовать единичное владение объектом?

10. Почему предпочтительней пользоваться std::make_shared и std::make_unique и от чего это защищает?

11. Что общего между умными указателями и lock_guard?

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

15. В каких случаях виртуальный деструктор важен?

16. В каких случаях будут утечки памяти?

17. Что такое поток?

18. Что такое процесс и в чем его отличие от потока?

19. Что такое единица трансляции?

20. У вас есть 2 мьютекса и два потока, случается дедлок. Из-за чего это чаще происходит и как его вызвать?

21. Какие есть примитивы синхронизации?

22. Что такое семафор, как он работает и зачем нужен?

23. Что такое критическая секция?

24. Есть ли в WinAPI понятие мьютекса?

25. Задача: Что произойдет в представленном коде и какое исключение выбросится? Можно ли из деструкторов кидать исключения и почему это плохо?

struct data_exception : public std::exception {};
struct main_exception : public std::exception {};

struct Data
{
    Data()
    {
        throw data_exception();
    }
};

int main()
{
    try
    {
        Data data;
        throw main_exception();
    }
    catch (const std::exception&)
    {
        // обработчик 1
    }
    catch (main_exception&)
    {
        // обработчик 2
    }
    catch (data_exception&)
    {
        // обработчик 3
    }

    return 0;
}

26. Задача: Где будет выделена память под указанные переменные и у каких из них может быть утечка памяти?

namespace
{
    class A { ... };
    A a1;
    const A a2;
}

void f()
{
    A a3;
    A* a4 = new A();
    std::unique_ptr a5 = std::make_unique();
    std::shared_ptr a6 = std::make_shared();
    char b1;
    char* b2 = reinterpret_cast<char*>(std::malloc(10));
}