Когда функция возвращается, выделяется ли память через malloc? Или он может быть доступен в функции main() с помощью указателей?
например.
void function(int *a)
{
a=(int *)malloc(sizeof(int));
*a=10;
}
int main()
{
int *num;
function(num);
printf("%d",*num);
return(0);
}
Может ли целое число, сохраненное в a, получить доступ к main() здесь?
Нет, память, выделенная с помощью malloc, не освобождается, когда вы покидаете область/возврат из функции.
Вы несете ответственность за освобождение памяти, которую вы malloc.
В вашем случае, однако, память НЕ доступна в main(), но это потому, что вы имеете дело только с локальной переменной.
void function(int *a)
{
a=(int *)malloc(sizeof(int));
Здесь a является локальной переменной внутри function. Указатели передаются по значению в C, поэтому a получает копию указателя в главном, когда вы делаете function(num); main() не видит, что вы назначаете эту локальную копию указателя.
Вы должны сделать это:
void function(int **a)
{
*a= malloc(sizeof(int));
**a=10;
}
int main()
{
int *num;
function(&num);
printf("%d",*num);
free(num);
return(0);
}
или
int* function(void)
{
int *a= malloc(sizeof(int));
*a=10;
return a;
}
int main()
{
int *num;
num = function();
printf("%d",*num);
free(num);
return(0);
}
malloc() ed memory освобождается только при вызове free() на нем. Доступ к нему может получить любой, у кого есть действительный указатель до этого времени.
Нет. Вы передаете указатель num по значению, поэтому изменения, сделанные function, не будут отображаться в main. Таким образом, нет эффективного доступа/освобождения выделенной памяти из main
Чтобы исправить это, вы можете передать адрес num или вернуть a из функции и собрать возвращаемое значение в num
malloc работает нормально (хотя вам придется вызывать free() по возвращаемому указателю). Проблема здесь в том, что вы не возвращаете указатель на выделенную память.
"int * a", ваш параметр функции() - это адрес целого числа. Обычный способ возврата состоит в том, чтобы переписать вашу функцию следующим образом:
int * function()
{
int * a = (int *)malloc(sizeof(int));
*a = 10;
return a;
}
Чтобы вернуть его с помощью параметра, вам нужно вернуть адрес указателя:
// pp points to a pointer
void function( int ** pp )
{
// Assign allocated memory to the thing that pp points to
*pp = (int *)malloc( sizeof( int ) );
// Get the thing pp points to -- a pointer.
// Then get the thing which THAT pointer points to -- an integer
// Assign 10 to that integer.
**pp = 10;
}
void main()
{
int * p = NULL;
function( & p );
printf( "%d\n", *p );
free( p );
}
И теперь вы знаете, почему они изобрели С#.
Здесь вы можете переписать свой объект размещения, чтобы он стал более понятным:
void function( int ** pp )
{
int * newmemory = (int *)malloc( sizeof( int ) );
// Assign 10 to the integer-sized piece of memory we just allocated.
*newmemory = 10;
// Assign allocated memory to the thing that pp points to.
*pp = newmemory;
}
Память не освобождена. Любая функция может выделять память, а любая другая может ее освободить. Это настоящий беспорядок, если вы не супер-finicky, пока... кто-то не изобрел сборник мусора.
Вы можете сохранить прямой адрес выделенной памяти в контейнере списка, затем создать функцию для цикла, получить доступ к каждому адресу в бесплатную функцию, а затем вытащить адрес. Вы можете вставить адрес непосредственно в свободную функцию, например free(myaddresslist.front()); myaddresslist.pop_front();. Это квази-способ сделать вашу собственную сборку мусора без необходимости менять весь проект на языки, основанные на GC. Используйте myaddresslist.size(), чтобы убедиться, что вы не вызываете free() в пустое поле (приводящее к сбою) и определяете количество циклов, которые нужно выполнить.