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

🤔 Строгая гарантия безопасности Гарантии безопасности исключений в C++ делятся на три уровня: Базовая гарантия (Basic Guarantee) – программа не падает, но объект может остаться в некорректном состоянии. Строгая гарантия (Strong Guarantee) – либо операция завершается успешно, либо объект остаётся в том же состоянии, что и до вызова. Гарантия отсутствия исключений (No-Throw Guarantee) – операция никогда не бросает исключений. 🚩Что такое строгая гарантия безопасности исключений? Строгая гарантия (Strong Guarantee) означает, что если во время выполнения операции выбрасывается исключение, объект остаётся неизменным. Это похоже на транзакции в базе данных – "всё или ничего".

    
        #include <iostream>
#include <vector>

class BadContainer {
    std::vector<int> data;
public:
    void add(int value) {
        data.push_back(value); // push_back() может выбросить исключение
    }

    void print() {
        for (int x : data) std::cout << x << " ";
        std::cout << std::endl;
    }
};

int main() {
    BadContainer c;
    c.add(1);
    c.add(2);
    c.add(3);
    c.print();  // Вывод: 1 2 3

    try {
        c.add(42);  // Может выбросить исключение (например, нехватка памяти)
    } catch (...) {
        std::cout << "Ошибка!\n";
    }

    c.print();  // ❌ Возможно, состояние испорчено!
}{}
    

🚩Как реализовать строгую гарантию? Чтобы добиться строгой гарантии, используем Copy & Swap: 1. Создаём временный объект. 2. Выполняем изменения на временном объекте. 3. Если всё прошло успешно – меняем указатель (swap).

    
        #include <iostream>
#include <vector>

class SafeContainer {
    std::vector<int> data;
public:
    void add(int value) {
        std::vector<int> temp = data;  // Создаём копию текущего состояния
        temp.push_back(value);         // Добавляем элемент в копию
        std::swap(data, temp);         // Если исключения не было, меняем данные
    }

    void print() {
        for (int x : data) std::cout << x << " ";
        std::cout << std::endl;
    }
};

int main() {
    SafeContainer c;
    c.add(1);
    c.add(2);
    c.add(3);
    c.print();  // Вывод: 1 2 3

    try {
        c.add(42);  // Если тут исключение, объект не изменится
    } catch (...) {
        std::cout << "Ошибка!\n";
    }

    c.print();  // ✅ Вывод: 1 2 3 (не испорчен!)
}{}
    

🚩Где используется строгая гарантия? Операции присваивания (operator=) с Copy & Swap Методы стандартных контейнеров (std::vector::resize, std::map::insert) Функции стандартной библиотеки (std::sort) Изменения объектов с ресурсами (файлы, сокеты, память) Ставь 👍 и забирай 📚 Базу знаний

🤔 Что можешь рассказать о little-endian и big-endian? Little-endian и big-endian — это порядки байтов в мультибайтовых данных, используемые в компьютерной архитектуре для хранения данных. В little-endian младший байт сохраняется по низкому адресу, а старший байт по высокому. В big-endian старший байт сохраняется по низкому адресу, а младший по высокому. Выбор порядка байтов влияет на совместимость и производительность системы в различных сценариях использования. Ставь 👍 если знал ответ, 🔥 если нет Забирай 📚Базу знаний

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

    
        #include <iostream>

class Base {
public:
    Base() {
        std::cout << "Base constructor\n";
        // Вызов виртуальной функции из конструктора
        this->virtualFunction();
    }

    virtual ~Base() {
        std::cout << "Base destructor\n";
        // Вызов виртуальной функции из деструктора
        this->virtualFunction();
    }

    virtual void virtualFunction() {
        std::cout << "Base virtualFunction\n";
    }
};

class Derived : public Base {
public:
    Derived() {
        std::cout << "Derived constructor\n";
    }

    ~Derived() override {
        std::cout << "Derived destructor\n";
    }

    void virtualFunction() override {
        std::cout << "Derived virtualFunction\n";
    }
};

int main() {
    Derived d;
    return 0;
}{}
    

🤔 Вывод программы:

    
        Base constructor
Base virtualFunction
Derived constructor
Derived destructor
Base destructor
Base virtualFunction{}
    

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

🤔 Какая есть разница ссылки и указателя? Ссылка — это алиас для существующего объекта и не может быть null или изменена для указания на другой объект после инициализации. Указатель — это переменная, которая хранит адрес объекта и может быть изменена для указания на разные объекты или быть null. Указатели поддерживают арифметику адресов, в то время как ссылки этого не делают. Ссылки обеспечивают более безопасное управление памятью, но менее гибкие, чем указатели. Ставь 👍 если знал ответ, 🔥 если нет Забирай 📚Базу знаний

🤔 Коллизия - когда для разных ключей получается одно и тоже хэш значение? В контексте хеш-таблиц и хеш-функций коллизия возникает, когда два разных входных значения (ключа) генерируют одно и то же хеш-значение. Это является фундаментальной проблемой в хеш-таблицах, поскольку идея хеширования заключается в эффективном размещении и извлечении данных с использованием хеш-кода как индекса в массиве или списке. 🚩Причины возникновения 🟠Ограниченное количество возможных хеш-значений Поскольку количество возможных хеш-значений фиксировано (и обычно меньше, чем количество возможных ключей), статистически неизбежно, что разные ключи будут иметь одинаковые хеш-значения. 🟠Неидеальные хеш-функции Хеш-функции могут не равномерно распределять хеш-значения, что увеличивает вероятность коллизий. 🚩Способы решения 🟠Цепочки (Chaining) В этом методе каждая ячейка хеш-таблицы содержит указатель на список (или другую структуру данных, например, связный список), которые хранят все элементы, имеющие одинаковый хеш. Это простой и эффективный метод, но может потребовать больше памяти и времени при обращении к элементам. 🟠Открытая адресация (Open Addressing) Включает в себя методы, такие как линейное пробирование, квадратичное пробирование и двойное хеширование. При возникновении коллизии метод находит следующую свободную ячейку в таблице для размещения нового элемента. 🟠Двойное хеширование (Double Hashing) Использует вторую хеш-функцию для определения интервала между пробами, уменьшая вероятность коллизий, которые происходят при первичном хешировании. Ставь 👍 и забирай 📚 Базу знаний

🤔 Как называется одинаковый результат после применения хэш-функции? Это называется коллизия (hash collision) — ситуация, при которой два разных значения дают один и тот же хэш. Ставь 👍 если знал ответ, 🔥 если нет Забирай 📚Базу знаний

🤔 Когда при вызове exception не зовутся деструкторы? В C++ деструкторы объектов вызываются автоматически при выходе из области видимости, даже если выход происходит из-за исключения. Однако есть ситуации, когда деструкторы могут не вызваться, что может привести к утечке ресурсов. 🟠Динамически выделенные объекты (`new`) Если объект был создан с помощью new, но перед его удалением произошло исключение, деструктор не вызовется автоматически.

    
        #include <iostream>

class A {
public:
    A() { std::cout << "Конструктор A\n"; }
    ~A() { std::cout << "Деструктор A\n"; }
};

void func() {
    A* obj = new A();  // Создаем объект динамически
    throw std::runtime_error("Ошибка!"); // Исключение, объект утечет
    delete obj; // Никогда не выполнится
}

int main() {
    try {
        func();
    } catch (...) {
        std::cout << "Исключение поймано\n";
    }
}{}
    

Как исправить? Использовать std::unique_ptr, который автоматически удаляет объект

    
        #include <memory>

void func() {
    std::unique_ptr<A> obj = std::make_unique<A>();
    throw std::runtime_error("Ошибка!"); // Деструктор вызовется автоматически
}{}
    

🟠Локальные объекты, созданные `new` внутри `try`, но `catch` не обработал исключение Если объект выделяется внутри try, но исключение не ловится в catch, программа завершится (std::terminate), и деструкторы не вызовутся.

    
        void func() {
    A* obj = new A();
    throw std::runtime_error("Ошибка!"); // std::terminate()
    delete obj;
}

int main() {
    func(); // Исключение не ловится => программа аварийно завершится
}{}
    

Как исправить? Нужно обрабатывать исключение на верхнем уровне

    
        int main() {
    try {
        func();
    } catch (...) {
        std::cout << "Ошибка обработана\n";
    }
}{}
    

🟠Исключение в конструкторе Если исключение возникает в конструкторе, деструктор этого объекта не вызывается, но деструкторы уже созданных объектов будут вызваны.

    
        class B {
public:
    B() { std::cout << "Конструктор B\n"; }
    ~B() { std::cout << "Деструктор B\n"; }
};

class A {
public:
    A() {
        std::cout << "Конструктор A\n";
        throw std::runtime_error("Ошибка в конструкторе A");
    }
    ~A() { std::cout << "Деструктор A\n"; } // Никогда не вызовется!
};

int main() {
    try {
        B b;
        A a;  // Исключение в конструкторе A
    } catch (...) {
        std::cout << "Исключение обработано\n";
    }
}{}
    

Вывод

    
        Конструктор B
Конструктор A
Исключение обработано
Деструктор B{}
    

Как исправить? - Использовать концепцию "умные указатели" (std::unique_ptr), чтобы ресурсы очищались автоматически. - Переносить ресурсоемкие операции в отдельный метод (init()), который можно вызывать после конструктора. 🟠Исключение в деструкторе Если деструктор объекта бросает исключение, это опасно, особенно если исключение возникло в момент обработки другого исключения.

    
        class A {
public:
    ~A() {
        std::cout << "Деструктор A\n";
        throw std::runtime_error("Ошибка в деструкторе!"); // Ошибка
    }
};

int main() {
    try {
        A a;
        throw std::runtime_error("Основное исключение");
    } catch (...) {
        std::cout << "Исключение обработано\n";
    }
}{}
    

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

    
        class A {
public:
    ~A() {
        try {
            throw std::runtime_error("Ошибка в деструкторе!");
        } catch (...) {
            std::cout << "Ошибка подавлена в деструкторе\n";
        }
    }
};{}
    

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

🤔 Какие виды конструкторов могут быть у класса? 🟠Конструктор по умолчанию (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-контейнеры vector и array? 1. vector: - Динамический массив, размер которого можно изменять. - Управляет памятью автоматически. - Подходит для сценариев, где размер данных неизвестен заранее. 2. array: - Статический массив, размер которого фиксирован при создании. - Не выделяет и не освобождает память динамически. - Быстрее и эффективнее для небольших данных с фиксированным размером. Ставь 👍 если знал ответ, 🔥 если нет Забирай 📚Базу знаний

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