Перейти к содержимому

Ghoster AI 3.3.5 — новый раздел «Прогресс»

C/C++

992 вопросов в базе, 188 с лайвкодингом. Ниже — разобранные вопросы с ответами.

21 разобрано188 лайвкодинг
01Что происходит, если оператор new не может выделить память?Junior — Middle

Вызывается обработчик исключения std::bad_alloc . По умолчанию этот обработчик завершает программу вызовом std::terminate . Можно установить свой обработчик с помощью std::set_new_handler . Он будет вызываться, если выделение памяти не удалось. Обработчик должен либо освободить память для последующей попытки new , либо бросить исключение, либо завершить программу ( abort , exit ). Существует также не выбрасывающая исключения версия оператора new ( new (std::nothrow) ), которая в случае неудачи возвращает nullptr . # include <iostream> # include <new> # include <cstdlib> // Пользовательский обработчик void my_new_handler () { std::cerr << "Ошибка выделения памяти!" << std::endl; // Попытка освободить память или завершить программу std:: abort (); } int main () { try { // Установка пользовательского обработчика std:: set_new_handler (my_new_handler); // Попытка выделить большой объем памяти int * large_array = new int [ 1000000000000000000ULL ]; // Очень большой размер // Этот код не будет достигнут в случае успешного вызова обработчика delete [] large_array; } catch ( const std::bad_alloc& e) { // Этот блок кода будет выполнен, если my_new_handler // выбросит исключение std::bad_alloc (что не соответствует // поведению my_new_handler выше) std::cerr << "Исключение: " << e. what () << std::endl; } // Не выбрасывающая версия new int * array_nothrow = new (std::nothrow) int [ 1000000000000000000ULL ]; if (array_nothrow == nullptr ) { std::cerr << "Не удалось выделить память с помощью new (std::nothrow)" << std::endl; } else { delete [] array_nothrow; } return 0 ; }

02Расскажи, пожалуйста, о самых запоминающихся задачах или проектах из твоего прошлого опыта — что понравилось и что, наоборот, не понравилось.Intern — Middle

В проектах на C/C++ я участвовал в разработке системного и прикладного ПО. Например: • Разработка драйверов устройств, где требовалась работа с низкоуровневым взаимодействием с аппаратурой и оптимизация по производительности. • Создание модулей для обработки данных в реальном времени, где важна была высокая скорость и надежность. • Участие в проекте по разработке кроссплатформенного приложения с использованием C++ и Qt, где я занимался реализацией бизнес-логики и интеграцией с внешними библиотеками. В каждом проекте я применял навыки работы с памятью, отладкой и оптимизацией, а также взаимодействием с командой через системы контроля версий и таск-трекеры.

03При удалении объекта через указатель базового класса с определенным виртуальным деструктором, каким образом вызываются деструкторы в цепочке наследования?Junior — Middle

Если у базового класса объявлен виртуальный деструктор, то при удалении объекта через указатель на базовый класс вызывается цепочка деструкторов начиная с самого производного класса и вверх по иерархии наследования до базового. Это гарантирует корректное освобождение ресурсов, выделенных в производных классах. Пример: class Base { public : virtual ~ Base () { std::cout << "Base destructor\n" ; } }; class Derived : public Base { public : ~ Derived () override { std::cout << "Derived destructor\n" ; } }; int main () { Base* ptr = new Derived (); delete ptr; // Вызовет сначала Derived::~Derived(), затем Base::~Base() } Без виртуального деструктора вызов delete через указатель базового класса приведет к неопределённому поведению и, как правило, не вызовет деструктор производного класса.

04Расскажите о своем профессиональном опыте (предыдущая работа, проекты, стек технологий).Intern — Middle

В коммерческих проектах на C/C++ я участвовал в разработке системного и прикладного ПО. Например, работал над оптимизацией алгоритмов обработки данных, где важно было эффективно использовать память и минимизировать время отклика. Использовал стандартные библиотеки STL для контейнеров и алгоритмов, а также писал собственные структуры данных для специфичных задач. В проектах применял отладку с помощью gdb и профилирование для выявления узких мест. Также имел опыт интеграции C++ модулей с другими языками через API и работу с многопоточностью, используя std::thread и mutex для синхронизации.

05Какова сложность удаления элемента в контейнерах list и vector по итератору?Junior — Middle

В std::vector удаление элемента по итератору имеет сложность O(N), так как все элементы после удаленного должны быть сдвинуты. В std::list удаление элемента по итератору имеет сложность O(1), так как изменяются только указатели соседних элементов.

06Что такое коллизия и как она разрешается в unordered_map? Какие методы разрешения коллизий ты знаешь?Junior — Middle

Открытая адресация и метод цепочек. Открытая адресация: • Линейное зондирование: Поиск свободной ячейки происходит последовательно (H + 1, H + 2, ...). • Квадратичное зондирование: Поиск свободной ячейки происходит по квадратичной зависимости (H + 1², H + 2², ...). • Двойное хеширование: Используется вторая хеш-функция для определения шага при поиске (H + H2, H + 2*H2, ...). Пример линейного зондирования: // Простая хеш-функция int hash ( int key, int tableSize) { return key % tableSize; } // Поиск свободной ячейки int probe_linear ( int key, int tableSize, int attempt) { return ( hash (key, tableSize) + attempt) % tableSize; } // Пример использования int tableSize = 10 ; int key = 23 ; int attempt = 0 ; int index = probe_linear (key, tableSize, attempt); // Первая попытка // Если ячейка занята, увеличиваем attempt и повторяем Метод цепочек: Каждая ячейка хеш-таблицы содержит указатель на связный список (или другой контейнер), где хранятся элементы, коллизировавшие по данному индексу. Пример метода цепочек с использованием std::list : # include <list> # include <vector> // Пример хеш-таблицы с методом цепочек class HashTableChain { private : std::vector<std::list< int >> table; int tableSize; public : HashTableChain ( int size) : tableSize (size) { table. resize (tableSize); } int hash ( int key) const { return key % tableSize; } void insert ( int key) { int index = hash (key); // Проверяем на дубликаты перед вставкой, если требуется table[index]. push_back (key); } bool search ( int key) const { int index = hash (key); for ( int val : table[index]) { if (val == key) { return true ; } } return false ; } }; // Пример использования // HashTableChain ht(10); // ht.insert(23); // ht.insert(13); // Оба будут иметь тот же хеш (23%10=3, 13%10=3) Краткое сравнение: Алгоритм Преимущества Недостатки Открытая адресация Эффективнее кэш-память, нет накладных расходов на указатели. Чувствительна к фактору загрузки, проблема кластеризации. Метод цепочек Менее чувствителен к фактору загрузки, простая реализация. Дополнительные накладные расходы на указатели, менее эффективен для кэша.

07Как использовать свои структуры данных в качестве ключей в unordered_map?Junior — Middle+

Чтобы класс MyClass можно было использовать как ключ в std::map<MyClass, ValueType> и std::unordered_map<MyClass, ValueType> , необходимо: Для std::map : • Определить оператор < как нестатический член или свободную функцию. # include <string> class MyClass { public : int id; std::string name; // Оператор < для std::map bool operator <( const MyClass& other) const { if (id != other.id) { return id < other.id; } return name < other.name; } }; Для std::unordered_map : • Определить функтор хеширования (hash function) для MyClass . • Определить оператор == для сравнения на равенство. # include <functional> // Для std::hash # include <string> class MyClass { public : int id; std::string name; // Оператор == для std::unordered_map bool operator ==( const MyClass& other) const { return id == other.id && name == other.name; } }; // Специализация std::hash для MyClass // Это внешний функтор хеширования namespace std { template <> struct hash <MyClass> { size_t operator () ( const MyClass& obj) const { // Комбинируем хеши полей size_t h1 = hash< int >{}(obj.id); size_t h2 = hash<std::string>{}(obj.name); // Простой способ комбинирования // Более сложные методы могут обеспечить лучшую производительность return h1 ^ (h2 << 1 ); } }; } Сводная таблица требований: Требование std::map std::unordered_map Примечание Оператор < ✔ ✘ Для упорядочивания Оператор == ✘ ✔ Для сравнения на равенство Функтор хеширования ✘ ✔ Для вычисления хеша ключа

08Есть ли опыт использования примитивов синхронизации, таких как мьютексы и семафоры?Junior — Middle+

Для синхронизации процессов или потоков в C/C++ применяются различные методы и механизмы: • Мьютексы (mutex) — обеспечивают взаимное исключение, чтобы только один поток мог выполнять критическую секцию. • Семафоры — позволяют ограничить количество потоков, одновременно выполняющих определённый участок кода. • Условные переменные (condition variables) — позволяют потокам ждать наступления определённого события. • Барьеры (barriers) — синхронизируют группу потоков, заставляя их ждать друг друга. • Атомарные операции — операции, которые выполняются без прерывания, используются для простых синхронизаций. Пример использования мьютекса на C++11: # include <mutex> std::mutex mtx; void critical_section () { mtx. lock (); // код, который должен выполняться одним потоком mtx. unlock (); } Или с RAII: void critical_section () { std::lock_guard<std::mutex> lock (mtx) ; // безопасный доступ к общим ресурсам }

09Какие инструменты и программы ты применяешь в своей работе?Junior — Middle

В работе с C/C++ обычно применяю следующие инструменты и программы: • Компиляторы: GCC, Clang, MSVC — для компиляции и сборки проектов. • Среды разработки (IDE): Visual Studio, CLion, VS Code с плагинами для C/C++ — для удобного написания и отладки кода. • Отладчики: GDB, встроенные в IDE инструменты — для пошагового анализа и поиска ошибок. • Системы сборки: CMake, Make — для управления процессом сборки и зависимостями. • Статический анализ кода: clang-tidy, cppcheck — для выявления потенциальных ошибок и улучшения качества кода. • Профилировщики: Valgrind, perf — для анализа производительности и поиска утечек памяти. Пример использования CMakeLists.txt для сборки простого проекта: cmake_minimum_required(VERSION 3.10) project(MyProject) set(CMAKE_CXX_STANDARD 17) add_executable(my_app main.cpp) Этот набор инструментов позволяет эффективно разрабатывать, тестировать и поддерживать проекты на C/C++.

10Что делает std::move, когда срабатывает семантика перемещения и что происходит с исходным объектом?Junior — Middle+

std::move не перемещает данные сама по себе . Она преобразует lvalue в rvalue-ссылку, что позволяет вызвать конструктор перемещения (или оператор присваивания перемещением), если таковой существует для данного типа. Это дает компилятору понять, что исходный объект может быть безопасно "опустошен", так как его ресурс (например, память) будет передан новому объекту, а не скопирован. Основная цель: оптимизация при передаче временных объектов или объектов, которые больше не потребуются, избегая дорогостоящего копирования. Пример: # include <iostream> # include <vector> # include <utility> int main () { std::vector< int > source = { 1 , 2 , 3 , 4 , 5 }; // Без std::move - вызовется конструктор копирования (медленно для больших векторов) // std::vector<int> destination = source; // Со std::move - вызовется конструктор перемещения (быстро, ресурс передан) std::vector< int > destination = std:: move (source); // source после этого может быть в неопределенном состоянии, но валидном std::cout << "source size: " << source. size () << std::endl; std::cout << "destination size: " << destination. size () << std::endl; return 0 ; } В данном примере, вместо копирования всех элементов вектора source в destination при использовании std::move , ресурс (вероятно, указатель на динамически выделенный массив) передается из source в destination . В результате, source становится пустым (размер 0), а destination содержит данные.

11Можете объяснить отличие между ключевыми словами 'virtual' и 'override' в контексте ООП?Junior — Middle

В контексте ООП и языков C++/C# ключевое слово virtual используется для объявления метода в базовом классе, который может быть переопределён в производных классах. Это позволяет реализовать полиморфизм — вызов метода через указатель или ссылку на базовый класс будет динамически направлен на версию метода производного класса. Ключевое слово override используется в производном классе для явного указания, что метод переопределяет виртуальный метод базового класса. Это помогает компилятору проверить, что метод действительно переопределяет существующий виртуальный метод, и избежать ошибок, например, из-за опечаток в имени или несовпадения сигнатуры. Пример на C++: class Base { public : virtual void foo () { // virtual - метод можно переопределить std::cout << "Base foo" << std::endl; } }; class Derived : public Base { public : void foo () override { // override - явно переопределяем базовый виртуальный метод std::cout << "Derived foo" << std::endl; } }; Таким образом: • virtual объявляет метод виртуальным в базовом классе. • override подтверждает, что метод в производном классе переопределяет виртуальный метод базового класса.

12Расскажите про std::unique_ptr, std::shared_ptr и std::weak_ptr, их отличия и потокобезопасность.Junior — Middle

std::unique_ptr — умный указатель, который владеет объектом эксклюзивно. Он не копируемый, только перемещаемый, что гарантирует единственного владельца ресурса. При уничтожении unique_ptr освобождает управляемый объект. std::shared_ptr — умный указатель с подсчётом ссылок. Несколько shared_ptr могут владеть одним объектом. Объект удаляется, когда последний shared_ptr уничтожается или переназначается. std::weak_ptr — слабая ссылка на объект, управляемый shared_ptr . Не влияет на подсчёт ссылок, используется для предотвращения циклических зависимостей. Чтобы получить доступ к объекту, нужно преобразовать weak_ptr в shared_ptr через метод lock() . Пример: # include <memory> # include <iostream> int main () { std::unique_ptr< int > uptr = std:: make_unique < int >( 10 ); // std::unique_ptr<int> uptr2 = uptr; // Ошибка: нельзя копировать std::shared_ptr< int > sptr1 = std:: make_shared < int >( 20 ); std::shared_ptr< int > sptr2 = sptr1; // Подсчёт ссылок увеличивается std::weak_ptr< int > wptr = sptr1; // Не увеличивает счётчик if ( auto spt = wptr. lock ()) { // Проверяем, что объект ещё жив std::cout << *spt << std::endl; } }

13Чем отличаются std::map и std::unordered_map и что нужно определить для их работы?Junior — Middle

std::map : • Хранит элементы в отсортированном порядке по ключам. • Реализована на основе красно-черного дерева. • Время доступа, вставки и удаления в среднем логарифмическое: O(log n). • Ключи должны иметь оператор < . • Подходит, когда важен упорядоченный обход элементов или частые операции поиска диапазона. std::unordered_map : • Не хранит элементы в каком-либо определенном порядке. • Реализована на основе хэш-таблицы. • Среднее время доступа, вставки и удаления: O(1). В худшем случае (при плохом хэшировании и большом количестве коллизий): O(n). • Ключи должны быть хэшируемыми (предоставлять хэш-функцию) и иметь оператор == . • Подходит, когда главный приоритет — быстрое присутствие (lookup) элементов по ключу и порядок неважен. Сравнительная таблица: Признак std::map std::unordered_map Порядок Сортированный Неупорядоченный Структура данных Красно-черное дерево Хэш-таблица Средняя сложность O(log n) O(1) Требования к ключу Оператор < Хэшируемость, == Использование Упорядоченный доступ, диапазоны Быстрый поиск по ключу Пример использования std::map : # include <map> # include <string> # include <iostream> // Пример использования std::map std::map< int , std::string> my_map; my_map[ 5 ] = "five" ; my_map[ 2 ] = "two" ; my_map[ 8 ] = "eight" ; // Элементы будут выведены в отсортированном порядке по ключу for ( const auto & pair : my_map) { std::cout << pair.first << ": " << pair.second << std::endl; } Пример использования std::unordered_map : # include <unordered_map> # include <string> # include <iostream> // Пример использования std::unordered_map std::unordered_map< int , std::string> my_unordered_map; my_unordered_map[ 5 ] = "five" ; my_unordered_map[ 2 ] = "two" ; my_unordered_map[ 8 ] = "eight" ; // Порядок вывода элементов не гарантируется for ( const auto & pair : my_unordered_map) { std::cout << pair.first << ": " << pair.second << std::endl; }

14Что вы можете рассказать о работе с исключениями в конструкторах?Junior — Middle+

При вызове конструктора, если при инициализации члена класса или в теле конструктора возникает исключение, выполнение конструктора прерывается. Если исключение выбрасывается до того, как конструктор объекта полностью завершился, деструктор этого объекта вызван не будет. Это может привести к утечкам ресурсов, если конструктор успел выделить ресурсы, но не успел их освободить до выброса исключения. При работе с исключениями в конструкторах важно учитывать следующее: • Утечки ресурсов: Если конструктор выделяет ресурсы (например, память, файлы) и затем выбрасывает исключение до того, как ресурсы будут освобождены, произойдет утечка. • Частично сконструированные объекты: В случае исключения объект может оказаться в неполностью инициализированном состоянии. Обращение к такому объекту после перехвата исключения может привести к неопределенному поведению. Для безопасной работы с исключениями в конструкторах применяют следующие подходы: • Идиома RAII (Resource Acquisition Is Initialization): Ресурсы заворачиваются в классы, чьи конструкторы их выделяют, а деструкторы освобождают. Таким образом, при выбросе исключения деструкторы автоматически вызываются для уже сконструированных членов и базовых классов, обеспечивая освобождение ресурсов. // Пример использования RAII с умным указателем # include <memory> # include <iostream> class Resource { public : Resource () { std::cout << "Resource acquired\n" ; } ~ Resource () { std::cout << "Resource released\n" ; } }; class MyClass { std::unique_ptr<Resource> res; public : MyClass () : res (std:: make_unique <Resource>()) { // Здесь может возникнуть исключение // Если исключение возникнет, unique_ptr освободит ресурс if ( true ) { // Имитация условия для исключения // throw std::runtime_error("Error in constructor"); } } }; // int main() { // try { // MyClass obj; // } catch (const std::exception& e) { // std::cerr << "Caught exception: " << e.what() << std::endl; // } // return 0; // } • Функция-член init() : В конструкторе выполняется только простая инициализация, а более сложная логика, которая может выбросить исключение, выносится в отдельную функцию-член init() , которую вызывается после успешного создания объекта. class MyClass { // Члены класса public : MyClass () { // Простая инициализация, не выбрасывающая исключения } void init () { // Более сложная логика, которая может выбросить исключение if ( true ) { // Имитация условия для исключения // throw std::runtime_error("Error in initialization"); } } }; // int main() { // try { // MyClass obj; // obj.init(); // Вызываем init после создания объекта // } catch (const std::exception& e) { // std::cerr << "Caught exception: " << e.what() << std::endl; // } // return 0; // } • Конструкторы-делегаты (C++11 и новее): Позволяют конструкторам вызывать другие конструкторы того же класса. Это может быть полезно для централизации логики инициализации, включая потенциальное выбрасывание исключений. class MyClass { int value; public : MyClass ( int v) : value (v) { if (v < 0 ) { throw std:: invalid_argument ( "Value must be non-negative" ); } // Дополнительная логика инициализации } MyClass () : MyClass ( 0 ) {} // Конструктор-делегат }; // int main() { // try { // MyClass obj1(10); // MyClass obj2(-5); // Выбросит исключение // } catch (const std::exception& e) { // std::cerr << "Caught exception: " << e.what() << std::endl; // } // return 0; // } Выбор подхода зависит от сложности инициализации и специфики класса. RAII является предпочтительным способом управления ресурсами в C++.

15Как работает оператор new в C++?Junior — Middle+

Оператор new размещает объект или массив объектов в динамической памяти (куче) и возвращает указатель на размещенный объект. Процесс работы: • Выделение памяти: Вызывается соответствующая функция выделения памяти. Для одиночного объекта - operator new(size_t) , для массива объектов - operator new[](size_t) . Эти функции по умолчанию выделяют сырую память. • Вызов конструктора(ов): Если выделяется объект (не просто сырая память), вызывается соответствующий конструктор для инициализации выделенного объекта. Для массива вызывается конструктор для каждого элемента массива. • Возврат указателя: Оператор new возвращает типизированный указатель на начало выделенной и инициализированной памяти. Пример выделения одиночного объекта: // Выделение памяти для объекта типа MyClass и вызов его конструктора по умолчанию MyClass* obj = new MyClass (); Пример выделения массива объектов: // Выделение памяти для массива из 10 объектов типа MyClass и вызов их конструкторов по умолчанию MyClass* arr = new MyClass[ 10 ]; Для освобождения памяти, выделенной с помощью new , используется оператор delete . Для массива - delete[] . Неверное использование delete или delete[] приведет к неопределенному поведению. Перегрузка operator new и operator delete позволяет кастомизировать процесс выделения и освобождения памяти.

16Можно ли безопасно вызывать оператор delete на нулевом указателе?Junior — Middle

Да, в C++ оператор delete можно безопасно вызывать на нулевом (nullptr) указателе. В стандарте языка указано, что вызов delete для нулевого указателя не приводит к ошибке и просто не выполняет никаких действий. Пример: int * p = nullptr ; delete p; // Безопасно, ничего не происходит Это позволяет не проверять указатель на nullptr перед удалением, упрощая код и предотвращая возможные ошибки.

17Можете объяснить назначение и работу ключевого слова 'virtual' в объектно-ориентированном программировании?Junior — Middle+

Ключевое слово virtual в C++ используется для объявления виртуальных функций — методов класса, которые могут быть переопределены в производных классах и вызываются динамически (во время выполнения), а не статически (во время компиляции). Это основа полиморфизма в объектно-ориентированном программировании. Когда функция объявлена как virtual в базовом классе, вызов этой функции через указатель или ссылку на базовый класс будет направлен на версию функции, соответствующую реальному типу объекта (даже если тип переменной — базовый). Пример: # include <iostream> class Base { public : virtual void show () { std::cout << "Base show" << std::endl; } }; class Derived : public Base { public : void show () override { std::cout << "Derived show" << std::endl; } }; int main () { Base* ptr = new Derived (); ptr-> show (); // Выведет "Derived show" благодаря virtual delete ptr; return 0 ; } Без virtual вызов ptr->show() вызвал бы метод базового класса, игнорируя переопределение в производном классе. Таким образом, virtual позволяет реализовать динамический полиморфизм, что важно для гибкой архитектуры программ.

18На каких контейнерах основаны структуры данных stack и queue?Junior — Middle

std::stack по умолчанию основан на std::deque . std::queue по умолчанию также основан на std::deque . Можно использовать и другие контейнеры: • std::stack может быть основан на std::vector или std::list . • std::queue может быть основан на std::list . Необходимое условие для базового контейнера: поддержка операций добавления и удаления элементов с одного или обоих концов (для stack - только с одного, для queue - с разных). Примеры использования с другими контейнерами: # include <stack> # include <queue> # include <vector> # include <list> // stack на базе std::vector std::stack< int , std::vector< int >> vector_stack; // stack на базе std::list std::stack< int , std::list< int >> list_stack; // queue на базе std::list std::queue< int , std::list< int >> list_queue;

19Можно ли выбрасывать исключение из деструктора и ловить его?Junior — Middle+

Можно, но крайне не рекомендуется. Выброшенное исключение из деструктора может привести к неопределённому поведению, особенно если деструктор вызывается в процессе раскрутки стека из-за другого исключения. # include <iostream> # include <stdexcept> struct Resource { ~ Resource () { // Крайне не рекомендуется выбрасывать исключение из деструктора std::cerr << "Деструктор Resource вызывается." << std::endl; // throw std::runtime_error("Исключение из деструктора Resource"); } }; void func_with_exception () { Resource r; throw std:: runtime_error ( "Исключение из func_with_exception" ); } int main () { try { func_with_exception (); } catch ( const std::exception& e) { // Если исключение выброшено из деструктора при раскрутке стека // здесь может произойти terminate() или другое неопределённое поведение. std::cerr << "Поймано исключение: " << e. what () << std::endl; } return 0 ; } Основные причины, почему не стоит выбрасывать исключения из деструкторов: • Двойные исключения: Если деструктор вызывается во время обработки другого исключения (например, при раскрутке стека), выброс нового исключения приведет к одновременному существованию двух активных исключений, что является неопределённым поведением и частому вызову std::terminate() . • Неполная очистка ресурсов: Если в деструкторе происходит ошибка и выбрасывается исключение, последующие операции очистки в том же деструкторе могут не выполняться, приводя к утечкам ресурсов или другим проблемам. • Сложное управление ошибками: Обработка исключений из деструкторов усложняет логику программы и затрудняет понимание потока выполнения. В C++11 и новее деструкторы по умолчанию считаются noexcept , что означает, что они не должны выбрасывать исключения. Если деструктор noexcept выбрасывает исключение, происходит немедленный вызов std::terminate() . Чтобы разрешить деструктору выбрасывать исключения, его нужно явно объявить как noexcept(false) . # include <iostream> # include <stdexcept> struct ResourceMayThrow { ~ ResourceMayThrow () noexcept ( false ) { std::cerr << "Деструктор ResourceMayThrow вызывается." << std::endl; // В данном случае исключение можно выбросить, но по-прежнему не рекомендуется // throw std::runtime_error("Исключение из деструктора ResourceMayThrow"); } }; int main () { try { ResourceMayThrow r; // Если здесь произойдет исключение, и деструктор также выбросит исключение, // это приведет к std::terminate(). } catch ( const std::exception& e) { std::cerr << "Поймано исключение в main: " << e. what () << std::endl; } return 0 ; } Вместо выбрасывания исключений из деструктора, рекомендуется использовать следующие подходы для обработки ошибок при освобождении ресурсов: • Возврат кода ошибки: Если деструктор может завершиться с ошибкой, структура может хранить флаг ошибки, который можно проверить после её удаления. • Логирование: Регистрировать ошибки при очистке ресурсов в лог-файл или стандартный поток ошибок. • Реализация функции close() или release() : Предоставить отдельную функцию для явного закрытия ресурса, которая может выбрасывать исключения, и вызвать её до выхода объекта из области видимости. RAII-объекты должны гарантировать освобождение ресурсов в своих деструкторах, даже если явный вызов close() не был сделан. Подход Рекомендуется ли Примечания Выбрасывание исключения Нет Может привести к std::terminate() и неопределённому поведению. Возврат кода ошибки Да (при необходимости) Требует явной проверки ошибки после использования объекта. Логирование Да Полезно для отладки, но не останавливает выполнение программы. Функция close / release Да Позволяет явно обрабатывать ошибки при освобождении, деструктор безопасен. В целом, безопасный деструктор — это такой, который никогда не выбрасывает исключения, что является частью принципа RAII (Resource Acquisition Is Initialization).

20Какова асимптотическая сложность операций вставки и удаления элементов в контейнерах list и vector?Junior — Middle

std::vector : Операция Асимптотическая сложность Примечания Вставка O(N) в худшем случае Требует сдвига всех последующих элементов. Вставка в конец ( push_back ) Амортизированная O(1) Может потребовать перевыделения памяти O(N). Удаление O(N) в худшем случае Требует сдвига всех последующих элементов. Удаление с конца ( pop_back ) O(1) Не требует сдвигов. std::list : Операция Асимптотическая сложность Примечания Вставка O(1) Требует лишь изменения указателей. Удаление O(1) Требует лишь изменения указателей.

21C/C++Junior — Senior

Ответ доступен в приложении.