Почему это " пока (!феоф (файл)) " всегда не так?

я хотел бы представить абстрактную, высокоуровневую перспективу.

параллелизма и одновременности

операции ввода-вывода взаимодействуют с окружающей средой. Среда не является частью вашей программы и не находится под вашим контролем. Среда действительно существует "одновременно" с вашей программой. Как и во всем параллельном, вопросы о "текущем состоянии" не имеют смысла: нет понятия "одновременности" между параллельными событиями. Многие свойства государства просто не надо по совместительству.

позвольте мне уточнить: Предположим, вы хотите спросить: "у вас есть больше данных". Вы можете спросить об этом у параллельного контейнера или вашей системы ввода-вывода. Но ответ, как правило, неосуществим и, следовательно, бессмыслен. Так что, если контейнер говорит "да" – к тому времени, когда вы пытаетесь читать, он больше не может иметь данных. Точно так же, если ответ "нет", к тому времени, когда вы попытаетесь прочитать, данные, возможно, прибыли. Вывод состоит в том, что там просто и нет такого свойства, как "у меня есть данные", так как вы не можете действовать осмысленно в ответ на любой возможный ответ. (Ситуация немного лучше с буферизованным вводом, где вы можете предположительно получить "да, у меня есть данные", что представляет собой некоторую гарантию, но вам все равно придется иметь дело с противоположным случаем. И с выходом ситуация, безусловно, так же плоха, как я описал: вы никогда не знаете, заполнен ли этот диск или этот сетевой буфер.)

так мы сделать вывод, что это невозможно, а на самом деле unразумный, чтобы спросить систему ввода / вывода, является ли это будет возможность выполнения операции ввода-вывода. Единственный возможный способ взаимодействия с ним (как и с параллельным контейнером) - это попытка операция и проверить, удалось ли это или не удалось. В тот момент, когда вы взаимодействуете с окружающей средой, тогда и только тогда вы можете знать, действительно ли это взаимодействие было возможно, и в этот момент Вы обязан выполнять взаимодействие. (Это "точка синхронизации", если хотите.)

EOF

теперь мы добираемся до EOF. EOF - это ответ вам попытка операции ввода-вывода. Это означает, что вы пытались что-то прочитать или написать, но при этом вам не удалось прочитать или записать какие-либо данные, и вместо этого был обнаружен конец ввода или вывода. Это верно по существу для всех API ввода-вывода, будь то C стандартная библиотека, c++ iostreams или другие библиотеки. Пока операции ввода-вывода выполняются успешно, вы просто не знаю будут ли дальнейшие, будущие операции успешными. Ты должны всегда сначала попробовать операцию, а затем реагировать на успех или неудачу.

примеры

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

• C stdio, читать из файла:

  for (;;) {
      size_t n = fread(buf, 1, bufsize, infile);
      consume(buf, n);
      if (n < bufsize) { break; }
  }
  

  результат, который мы должны использовать n, число элементов, которые были прочитаны (которые могут быть всего лишь нулем).

• C stdio,scanf:

  for (int a, b, c; scanf("%d %d %d", &a, &b, &c) == 3; ) {
      consume(a, b, c);
  }
  

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

• C++, извлечение в формате iostreams:

  for (int n; std::cin >> n; ) {
      consume(n);
  }
  

  результат, который мы должны использовать std::cin сам, который может быть оценен в логическом контексте и говорит нам, находится ли поток все еще в good() государство.

• C++, iostreams getline:

  for (std::string line; std::getline(std::cin, line); ) {
      consume(line);
  }
  

  результат мы должны использовать снова std::cin, так же как и раньше.

• POSIX,write(2) to промывочный буфер:

  char const * p = buf;
  ssize_t n = bufsize;
  for (ssize_t k = bufsize; (k = write(fd, p, n)) > 0; p += k, n -= k) {}
  if (n != 0) { /* error, failed to write complete buffer */ }
  

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

• POSIX getline()

  char *buffer = NULL;
  size_t bufsiz = 0;
  ssize_t nbytes;
  while ((nbytes = getline(&buffer, &bufsiz, fp)) != -1)
  {
      /* Use nbytes of data in buffer */
  }
  free(buffer);
  

  результат, который мы должны использовать nbytes, число байтов до и включая новую строку (или EOF, если файл не заканчивается новой строкой).

  отметим, что функция явно возвращает -1 (а не EOF!) при возникновении ошибки или достижении конца файла.

вы можете заметить, что мы очень редко пишем фактическое слово "EOF". Мы обычно обнаруживаем состояние ошибки каким-то другим способом, который нам более интересен (например, неспособность выполнить столько операций ввода-вывода, сколько мы хотели). В каждом примере есть некоторая функция API, которая может явно сказать нам, что состояние EOF было обнаружено, но это на самом деле не a очень полезная информация. Это гораздо больше деталей, чем мы часто заботимся. Важно ли ввода/вывода удалось, более-так как это не удалось.

• последний пример, который фактически запрашивает состояние EOF: предположим, что у вас есть строка и вы хотите проверить, что она представляет целое число целиком, без дополнительных битов в конце, кроме пробелов. Используя C++ iostreams, это выглядит так:

  std::string input = "   123   ";   // example
  
  std::istringstream iss(input);
  int value;
  if (iss >> value >> std::ws && iss.get() == EOF) {
      consume(value);
  } else {
      // error, "input" is not parsable as an integer
  }
  

  здесь мы используем два результата. Первый это iss, сам объект потока, чтобы проверить, что отформатированное извлечение в value удалось. Но затем, после того, как мы также потребляем пробелы, мы выполняем другую операцию ввода-вывода,iss.get(), и ожидайте, что он потерпит неудачу как EOF, что имеет место, если вся строка уже была использована для форматированного извлечения.

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

ответ

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