функция malloc в c?

Question

Я не могу понять причину вывода pf следующей программы

#include <stdio.h>
#include <stdlib.h>
int main(){
int* ip = (int*)malloc(100*sizeof(int));
if (ip){
int i;
for (i=0; i < 100; i++)
  ip[i] = i*i;
}
free(ip);
int* ip2 = (int*)malloc(10*sizeof(int));
printf("%d\n", ip[5]);
printf("%d\n", ip2[5]);
ip[5] = 10;
printf("%d\n", ip2[5]);
return 0;
}

вывод показывает, что ip & ip2 будет иметь ту же ссылку в куче. когда мы выделяем 100 int в (ip2), как он возвращает ту же ссылку для ip1. это особенность функции malloc? Я знаю, что malloc работает как "новый", верно? если это так, то он должен вернуть какую-то случайную ссылку, верно?

Answer 1

Все ваши выходы имеют неопределенное поведение, поэтому они ничего не указывают:

printf("%d\n", ip[5]);  // ip was freed, so the memory it points to may not be accessed
printf("%d\n", ip2[5]); // reading uninitialized memory
ip[5] = 10;             // writing to freed memory
printf("%d\n", ip2[5]); // still reading uninitialized memory

Как правило, вполне возможно, что ip2 получает тот же адрес, что и ip. Но вы не тестируете это в своем коде. Вы можете сделать это, например, так:

#include <stdio.h>
#include <stdlib.h>
int main() {
    int* ip = (int*)malloc(100 * sizeof(int));
    printf("%p\n", ip);
    free(ip);
    int* ip2 = (int*)malloc(100 * sizeof(int));
    printf("%p\n", ip2);
    free(ip2);
}

Когда я запускаю это, я получаю один и тот же адрес дважды (но нет гарантии, что это произойдет).

Answer 2

Это неопределенное поведение, на которое не следует полагаться. Когда вы выделяете память, как правило, из памяти страниц, когда вы освобождаете ее, она не освобождается сразу для ОС, а при попытке повторного выделения памяти, скорее всего, вы получаете то же самое, что горячо в кэше. Типичный блок памяти ОС выделяет тот же размер в следующей итерации из тех же блоков, освобожденных из памяти, в режиме LIFO.

Answer 3

Я действительно не понимаю, в чем ваша проблема.

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

Ваш первый malloc() резервирует некоторую память, вы записываете в нее, а затем освобождаете ее.

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

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

Ваш код также показывает неопределенное поведение, потому что вам не разрешен доступ к ip[5] после free(it).