Освобождение памяти, возвращенной из функций C

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

Пример выделения / освобождения вызывающего объекта:

int * mymem = (int *)malloc(20 * sizeof(int));
...
a_func_to_call(mymem);
...
free(mymem);

Пример выделения / освобождения вызываемого объекта:

FILE* f = fopen("blah", "w"); // allocs a FILE struct
fclose(f); // The implementation of fclose() will do what's necessary to 
           // free resources and if it chooses to deallocate any memory
           // previously allocated

Вы не можете освободить ФАЙЛ * это не было выделено malloc.
Поскольку вы не отвечали за его распределение, вам не следует его освобождать.

FILE * f - это указатель на объект FILE, который используется для идентификации потока во всех дальнейших операциях с файлом. Вы не должны использовать free (f) , поскольку память не выделяется функцией malloc ().

fclose достаточно, чтобы закрыть файл, связанный с потоком.

] По поводу вашего вопроса о предоставлении функции деструктора для освобождения памяти: Я считаю, что уместно предоставить функцию типа деструктора, если функция делает больше, чем освобождает память.

wrapperFree(Pointer* p)
{
 //do some additional work [ other cleanup operations ]
 free(p);
}

Кроме того, для WrapperFree необходимо предоставить WrapperAllocate.

В противном случае, я думаю, что для каждого malloc () явно вызовите free () .

fopen возвращает указатель на структуру библиотеки C, управляемую изнутри FILE , которая освобождается (не обязательно бесплатно d) при вызове fclose .

I думаю, вы имели в виду malloc () , а не fopen () . malloc () выделяет память и возвращает адрес выделенной памяти. Это должно быть выпущено с помощью вызова free () .

Как говорит mgb, нет необходимости в free () ФАЙЛ * . Но в типичном использовании есть вызовы библиотеки и ваш собственный код, который выделяет память и заставляет вас отвечать. Вот несколько общих рекомендаций:

• Создайте функцию «деструктор», когда что-то должно произойти, помимо освобождения памяти. Пример FILE * - прекрасный пример: он должен работать как с самим файлом, так и с памятью.
• Используйте голый free () , когда это всего лишь кусок объем памяти. Все остальное является излишним.

Нет лучшей практики без контекста ...

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

Функция open / allocate должна возвращать непрозрачный дескриптор какого-либо типа, который закрывается / освобождается функцией закрытия.

FILE * можно рассматривать как такой непрозрачный дескриптор.

Как упоминалось ранее, обертывание "служебного" кода внутри соответствующих функций (например, конструктора / деструктора), как правило, является хорошей практикой, в частности, это также может быть полезно при работе с исключениями или даже когда указание ваших собственных обработчиков выхода / сигналов:

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

Мне нравятся не только функции деструктора, но и соглашение Дейва Хэнсона, которое принимает адрес указателя и обнуляет указатель при освобождении памяти:

Thing_T *Thing_new(void);
void Thing_dispose(Thing_T **p);   // free *p and set *p = NULL