Предположим, что у меня есть функция, которая выделяет память для вызывающего:
int func(void **mem1, void **mem2) {
*mem1 = malloc(SIZE);
if (!*mem1) return 1;
*mem2 = malloc(SIZE);
if (!*mem2) {
/* ... */
return 1;
}
return 0;
}
Я хотел бы услышать ваши отзывы о наилучшем способе освобождения() выделенной памяти в случае неудачи второго malloc(). Вы можете представить более сложную ситуацию с большим количеством точек выхода из-за ошибки и более выделенной памяти.
Я знаю, что люди не любят их использовать, но это идеальная ситуация для goto в C.
int func( void** mem1, void** mem2 )
{
int retval = 0;
*mem1 = malloc(SIZE);
if (!*mem1) {
retval = 1;
goto err;
}
*mem2 = malloc(SIZE);
if (!*mem2) {
retval = 1;
goto err;
}
// ...
goto out;
// ...
err:
if( *mem1 ) free( *mem1 );
if( *mem2 ) free( *mem2 );
out:
return retval;
}
Вот где, по-моему, подходит. Раньше я придерживался догмы антигуто, но я изменил это, когда мне было указано, что {...} while (0); компилируется в один и тот же код, но не так легко читать. Просто следуйте некоторым основным правилам, например, не отказывайтесь от них, сохраняя их до минимума, используя их только для условий ошибок и т.д.
int func(void **mem1, void **mem2)
{
*mem1 = NULL;
*mem2 = NULL;
*mem1 = malloc(SIZE);
if(!*mem1)
goto err;
*mem2 = malloc(SIZE);
if(!*mem2)
goto err;
return 0;
err:
if(*mem1)
free(*mem1);
if(*mem2)
free(*mem2);
*mem1 = *mem2 = NULL;
return 1;
}
Это немного противоречиво, но я думаю, что подход goto, используемый в ядре Linux, действительно работает в этой ситуации очень хорошо:
int get_item(item_t* item)
{
void *mem1, *mem2;
int ret=-ENOMEM;
/* allocate memory */
mem1=malloc(...);
if(mem1==NULL) goto mem1_failed;
mem2=malloc(...);
if(mem2==NULL) goto mem2_failed;
/* take a lock */
if(!mutex_lock_interruptible(...)) { /* failed */
ret=-EINTR;
goto lock_failed;
}
/* now, do the useful work */
do_stuff_to_acquire_item(item);
ret=0;
/* cleanup */
mutex_unlock(...);
lock_failed:
free(mem2);
mem2_failed:
free(mem1);
mem1_failed:
return ret;
}
Это читаемая альтернатива:
int func(void **mem1, void **mem2) {
*mem1 = malloc(SIZE);
*mem2 = malloc(SIZE);
if (!*mem1 || !*mem2) {
free(*mem2);
free(*mem1);
return 1;
}
return 0;
}
Помогает ли вызывающий абонент делать что-либо полезное с блоками памяти, которые были правильно распределены до отказа? Если нет, вызывающий должен обработать освобождение.
Одной из возможностей эффективной очистки является использование do..while(0), что позволяет break, где ваш пример return s:
int func(void **mem1, void **mem2)
{
*mem1 = NULL;
*mem2 = NULL;
do
{
*mem1 = malloc(SIZE);
if(!*mem1) break;
*mem2 = malloc(SIZE);
if(!*mem2) break;
return 0;
} while(0);
// free is NULL-safe
free(*mem1);
free(*mem2);
return 1;
}
Если вы делаете много распределений, вы можете использовать свою функцию freeAll() для очистки здесь.
лично; У меня есть библиотека отслеживания ресурсов (в основном сбалансированное двоичное дерево), и у меня есть обертки для всех функций распределения.
Ресурсы (такие как память, сокеты, дескрипторы файлов, семафоры и т.д. - все, что вы выделяете и освобождаете) могут принадлежать набору.
У меня также есть библиотека обработки ошибок, в которой первый аргумент каждой функции является установленной ошибкой, и если что-то пойдет не так, функция, испытывающая ошибку, отправляет ошибку в набор ошибок.
Если установленная ошибка содержит ошибку, никакие функции не выполняются. (У меня есть макрос в верхней части каждой функции, которая заставляет его возвращаться).
Таким образом, несколько mallocs выглядят следующим образом:
mem[0] = malloc_wrapper( error_set, resource_set, 100 );
mem[1] = malloc_wrapper( error_set, resource_set, 50 );
mem[2] = malloc_wrapper( error_set, resource_set, 20 );
Нет необходимости проверять возвращаемое значение, потому что, если возникает ошибка, не выполняются следующие функции, например. следующие mallocs никогда не встречаются.
Итак, когда приходит время для освобождения ресурсов (например, в конце функции, где все ресурсы, используемые внутри этой функции, были помещены в набор), я освобождаю набор. Это всего лишь один вызов функции.
res_delete_set( resource_set );
Мне не нужно специально проверять наличие ошибок - в моей проверке кода возвращаются значения if() s, что делает его пригодным для обслуживания; Я нахожу, что разграничение проверки ошибок в строке разрушает читаемость и, следовательно, ремонтопригодность. У меня просто хороший список вызовов функций.
Это искусство, человек: -)
Моя собственная склонность заключается в создании переменной функции аргументов, которая освобождает все указатели, отличные от NULL. Затем вызывающий может обрабатывать случай ошибки:
void *mem1 = NULL;
void *mem2 = NULL;
if (func(&mem1, &mem2)) {
freeAll(2, mem1, mem2);
return 1;
}
Если приведенные выше утверждения goto вы по каким-то причинам ужасны, вы всегда можете сделать что-то вроде этого:
int func(void **mem1, void **mem2)
{
*mem1 = malloc(SIZE);
if (!*mem1) return 1;
*mem2 = malloc(SIZE);
if (!*mem2) {
/* Insert free statement here */
free(*mem1);
return 1;
}
return 0;
}
Я использую этот метод довольно регулярно, но только когда он очень четко понимает, что происходит.
Я немного испугался всех рекомендаций для инструкции goto!
Я обнаружил, что использование goto приводит к запутыванию кода, который, скорее всего, приведет к ошибкам программиста. Теперь я предпочитаю избегать его использования, за исключением самых экстремальных ситуаций. Я почти никогда не использовал его. Не из-за академического перфекционизма, а потому, что год или более позже всегда кажется сложнее вспомнить общую логику, чем с альтернативой, которую я предлагаю.
Будучи тем, кто любит реорганизовывать вещи, чтобы свести к минимуму мой вариант забыть вещи (например, очистить указатель), я бы добавил несколько функций в первую очередь. Вероятно, я предположим, что я буду использовать их совсем немного в одной программе. Функция imalloc() выполнила операцию malloc с косвенным указателем; ifree() отменит это. cifree() освобождает память условно.
С моей стороны, моя версия кода (с третьим аргументом для демонстрации) будет выглядеть так:
// indirect pointer malloc
int imalloc(void **mem, size_t size)
{
return (*mem = malloc(size));
}
// indirect pointer free
void ifree(void **mem)
{
if(*mem)
{
free(*mem);
*mem = NULL;
}
}
// conditional indirect pointer free
void cifree(int cond, void **mem)
{
if(!cond)
{
ifree(mem);
}
}
int func(void **mem1, void **mem2, void **mem3)
{
int result = FALSE;
*mem1 = NULL;
*mem2 = NULL;
*mem3 = NULL;
if(imalloc(mem1, SIZE))
{
if(imalloc(mem2, SIZE))
{
if(imalloc(mem3, SIZE))
{
result = TRUE;
}
cifree(result, mem2);
}
cifree(result, mem1);
}
return result;
}
Я предпочитаю иметь только один возврат из функции, в конце. Выпрыгивание между ними происходит быстро (и, на мой взгляд, вроде грязно). Но, что более важно, вы можете легко обойти связанный код очистки непреднамеренно.