Здравствуйте.
Написал как-то приложение, мой начальник посмотрел и сказал: что у меня за глупость в приложении — в конце приложения стоят операторы delete для выделенной мной памяти операторами new. Ведь она же и так освободится по завершению процесса!

Объясните мне пожалуйста, что действительно delete делать не стоит? А если у меня небольшое приложение, которое недолго работает, так вообще ни одного delete для выделенной памяти не нужно?
Чувствую себя опплеванным дураком, а возразить то вроде и нечего.

Здравствуйте, SoulKeeper, Вы писали:

SK>Написал как-то приложение, мой начальник посмотрел и сказал: что у меня за глупость в приложении — в конце приложения стоят операторы delete для выделенной мной памяти операторами new. Ведь она же и так освободится по завершению процесса!

— Деструкторы вызвать.
— Подготовить код к возможным изменениям. Приложение может неожиданно стать большим. Или этот кусок кода переедет в другое место, а эта неявная зависимость (код должен выполняться перед концом приложения) останется.
— Хуже от этого не будет, а лучше может быть.

А вообще явные вызовы delete это от лукавого. Раз уж пишешь на С++, использую смартпоинтеры.

SK>Чувствую себя опплеванным дураком, а возразить то вроде и нечего.

Плохо, вещи-то элементарные.

Здравствуйте, SoulKeeper, Вы писали:

SK>Здравствуйте.
SK>Написал как-то приложение, мой начальник посмотрел и сказал: что у меня за глупость в приложении — в конце приложения стоят операторы delete для выделенной мной памяти операторами new. Ведь она же и так освободится по завершению процесса!

Некоторые объекты при разрушении делают чуть больше чем освобождают память.

SK>Объясните мне пожалуйста, что действительно delete делать не стоит? А если у меня небольшое приложение, которое недолго работает, так вообще ни одного delete для выделенной памяти не нужно?

Хотя конечно если вся программа такая маленькая, что можно видеть все delete "в конце", то можно делать что угодно. (незабыв то что SergH написал)

SK>Чувствую себя опплеванным дураком, а возразить то вроде и нечего.

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

SK>Объясните мне пожалуйста, что действительно delete делать не стоит? А если у меня небольшое приложение, которое недолго работает, так вообще ни одного delete для выделенной памяти не нужно?
SK>Чувствую себя опплеванным дураком, а возразить то вроде и нечего.

Здравствуйте, SergH, Вы писали:

SH>- Деструкторы вызвать.
SH>- Подготовить код к возможным изменениям. Приложение может неожиданно стать большим. Или этот кусок кода переедет в другое место, а эта неявная зависимость (код должен выполняться перед концом приложения) останется.
SH>- Хуже от этого не будет, а лучше может быть.

SH>А вообще явные вызовы delete это от лукавого. Раз уж пишешь на С++, использую смартпоинтеры.

Никогда не задумывался: А деструктор сам не вызовется при завершении приложения?
У миен — это очишение памяти происходит в деструкторе. Такой момент, что этот освобождение из деструктора точно никуда не переедет Аргумент "Хуже от этого не будет" с самого начала не прокатил

Здравствуйте, SoulKeeper, Вы писали:

SK>Никогда не задумывался: А деструктор сам не вызовется при завершении приложения?

Смотря какого объекта.

Если объект глобальный, статический -- вызовется в конце.
Если в стеке -- при выходе за область видимости.
Если в куче -- только при явном удалении, т.е. при вызове delete.

SK>У миен — это очишение памяти происходит в деструкторе. Такой момент, что этот освобождение из деструктора точно никуда не переедет Аргумент "Хуже от этого не будет" с самого начала не прокатил

А этот объект может использоваться в другой ситуации? Внутри функции какой-нибудь? Если да, то там отсутствие delete станет утечкой. Или он всегда создаётся только глобально? А если его немного поменять -- в следующей версии, или вообще в другом приложении -- всё равно только глобально?

Здравствуйте, rippi, Вы писали:

R>delete — это не только освобождение памяти, а еще и вызов метода — деструктора. К примеру, в ходе выполнения был захвачен какой-то внешний ресурс по отношению к программе, который должен быть освобожден синхронно с уничтожением объекта — в деструкторе. Соответственно, память то без delete освободиться, а вот внешние ресурсы будут висеть.

Спасибо, это понял. А если не объект удаляется , а, например, массив чисел, то delete в принципе не обязательно? Как то странно все это, меня учили, что если есть new, то должен быть delete, а тут до меня докапываются, что я зря написал их

Здравствуйте, SoulKeeper, Вы писали:

SK>Написал как-то приложение, мой начальник посмотрел и сказал: что у меня за глупость в приложении — в конце приложения стоят операторы delete для выделенной мной памяти операторами new.

если это действительно так- ваш начальник безграмотный идиот(в вопросе с++, еслибы это было не так- он бы вам даже голыми указателями пользоваться бы запретил), и на вашем месте я бы как можно скорее начал бы искать другого начальника, поскольку очевидно у вас цель сейчас изучить язык, а текущий руководитель вас от этой цели только отодвигает.

Здравствуйте, SoulKeeper, Вы писали:

Даже как-то покоробило меня... Да даже елси это просто new BYTE[], не убирать за собой.... это все равно что в общественном туалете не смывать за собой...

Здравствуйте, SoulKeeper, Вы писали:

SK>Здравствуйте, rippi, Вы писали:

SK>Спасибо, это понял. А если не объект удаляется , а, например, массив чисел, то delete в принципе не обязательно? Как то странно все это, меня учили, что если есть new, то должен быть delete, а тут до меня докапываются, что я зря написал их
Это золотая практика: написал new — тут же напиши и delete. Не только с памятью, но и со всеми другими ресурсами (например, файловыми ссылками).
А лучше, как уже подсказали, воспользоваться умными указателями и идиомой RAII.

Здравствуйте, SergH, Вы писали:

SH>Смотря какого объекта.

SH>Если объект глобальный, статический -- вызовется в конце.
SH>Если в стеке -- при выходе за область видимости.
SH>Если в куче -- только при явном удалении, т.е. при вызове delete.

интересно, никогда об этом не задумывался.

SH>А этот объект может использоваться в другой ситуации? Внутри функции какой-нибудь? Если да, то там отсутствие delete станет утечкой. Или он всегда создаётся только глобально? А если его немного поменять -- в следующей версии, или вообще в другом приложении -- всё равно только глобально?

Извините, поясню из чего сложилась вся ситуация (просто хотел более общий вопрос построить).

У меня есть синглтон, который создается в функции класса, а освобождается по функции std::atexit().
На что мне было заявлено, что очищение памяти на уровне atexit() — это глупо и мне нужно книжки читать, а не программировать.
А что вы имеете ввиду не глобальное создание объекта?

Здравствуйте, SoulKeeper, Вы писали:

SK>Объясните мне пожалуйста, что действительно delete делать не стоит? А если у меня небольшое приложение, которое недолго работает, так вообще ни одного delete для выделенной памяти не нужно?
SK>Чувствую себя опплеванным дураком, а возразить то вроде и нечего.

Деструктор может влиять на внешние объекты — сохранять данные, освобождать объекты синхрноизации, и т.д., тогда его вызов необходим.

Деструктор нетривиального объекта может удалять COM-объекты, освобождать объекты синхронизации, отписываться от событий, останавливать треды, так что при завершении программы без его вызова могут быть, например, зависания или AV. Поэтому при большом желании сэкономить на завершении лучше явно ExitProcess вызвать, чем пропускать код завершения избирательно.

Здравствуйте, Anpek, Вы писали:

A>Здравствуйте, SoulKeeper, Вы писали:

A>Даже как-то покоробило меня... Да даже елси это просто new BYTE[], не убирать за собой.... это все равно что в общественном туалете не смывать за собой...

"процесс заврешится и все очистится само", с этим поспорить сложно

Здравствуйте, Alexander G, Вы писали:

AG>Деструктор может влиять на внешние объекты — сохранять данные, освобождать объекты синхрноизации, и т.д., тогда его вызов необходим.

AG>Деструктор нетривиального объекта может удалять COM-объекты, освобождать объекты синхронизации, отписываться от событий, останавливать треды, так что при завершении программы без его вызова могут быть, например, зависания или AV. Поэтому при большом желании сэкономить на завершении лучше явно ExitProcess вызвать, чем пропускать код завершения избирательно.

а если это delete double-а например, то тогда delete получается не нужен?

Здравствуйте, SoulKeeper, Вы писали:

SK>"процесс заврешится и все очистится само", с этим поспорить сложно

Ну это ясно. Уборщица придет и всяко твое г.. уберет... Дело в какйо-то культуре хотя бы.

Здравствуйте, SoulKeeper, Вы писали:

SK>У меня есть синглтон, который создается в функции класса, а освобождается по функции std::atexit().
SK>На что мне было заявлено, что очищение памяти на уровне atexit() — это глупо и мне нужно книжки читать, а не программировать.

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

SK>А что вы имеете ввиду не глобальное создание объекта?

Это я просто неправильно понял твою ситуацию. Когда ты написал про delete в деструкторе, я предположил следующее:

class A:
{
public:
    A() : p(new int[100]) {}
    ~A() {} // начальник сказал, что тут delete не нужен

private:
    int *p;
};

Если сделать такой объект глобальным, выделенная память освободится в конце. Если же сделать так:

void f()
{
    A a;
}

При каждом вызове функции f будет утекать кусок памяти. Хотя в конце, конечно, тоже всё освободится, но это может оказаться немного поздно.

Здравствуйте, SoulKeeper, Вы писали:

SK>Здравствуйте.
SK>Написал как-то приложение, мой начальник посмотрел и сказал: что у меня за глупость в приложении — в конце приложения стоят операторы delete для выделенной мной памяти операторами new. Ведь она же и так освободится по завершению процесса!

SK>Объясните мне пожалуйста, что действительно delete делать не стоит? А если у меня небольшое приложение, которое недолго работает, так вообще ни одного delete для выделенной памяти не нужно?
SK>Чувствую себя опплеванным дураком, а возразить то вроде и нечего.

Как минимум — чтобы при скане на меморилики были видны действительно мемори лики, а не эти Ваши "глобальные" объекты (которые, да, можно не освобождать).

Здравствуйте, SoulKeeper, Вы писали:

SK>Здравствуйте.
SK>Написал как-то приложение, мой начальник посмотрел и сказал: что у меня за глупость в приложении — в конце приложения стоят операторы delete для выделенной мной памяти операторами new. Ведь она же и так освободится по завершению процесса!
Эт из разряда что это за глупость, зачем вы за собой посуду моете, чашку убираете и вообще стараетесь не срать на рабочем месте. Ночью же уборщица придет и все уберет.

Здравствуйте, SoulKeeper, Вы писали:

SK>а если это delete double-а например, то тогда delete получается не нужен?

Если был new double — то delete тоже нужен. Но вот вызов delete при atexit (как выше было написано)- спорный вариант.

Здравствуйте, SergH, Вы писали:

SH>- освобождение памяти на этом этапе и правда бессмысленно. Пожалуй тут согласен с начальником. Хотя оно и никому не мешает.

К fclose эти рассуждения тоже относятся?