Разница между висячим указателем и утечкой памяти

Ответ 1

A оборванный указатель указывает на уже освобожденную память. Хранилище больше не выделяется. Попытка получить доступ к нему может привести к ошибке сегментации.

Обычный способ попасть в висячий указатель:

char* func()
{
   char str[10];
   strcpy(str,"Hello!");
   return(str); 
}
//returned pointer points to str which has gone out of scope. 

Вы возвращаете адрес, который был локальной переменной, которая вышла бы из области действия, и элемент управления временем был возвращен вызывающей функции. (Undefined поведение)

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

int *c = malloc(sizeof(int));
free(c);
*c = 3; //writing to freed location!

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

void func(){
    char *ch;
    ch = (char*) malloc(10);
}
//ch not valid outside, no way to access malloc-ed memory

Char -ptr ch - локальная переменная, выходящая за пределы области действия в конце функции, протекающая динамически распределенная 10 байт.

Ответ 2

Вы можете рассматривать их как противоположности друг друга.

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

char *c = malloc(16);
free(c);
c[1] = 'a'; //invalid access through dangling pointer!

Когда вы теряете указатель, но сохраняете выделенную память, у вас есть утечка памяти:

void myfunc()
{
    char *c = malloc(16);
} //after myfunc returns, the the memory pointed to by c is not freed: leak!

Ответ 3

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

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

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

Ответ 4

Висячий указатель

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

#include<stdio.h>

  int *call();

  void main(){

      int *ptr;
      ptr=call();

      fflush(stdin);
      printf("%d",*ptr);

   }

 int * call(){

   int x=25;
   ++x;
   return &x;
 }

Выход: значение мусора

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

Объяснение: переменная x является локальной переменной. Его область действия и время жизни находятся внутри вызова функции, поэтому после возвращения адреса переменной x x стал мертвым, а указатель все еще указывает, что ptr все еще указывает на это местоположение.

Решение этой проблемы: сделать переменную x такой же статической. Другими словами, мы можем сказать, что указатель, объект которого был удален, называется висячим указателем.

Утечка памяти

В информатике утечка памяти происходит, когда компьютерная программа неправильно управляет выделениями памяти. В соответствии с простым мы выделили память, а не Свободный язык другого языка, скажем, не освобождают его утечку памяти вызова, это вредно для приложения и неожиданный сбой.

Ответ 5

Указатель помогает создать пользовательскую область видимости переменной, которая называется динамической переменной. Динамическая переменная может быть одиночной переменной или группой переменных одного типа (array) или группой переменных разных типов (struct). Область локальных переменных по умолчанию запускается, когда управление входит в функцию и заканчивается, когда из этой функции выходит элемент управления. Глобальная виртуальная область по умолчанию запускается при выполнении программы и заканчивается после завершения программы.

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

Утечка памяти произойдет, если программист, не записывает код (free указателя) для завершения области для динамических переменных. Любой способ, когда программа выйдет из полной памяти процесса, будет освобождена, в это время эта просочившаяся память также будет освобождена. Но это вызовет очень серьезную проблему для процесса, который работает долгое время.

Как только область динамической переменной заканчивается (освобождается), NULL следует назначать переменной указателя. В противном случае, если код ошибочно обратится к нему, будет выполняться поведение undefined. Так что оборванный указатель - это не что иное, как указатель, указывающий на динамическую переменную, область видимости которой уже завершена.

Ответ 6

Утечка памяти. Если в куче есть область памяти, но нет никакой переменной в стеке, указывающей на эту память.

char *myarea=(char *)malloc(10);

char *newarea=(char *)malloc(10);

myarea=newarea;

Висячий указатель: когда указательная переменная в стеке, но не память в куче.

char *p =NULL;

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