Здравствуйте.
Написал как-то приложение, мой начальник посмотрел и сказал: что у меня за глупость в приложении — в конце приложения стоят операторы 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 эти рассуждения тоже относятся?

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

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

Если речь все же идет о сингтонах, то можно посмотреть на Loki::Singleton (это библиотека от Андрея Александреску), там процесс управления временем жизни отдан на откуп отдельной стратегии, в результате чего можно изменив одну строку кода изменить поведение синглтона, произвольно добавляя или удаляя вызовы деструктора в момент закрытия приложения.

//деструктор будет вызван в момент закрытия приложения
typedef Loki::SingletonHolder<
      Log,
      Loki::CreateUsingNew,
      Loki::DefaultLifetime,
      Loki::ClassLevelLockable> globalLog;

//деструктор не будет вызван вовсе
typedef Loki::SingletonHolder<
      Log,
      Loki::CreateUsingNew,
      Loki::NoDestroy,
      Loki::ClassLevelLockable> globalLog;

З.Ы. а вообще, в ветке верно говорили, что нужно почитать о том, что такое RAII и почему плохо руками вызывать delete. Смотреть книги Мейерса, Страуструпа, Саттера (цикл статей Саттера о безопасности исключений очень быстро отбивает всякую охоту в ручном управлении ресурсами).

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

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

Да дело не в atexit, он вообще сказал, что очищать любые объекты перед выходом — бред, по типу даже если это delete [] my_numbers; в деструкторе глобального класса (который уничтожается вместе с приложением).
И насколько я понял, получается он прав, ведь этот массив double* numbers все равно будет освобожден как и вся куча. Или я неправильно понял?

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


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

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

Не относится, т.к. по закрытию приложения все handle-ы будут освобождены. Но это не относится, например, к именованным мьютексам.

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

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

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

Я же специально написал и даже курсивом не поленился выделить, что это относится к освобождению памяти.
Все остальные случаи нужно рассматривать подробно и отдельно, сразу про всё не сказать.

С fclose этот номер может не пройти, если fwrite и прочие буферизирует вывод. Тогда часть данных может остаться в буфере. Если же не буферизирует, [любая вменяемая] ОС закроет файл сама и всё будет нормально. На такие вещи, конечно, лучше не полагаться.

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

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

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

SH>Хотя в конце, конечно, тоже всё освободится, но это может оказаться немного поздно.

Но ведь по его мнению все равно освободится

Остался последний вопрос а как умудряются завершенные процессы (например, некоторые игры) отъесть "безвозвратно" часть памяти, если все равно вся память (heap) по завершению освобождается, за исключением разделяемых разными процессами переменных?

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

ST>З.Ы. а вообще, в ветке верно говорили, что нужно почитать о том, что такое RAII и почему плохо руками вызывать delete. Смотреть книги Мейерса, Страуструпа, Саттера (цикл статей Саттера о безопасности исключений очень быстро отбивает всякую охоту в ручном управлении ресурсами).

Да, спасибо обязательно почитаю про RAII и smart pointer.

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

SK>Но ведь по его мнению все равно освободится

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

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

SK>Остался последний вопрос а как умудряются завершенные процессы (например, некоторые игры) отъесть "безвозвратно" часть памяти, если все равно вся память (heap) по завершению освобождается, за исключением разделяемых разными процессами переменных?

На уровне С++ ответа на этот вопрос нет. Какие-то системно-зависимые вещи, которые ОС почему-то не может почистить за процессом. В зависимости от ситуации, скорее всего можно рассматривать как баг в ОС. По идее отдельный процесс не должен быть способен таким образом повлиять на всю систему.

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

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

Это же элементарные средства гигиены.

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

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

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

SK>И насколько я понял, получается он прав, ведь этот массив double* numbers все равно будет освобожден как и вся куча. Или я неправильно понял?

Возможна такая система, которая не будет подчищать память за приложением.

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

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

Тебе лучше всё-таки писать delete там, где надо, потому что для тебя это на уровне правил, которые ты ещё не понимаешь.

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

SK>Да дело не в atexit, он вообще сказал, что очищать любые объекты перед выходом — бред, по типу даже если это delete [] my_numbers; в деструкторе глобального класса (который уничтожается вместе с приложением).
Де факто ОС конечно подотрёт за нагадившим, но я б такого разработчика жестоко бил по голове железной палкой, ибо такой код содержит грубейшую ошибку управления ресурсами и потому не реюзабелен.
И если вдруг в какой то момент этот класс перестанет быть глобальным то на ровном месте получим "полну жопу огурцов". И все только потому, что какому то лентяю было впадлу прибрать за собой.
Так что не слушай дебилов, а еще лучше смени работу. Потому как такие тараканы обычно не водятся поодиночке, и есть риск что из головы начальства скоро попрёт вша красная, вша жОлтая и еще более суровые усеницы.

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

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

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

SK>Да дело не в atexit, он вообще сказал, что очищать любые объекты перед выходом — бред, по типу даже если это delete [] my_numbers; в деструкторе глобального класса (который уничтожается вместе с приложением).
SK>И насколько я понял, получается он прав, ведь этот массив double* numbers все равно будет освобожден как и вся куча. Или я неправильно понял?

Поинтересуйся у начальства, а зачем вообще освобождать память и правильно проектировать приложения?

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

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

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

Можно использовать идиому вроде

#ifndef NDEBUG
delete ...
#endif

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

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

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

Да ладно, это ж начальник! Ему же надо что-то умное сказать и поучить "молодое поколение". Видимо, больше не нашел к чему придраться

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

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


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

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

ST>Не относится, т.к. по закрытию приложения все handle-ы будут освобождены. Но это не относится, например, к именованным мьютексам.

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

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

SK>И насколько я понял, получается он прав, ведь этот массив double* numbers все равно будет освобожден как и вся куча. Или я неправильно понял?

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

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

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

Слушай, а ты уверен, что верно понял начальника?
Случаи они того, разные бывают...
Не могло быть так, что он поручил тебе написать какую-то нужную программу, а ты, вместо этого, написал самопальный синглетон с delete (double*) в atexit, который и отлаживал пару месяцев?...

Зачем тебе вообще понадобился синглетон с вектором из double?
Чем тебе просто глобальный std::vector<double> не подоёшл? И почему он сенглитон, кстати? Это зачем теюе понадобилось?

Шнфа твоего мы тут выслушать не можем, может ты расскажешь подробнее про свою задачу?
А то вдруг правда тебе совсем про другое сказали, а ты понял совсем и не так?

SoulKeeper пишет:

> Объясните мне пожалуйста, что действительно delete делать не стоит? А

Не то, что стоит, а ОБЯЗАТЕЛЬНО!

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

В общем, по умолчанию, в 99% случаев ты должен делать delete.

SoulKeeper пишет:

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

Начальнику же порекомендуй написать что-либо для DOS-а.

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

MZ>Начальнику же порекомендуй написать что-либо для DOS-а.

А какие проблемы с DOS'ом?
Там куча была личным делом предложения и умирала вместе с ним, помнится...

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

W>Возможна такая система, которая не будет подчищать память за приложением.

А есть примеры таких систем? В ДОСЕ куча удаляется по заврешению?

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

E>Слушай, а ты уверен, что верно понял начальника?
E>Случаи они того, разные бывают...
E>Не могло быть так, что он поручил тебе написать какую-то нужную программу, а ты, вместо этого, написал самопальный синглетон с delete (double*) в atexit, который и отлаживал пару месяцев?...

E>Зачем тебе вообще понадобился синглетон с вектором из double?
E>Чем тебе просто глобальный std::vector<double> не подоёшл? И почему он сенглитон, кстати? Это зачем теюе понадобилось?

E>Шнфа твоего мы тут выслушать не можем, может ты расскажешь подробнее про свою задачу?
E>А то вдруг правда тебе совсем про другое сказали, а ты понял совсем и не так?

Смешно Ты поработай в среде физиков много чего умного услышишь. Я же говорю, он сказал, что в atexit глупо delete делать, так как приложение завершится и все равно все освободится, и ВООБЩЕ в конце приложения делать delete глупо. А пара new — delete , совсем необязательна, так как в ряде случаев в этой системе (ROOT from CERN) она не работает.
Сиглетон действительно нужен, так как он нужен различным таскам, которые появляются на этапе анализа. У меня нет delete (double*) в atexit это я для примера в деструкторе. В atexit у меня delete сам синглетон. И пару месяцев я его не отлаживал
От шефа могу тока фотку кинуть

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

E>>Шефа твоего мы тут выслушать не можем, может ты расскажешь подробнее про свою задачу?
E>>А то вдруг правда тебе совсем про другое сказали, а ты понял совсем и не так?

SK>Смешно Ты поработай в среде физиков много чего умного услышишь.
Смешно, IMHO, тут то, что ты написал несколько абзацев текста, а на вопрос так и не ответил...

SK>Я же говорю, он сказал, что в atexit глупо delete делать, так как приложение завершится и все равно все освободится, и ВООБЩЕ в конце приложения делать delete глупо.

Это-то ты давно уже сказал. А вот контекст этого высказывания не ясен.
Кстати, можно обсудить глупо или нет удалять в конце синглетоны. Особенно если они ничем, кроме памяти не владеют...

SK>А пара new — delete , совсем необязательна, так как в ряде случаев в этой системе (ROOT from CERN) она не работает.
Дык это, если не работает в ряде случаев, то не только не обязательна, но и недопустима в тех самых случаях. Что за случаи, кстати?

SK>Сиглетон действительно нужен, так как он нужен различным таскам, которые появляются на этапе анализа. У меня нет delete (double*) в atexit это я для примера в деструкторе. В atexit у меня delete сам синглетон. И пару месяцев я его не отлаживал

У тебя в сообщении, что ни копнёшь -- всё на поверку оказывается "для примера", "понарошку" и "так сказать". У тебя хоть слово правды в оригинальном сообщении есть?

SK>От шефа могу тока фотку кинуть
Лучше опиши свою задачу. В частности, почему нельзя было вместо синглетона сделать просто глобальный объект, с методом Init(), вызываемым в начале приложения, или ещё когда?