NULL-указатель - это то же самое, что освободить его?
Вы были прав, чтобы использовать WaitForSeconds. Но я подозреваю, что вы пытались использовать его без сопрограмм. Вот как это должно работать:
public void SomeMethod()
{
StartCoroutine(SomeCoroutine());
}
private IEnumerator SomeCoroutine()
{
TextUI.text = "Welcome to Number Wizard!";
yield return WaitForSeconds (3);
TextUI.text = ("The highest number you can pick is " + max);
yield return WaitForSeconds (3);
TextUI.text = ("The lowest number you can pick is " + min);
}
11 ответов
A = new MyClass();
{...do something in the meantime...}
A = NULL;
Я слежу за этим по двум отдельным объектам. Где-то в куче экземпляр MyClass выделяется new . А в стеке есть указатель с именем A .
A - это просто указатель, в нем нет ничего волшебного, и он не имеет какой-то особой связи с кучей. выделенный объект MyClass . Просто прямо сейчас на это указывает, но это может измениться.
И в последней строке, именно это и происходит. Вы меняете указатель, чтобы он указывал на что-то еще. Это не влияет на другие объекты. Это не влияет на объект, на который он указывал раньше, и не влияет на объект (если таковой имеется), на который он теперь указывает. Опять же, A - это просто тупой необработанный указатель, как и любой другой. Это может быть NULL, или он может указывать на объект в стеке, или он может указывать на объект в куче, или он может быть неинициализированным и указывать на случайный мусор. Но это все, что он делает. Он указывает, он никоим образом не становится владельцем и не изменяет объект, на который указывает.
Это классическая утечка. Как вы говорите, память остается выделенной, но ничто не ссылается на нее, поэтому ее нельзя освободить - до тех пор, пока процесс не завершится.
Память должна быть освобождена с помощью delete - но с использованием интеллектуального указателя (например, std :: auto_ptr или boost :: shared_ptr (или tr1 :: shared_ptr) для обертывания указателя - гораздо более безопасный способ работы с указателями.
Вот как вы могли бы переписать свой пример, используя std :: auto_ptr:
std::auto_ptr a( new MyClass() );
/*...do something in the meantime...*/
a.reset();
(Вместо вызова сброса () вы можете просто позволить экземпляру auto_ptr выйти за пределы области видимости)
В большинстве случаев это вызовет утечку памяти в вашем процессе. У вас есть несколько вариантов управления памятью в C ++.
Используйте
delete, чтобы вручную освободить память, когда вы закончите с ней. Это может быть сложно сделать правильно, особенно в контексте обработки исключений.Используйте умный указатель для управления памятью (auto_ptr, shared_ptr, unique_ptr и т. Д.)
C ++ не имеет сборщика мусора, но ничто не мешает вам использовать его (например, Boehm GC ), если вы хотите пойти по этому пути.
Вам необходимо удалить A;
Для обычных объектов установка указателя на NULL ничего не делает, кроме аннулирования указателя, объект все еще находится в памяти, это особенно верно, если вы заметили, что у вас может быть более одного указателя на один и тот же объект, изменение одного не должно влиять на другие.
Это утечка памяти. Вы должны удалить память, которую вы выделяете вручную.
В большинстве современных ОС память приложения будет освобождена при выходе из приложения. Между тем, у вас утечка памяти.
В C ++ нет сборщика мусора, как в некоторых других языках (Java, C #, ...), поэтому вы должны удалить выделенные объекты самостоятельно.
Согласно комментарию Фила Нэша, для каждого нового есть соответствующее удаление, аналогично для каждого malloc есть соответствующий свободный. Если соответствующего удаления / освобождения нет, у вас утечка.
Надеюсь, это поможет, С наилучшими пожеланиями, Том.
Нет, он будет потерян для процесса навсегда. У вас будет утечка памяти. Если вы продолжите делать это, ваша программа в конечном итоге исчерпает память !! Чтобы избежать этого, удалите объект, когда он вам больше не нужен.
Часто люди устанавливают указатель на NULL после его удаления, чтобы другие части программы могли проверить, что объект был удален. , и тем самым избежать доступа к нему или его повторного удаления.
Переменные, хранящиеся в стеке, являются локальными переменными каждой функции, например int big [10]; Переменные, хранящиеся в куче, - это переменные, которые вы инициировали с помощью процедур явного выделения памяти, таких как malloc (), calloc (), new () и т. Д.
Переменные, хранящиеся в стеке, имеют время жизни, равное времени жизни текущего кадра стека. На английском языке, когда функция возвращается, вы больше не можете предполагать, что переменные содержат то, что вы ожидаете от них. Вот почему это классическая ошибка - возвращать переменную, которая была объявлена локальной в функции.
Назначив указателю NULL , вы не освободите выделенную память. Вы должны вызвать функцию освобождения памяти, чтобы освободить выделенную память. Согласно Стандарту C ++ 5.3.4 / 8: «Если выделенный тип не является массивом, имя функции выделения - operator new , а имя функции освобождения - operator delete » . Я мог бы предложить следующую функцию для безопасного удаления указателей (с присвоением им NULL ):
template<typename T>
inline void SafeDelete( T*& p )
{
// Check whether type is complete.
// Deleting incomplete type will lead to undefined behavior
// according to C++ Standard 5.3.5/5.
typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
(void) sizeof(type_must_be_complete);
delete p;
p = NULL;
}