Каков хороший шаблон программирования для обработки возвращаемых значений из функций записи файла stdio

Я бы сделал что-нибудь в этом роде:

FILE * file = fopen("foo", "wb");
if(!file) return FAILURE;

// assume failure by default
_Bool success = 0;

do
{
    if(!fwrite(&bar, sizeof(bar), 1, file))
        break;

    // [...]

    if(!fwrite(&baz, sizeof(baz), 1, file))
        break;

    // [...]

    success = 1;
} while(0);

fclose(file);

return success ? SUCCESS : FAILURE;

С небольшой магией макросов C99

#define with(SUBJECT, FINALIZE, ...) do { \
    if(SUBJECT) do { __VA_ARGS__ } while(0); if(SUBJECT) FINALIZE; \
} while(0)

и используя ferror() вместо нашего собственного флага ошибки, как предложил Джонатан Леффлер, это можно записать как

FILE * file = fopen("foo", "wb");
with(file, fclose(file),
{
    if(!fwrite(&bar, sizeof(bar), 1, file))
        break;

    // [...]

    if(!fwrite(&baz, sizeof(baz), 1, file))
        break;

    // [...]
});

return file && !ferror(file) ? SUCCESS : FAILURE;

Однако, если есть другие условия ошибки, помимо ошибок io, вам все равно придется отслеживать их с помощью одной или нескольких переменных ошибки.

Кроме того, ваша проверка на sizeof(blah) неверна: fwrite() возвращает количество записанных объектов!

Обработка исключений C для бедняков, основанная на goto (фактически, единственный и единственный экземпляр goto, НЕ являющийся вредоносным):

int foo() {
    FILE * fp = fopen(...);
    ....

    /* Note: fwrite returns the number of elements written, not bytes! */
    if (fwrite (&blah, sizeof (blah), 1, fp) != 1) goto error1;

    ...

    if (fwrite (&foo, sizeof (foo), 1, fp) != 1) goto error2;

    ...

ok:
    /* Everything went fine */
    fclose(fp);
    return 0;

error1:
    /* Error case 1 */
    fclose(fp);
    return -1;

error2:
    /* Error case 2 */
    fclose(fp);
    return -2;
}

Вы уловили идею. Реструктурируйте по своему усмотрению (однократный / многократный возврат, однократная очистка, настраиваемые сообщения об ошибках и т. Д.). По моему опыту, это наиболее распространенный шаблон обработки ошибок C. Ключевой момент: НИКОГДА, НИКОГДА не игнорируйте коды возврата stdlib, и любая веская причина для этого (например, удобочитаемость) недостаточно хороша.

Вы можете написать функцию-оболочку

void new_fwrite(a, b, c, d) {
    if (fwrite (a, b, c, b) != b) 
       throw exception;
}

а затем замените все вызовы fwrite на new_fwrite

Игнорировать ошибки - плохая идея. Гораздо лучше сделать что-нибудь неприятное, например, вывести программу из строя, чтобы хотя бы вы знали, что что-то пошло не так, чем продолжать молча. Еще лучше хорошая проверка ошибок и восстановление.

Если вы используете C ++, вы можете создать оболочку RAII для ФАЙЛА *, чтобы он всегда закрывался. Посмотрите std :: auto_ptr для идей. Затем вы можете вернуть полезный код ошибки или из функции, когда захотите, или вызвать исключение и не беспокоиться о забытых элементах очистки.

Вы можете удалить предупреждения следующим образом:

(void) fwrite ( ,,,, );

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

Вложенность - это плохо, и многократный возврат - тоже нехорошо.

Раньше я использовал следующий шаблон:

#define SUCCESS (0)
#define FAIL    (-1)
int ret = SUCCESS;

if (!fwrite(...))
    ret = FAIL;
if (SUCCESS == ret) {
    do_something;
    do_something_more;
    if (!fwrite(...))
        ret = FAIL;
}
if (SUCCESS == ret)
    do_something;

return ret;

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

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

int safe_fwrite(FILE *file, const void *data, size_t nbytes, unsigned int retries);
void print_and_exit(const char *message);

Тогда ваш основной код можно было бы записать как

#define RETRIES 5
if(!safe_fwrite(fp, &blah, sizeof blah, RETRIES))
  print_and_exit("Blah writing failed, aborting");
if(!safe_fwrite(fp, &foo, sizeof foo, RETRIES))
  print_and_exit("Foo writing failed, aborting");

Ваше первое решение выглядит нормально. Обычно goto err; бывает более удобным, так как вам может потребоваться какая-то общая часть очистки (например, перемотка в известное положение).

Чтобы сделать GCC тихим, просто сделайте:

(void)fwrite (&blah, sizeof (blah), 1, fp);
(void)fwrite (&foo, sizeof (foo), 1, fp);

Почему бы вам не обернуть fwrite в какой-либо объект Writer и не выбросить исключение, если fwrite () возвращает код ошибки? Легко кодировать, легко использовать, легко управлять. ИМХО конечно. :)

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

#define WRITE_ERROR 100
#define WRITE_OK 0

int do_fwrite(void* ptr, size_t bytes, int fp) {
  if ( fwrite(ptr, bytes, 1, fp) != bytes ) return WRITE_ERROR;
  return WRITE_OK;
}

int my_func() {
   int errcode = 0;

   ...
   do {
     if ( errcode = do_fwrite(&blah, sizeof(blah), fp) ) break;
     ....
     if ( errcode = do_fwrite(&foo, sizeof(foo), fp) ) break;
     ....
     etc
   } while( false );

   fclose(fp);
   return errcode;
}

Что-то вроде этого сработает

if (fwrite (&blah, sizeof (blah), 1, fp) != 1) throw SomeException;

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

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

if (fwrite (&blah, sizeof (blah), 1, fp) != 1) {
    //cleanup here
    throw SomeException;
}

Потенциально элегантным решением C для этого может быть что-то вроде этого (предупреждение - впереди непроверенный, некомпилированный код):

  size_t written;
  int    ok = 1;
  size_t num_elements = x;
  ok = (fwrite(stuff, sizeof(data), num_elements, outfile) == num_elements);

  if (ok) {
    ... do other stuff ...
  }

  ok = ok && (fwrite(stuff, sizeof(data), num_elements, outfile) == num_elements);

  if (ok) {
    ... etc etc ad nauseam ...
  }

  fclose(outfile);

  return ok;

Вышеупомянутое позволяет достичь двух целей одновременно:

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

К сожалению, «уродливые» блоки if (ok) необходимы, если вы не хотите везде использовать оценку короткого замыкания. Я видел, как этот шаблон использовался в сравнительно небольших функциях, использующих оценку короткого замыкания повсюду, и я думаю, что он, вероятно, лучше всего подходит для этого конкретного использования.

Хорошо, учитывая, что я ищу c решение (без исключений), как насчет:

void safe_fwrite(data,size,count,fp) {
   if (fwrite(data,size,count,fp) != count) {
      printf("[ERROR] fwrite failed!\n");
      fclose(fp);
      exit(4);
   }
}

И тогда в моем коде у меня есть:

safe_fwrite (&blah, sizeof (blah), 1, fp);
// ... more code ...
safe_fwrite (&foo, sizeof (foo), 1, fp);
// ... more code ...