С ++ Кратко: приобретение ресурсов — это инициализация

Что такое РАИИ?

RAII означает «получение ресурсов — это инициализация». RAII — это шаблон проектирования, использующий код C ++ для устранения утечек ресурсов. Утечка ресурсов происходит, когда ресурс, полученный вашей программой, впоследствии не освобождается. Самый знакомый пример — утечка памяти. Поскольку в C ++ нет GC, как в C #, вам нужно быть осторожным, чтобы освободить динамически выделенную память. В противном случае вы потеряете эту память. Утечка ресурсов также может привести к невозможности открытия файла, поскольку файловая система считает, что он уже открыт, невозможности получить блокировку в многопоточной программе или невозможности освободить объект COM.

Как работает RAII?

RAII работает из-за трех основных фактов.

1. Когда объект длительности автоматического хранения выходит из области видимости, запускается его деструктор.
2. Когда возникает исключение, все объекты автоматической продолжительности, которые были полностью сконструированы с момента начала последнего блока try, уничтожаются в обратном порядке, в котором они были созданы до вызова любого обработчика catch.
3. Если вы вкладываете try-блоки, и ни один из обработчиков catch внутреннего try-блока не обрабатывает этот тип исключения, тогда исключение распространяется на внешний try-блок. Все объекты автоматической длительности, которые были полностью построены в этом внешнем блоке try, затем уничтожаются в обратном порядке создания, прежде чем вызывается какой-либо обработчик catch и т. Д., Пока что-то не перехватит исключение или ваша программа не вылетит.

RAII помогает вам высвобождать ресурсы без исключений, просто используя объекты автоматического хранения, которые содержат ресурсы. Это похоже на комбинацию интерфейса System.IDisposable вместе с оператором using в C #. Как только выполнение покидает текущий блок, будь то в результате успешного выполнения или исключения, ресурсы освобождаются.

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

Это не означает, что его переменные-члены, которые являются объектами, не будут уничтожены. Любые объекты переменных-членов, которые были полностью созданы в конструкторе до возникновения исключения, являются полностью созданными объектами автоматической длительности. Таким образом, эти объекты-члены будут уничтожены так же, как и любые другие полностью построенные объекты.

Вот почему вы всегда должны помещать динамические выделения в std::unique_ptr или std::shared_ptr . Экземпляры этих типов становятся полностью сконструированными объектами при успешном размещении. Даже если в дальнейшем конструктор созданного вами объекта завершится сбоем, ресурсы std::unique_ptr будут освобождены его деструктором, а для ресурсов std::shared_ptr их счетчик ссылок будет уменьшен и будет освобожден, если счет станет равным нулю.

RAII, конечно, не только о shared_ptr и unique_ptr. Это также относится к другим типам ресурсов, таким как файловый объект, где получение является открытием файла, а деструктор обеспечивает правильное закрытие файла. Это особенно хороший пример, поскольку вам нужно только один раз создать правильный код — когда вы пишете класс, — а не снова и снова, что вам нужно делать, если вы пишете логику закрытия в каждом месте, где вам нужно открыть файл.

Как я могу использовать RAII?

Использование RAII описывается его именем: получение динамического ресурса должно завершить инициализацию объекта. Если вы следуете этому шаблону «один ресурс на объект», то невозможно получить утечку ресурса. Либо вы успешно приобретете ресурс, и в этом случае объект, который его инкапсулирует, завершит строительство и будет подвергнут уничтожению, либо попытка получения не удастся, и в этом случае вы не получили ресурс; таким образом, нет ресурса для освобождения.

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

Если деструктор сгенерировал необъяснимое исключение, то, цитируя Бьярна Страуструпа, «все виды плохих вещей могут произойти, потому что основные правила стандартной библиотеки и самого языка будут нарушены. Не делай этого.

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

Теперь вы можете подумать, что если вы будете следовать этому шаблону, вы в конечном итоге будете писать массу классов. Время от времени вы будете писать дополнительный класс здесь, но вряд ли вы будете писать слишком много из-за умных указателей. Умные указатели тоже объекты. Большинство типов динамических ресурсов можно поместить по крайней мере в один из существующих классов интеллектуальных указателей. Если вы поместите получение ресурса в подходящий интеллектуальный указатель, и если получение будет успешным, тогда этот интеллектуальный указатель будет полностью создан. Если возникает исключение, то будет вызван деструктор объекта смарт-указатель, и ресурс будет освобожден.

Существует несколько важных типов интеллектуальных указателей. Давайте посмотрим на них.

Функция std::unique_ptr

Уникальный указатель std::unique_ptr предназначен для хранения указателя на динамически размещенный объект. Вы должны использовать этот тип только тогда, когда вы хотите, чтобы существовал один указатель на объект. Это шаблонный класс, который принимает обязательный и необязательный аргумент шаблона. Обязательный аргумент — это тип указателя, который он будет содержать. Например, auto result = std::unique_ptr<int>(new int()); создаст уникальный указатель, который содержит int *. Необязательный аргумент — это тип удалителя. Мы видим, как написать удалитель в следующем примере. Как правило, вы можете избежать указания удалителя, так как default_deleter, который предоставляется вам, если не указан ни один удалитель, охватывает почти все случаи, которые вы можете себе представить.

Класс, в котором переменная-член std::unique_ptr не может иметь конструктор копирования по умолчанию. Семантика копирования отключена для std::unique_ptr . Если вам нужен конструктор копирования в классе, который имеет уникальный указатель, вы должны написать его. Вы также должны написать перегрузку для оператора копирования. Обычно в этом случае вы хотите использовать std::shared_ptr .

Однако у вас может быть что-то вроде массива данных. Вы также можете захотеть, чтобы любая копия класса создала копию данных, существующих в то время. В этом случае уникальный указатель с пользовательским конструктором копирования может быть правильным выбором.

std::unique_ptr определяется в заголовочном файле <memory>.

std::unique_ptr имеет четыре представляющие интерес функции-члена.

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

Функция-член release также возвращает сохраненный указатель, но release отменяет действие unique_ptr в процессе, заменяя сохраненный указатель нулевым указателем. Если у вас есть функция, в которой вы хотите создать динамический объект и затем вернуть его, сохраняя при этом безопасность исключений, используйте std:unique_ptr для хранения динамически созданного объекта, а затем верните результат вызова release. Это дает вам исключительную безопасность, позволяя вам возвращать динамический объект, не разрушая его с помощью деструктора std::unique_ptr , когда элемент управления выходит из функции после возврата освобожденного значения указателя в конце.

Функция-член swap позволяет двум уникальным указателям обмениваться своими сохраненными указателями, поэтому если A содержит указатель на X, а B содержит указатель на Y, результат вызова A::swap(B); является то, что теперь A будет содержать указатель на Y, а B будет содержать указатель на X. Удалители для каждого также будут поменяны местами, поэтому, если у вас есть пользовательский удалитель для одного или обоих уникальных указателей, будьте уверены, что каждый будет сохранить связанный с ним удалитель.

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

Функция std::shared_ptr

Общий указатель, std::shared_ptr , предназначен для хранения указателя на динамически размещенный объект и для подсчета ссылок на него. Это не волшебство; если вы создадите два общих указателя и передадите им каждый указатель на один и тот же объект, вы получите два общих указателя — каждый со счетчиком ссылок 1, а не 2. Первый уничтоженный освободит базовый ресурс, давая катастрофические результаты, когда вы пытаетесь использовать другой или когда другой уничтожается и пытается освободить уже освобожденный базовый ресурс.

Чтобы правильно использовать общий указатель, создайте один экземпляр с указателем объекта, а затем создайте все другие общие указатели для этого объекта из существующего действительного общего указателя для этого объекта. Это обеспечивает общий счетчик ссылок, поэтому ресурс будет иметь правильное время жизни. Давайте рассмотрим быстрый пример, чтобы увидеть правильные и неправильные способы создания объектов shared_ptr.

Образец: SharedPtrSample \ SharedPtrSample.cpp

std::shared_ptr определен в заголовочном файле <memory>.

std::shared_ptr имеет пять функций-членов.

Функция-член get работает так же, как и функция-член std :: unique_ptr :: get.

Функция-член use_count возвращает long, который сообщает вам текущий счетчик ссылок для целевого объекта. Это не включает слабые ссылки.

Уникальная функция-член возвращает bool, сообщая вам, является ли данный конкретный общий указатель единственным владельцем целевого объекта.

Функция-член swap работает так же, как и функция-член std::unique_ptr::swap , с тем добавлением, что подсчет ссылок для ресурсов остается прежним.

Функция-член сброса уменьшает счетчик ссылок для базового ресурса и уничтожает его, если счетчик ресурсов становится равным нулю. Если указатель на объект передается, общий указатель сохранит его и начнет новый счетчик ссылок для этого указателя. Если передается nullptr или параметр не передается, то общий указатель будет хранить ноль.

Функция std::make_shared

Функция шаблона std::make_shared — это удобный способ создания исходного std::shared_ptr . Как мы видели ранее в SharedPtrSample , вы передаете тип в качестве аргумента шаблона, а затем просто передаете аргументы, если они есть, для нужного конструктора. std::make_shared создаст экземпляр кучи типа объекта аргумента шаблона и превратит его в std::shared_ptr . Затем вы можете передать этот std::shared_ptr в качестве аргумента конструктору std::shared_ptr чтобы создать больше ссылок на этот общий объект.

ComPtr в WRL для приложений в стиле Metro

Библиотека шаблонов времени выполнения Windows (WRL) предоставляет интеллектуальный указатель с именем ComPtr в пространстве имен Microsoft :: WRL для использования с COM-объектами в приложениях в стиле Metro в Windows 8. Указатель находится в заголовке <wrl / client.h> как часть Windows SDK (минимальная версия 8.0).

Большая часть функциональности операционной системы, которую вы можете использовать в приложениях в стиле Metro, предоставляется средой выполнения Windows («WinRT»). Объекты WinRT предоставляют свои собственные функции автоматического подсчета ссылок для создания и уничтожения объектов. Некоторые системные функции, такие как Direct3D, требуют непосредственного использования и управления им через классический COM. ComPtr обрабатывает подсчет ссылок на основе IUnknown для вас. Он также предоставляет удобные оболочки для QueryInterface и включает в себя другие функциональные возможности, которые полезны для интеллектуальных указателей.

Обычно вы используете две функции-члена As, чтобы получить другой интерфейс для нижележащего COM-объекта, и Get для получения указателя интерфейса на нижележащий COM-объект, который содержит ComPtr (это эквивалентно std::unique_ptr::get ).

Иногда вы будете использовать Detach, который работает так же, как std :: unique_ptr :: release, но имеет другое имя, потому что release в COM подразумевает уменьшение количества ссылок, а Detach этого не делает.

Вы можете использовать ReleaseAndGetAddressOf для ситуаций, когда у вас есть существующий ComPtr, который уже может содержать COM-объект, и вы хотите заменить его новым COM-объектом того же типа. ReleaseAndGetAddressOf делает то же самое, что и функция-член GetAddressOf, но сначала высвобождает базовый интерфейс, если таковой имеется.

Исключения в C ++

В отличие от .NET, где все исключения происходят из System.Exception и имеют гарантированные методы и свойства, исключения C ++ не обязаны происходить из чего-либо; и при этом они даже не обязаны быть типами классов. В C ++ бросьте L «Hello World!»; вполне приемлемо для компилятора, как и throw 5 ;. В принципе, исключения могут быть чем угодно.

Тем не менее, многие программисты на C ++ будут недовольны, увидев исключение, которое не является производным от std::exception (находится в заголовке <exception>). Вывод всех исключений из std::exception обеспечивает способ перехвата исключений неизвестного типа и извлечения информации из них через функцию what перед повторным вызовом. std::exception::what принимает параметров и возвращает const char* string , которую вы можете просмотреть или записать в журнал, чтобы вы знали, что вызвало исключение.

Нет трассировки стека — не считая возможностей трассировки стека, которые предоставляет ваш отладчик, — за исключением C ++. Поскольку объекты автоматической длительности в области действия блока try, который перехватывает исключение, автоматически уничтожаются до активации соответствующего обработчика перехвата, если таковой имеется, вы не можете позволить себе роскошь изучить данные, которые могли вызвать исключение. Все, что вам нужно для начала работы, — это сообщение от функции-члена what.

Если легко воссоздать условия, которые привели к исключению, вы можете установить точку останова и перезапустить программу, что позволит вам выполнить выполнение проблемной области и, возможно, выявить проблему. Поскольку это не всегда возможно, важно быть максимально точным с сообщением об ошибке.

При выводе из std::exception вы должны обязательно переопределить функцию-член what для предоставления полезного сообщения об ошибке, которое поможет вам и другим разработчикам диагностировать неисправность.

Некоторые программисты используют вариант правила, утверждающего, что вы всегда должны генерировать std::exception определенные в std::exception -derived. Помня, что точка входа (main или wmain) возвращает целое число, эти программисты будут генерировать std::exception derived, когда их код сможет восстановиться, но просто выдают четко определенное целочисленное значение, если сбой неустранимый. Код точки входа будет заключен в блок try, в котором есть зацепка для int. Обработчик catch возвращает возвращенное значение int. В большинстве систем возвращаемое значение 0 из программы означает успех. Любое другое значение означает неудачу.

Если происходит катастрофический сбой, то бросание четко определенного целочисленного значения, отличного от 0, может помочь придать некоторое значение. Если вы не работаете над проектом, в котором этот стиль является предпочтительным, вам следует придерживаться std::exception полученных из std::exception — так как они позволяют программам обрабатывать исключения с помощью простой системы ведения журнала для записи сообщений от исключений, которые не были обработаны, и выполняют любую очистку это безопасно. Бросок чего-то, что не является производным от std::exception будет мешать этим механизмам регистрации ошибок.

И последнее, на что следует обратить внимание, — это то, что конструкция finally C # не имеет эквивалента в C ++. Идиома RAII, при правильном применении, делает ее ненужной, поскольку все будет очищено.

Исключения стандартной библиотеки C ++

Мы уже обсуждали std::exception , но в стандартной библиотеке доступно больше типов, чем доступно, и есть дополнительные функциональные возможности для изучения. Давайте сначала посмотрим на функциональность из заголовочного файла <exception>.

Функция std::terminate по умолчанию позволяет вам std::terminate работу любого приложения. Его следует использовать с осторожностью, поскольку его вызов, а не создание исключения, обойдет все обычные механизмы обработки исключений. Если вы хотите, вы можете написать пользовательскую функцию завершения без параметров и возвращаемых значений. Пример этого будет видно в ExceptionsSample, который будет опубликован.

Чтобы установить пользовательский терминатор, вы вызываете std::set_terminate и передаете ему адрес функции. Вы можете изменить пользовательский обработчик завершения в любое время; последний набор функций — это то, что будет вызываться в случае вызова std::terminate или необработанного исключения. Обработчик по умолчанию вызывает функцию прерывания из заголовочного файла <cstdlib>.

Заголовок <stdexcept> обеспечивает элементарную структуру для исключений. Он определяет два класса, которые наследуются от std::exception . Эти два класса служат родительским классом для нескольких других классов.

Класс std::runtime_error является родительским классом для исключений, std::runtime_error средой выполнения или из-за ошибки в функции стандартной библиотеки C ++. Его потомками являются класс std::overflow_error класс std::range_error класс std::range_error .

Класс std::logic_error является родительским классом для исключений, std::logic_error из-за ошибки программиста. Его потомками являются класс std::domain_error класс std::invalid_argument класс std::length_error класс std::out_of_range .

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

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

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

Класс шаблона может показаться запутанным прямо сейчас; мы будем обсуждать шаблоны в следующей главе, после чего все, что в настоящее время неясно, должно проясниться.

Образец: ExceptionsSample \ InvalidArgumentException.h

Образец: ExceptionsSample \ ExceptionsSample.cpp

Хотя я упоминал об этом в комментариях, я просто хотел еще раз указать, что пользовательская функция завершения не будет работать, пока вы не запустите этот пример из командной строки. Если вы запустите его в Visual Studio, отладчик перехватит программу и организует собственное завершение после того, как даст вам возможность проверить состояние, чтобы увидеть, можете ли вы определить, что пошло не так. Также обратите внимание, что эта программа всегда будет аварийно завершать работу. Это сделано специально, так как позволяет увидеть обработчик завершения в действии.

Вывод

Как мы видели в этой статье, RAII помогает обеспечить высвобождение ресурсов без исключений, просто используя объекты автоматического хранения, содержащие ресурсы. В следующем выпуске этой серии мы увеличим указатели и ссылки.

Этот урок представляет собой главу из C ++ Succinctly , бесплатной книги от команды Syncfusion .