Может ли кто-нибудь сказать мне разницу между:
int *p;
p=(int*)malloc(10*sizeof(int));
free(p);
или
int *p;
p=(int*)malloc(10*sizeof(int));
p=NULL;
free освободит память, на которую указывает p - просто присваивание ей NULL не будет (и, следовательно, вы будете иметь утечку памяти).
Следует упомянуть, что рекомендуется назначить ваш указатель на NULL ПОСЛЕ обращения к free, поскольку это предотвратит случайную попытку доступа к освобожденной памяти (что еще возможно, но абсолютно необходимо не будет сделано).
В C нет коллекции мусора, поэтому, если вы явно не освобождаете кусок памяти, она никогда не будет освобождена, даже если на ней нет ссылок. Возможно, вы зашли на задний план в сборках мусора, поэтому было бы сложно изменить свой образ мыслей, но всегда важно помнить, что "вручную" освобождать все ресурсы на языках низкого уровня, например, C.
Надеюсь, что это поможет Приветствия
p - указатель (для блока, распределенного динамически в памяти [ "на куче" ])
Это означает, что p - это переменная, которая содержит адрес в памяти определенного блока (или некоторого определенного размера, в примере - блок, достаточно большой, чтобы содержать 10 целых чисел).
free(p); указывает логику управления памятью (времени выполнения C), что память, ранее занятая блоком, для которого p указывает, может быть повторно использована.
p = NULL; устанавливает значение p в NULL (адрес, который ранее содержался, был потерян), но блок в памяти, который он указал, все еще рассматривается в использовании.
Может быть некоторая путаница, потому что в таких языках, как Java, С#, Python и т.д., просто присваивая переменную NULL (или другому адресу, если на то пошло), автоматически освободит базовую память (если не считать других ссылок на этот адрес существуют в других живых переменных).
Это не относится к C или С++, что приводит к следующим ошибкам:
free(p);
// possibly some some code etc.
// later:
p[6] = 'a'; // <<--- Ouch we're modifying whatever new variable is there !!!
или
// didn't call free(p)
p = NULL;
// now the memory allocated for p is held in memory even though it
// is not going to be used (assuming no copies of p or of pointers to part
// of that block were made.
Последний случай - это только расточительство ресурсов, первое может привести к затруднению поиска ошибок.
Вот почему типичная C-идиома:
free(p);
p = NULL;
Не вызывать бесплатное и прямое присвоение NULL приведет к утечке памяти, как объясняют другие. Вы можете обратиться к этой ссылке, чтобы получить четкие сведения об утечках памяти и других проблемах, связанных с памятью.
Освобождение выделенной памяти освобождает его и позволяет использовать эту память в другом месте, в то время как указатель на то, где была выделена память, сохраняется.
Установка указателя на выделенную память на NULL не освобождает его.
Если вы используете реализацию, использующую malloc на основе кучи, отлаживайте что-то, что выделяет, использует и освобождает память, и делает то же самое с тем, что выделяет, использует и устанавливает указатель на память в NULL.
Управление памятью зависит от реализации (см. http://en.wikipedia.org/wiki/Malloc#Implementations).
Лучший способ - сначала освободить память, а затем установить ее в NULL:
free(p);
p = NULL;
1.
int *p;
p= (int * ) malloc(10*sizeof(int));
free(p);
память возвращается в кучу. но указатель все еще указывает на освобожденную ячейку памяти. Таким образом, если его дальнейшее использование приведет к повреждению памяти.
Таким образом, правильная вещь - сбросить указатель в NULL явно, чтобы избежать дальнейшего использования этого указателя.
Не рекомендуется указывать тип возвращаемого указателя в C
2.
int *p;
p=(int * )malloc(10*sizeof(int));
p=NULL;
Это приведет к утечке памяти: поскольку выделенная память здесь не освобождается. вы просто reset указатель на NULL.
p=NULL не освобождает память. Если вам больше не нужно использовать память, обозначенную p, вы должны использовать free(), иначе будет утечка памяти. Вы также должны установить p=NULL после вызова free(), чтобы избежать ошибочного доступа к этой памяти в будущем.