Операции new и delete в c. Всё ли мы знаем об операторах new и delete? Пример освобождения памяти
Автоматические объекты удаляются неявно в соответствии с чёткими правилами, которые реализованы в компиляторе. Локальные переменные функции удаляются, когда поток управления покидает область видимости, в которой они объявлены. Члены класса удаляются после выполнения деструктора этого класса.
А вот для динамических объектов таких правил нет. Их нужно всегда удалять явно (явное удаление может быть скрыто в недрах утилитарных классов и функций). Вот небольшая иллюстрация для лучшего понимания:
struct A
{
std::string str; // Автоматический объект, неявно удаляется в деструкторе A (который сгенерирован
// автоматически). Сам строковый буфер - динамический объект (*), будет явно
// удалён в деструкторе std::string, который будет неявно вызван в деструкторе A.
// (*) Если только строка не слишком короткая, тогда сработает Small String Optimization и динамический
// буфер вообще не будет выделен.
};
void foo()
{
std::vector
Обычно динамические объекты находятся в куче, хотя в общем случае это не так. Автоматические объекты могут находиться как на стеке, так и в куче. В примере выше автоматический объект upa->str находится в куче, т.к. он - часть динамического объекта *upa . Т.е. свойства динамический/автоматический определяют время жизни, но не место жизни объекта.
Свойство динамический/автоматический принадлежит именно объекту, а не типу, т.к. объекты одного и того же типа могут быть как динамическими, так и автоматическими ). В примере выше объекты a и *pa оба имеют тип А, но первый является автоматическим, а второй - динамическим.
Динамические объекты в С++ создаются с помощью new , а удаляются с помощью delete . Вот отсюда и все проблемы: никто не говорил, что эти конструкции следует использовать напрямую! Это низкоуровневые вызовы, они как бы под капотом. И не нужно лезть под капот без необходимости.
О том, зачем вообще могут понадобиться динамические объекты, мы поговорим чуть позже.
* Существуют техники, чтобы ограничить свойство динамический/автоматический на уровне типа. Например, закрытые конструкторы.
В чём проблема с new и delete ?
С самого момента своего изобретения операторы new и delete используются неоправданно часто. Самые большие проблемы относятся к оператору delete:- Можно вообще забыть вызвать delete (утечка памяти, memory leak).
- Можно забыть вызвать delete в случае исключения или досрочного возврата из функции (тоже утечка памяти).
- Можно вызвать delete дважды (двойное удаление, double delete).
- Можно вызвать не ту форму оператора: delete вместо delete или наоборот (неопределённое поведение, undefined behavior).
- Можно использовать объект после вызова delete (dangling pointer).
Поэтому люди давно сообразили прятать оператор delete в недрах контейнеров и умных указателей, убрав тем самым его из клиентского кода. Однако с оператором new тоже связаны проблемы, но для них решения появились не сразу, и, по факту, многие разработчики до сих пор стесняются этими решениями пользоваться. Об этом мы подробнее поговорим, когда дойдём до make -функций.
Теперь перейдём к сценариям использования new и delete . Напомню, что мы рассмотрим несколько сценариев и планомерно покажем, что в большинстве из них код станет лучше, если отказаться от использования new и delete .
Начнём с простого - с динамических массивов.
Динамические массивы
Динамический массив - это массив с элементами, выделенными в динамической памяти. Он необходим в случае, если размер неизвестен на этапе компиляции, или если размер достаточно большой, и мы не хотим выделять массив на стеке, размер которого обычно сильно ограничен.Для выделения динамических массивов С++ на низком уровне предоставляет векторную форму операторов new и delete: new и delete . В качестве примера рассмотрим некоторую функцию, которая работает с внешним буфером:
void DoWork(int* buffer, size_t bufSize);
Подобные функции часто встречаются в библиотеках с API на чистом С . Ниже приведён пример, как может выглядеть использующий её код. Это плохой код, т.к. он в явном виде использует delete , а связанные с ним проблемы мы уже описали выше.
void Call(size_t n)
{
int* p = new int[n];
DoWork(p, n);
delete p; // Плохо!
}
Тут всё просто и большинству известно, что для подобных целей в С++ следует использовать стандартный контейнер std::vector . Он сам выделит память в конструкторе и освободит её в деструкторе. К тому же, он ещё может менять свой размер во время жизни, но для нас это сейчас значения не имеет. С использованием вектора код будет выглядеть так:
void Call(size_t n)
{
std::vector
Тем самым мы решаем все проблемы, связанные с вызовом delete , и к тому же вместо безликой пары указатель+число, имеем явный контейнер с удобным интерфейсом.
При этом никаких new и delete . Не буду более подробно останавливаться на этом сценарии. По моему опыту большинство разработчиков и так знает, что следует делать в данном случае и почему.
* На С++ подобный интерфейс следовало бы реализовать с использованием типа span
** Поскольку эту статью читают программисты на С++, я почти уверен, что кто-то подумает: «Ха! std::vector хранит в себе целых три (!) указателя, когда старый добрый int* - это по определению всего один указатель. Налицо перерасход памяти и нескольких машинных инструкций на их инициализацию! Это неприемлемо!». Майерс отлично прокомментировал это свойство программистов на С++ в своём докладе Why C++ Sails When the Vasa Sank . Если для вас это действительно
проблема, то могу порекомендовать std::unique_ptr
Динамические объекты
Динамические объекты обычно используются, когда невозможно привязать время жизни объекта к какой-то конкретной области видимости. Если это можно сделать, наверняка следует использовать автоматическую память , (см. почему не стоит злоупотреблять динамическими объектами). Но это предмет отдельной статьи.Когда динамический объект создан, кто-то должен его удалить, и условно типы объектов можно разделить на две группы: те, которые никак не осведомлены о процессе своего удаления, и те, которые что-то подозревают. Будем говорить, что первые имеют стандартную модель управления памятью, а вторые - нестандартную.
К типам со стандартной моделью управления памятью относятся все стандартные типы , включая контейнеры. В самом деле, контейнер управляет памятью, которую он выделил сам. Ему нет никакого дела до того, кто его создал и как он будет удалён.
К типам с нестандартной моделью управления памятью можно отнести, например, объекты Qt. Здесь у каждого объекта есть родитель, который ответственен за его удаление. И объект об этом знает, т.к. он наследуется от класса QObject . Сюда же относятся типы со счётчиком ссылок, например, рассчитанные на работу с boost::intrusive_ptr .
Иными словами, тип со стандартной моделью управления памятью не предоставляет никаких дополнительных механизмов для управления своим временем жизни. Этим целиком и полностью должна заниматься пользовательская сторона. А вот тип с нестандартной моделью такие механизмы предоставляет. Например, QObject имеет методы setParent() и children() и содержит в себе список детей, а тип boost::intrusive_ptr опирается на функции intrusive_ptr_add_ref и intrusive_ptr_release и содержит в себе счётчик ссылок.
Если тип объекта имеет стандартную модель управления памятью, то будем для краткости говорить, что это объект со стандартным управлением памятью. Аналогично, если тип объекта имеет нестандартную модель управления памятью, то будем говорить, что это объект с нестандартным управлением памятью.
Далее рассмотрим объекты обеих моделей. Забегая вперёд, стоит сказать, что для объектов со стандартным управлением памятью однозначно не стоит использовать new и delete в клиентском коде, а для объектов с нестандартным - зависит от конкретной модели.
* Некоторые исключения: идиома pimpl; очень большой объект (например, буфер памяти).
** Исключение составляет std::locale::facet (см. дальше).
Динамические объекты со стандартным управлением памятью
Таковые чаще всего встречаются на практике. И именно их следует стараться использовать в современном С++, потому как с ними работают стандартные подходы, используемые в частности в умных указателях.Собственно, умные указатели, да, это ответ. Именно им следует отдать управление временем жизни динамических объектов. Их в С++ целых два: std::shared_ptr и std::unique_ptr . Не будем здесь выделять std::weak_ptr , т.к. это просто помощник для std::shared_ptr в определённых сценариях использования.
Что касается std::auto_ptr , он был официально исключён из С++ начиная с С++17. Покойся с миром!
Не буду здесь останавливаться на устройстве и использовании умных указателей, т.к. это выходит за рамки статьи. Сразу напомню, что они идут в комплекте с замечательными функциями std::make_shared и std::make_unique , и именно их следует использовать для создания умных указателей.
Т.е. вместо вот такого:
std::unique_ptr
следует писать вот так:
auto cookie = std::make_unique
Преимущества make -функций над явным созданием умных указателей прекрасно описаны Гербом Саттером в его GotW #89 и Скоттом Майерсом в его Effective Modern C++ , Item 21. Не буду повторяться, лишь приведу здесь краткий список тезисов:
- Для обеих make -функций:
- Безопасность с точки зрения исключений.
- Нет дублирования имени типа.
- Для std::make_shared:
- Выигрыш в производительности, т.к. контрольный блок выделяется рядом с самим объектом, что уменьшает количество обращений к менеджеру памяти и увеличивает локальность данных. Оптимизация .
- Для обеих make -функций:
- Нельзя передать свой deleter . Это вполне логично, т.к. внутри себя make -функции по определению используют стандартный new .
- Нельзя использовать braced initializer , а также все прочие тонкости, связанные с perfect forwarding (см. Effective Modern C++, Item 30).
- Для std::make_shared:
- Потенциальный перерасход памяти для больших объектов при долгоживущих слабых ссылках (std::weak_pointer).
- Проблемы с операторами new и delete переопределёнными на уровне класса.
- Потенциальное ложное разделение (false sharing) между объектом и контрольным блоком (см. вопрос на StackOverflow).
Кстати, устройство make -функций серьёзно раскрывает в своих докладах Стефан Лававей (a.k.a. STL). Приведу здесь красноречивый слайд из его доклада Don’t Help the Compiler:
Динамические объекты с нестандартным управлением памятью
Помимо стандартного подхода управления памятью через умные указатели встречаются и другие модели. Например, подсчёт количества ссылок (reference counting) и отношения родитель-ребёнок (parent to child relationship).Динамические объекты с подсчётом ссылок
Очень часто встречающийся приём, используемый во многих библиотеках. Рассмотрим в качестве примера библиотеку OpenSceneGraph. Это открытый кроссплатформенный 3D-движок, написанный на С++ и OpenGL.
Большая часть классов в нём наследуется от класса osg::Referenced , который осуществляет внутри себя подсчёт ссылок. Метод ref() увеличивает счётчик, метод unref() уменьшает счётчик и удаляет объект, когда счётчик опускается до нуля.
В комплекте также идёт умный указатель osg::ref_ptr
Рассмотрим фрагмент кода, который приведён в официальном руководстве OpenSceneGraph 3.0: Beginner"s guide :
osg::ref_ptr
Очень знакомые конструкции вида osg::ref_ptr
namespace osg
{
template
Перепишем этот фрагмент кода вооружившись нашей новой функцией:
auto vertices = osg::make_ref
Изменения тривиальны и легко могут быть выполнены автоматически. Таким нехитрым способом мы получаем безопасность с точки зрения исключений , отсутствие дублирования имени типа и прекрасное соответствие стандартному стилю.
Вызов delete уже был спрятан в методе osg::Referenced::unref() , а теперь мы спрятали и вызов new в функции osg::make_ref . Так что никаких new и delete .
* Технически, в данном фрагменте нет ситуаций небезопасных с точки зрения исключений, но в более сложных конфигурациях они могли бы быть.
Динамические объекты для немодальных диалогов в MFC
Рассмотрим пример, специфичный для библиотеки MFC. Это обёртка из классов С++ над Windows API. Она используется для упрощения разработки GUI под Windows.
Интересен приём, которым Microsoft официально рекомендует пользоваться для создания немодальных диалогов. Т.к. диалог немодальный, не совсем ясно, кто ответственен за его удаление. Предлагается ему удалять себя самому в переопределённом методе CDialog::PostNcDestroy() . Этот метод вызывается после обработки сообщения WM_NCDESTROY - последнего сообщения, получаемого окном в его жизненном цикле.
В примере ниже диалог создаётся по нажатию на кнопку в методе CMainFrame::OnBnClickedCreate() и удаляется в переопределённом методе CMyDialog::PostNcDestroy() .
void CMainFrame::OnBnClickedCreate()
{
auto* pDialog = new CMyDialog(this);
pDialog->ShowWindow(SW_SHOW);
}
class CMyDialog: public CDialog
{
public:
CMyDialog(CWnd* pParent)
{
Create(IDD_MY_DIALOG, pParent);
}
protected:
void PostNcDestroy() override
{
CDialog::PostNcDestroy();
delete this;
}
};
Здесь у нас не спрятан ни вызов new , ни вызов delete . Способов выстрелить себе в ногу - масса. Помимо обычных проблем с указателями, можно забыть переопределить в своём диалоге метод PostNcDestroy() , получим утечку памяти. При виде вызова new , может возникнуть желание самостоятельно вызвать в определённый момент delete , получим двойное удаление. Можно случайно создать объект диалога в автоматической памяти, снова получим двойное удаление.
Попробуем спрятать вызовы к new и delete внутри промежуточного класса CModelessDialog и фабрики CreateModelessDialog , которые будут отвечать в нашем приложении за немодальные диалоги:
class CModelessDialog: public CDialog
{
public:
CModelessDialog(UINT nIDTemplate, CWnd* pParent)
{
Create(nIDTemplate, pParent);
}
protected:
void PostNcDestroy() override
{
CDialog::PostNcDestroy();
delete this;
}
};
// Фабрика для создания модальных диалогов
template
Класс сам переопределяет метод PostNcDestroy() , в котором мы спрятали delete , а для создания классов наследников используется фабрика, в которой мы спрятали new . Создание и определение класса наследника теперь выглядит так:
void CMainFrame::OnBnClickedCreate()
{
CreateModelessDialog
Конечно, подобным образом мы не решили всех проблем. Например, объект всё равно можно выделить на стеке и получить двойное удаление. Запретить выделение объекта на стеке можно только путём модификации самого класса объекта, например добавлением закрытого конструктора. Но мы никак не можем этого сделать из базового класса CModelessDialog . Можно, конечно, вообще сокрыть класс CMyDialog и сделать фабрику не шаблонной, а более классической, принимающей некоторый идентификатор класса. Но это всё уже выходит за рамки статьи.
Так или иначе, мы упростили создание диалога из клиентского кода и написание нового класса диалога. И при этом мы убрали из клиентского кода вызовы new и delete .
Динамические объекты с отношением родитель-ребёнок
Встречаются достаточно часто, особенно в библиотеках для разработки GUI. В качестве примера рассмотрим Qt - хорошо известную библиотеку для разработки приложений и UI.
Большая часть классов наследуется от QObject . Он хранит в себе список детей и удаляет их, когда удаляется сам. Хранит указатель на родителя (может быть нулевой) и может менять родителя в процессе жизни.
Отличный пример ситуации, когда избавиться от new и delete так просто не получится. Библиотека проектировалась таким образом, что эти операторы можно и нужно применять во многих случаях. Я предлагал обёртку для создания объектов с ненулевым родителем, но идея не пошла (см. обсуждение в Qt mailing list).
Таким образом, мне неизвестен хороший способ избавиться от new и delete в Qt.
Динамические объекты std::locale::facet
Для управления выводом данных в потоки в С++ используются объекты std::locale . Локаль является набором фасетов (facet), которые определяют способ вывода тех или иных данных. Фасеты имеют свой счётчик ссылок и при копировании локалей не происходит копирования фасетов, копируется лишь указатель и увеличивается счётчик ссылок.
Локаль сама ответственна за удаление фасетов, когда счётчик ссылок падает до нуля, но вот создавать фасеты должен пользователь, используя оператор new (см. секцию Notes в описании конструктора std::locale) :
std::locale default;
std::locale myLocale(default, new std::codecvt_utf8
Этот механизм был реализован ещё до внедрения стандартных умных указателей и выбивается из общих правил применения классов стандартной библиотеки.
Можно сделать простую обёртку, создающую локаль, чтобы убрать new из клиентского кода. Однако это достаточно известное исключение из общих правил, и может быть, нет смысла городить ради него огород.
Заключение
Итак, сначала мы рассмотрели такие сценарии, как создание динамических массивов и динамических объектов со стандартным управлением памятью. Вместо new и delete мы использовали стандартные контейнеры и make -функции и получили более простой и надёжный код.Затем мы рассмотрели ряд примеров нестандартного управления памятью и увидели, как можно сделать код лучше, убрав new и delete в подходящие обёртки. Мы также обнаружили пример, когда подобный подход не работает.
Тем не менее, в большинстве случаев эта рекомендация даёт отличные результаты, и можно использовать её в качестве принципа по умолчанию. Теперь мы можем считать, что, если код использует new или delete , это особый случай, который требует особого внимания. Если вы видите эти вызовы в клиентском коде, задумайтесь, действительно ли они оправданы.
- Избегайте использования new и delete в коде. Воспринимайте их как низкоуровневые операции ручного управления динамической памятью.
- Используйте стандартные контейнеры для динамических структур данных.
- Используйте make -функции для создания динамических объектов, когда это возможно.
- Создавайте обёртки для объектов с нестандартной моделью памяти.
От автора
Лично мне приходилось сталкиваться с множеством случаев утечек памяти и падений из-за чрезмерного использования new и delete . Да, большая часть такого кода была написана много лет назад, но потом с ним начинают работать молодые программисты и думают, что вот так и надо писать.Я надеюсь, данная статья подойдёт в качестве практического руководства, к которому можно отправить молодого разработчика, дабы он не сбился с пути истинного.
Чуть больше года назад я выступал с докладом на эту тему на конференции C++ Russia. После моего выступления аудитория разделилась на две группы: те, для кого всё было очевидным, и те, кто сделал для себя замечательное открытие. Полагаю, что на конференции чаще ходят уже достаточно опытные разработчики, так что, если даже среди них было множество людей, для кого эта информация была в новинку, я надеюсь, что эта статья будет полезна для сообщества.
PS В процессе обсуждения статьи, у нас с коллегами разгорелся целый спор, как правильно: «Майерс» или «Мейерс». С одной стороны, для русского слуха более привычно звучит «Мейерс», и мы сами вроде бы всегда говорили именно так. С другой стороны, на вики используется именно «Майерс». Если посмотреть локализованные книги , то там вообще кто во что горазд: к этим двум вариантам прибавляется ещё и «Мэйерс». На конференциях разные люди представляют его по-разному. В конечном итоге нам удалось выяснить , что сам себя он называет именно «Майерс», на чём и порешили.
Ссылки
- Herb Sutter, GotW #89 Solution: Smart Pointers .
- Scott Meyers, Effective Modern C++ , Item 21, p. 139.
- Stephan T. Lavavej, Don’t Help the Compiler .
- Bjarne Stroustrup, The C++ Programming Language , 11.2.1, p. 281.
- Five Popular Myths about C++ . , Part 2
- Mikhail Matrosov, C++ without new and delete .
Теги:
Добавить меткиКомментарии 134
- Tutorial
Привет! Ниже речь пойдет об известных всем операторах new
и delete
, точнее о том, о чем не пишут в книгах (по крайней мере в книгах для начинающих).
На написание данной статьи меня побудило часто встречаемое заблуждение по поводу new
и delete
, которое я постоянно вижу на форумах и даже(!!!) в некоторых книгах.
Все ли мы знаем, что такое на самом деле new
и delete
? Или только думаем, что знаем?
Эта статья поможет вам разобраться с этим (ну, а те, кто знают, могут покритиковать:))
Note
: ниже пойдет речь исключительно об операторе new, для других форм оператора new и для всех форм оператора delete все ниженаписанное также является правдой и применимо по аналогии.
Итак, начнем с того, что обычно пишут в книгах для начинающих, когда описывают new
(текст взят «с потолка», но вцелом соответствует правде):
Оператор new выделяет память больше или равную требуемому размеру и, в отличие от функций языка С, вызывает конструктор(ы) для объекта(ов), под которые память выделена… вы можете перегрузить (где-то пишут реализовать) оператор new под свои нужды.
И для примера показывают примитивную перегрузку (реализацию) оператора new, прототип которого выглядит так
void* operator new (std::size_t size) throw (std::bad_alloc);
На что хочется обратить внимание:
1. Нигде не разделяют new
key-word
языка С++ и оператор new
, везде о них говорят как об одной сущности.
2. Везде пишут, что new
вызывает конструктор(ы) для объекта(ов).
И первое и второе является распространенным заблуждением.
Но не будем надеяться на книги для начинающих, обратимся к Стандарту, а именно к разделу 5.3.4 и к 18.6.1, в которых собственно и раскрывается (точнее приоткрывается) тема данной статьи.
5.3.4
The new-expression attempts to create an object of the type-id (8.1) or new-type-id to which it is applied. /*дальше нам не интересно*/
18.6.1
void* operator new(std::size_t size) throw(std::bad_alloc);
Effects: The allocation function called by a new-expression (5.3.4) to allocate size bytes of
storage suitably aligned to represent any object of that size /*дальше нам не интересно*/
Тут мы уже видим, что в первом случае new
именуется как expression
, а во втором он объявлен как operator.
И это действительно 2 разные сущности!
Попробуем разобраться почему так, для этого нам понадобятся ассемблерные листинги, полученные после компиляции кода, использующего new.
Ну, а теперь обо все по порядку.
new-expression
- это оператор языка, такой же как if
, while
и т.д. (хотя if,
while
и т.д. все же именуются как statement
, но отбросим лирику) Т.е. встречая его в листинге компилятор генерирует определенный код, соответствующий этому оператору. Так же new
- это одно из key-words
языка С++, что еще раз подтверждает его общность с if
"ами, for"
ами и т.п. А operator new()
в свою очередь - это просто одноименная функция языка С++, поведение которой можно переопределить. ВАЖНО
- operator new()
НЕ
вызывает конструктор(ы) для объекта(ов), под который(ые) выделяется память. Он просто выделяет память нужного размера и все. Его отличие от сишных функций в том, что он может бросить исключение и его можно переопределить, а так же сделать оператором для отдельно взятого класса, тем самым переопределить его только для этого класса (остальное вспомните сами:)).
А вот new-expression
как раз и вызывает конструктор(ы) объекта(ов). Хотя правильней сказать, что он тоже ничего не вызывает, просто, встречая его, компилятор генерирует код вызова конструктора(ов).
Для полноты картины рассмотрим следующий пример:
#include
После исполнения данного кода, как и ожидалось, будет напечатано «Foo()». Разберемся почему, для этого понадобится заглянуть в ассемблер, который я немного прокомментировал для удобства.
(код получен компилятором cl, используемым в MSVS 2012, хотя в основном я использую gcc, но это к делу не относится)
/Foo *bar = new Foo;
push 1 ; размер в байтах для объекта Foo
call operator new (02013D4h) ; вызываем operator new
pop ecx
mov dword ptr ,eax ; записываем указатель, вернувшийся из new, в bar
and dword ptr ,0
cmp dword ptr ,0 ; проверяем не 0 ли записался в bar
je main+69h (0204990h) ; если 0, то уходим отсюда (возможно вообще из main или в какой-то обработчик, в данном случае неважно)
mov ecx,dword ptr ; кладем указатель на выделенную память в ecx (MSVS всегда передает this в ecx(rcx))
call Foo::Foo (02011DBh) ; и вызываем конструктор; дальше не интересно
Для тех, кто ничего не понял, вот (почти) аналог того, что получилось на сиподобном псевдокоде (т.е. не надо пробовать это компилировать:))
Foo *bar = operator new (1); // где 1 - требуемый размер
bar->Foo(); // вызываем конструктор
Приведенный код подтверждает все, написанное выше, а именно:
1. оператор (языка) new
и operator new()
- это НЕ одно и тоже.
2. operator new()
НЕ вызывает конструктор(ы)
3. вызов конструктора(ов) генерирует компилятор, встречая в коде key-word «new»
Итог: надеюсь, эта статья помогла вам понять разницу между new-expression и operator new() или даже узнать, что она (эта разница) вообще существует, если кто-то не знал.
P.S. оператор delete и operator delete() имеют аналогичное различие, поэтому в начале статьи я сказал, что не буду его описывать. Думаю, теперь вы поняли, почему его описание не имеет смысла и сможете самостоятельно проверить справедливость написанного выше для delete .
Update:
Хабражитель с ником khim
в личной переписке предложил следующий код, который хорошо демонстрирует суть написанного выше.
#include
Этот код выведет следующее
Test::operator new(1)
Test::Test()
Test::operator new(100)
что и следовало ожидать.
Оператор new позволяет выделять память под массивы. Он возвращает
указатель на первый элемент массива в квадратных скобках. При выделении памяти под многомерные массивы все размерности кроме крайней левой должны быть константами. Первая размерность может быть задана переменной, значение которой к моменту использования new известно пользователю, например:
int *p=new int[k]; // ошибка cannot convert from "int (*)" to "int *"
int (*p)=new int[k]; // верно
При выделении памяти под объект его значение будет неопределенным. Однако объекту можно присвоить начальное значение.
int *a = new int (10234);
Этот параметр нельзя использовать для инициализации массивов. Однако
на место инициализирующего значения можно поместить через запятую список
значений, передаваемых конструктору при выделении памяти под массив (мас-
сив новых объектов, заданных пользователем). Память под массив объектов
может быть выделена только в том случае, если у соответствующего класса
имеется конструктор, заданный по умолчанию.
matr(){}; // конструктор по умолчанию
matr(int i,float j): a(i),b(j) {}
{ matr mt(3,.5);
matr *p1=new matr; // верно р1 − указатель на 2 объекта
matr *p2=new matr (2,3.4); // неверно, невозможна инициализация
matr *p3=new matr (2,3.4); // верно р3 – инициализированный объект
{ int i; // компонента-данное класса А
A(){} // конструктор класса А
~A(){} // деструктор класса А
{ A *a,*b; // описание указателей на объект класса А
float *c,*d; // описание указателей на элементы типа float
a=new A; // выделение памяти для одного объекта класса А
b=new A; // выделение памяти для массива объектов класса А
c=new float; // выделение памяти для одного элемента типа float
d=new float; // выделение памяти для массива элементов типа float
delete a; // освобождение памяти, занимаемой одним объектом
delete b; // освобождение памяти, занимаемой массивом объектов
delete c; // освобождение памяти одного элемента типа float
delete d; } // освобождение памяти массива элементов типа float
Организация внешнего доступа к локальным компонентам класса(friend)
Мы уже познакомились с основным правилом ООП – данные (внутренние
переменные) объекта защищены от воздействий извне и доступ к ним можно
получить только с помощью функций (методов) объекта. Но бывают такие слу-
чаи, когда нам необходимо организовать доступ к данным объекта, не исполь-
зуя его интерфейс (функции). Конечно, можно добавить новую public-функцию
к классу для получения прямого доступа к внутренним переменным. Однако в
большинстве случаев интерфейс объекта реализует определенные операции, и
новая функция может оказаться излишней. В то же время иногда возникает не-
обходимость организации прямого доступа к внутренним (локальным) данным
двух разных объектов из одной функции. При этом в С++ одна функция не мо-
жет быть компонентой двух различных классов.
Для реализации этого в С++ введен спецификатор friend. Если некоторая
функция определена как friend-функция для некоторого класса, то она:
Не является компонентой-функцией этого класса;
Имеет доступ ко всем компонентам этого класса (private, public и protected).
Ниже рассматривается пример, когда внешняя функция получает доступ к
внутренним данным класса.
#include
using namespace std;
kls(int i,int J) : i(I),j(J) {} // конструктор
int max() {return i>j? i: j;} // функция-компонента класса kls
friend double fun(int, kls&); // friend-объявление внешней функции fun
double fun(int i, kls &x) // внешняя функция
{ return (double)i/x.i;
cout << obj.max() << endl;
В С(С++) известны три способа передачи данных в функцию: по значе-
можно на некоторый существующий объект. Можно выделить следующие раз-
личия ссылок и указателей. Во-первых, невозможность существования нулевых
ссылок подразумевает, что корректность их не требуется проверять. А при использовании указателя требуется проверять его на ненулевое значение. Во-вторых, указатели могут указывать на различные объекты, а ссылка всегда на один объект, заданный при ее инициализации. Если требуется предоставить возможность функции изменять значения
передаваемых в нее параметров, то в языке С они должны быть объявлены либо
глобально, либо работа с ними в функции осуществляется через передаваемые в
нее указатели на эти переменные. В С++ аргументы в функцию можно переда-
ром ставится знак &.
void fun1(int,int);
void fun2(int &,int &);
{ int i=1,j=2; // i и j – локальные параметры
cout << "\n адрес переменных в main() i = "<<&i<<" j = "<<&j;
cout << "\n i = "<
Вывод программы:
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 arr => 0xbffc8f00 arr => 0xbffc8f04 arr => 0xbffc8f08 arr => 0xbffc8f0c arr => 0xbffc8f10 arr => 0xbffc8f14 arr => 0xbffc8f18 arr => 0xbffc8f1c arr => 0xbffc8f20 arr => 0xbffc8f24
Выражение arr[i] – обращение к элементу по индексу соответствует выражению *(arr + i) , которое называется указателем-смещением (строка 22). Это выражение более наглядно иллюстрирует, как C++ на самом деле работает с элементами массива. Переменная-счетчик i указывает на сколько элементов необходимо сместиться от первого элемента . В строке 17 значение элемента массива выводится после разыменования указателя.
Что означает выражение *p++ ? Оператор * имеет более низкий приоритет, в тоже время постфиксный инкремент ассоциативен слева-направо. Следовательно, в этом сложном выражении сначала будет выполняться косвенная адресация (получение доступа к значению элемента массива), а затем инкрементация указателя. Иначе это выражение можно было бы представить так: cout
Примечание
. Оператор sizeof() , применяемый к имени массива, вернет размер всего массива (а не первого элемента).
Примечание
. Оператор взятия адреса (&) для элементов массива используется также, как и для обычных переменных (элементы массива иногда называют индексированными переменными). Например, &arr . Поэтому можно всегда получить указатель на любой элемент массива. Однако, операция &arr (где arr - имя массива) вернет адрес всего массива и такая, например, операция (&arr + 1) будет означать шаг размером с массив, т. е. получение указателя на элемент, следующий за последним.
Преимущества использования указателей при работе с элементами массива
Рассмотрим два примера программ приводящих к одинаковому результату: элементам массива присваиваются новые значения от 0 до 1999999 и осуществляется их вывод.
Программа 11.2
#include
Программа 11.3
#include
Программа 11.3 будет выполняться быстрее, чем программа 11.2 (с ростом количества элементов эффективность программы 11.3 будет возрастать)! Причина заключается в том, что в программе 11.2 каждый раз пересчитывается местоположение (адрес) текущего элемента массива относительно первого (11.2, строки 12 и 13). В программе 11.3 обращение к адресу первого элемента происходит один раз в момент инициализации указателя (11.3, строка 11).
Выход за границы массива
Отметим еще одну важный аспект работы с С-массивами в С++. В языке С++ отсутствует контроль соблюдения выхода за границы С-массива
. Т. о. ответственность за соблюдение режима обработки элементов в пределах границ массива лежит целиком на разработчике алгоритма. Рассмотрим пример.
Программа 11.4
#include
Программа выведет приблизительно следующее:
Элементы массива: 21 58 38 91 23 5 38 -1219324996 -1074960992 0
В программе 11.4 умышленно допущена ошибка. Но компилятор не сообщит об ошибке: в массиве объявлено пять элементов, а в циклах подразумевается, что элементов 10! В итоге, правильно проинициализированы будут только пять элементов (далее возможно повреждение данных), они же и будут выведены вместе с "мусором". С++ предоставляет возможность контроля границ с помощью библиотечных функций begin() и end() (необходимо подключить заголовочный файл iterator). Модифицируем программу 11.4
Программа 11.5
#include
Функции begin() и end() возвращают . Понятие итераторов мы раскроем позже, а пока скажем, что они ведут себя как указатели, указывающие на первый элемент (first) и элемент, следующий за последним (last). В программе 11.5 мы, для компактности и удобства, заменили цикл for на while (поскольку счетчик нам уже здесь не нужен - мы используем арифметику указателей). Имея два указателя мы легко можем сформулировать условие выхода из цикла, так как на каждом шаге цикла указатель first инкрементируется.
Еще одним способом сделать обход элементов массива более безопасным основан на применении цикла range-based for , упомянутого нами в теме ()
Операции new и delete
До момента знакомства с указателями вам был известен единственный способ записи изменяемых данных в память посредством переменных. Переменная - это поименованная область памяти. Блоки памяти для соответствующих переменных выделяются в момент запуска программы и используются до прекращения ее работы. С помощью указателей можно создавать неименованные блоки памяти определенного типа и размера (а также освобождать их) в процессе работы самой программы. В этом проявляется замечательная особенность указателей, наиболее полно раскрывающаяся в объектно-ориентированном программировании при создании классов.
Динамическое выделение памяти осуществляется с помощью операции new . Синтаксис:
Тип_данных *имя_указателя = new тип_данных;
Например:
Int *a = new int; // Объявление указателя типа int int *b = new int(5); // Инициализация указателя
Правая часть выражения говорит о том, что new запрашивает блок памяти для хранения данных типа int . Если память будет найдена, то возвращается адрес, который присваивается переменной-указателем, имеющей тип int . Теперь получить доступ к динамически созданной памяти можно только с помощью указателей! Пример работы с динамической памятью показан в программе 3.
Программа 11.6
#include
После выполнения работы с выделенной памятью ее необходимо освободить (вернуть, сделать доступной для других данных) с помощью операции delete . Контроль над расходованием памяти - важная сторона разработки приложений. Ошибки, при которых память не освобождается, приводят к "утечкам памяти ", что, в свою очередь, может привести к аварийному завершению программы. Операция delete может применяться к нулевому указателю (nullptr) или созданному с помощью new (т. о. new и delete используются в паре).
Динамические массивы
Динамический массив
- это массив, размер которого определяется в процессе работы программы. Строго говоря C-массив не является динамическим в C++. То есть, можно определять только размер массива, а изменение размера массива, в процессе работы программы, по-прежнему невозможно. Для получения массива нужного размера необходимо выделять память под новый массив и копировать в него данные из исходного, а затем освобождать память выделенную ранее под исходный массив. Подлинно динамическим массивом в C++ является тип , который мы рассмотрим позднее. Для выделения памяти под массив используется операция new . Синтаксис выделения памяти для массива имеет вид:
указатель = new тип[размер] . Например:
Int n = 10; int *arr = new int[n];
Освобождение памяти производится с помощью оператора delete:
Delete arr;
При этом размер массива не указывается.
Пример программы. Заполнить динамический целочисленный массив arr1 случайными числами. Показать исходный массив. Переписать в новый динамический целочисленный массив arr2 все элементы с нечетными порядковыми номерами (1, 3, ...). Вывести содержимое массива arr2 .
Программа 11.7
#include
Мы знаем, что в C++ двумерный массив представляет собой массив массивов. Следовательно, для создания двумерного динамического массива необходимо выделять память в цикле для каждого входящего массива, предварительно определив количество создаваемых массивов. Для этого используется указатель на указатель , иными словами описание массива указателей:
Int **arr = new int *[m];
где m - количество таких массивов (строк двумерного массива).
Пример задачи. Заполнить случайными числами и вывести элементы двумерного динамического массива.
Программа 11.8
#include
Вопросы
- В чем заключается связь указателей и массивов?
- Почему использование указателей при переборе элементов массива более эффективно, нежели использование операции обращения по индексу ?
- В чем суть понятия "утечка памяти"?
- Перечислите способы предупреждения выхода за границы массива?
- Что такое динамический массив? Почему в С++ С-массив не является динамическим по существу?
- Опишите процесс создания динамического двумерного массива
Презентация к уроку
Домашнее задание
Используя динамические массивы решить следующую задачу: Дан целочисленный массив A размера N . Переписать в новый целочисленный массив B все четные числа из исходного массива (в том же порядке) и вывести размер полученного массива B и его содержимое.
Учебник
§62 (10) §40 (11)
Литература
- Лафоре Р. Объектно-ориентированное программирование в C++ (4-е изд.). Питер: 2004
- Прата, Стивен. Язык программирования C++. Лекции и упражнения, 6-е изд.: Пер. с англ. - М.: ООО «И.Д. Вильяме», 2012
- Липпман Б. Стенли, Жози Лажойе, Барбара Э. Му. Язык программирования С++. Базовый курс. Изд. 5-е. М: ООО "И. Д. Вильямс", 2014
- Эллайн А. C++. От ламера до программера. СПб.: Питер, 2015
- Шилдт Г. С++: Базовый курс, 3-изд. М.: Вильямс, 2010
Как известно, в языке С для динамического выделения и освобождения памяти используются функции malloc() и free(). Вместе с тем С++ содержит два оператора, выполняющих выделение и освобождение памяти более эффективно и более просто. Этими операторами являются new и delete. Их общая форма имеет вид:
переменная_указатель = new тип_переменной;
delete переменная_указатель;
Здесь переменная_указaтель является указателем типа тип_переменной. Оператор new выделяет память для хранения значения типа тип_переменной и возвращает ее адрес. С помощью new могут быть размещены любые типы данных. Оператор delete освобождает память, на которую указывает указатель переменная_указатель.
Если операция выделения памяти не может быть выполнена, то оператор new генерирует исключение типа xalloc. Если программа не перехватит это исключение, тогда она будет снята с выполнения. Хотя для коротких программ такое поведение по умолчанию является удовлетворительным, для реальных прикладных программ обычно требуется перехватить исключение и обработать его соответствующим образом. Для того чтобы отследить это исключение, необходимо включить заголовочный файл except.h.
Оператор delete следует использовать только для указателей на память, выделенную с использованием оператора new. Использование оператора delete с другими типами адресов может породить серьезные проблемы.
Есть ряд преимуществ использования new перед использованием malloc(). Во-первых, оператор new автоматически вычисляет размер необходимой памяти. Нет необходимости в использовании оператора sizeof(). Более важно то, что он предотвращает случайное выделение неправильного количества памяти. Во-вторых, оператор new автоматически возвращает указатель требуемого типа, так что нет необходимости в использовании оператора преобразования типа. В-третьих, как скоро будет описано, имеется возможность инициализации объекта при использовании оператора new. И наконец, имеется возможность перегрузить оператор new и оператор delete глобально или по отношению к тому классу, который создается.
Ниже приведен простой пример использования операторов new и delete. Следует обратить внимание на использование блока try/catch для отслеживания ошибок выделения памяти.
#include
#include
int main()
{
int *p;
try {
p = new int; // выделение памяти для int
} catch (xalloc xa) {
cout << "Allocation failure.\n";
return 1;
}
*p = 20; // присвоение данному участку памяти значения 20
cout << *р; // демонстрация работы путем вывода значения
delete р; // освобождение памяти
return 0;
}
Эта программа присваивает переменной р адрес блока памяти, имеющего достаточный размер для того, чтобы содержать число целого типа. Далее этой памяти присваивается значение и содержимое памяти выводится на экран. Наконец, динамически выделенная память освобождается.
Как отмечалось, можно инициализировать память с использованием оператора new. Для этого надо указать инициализирующее значение в скобках после имени типа. Например, в следующем примере память, на которую указывает указатель р, инициализируется значением 99:
#include
#include
int main()
{
int *p;
try {
p = new int (99); // инициализация 99-ю
} catch (xalloc xa) {
cout << "Allocation failure.\n";
return 1;
}
cout << *p;
delete p;
return 0;
}
С помощью new можно размещать массивы. Общая форма для одномерного массива имеет вид:
переменная_указатель = new тип_переменной [размер];
Здесь размер определяет число элементов в массиве. Необходимо запомнить важное ограничение при размещении массива: его нельзя инициализировать.
Для освобождения динамически размещенного массива необходимо использовать следующую форму оператора delete:
delete переменная_указатель;
Здесь скобки информируют оператор delete, что необходимо освободить память, выделенную для массива.
В следующей программе выделяется память для массива из 10 элементов типа float. Элементам массива присваиваются значения от 100 до 109, а затем содержимое массива выводится на экран:
#include
#include
int main()
{
float *p;
int i;
try {
p = new float ; // получение десятого элемента массива
} catch(xalloc xa) {
cout << "Allocation failure.\n";
return 1;
}
// присвоение значений от 100 до 109
for (i=0; i<10; i + +) p[i] = 100.00 + i;
// вывод содержимого массива
for (i=0; i<10; i++) cout << p[i] << " ";
delete p; // удаление всего массива
return 0;
}
Загрузка...
