fgetc — Считывает символ из файла


Содержание

fgetc () читает символ 0c, а элементы массива обнуляются? это почему?

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

Я получил некоторый код, который использует fgetc (); читать символы из файла и сохранять их в int скажем l;

файл открывается в режиме чтения двоичных файлов («rb»); с помощью

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

Проблема в том, что когда fgetc (); читает символ, который в таблице ASCII представляется как OC в шестнадцатеричном формате или FF как char мой окончательный массив char заполняется нулями.

Короче говоря, если элемент char [] содержит 0c, остальные элементы равны 0;

Я понятия не имею, почему это происходит. Когда я отредактировал свой файл с помощью шестнадцатеричного редактора и заменил 0c чем-то другим Этот файл был прочитан правильно, и все символы были сохранены в массиве, как они были записаны в файле.

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

Хорошо. Полный код:

Так как вы спросили, теперь у вас есть это.

  1. этот код не будет компилироваться, потому что у вас нет необходимых библиотек.
  2. упрощенный код в начале этого поста.
  3. те библиотеки, которыми вы не обладаете, не имеют ничего общего с этой проблемой.

Решение

Вы предполагаете, что

результаты в the_string содержащий «0c» , Тем не менее, он будет содержать «c» ,

Это означает, что в дальнейшем вы преобразуете входные данные «\x0c\xfe» в ‘c’, ‘\0’, ‘f’, ‘e’ , Если вы используете это в любой точке строки в стиле C, конечно, она завершает строку после c ,

Было довольно сложно отлаживать эту программу. В будущем, пожалуйста, напишите читаемый и понятный код. Ниже приведен неполный список проблем, которые я обнаружил.

  • while(!feof(file)) всегда неправильно.
  • Используйте переменную область видимости. Если вы потянете декларацию sL а также sR в цикл, вам не нужно их сбрасывать. Меньше кода, меньше потенциальных ошибок.
  • Вы используете много кода для чего-то столь же простого, как преобразование предположительно 8-битного char в шестнадцатеричном представлении. Фактически, единственная причина, по которой вы когда-либо использовали std::stringstream в вашем коде стоит сделать именно это. Почему вы не изолируете эту функцию от функции?

    Из-за плохого форматирования кода вы, вероятно, не заметили ошибок копирования-вставки при использовании sL а также sR :

    Очевидно, что последняя строка должна читать sR[1] = ‘\0’;

    Здесь очень много, много что-то не так с вашим кодом, но одна вещь, которая легко мешает людям помогать, это форматирование. В частности, форматирование пространства сделало ваш код очень трудным для чтения, поэтому я позволил себе отредактировать «полный» код в вашем вопросе, чтобы иметь (почти) согласованное форматирование. Несколько основных проблем становятся очевидными:

    • Используйте значимые имена для переменных и функций. Я понятия не имею, что вы пытаетесь сделать здесь, что не помогает найти реальную проблему в коде.
    • смешивание а также не помогает читабельность вашего кода. Выберите один или другой. По факту, только когда-либо использовать в C ++.
    • Кроме того, используйте соответствующие имена заголовков для C ++ ( а также вместо а также ).

    Не пишите точку с запятой после составного оператора. Вместо

    ты должен написать

    ; является частью отдельное заявление. Это также мешает вам использовать else строит.

    При необходимости используйте инициализаторы. Так что не пиши

    Другие решения

    Эта проблема 0c может быть решена с помощью:

    изменение массива char [], в котором хранится значение, на unsigned char [];

    когда ввод читается с потоком строк, эта строка очень полезна

    Когда 0c конвертируется в c setw (); устанавливает ширину потока и setfill () дополняет его нулями.

    fgets

    Функция fgets() считывает до num-1 символов из файла stream и помещает их в массив символов, на который указывает str. Символы считываются до тех пор, пока не встретится символ «новая строка», EOF или до достижения указанного предела. По окончании считывания в массив str сразу после последнего считанного символа помещается нулевой символ. Символ «новая строка» при считывании будет сохранен и станет частью массива str.

    В случае удачи fgets() возвращает str, при неудаче возвращается NULL. В случае ошибки по чтению содержимое массива, на который указывает str, не определено. Поскольку как в случае ошибки, так и при достижении конца файла возвращается null, для определения того, что имен­но произошло, необходимо использовать feof() или ferror().

    Считывание из файла

    Уже сейчас клиенты компании “Автозапчасти от Вована” могут отправлять свои заказы через Интернет, однако если сотрудники компании Вована захотят просмотреть заказы, им придется открывать файлы самостоятельно.

    Давайте создадим веб-интерфейс, который позволит служащим компании “Автозапчасти от Вована” легко читать файлы. Код такого интерфейса приведен в листинге 2.3.

    В этом сценарии выполняется последовательность действий, которая упоминалась выше: открытие файла, чтение из файла, закрытие файла. Вывод, генерируемый этим сценарием с использованием файла данных из листинга 2.1, показан на рис. 2.4.

    Теперь подробно рассмотрим функции, используемые в этом сценарии.

    Открытие файла для чтения: функция fopen ()

    И снова мы открываем файл с помощью функции fopen () . На этот раз файл открывается только для чтения, поэтому используется режим файла ‘ r’ :

    $fp = fopen(«$DOCUMENT_ROOT/../orders/orders.txt», ‘rb’);

    Как узнать, где остановиться: функция feof ()

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

    Функция feof () принимает один параметр – дескриптор файла. Она возвращает значение true , если указатель файла находится в конце файла. И хотя имя функции может показаться странным, его легко запомнить, если знать, что feof означает File End Of File (“файл: конец файла”).

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

    Построчное чтение: функции fgets (), fgetss () и fgetcsv ()

    В рассматриваемом примере для считывания из файла используется функция fgets () :

    $order = fgets($fp, 999);

    Эта функция используется для чтения из файла строк по одной за раз. В данном случае считывание будет выполняться до тех пор, пока не встретится символ новой строки (\n) , символ EOF или из файла не будут прочитаны 998 байт. Максимальная длина считываемой строки равна указанной длине минус 1 байт.

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

    Интересной разновидностью функции fgets () является функция fgetss () , имеющая следующий прототип:

    string fgetss(resource fp, int length, string [allowable_tags] );

    Эта функция во многом подобна функции fgets () и отличается от нее только тем, что она удаляет любые РНР- и HTML-дескрипторы, обнаруженные в строке.

    Если вы хотите сохранить в файле какие-то конкретные дескрипторы, их следует поместить в строку разрешенных дескрипторов allowable_tags . Функцию fgetss () следует использовать для достижения большей безопасности во время чтения файла, записанного кем-либо другим или содержащего данные, введенные пользователем. Включение в файл HTML-кода без каких-либо ограничений может привести к нарушению тщательно спланированного форматирования. Отсутствие ограничений на наличие в файле РНР-кода может предоставить злонамеренному пользователю практически полную свободу действий на вашем сервере.

    Функция fgetcsv () представляет собой еще одну разновидность функции fgets () . Она имеет следующий прототип:

    array fgetcsv(resource fp, int length [, string delimiter [, string enclosure]]) ;

    Эта функция разбивает строки файлов при использовании некоторого символа в качестве разделителя, например, табуляции (как предлагалось ранее) или запятой (которая обычно применяется в электронных таблицах и других приложениях). Если требуется восстановить переменные заказа по отдельности, а не иметь дело со строкой текста, следует прибегнуть к услугам функции fgetcsv () . Она вызывается примерно так же, как и функция fgets () , но ей необходимо передать разделитель, который служит разделителем полей. Например, оператор

    $order = fgetcsv($fp, 100, «\t»);

    извлекает строку из файла и разделяет ее при каждом обнаружении символа табуляции (\t) . Полученные при этом строки помещаются в массив (в данном примере это массив $order ).

    Параметр длины length должен быть больше длины самой длинной строки считываемого файла, выраженной в символах.

    Параметр вложения enclosure используется для описания символов, в которые заключаются каждое поле в строке. Если эти символы не заданы, по умолчанию принимается символ » (двойные кавычки).

    Чтение всего файла: функции readfile (), fpassthru () и file ()

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

    Первый способ предусматривает использование функции readfile () . Весь приведенный выше сценарий можно заменить одной строкой:

    Обращение к функции readfile () открывает файл, отображает его содержимое в стандартном выводе (окне браузера), а затем закрывает файл. Прототип этой функции readfile () выглядит следующим образом:

    int readfile(string filename[, int use_include_path[, resource context]]);

    Необязательный второй параметр use_include_path указывает, должен ли РНР при поиске файла использовать путь, хранящийся в include_path , и действует так же, как и в функции fopen () . Третий необязательный параметр context используется, только если файл открыт удаленно, например, через HTTP. Функция readfile () возвращает общее количество байт, считанных из файла.

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

    $fp = fopen(«$DOCUMENT_ROOT/../orders/orders.txt», ‘rb’);

    Функция fpassthru () возвращает значение true , если чтение прошло успешно, и false – в противном случае.

    Третья возможность считывания всего файла предусматривает использование функции file () . Эта функция идентична функции readfile () за исключением того, что вместо отображения файла в стандартном выводе она преобразует его в массив. Более подробно данная функция будет рассматриваться во время изучения массивов. А пока просто отметим, что эту функцию можно вызвать следующим образом:

    Эта строка приведет к считыванию всего файла в массив с именем $filearray . Каждая строка файла сохраняется в отдельном элементе этого массива. Обратите внимание, что эта функция не является безопасной в отношении бинарных файлов в устаревших версиях РНР.

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

    Чтение символа: функция fgetc ()

    Еще одна возможность обработки файлов состоит в чтении из файла по одному символу за раз. Это реализуется с помощью функции fgetc () (“file get character” – “получить символ из файла”). В качестве своего единственного параметра она принимает указатель файла и возвращает следующий символ из файла. Цикл while в нашем первоначальном сценарии можно заменить циклом, в котором используется функция fgetc() :

    С помощью функции fgetc () этот код считывает из файла по одному символу за раз и сохраняет его в переменной $char , пока не будет достигнут конец файла. Затем выполняется небольшая дополнительная обработка с целью замены текстовых символов конца строки \п HTML-разделителями строк
    .

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

    Незначительный побочный эффект использования функции fgetc() вместо функции fgets () заключается в том, что fgetc () будет возвращать символ EOF , в то время как fgets () этого не делает. После чтения символа приходится снова проверять feof () , поскольку символ EOF в окне браузера отображаться не должен.

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

    Чтение строк произвольной длины: функция fread()

    Последний способ чтения из файла предусматривает использование функции fread () , которая читает из файла произвольное количество байт. Эта функция имеет следующий прототип:

    string fread(resource fp, int length);

    Функция считывает length байт или все байты до конца файла – в зависимости от того, что произойдет раньше.

    Работа с файлами в си ввод и вывод в файл в си

    Работа с файлами в си

    В этой статье мы узнаем, как считывать данные из файлов и записывать информацию в файлы в программах си. Файлы в си используются для того, чтобы сохранять результат работы программы си и использовать его при новом запуске программы . Например можно сохранять результаты вычислений , статистику игр.
    Чтобы работать с файлами в си необходимо подключить библиотеку stdio.h
    #include
    Чтобы работать с файлом в си необходимо задать указатель на файл по образцу
    FILE *имя указателя на файл;
    Например
    FILE *fin;
    Задает указатель fin на файл
    Дальше необходимо открыть файл и привязать его к файловому указателю. Для открытия файла в си на чтение используется команда
    Имя указателя на файл= fopen(«путь к файлу», «r»);
    Например следующая команда
    fin = fopen(«C:\\Users\\user\\Desktop\\data.txt», «r»);
    откроет файл data.txt, находящийся на рабочем столе по пути C:\\Users\\user\\Desktop Чтобы узнать путь к файлу можно выбрать файл мышью нажать на правую кнопку мыши и выбрать свойства файла. В разделе Расположение будет указан путь к файлу. Обратите внимание , что в си путь указывается с помощью двух слешей.
    После работы с файлом в си , необходимо его закрыть с помощью команды
    fclose(имя указателя на файл)

    Считывание информации из текстового файла в Си

    Чтобы можно было считывать русские символы из файла, необходимо настроить работу с Кириллицей с помощью команды
    setlocale(LC_ALL, «Russian»);

    При этом необходимо в начале программы подключить #include

    fgets, fgetws fgets, fgetws

    Получает строку из потока. Get a string from a stream.

    Синтаксис Syntax

    Параметры Parameters

    str str
    Место хранения данных. Storage location for data.

    numChars numChars
    Максимальное число считываемых символов. Maximum number of characters to read.

    вышестоящий stream
    Указатель на структуру FILE. Pointer to FILE structure.

    Возвращаемое значение Return Value

    Каждая из этих функций возвращает str. Each of these functions returns str. Возвращается значение NULL , указывающее на ошибку или условие конца файла. NULL is returned to indicate an error or an end-of-file condition. Чтобы определить, произошла ли ошибка, используйте feof или ferror . Use feof or ferror to determine whether an error occurred. Если str или Stream является пустым указателем, или numChars меньше или равен нулю, эта функция вызывает обработчик недопустимых параметров, как описано в разделе Проверка параметров. If str or stream is a null pointer, or numChars is less than or equal to zero, this function invokes the invalid parameter handler, as described in Parameter Validation. Если выполнение может быть продолжено , для параметра еинвал устанавливается значение, а функция возвращает значение NULL. If execution is allowed to continue, errno is set to EINVAL and the function returns NULL.

    Дополнительные сведения об этих и других кодах ошибок см. в разделе _doserrno, errno, _sys_errlist и _sys_nerr. See _doserrno, errno, _sys_errlist, and _sys_nerr for more information on these, and other, error codes.

    Примечания Remarks

    Функция fgets считывает строку из аргумента входного потока и сохраняет ее в str. The fgets function reads a string from the input stream argument and stores it in str. fgets считывает символы из текущей позиции в потоке в, включая первый символ новой строки, в конец потока или до тех пор, пока количество считываемых символов не будет равно numChars -1, в зависимости от того, что происходит первым. fgets reads characters from the current stream position to and including the first newline character, to the end of the stream, or until the number of characters read is equal to numChars — 1, whichever comes first. Результат, сохраненный в str , добавляется с нулевым символом. The result stored in str is appended with a null character. Считываемый символ новой строки (если такой есть) включается в строку. The newline character, if read, is included in the string.

    fgetws — это версия fgetsдля расширенных символов. fgetws is a wide-character version of fgets.

    fgetws считывает строку аргумента расширенных символов в виде строки многобайтовых символов или строки расширенных символов в зависимости от того, открыт ли поток в текстовом или двоичном режиме соответственно. fgetws reads the wide-character argument str as a multibyte-character string or a wide-character string according to whether stream is opened in text mode or binary mode, respectively. Дополнительные сведения об использовании текстового и двоичного режима в Юникоде и многобайтовом потоковом вводе-выводе см. в разделах Файловый ввод-вывод в текстовом и двоичном режиме и Ввод-вывод в поток в кодировке Юникод в текстовом и двоичном режиме. For more information about using text and binary modes in Unicode and multibyte stream-I/O, see Text and Binary Mode File I/O and Unicode Stream I/O in Text and Binary Modes.

    Сопоставления подпрограмм обработки обычного текста Generic-Text Routine Mappings

    Подпрограмма TCHAR.H TCHAR.H routine _UNICODE и _MBCS не определены _UNICODE & _MBCS not defined _MBCS определено _MBCS defined _UNICODE определено _UNICODE defined
    _fgetts _fgetts fgets fgets fgets fgets fgetws fgetws

    Требования Requirements

    Функция Function Обязательный заголовок Required header
    fgets fgets
    fgetws fgetws или or

    Дополнительные сведения о совместимости см. в разделе Совместимость. For additional compatibility information, see Compatibility.

    fgetc, fgetwc fgetc, fgetwc

    Считывает символ из потока. Read a character from a stream.

    Синтаксис Syntax

    Параметры Parameters

    вышестоящий stream
    Указатель на структуру FILE. Pointer to FILE structure.

    Возвращаемое значение Return Value

    fgetc возвращает символ, считанный как целое число, или возвращает EOF , чтобы указать на ошибку или конец файла. fgetc returns the character read as an int or returns EOF to indicate an error or end of file. fgetwc возвращает, как wint_t, широкий символ, соответствующий считанному символу, или возвращает WEOF , чтобы указать ошибку или конец файла. fgetwc returns, as a wint_t, the wide character that corresponds to the character read or returns WEOF to indicate an error or end of file. Для обеих функций используйте feof или ferror для различения ошибки и условия конца файла. For both functions, use feof or ferror to distinguish between an error and an end-of-file condition. Если возникает ошибка чтения, то для потока устанавливается индикатор ошибки. If a read error occurs, the error indicator for the stream is set. Если Stream имеет значение NULL, fgetc и fgetwc вызывают обработчик недопустимого параметра, как описано в разделе Проверка параметров. If stream is NULL, fgetc and fgetwc invoke the invalid parameter handler, as described in Parameter Validation. Если выполнение может быть продолжено, эти функции устанавливают значение еинвал и возвращают EOF. If execution is allowed to continue, these functions set errno to EINVAL and return EOF.

    Примечания Remarks

    Каждая из этих функций считывает один символ из текущей позиции файла, связанного с потоком. Each of these functions reads a single character from the current position of the file associated with stream. Функция затем увеличивает указатель связанного файла (если определен), чтобы он указывал на следующий символ. The function then increments the associated file pointer (if defined) to point to the next character. Если поток находится в конце файла, для него устанавливается индикатор конца файла. If the stream is at end of file, the end-of-file indicator for the stream is set.

    fgetc эквивалентен getc, но реализуется только как функция, а не как функция и макрос. fgetc is equivalent to getc, but is implemented only as a function, rather than as a function and a macro.

    fgetwc — это версия fgetcдля расширенных символов; Он считывает c в виде многобайтового символа или расширенного символа в зависимости от того, открыт ли поток в текстовом или двоичном режиме. fgetwc is the wide-character version of fgetc; it reads c as a multibyte character or a wide character according to whether stream is opened in text mode or binary mode.

    Версии с суффиксом _nolock идентичны за исключением того, что они не защищены от помех со стороны других потоков. The versions with the _nolock suffix are identical except that they are not protected from interference by other threads.

    Дополнительные сведения об обработке расширенных и многобайтовых символов в текстовом и двоичном режиме см. в разделе Ввод-вывод в поток в кодировке Юникод в текстовом и двоичном режиме. For more information about processing wide characters and multibyte characters in text and binary modes, see Unicode Stream I/O in Text and Binary Modes.

    Сопоставления подпрограмм обработки обычного текста Generic-Text Routine Mappings

    Подпрограмма TCHAR.H TCHAR.H routine _UNICODE и _MBCS не определены _UNICODE & _MBCS not defined _MBCS определено _MBCS defined _UNICODE определено _UNICODE defined
    _fgettc _fgettc fgetc fgetc fgetc fgetc fgetwc fgetwc

    Требования Requirements

    Функция Function Обязательный заголовок Required header
    fgetc fgetc
    fgetwc fgetwc или or

    Дополнительные сведения о совместимости см. в разделе Совместимость. For additional compatibility information, see Compatibility.

    fgets

    (PHP 4, PHP 5, PHP 7)

    fgets — Читает строку из файла

    Описание

    Читает строку из файлового указателя.

    Список параметров

    Указатель на файл должен быть корректным и указывать на файл, успешно открытый функциями fopen() или fsockopen() (и все еще не закрытый функцией fclose() ).

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

    Возвращаемые значения

    Возвращает строку размером в length — 1 байт, прочитанную из дескриптора файла, на который указывает параметр handle . Если данных для чтения больше нет, то возвращает FALSE .

    В случае возникновения ошибки возвращает FALSE .

    Примеры

    Пример #1 Построчное чтение файла

    Примечания

    Замечание: Если у вас возникают проблемы с распознаванием PHP концов строк при чтении или создании файлов на Macintosh-совместимом компьютере, включение опции auto_detect_line_endings может помочь решить проблему.

    Программисты, привыкшие к семантике ‘C’ функции fgets() , должны принимать во внимание разницу в том, каким образом возвращается признак достижения конца файла (EOF).

    Смотрите также

    • fgetss() — Читает строку из файла и удаляет HTML-теги
    • fread() — Бинарно-безопасное чтение файла
    • fgetc() — Считывает символ из файла
    • stream_get_line() — Получает строку из потокового ресурса до указанного разделителя
    • fopen() — Открывает файл или URL
    • popen() — Открывает файловый указатель процесса
    • fsockopen() — Открывает соединение с интернет-сокетом или доменным сокетом Unix
    • stream_set_timeout() — Установить значение тайм-аута для потока

    User Contributed Notes 37 notes

    A better example, to illustrate the differences in speed for large files, between fgets and stream_get_line.

    This example simulates situations where you are reading potentially very long lines, of an uncertain length (but with a maximum buffer size), from an input source.

    As Dade pointed out, the previous example I provided was much to easy to pick apart, and did not adequately highlight the issue I was trying to address.

    Note that specifying a definitive end-character for fgets (ie: newline), generally decreases the speed difference reasonably significantly.

    #!/usr/bin/php
    = file_get_contents ( ‘http://loripsum.net/api/60/verylong/plaintext’ ); # Should be around 90k characters
    $plaintext = str_replace ( «\n» , » » , $plaintext ); # Get rid of newlines

    $fp = fopen ( «/tmp/SourceFile.txt» , «w» );
    for( $i = 0 ; $i 100000 ; $i ++) <
    fputs ( $fp , substr ( $plaintext , 0 , rand ( 4096 , 65534 )) . «\n» );
    >
    fclose ( $fp );

    $fp = fopen ( «/tmp/SourceFile.txt» , «r» );
    $start = microtime ( true );
    while( $line = fgets ( $fp , 65535 )) <
    1 ;
    >
    $end = microtime ( true );
    fclose ( $fp );
    $delta1 =( $end — $start );

    $fp = fopen ( «/tmp/SourceFile.txt» , «r» );
    $start = microtime ( true );
    while( $line = stream_get_line ( $fp , 65535 )) <
    1 ;
    >
    $end = microtime ( true );
    fclose ( $fp );
    $delta2 =( $end — $start );

    $pdiff = $delta1 / $delta2 ;
    print «stream_get_line is » . ( $pdiff > 1 ? «faster» : «slower» ) . » than fgets — pdiff is $pdiff \n» ;
    ?>

    $ ./testcase.php
    stream_get_line is faster than fgets — pdiff is 1.760398041785

    Note that, in a vast majority of situations in which php is employed, tiny differences in speed between system calls are of negligible importance.

    There’s an error in the documentation:

    The file pointer must be valid, and must point to a file successfully opened by fopen() or fsockopen() (and not yet closed by fclose()).

    You should also add «popen» and «pclose» to the documentation. I’m a new PHP developer and went to verify that I could use «fgets» on commands that I used with «popen».

    One thing I discovered with fgets, at least with PHP 5.1.6, is that you may have to use an IF statement to avoid your code running rampant (and possibly hanging the server). This can cause problems if you do not have root access on the server on which you are working.

    This is the code I have implemented ($F1 is an array):

    if( $fh = fopen ( «filename» , «r» )) <
    while (! feof ( $fh )) <
    $F1 [] = fgets ( $fh , 9999 );
    >
    fclose ( $fh );
    >
    ?>

    I have noticed that without the IF statement, fgets seems to ignore when $fh is undefined (i.e., «filename» does not exist). If that happens, it will keep attempting to read from a nonexistent filehandle until the process can be administratively killed or the server hangs, whichever comes first.


    tag without a hitch, but when I moved the code to a LAMP production server, every \r\n created two fgets and I got free empty lines.

    I tried deleting with $string=str_replace(«\r\n»,»\n»,$string); but it had no effect whatsoever. The solution was to do an fread() and explode the contents by PHP_EOL and do a foreach($lines as $line) so every line did not get duplicated.

    Here is the example code:

    $file=fopen(«test.txt,»r»);
    $text=fread($file,filesize(«test.txt»));
    $lines=explode(PHP_EOL,$text);
    foreach($lines as $line)
    <
    // Do something
    >

    I think that the quickest way of read a (long) file with the rows in reverse order is

    = ‘myfile.txt’ ;
    $command = «tac $myfile > /tmp/myfilereversed.txt» ;
    passthru ( $command );
    $ic = 0 ;
    $ic_max = 100 ; // stops after this number of rows
    $handle = fopen ( «/tmp/myfilereversed.txt» , «r» );
    while (! feof ( $handle ) && ++ $ic $ic_max ) <
    $buffer = fgets ( $handle , 4096 );
    echo $buffer . «
    » ;
    >
    fclose ( $handle );
    ?>

    It echos the rows while it is reading the file so it is good for long files like logs.

    It’s strange no one mentions «0» in this context.

    Since «0» is considered to be false, a line with a single «0» can be treated as EOF if using the while assign idiom.

    while ($line = fgets(STDIN, 2)) <
    >

    This may surprisingly break if a line starts with «)»

    if((!isset( $_GET [ ‘filepath’ ]) || ! file_exists ( $_GET [ ‘filepath’ ])) || !isset( $_GET [ ‘sel’ ]))
    exit( «» );

    echo «List
    » ;
    $fullPath = «D:\\OSPanel\\domains\\» . $_GET [ «filepath» ];
    $f = fopen ( $fullPath , «r» );
    $arr ;
    for( $i = 0 ; $str = fgets ( $f ); $i ++) <
    $tempArr0 = explode ( ‘-‘ , $str );
    $arr [ $i ][ 0 ] = trim ( $tempArr0 [ 0 ]);
    $arr [ $i ][ 1 ] = trim ( $tempArr0 [ 1 ]);
    >

    if( $_GET [ «sel» ] == «var1» ) <
    sort ( $arr );
    echo «

    » ;
    for( $i = 0 ; $i count ( $arr ); $i ++)
    echo » ; » ;
    echo «

    » ;
    >
    else if( $_GET [ «sel» ] == «var2» ) <
    for( $i = 0 ; $i count ( $arr ); $i ++)
    echo «

    » ;
    >
    else if( $_GET [ «sel» ] == «var3» ) <
    for( $i = 0 ; $i count ( $arr ); $i ++)
    echo «

    Error in the example number 1 of this page.

    change this line:
    $buffer = fgets($fd, 4096);
    into:
    $buffer = fgets($handle, 4096);

    I’m using this function to modify the header of a large postscript document on copy. Works extremely quickly so far.

    function write($filename) <
    $fh = fopen($this->sourceps,’r’);
    $fw = fopen($filename,’w’);

    while (!feof($fh)) <
    $buffer = fgets($fh);
    fwrite($fw,$buffer);
    if (!$setupfound && ereg(«^%%BeginSetup»,$buffer)) <
    $setupfound++;
    if (array_key_exists(«$filename»,$this->output)) <
    foreach ($this->output[$filename] as $function => $value) <
    fwrite($fw,$value);
    >
    >
    stream_copy_to_stream($fh,$fw);
    >
    >
    fclose($fw);
    fclose($fh);
    >

    fscanf($file, «%s\n») isn’t really a good substitution for fgets(), since it will stop parsing at the first whitespace and not at the end of line!

    (See the fscanf page for details on this)

    An easy way to authenticate Windows Domain users from scripts running on a non-Windows or non-Domain box — pass the submitted username and password to an IMAP service on a Windows machine.

    = ‘imapserver’ ;
    $user = ‘user’ ;
    $pass = ‘pass’ ;

    if ( authIMAP ( $user , $pass , $server )) <
    echo «yay» ;
    > else <
    echo «nay» ;
    >

    function authIMAP ( $user , $pass , $server ) <
    $connection = fsockopen ( $server , 143 , $errno , $errstr , 30 );

    if(! $connection ) return false ;

    $output = fgets ( $connection , 128 ); // banner
    fputs ( $connection , «1 login $user $pass \r\n» );
    $output = fgets ( $connection , 128 );
    fputs ( $connection , «2 logout\r\n» );
    fclose ( $connection );

    if ( substr ( $output , 0 , 4 ) == ‘1 OK’ ) return true ;

    It appears that fgets() will return FALSE on EOF (before feof has a chance to read it), so this code will throw an exception:

    while (!feof($fh)) <
    $line = fgets($fh);
    if ($line === false) <
    throw new Exception(«File read error»);
    >
    >

    Saku’s example may also be used like this:

    @ $pointer = fopen ( » $DOCUMENT_ROOT /foo.txt» , «r» ); // the @ suppresses errors so you have to test the pointer for existence
    if ( $pointer ) <
    while (! feof ( $pointer )) <
    $preTEXT = fgets ( $pointer , 999 );
    // $TEXT .= $preTEXT; this is better for a string
    $ATEXT [ $I ] = $preTEXT ; // maybe better as an array
    $I ++;
    >
    fclose ( $pointer );
    >
    ?>

    Sometimes the strings you want to read from a file are not separated by an end of line character. the C style getline() function solves this. Here is my version:
    function getline ( $fp , $delim )
    <
    $result = «» ;
    while( ! feof ( $fp ) )
    <
    $tmp = fgetc ( $fp );
    if( $tmp == $delim )
    return $result ;
    $result .= $tmp ;
    >
    return $result ;
    >

    // Example:
    $fp = fopen ( «/path/to/file.ext» , ‘r’ );
    while( ! feof ( $fp ) )
    <
    $str = getline ( $fp , ‘|’ );
    // Do something with $str
    >
    fclose ( $fp );
    ?>

    If you need to simulate an un-buffered fgets so that stdin doesnt hang there waiting for some input (i.e. it reads only if there is data available) use this :
    function fgets_u ( $pStdn ) <

    $pArr = array( $pStdn );

    if ( false === ( $num_changed_streams = stream_select ( $pArr , $write = NULL , $except = NULL , 0 ))) <
    print( «\$ 001 Socket Error : UNABLE TO WATCH STDIN.\n» );
    return FALSE ;
    > elseif ( $num_changed_streams > 0 ) <
    return trim ( fgets ( $pStdn , 1024 ));
    >

    Regarding Leigh Purdie’s comment (from 4 years ago) about stream_get_line being better for large files, I decided to test this in case it was optimized since then and I found out that Leigh’s comment is just completely incorrect

    fgets actually has a small amount of better performance, but the test Leigh did was not set up to produce good results

    The suggested test was:

    $ time yes «This is a test line» | head -1000000 | php -r ‘$fp=fopen(«php://stdin»,»r»); while($line=stream_get_line($fp,65535,»\n»)) < 1; >fclose($fp);’

    $ time yes «This is a test line» | head -1000000 | php -r ‘$fp=fopen(«php://stdin»,»r»); while($line=fgets($fp,65535)) < 1; >fclose($fp);’

    The reason this is invalid is because the buffer size of 65535 is completely unnecessary

    piping the output of «yes ‘this is a test line'» in to PHP makes each line 19 characters plus the delimiter

    so while I don’t know why stream_get_line performs better with an oversize buffer, if both buffer sizes are correct, or default, they have a negligable performance difference — although notably, stream_get_line is consistent — however if you’re thinking of switching, make sure to be aware of the difference between the two functions, that stream_get_line does NOT append the delimiter, and fgets DOES append the delimiter

    Here are the results on one of my servers:

    Buffer size 65535
    stream_get_line: 0.340s
    fgets: 2.392s

    Buffer size of 1024
    stream_get_line: 0m0.348s
    fgets: 0.404s

    Buffer size of 8192 (the default for both)
    stream_get_line: 0.348s
    fgets: 0.552s

    Buffer size of 100:
    stream_get_line: 0.332s
    fgets: 0.368s

    Some people try to call feof before fgets, and then ignoring the return value of fgets. This method leads to processing value FALSE when reaching the end of file.

    Bad example:
    = fopen ( «fgetstest.php» , «r» );
    $ln = 0 ;
    while (! feof ( $f )) <
    $line = fgets ( $f );
    ++ $ln ;
    printf ( «%2d: » , $ln );
    if ( $line === FALSE ) print ( «FALSE\n» );
    else print ( $line );
    >
    fclose ( $f );
    ?>

    Good example:
    = fopen ( «fgetstest.php» , «r» );
    $ln = 0 ;
    while ( $line = fgets ( $f )) <
    ++ $ln ;
    printf ( «%2d: » , $ln );
    if ( $line === FALSE ) print ( «FALSE\n» );
    else print ( $line );
    >
    fclose ( $f );
    ?>

    I would have expected the same behaviour from these bits of code:-

    /*This times out correctly*/
    while (! feof ( $fp )) <
    echo fgets ( $fp );
    >

    /*This times out before eof*/
    while ( $line = fgets ( $fp )) <
    echo $line ;
    >

    /*A reasonable fix is to set a long timeout*/
    stream_set_timeout ( $fp , 180 );
    while ( $line = fgets ( $fp )) <
    echo $line ;
    >
    ?>

    Note that — afaik — fgets reads a line until it reaches a line feed (\\n). Carriage returns (\\r) aren’t processed as line endings.
    However, nl2br insterts a
    tag before carriage returns as well.
    This is useful (but not nice — I must admit) when you want to store a more lines in one.
    function write_lines ( $text ) <
    $file = fopen ( ‘data.txt’ , ‘a’ );
    fwrite ( $file , str_replace ( «\n» , ‘ ‘ , $text ). «\n» );
    fclose ( $file );
    >

    function read_all () <
    $file = fopen ( ‘data.txt’ , ‘r’ );
    while (! feof ( $file )) <
    $line = fgets ( $file );
    echo ‘Section

    For large files, consider using stream_get_line rather than fgets — it can make a significant difference.

    $ time yes «This is a test line» | head -1000000 | php -r ‘$fp=fopen(«php://stdin»,»r»); while($line=stream_get_line($fp,65535,»\n»)) < 1; >fclose($fp);’

    real 0m1.482s
    user 0m1.616s
    sys 0m0.152s

    $ time yes «This is a test line» | head -1000000 | php -r ‘$fp=fopen(«php://stdin»,»r»); while($line=fgets($fp,65535)) < 1; >fclose($fp);’

    real 0m7.281s
    user 0m7.392s
    sys 0m0.136s

    When working with VERY large files, php tends to fall over sideways and die.

    Here is a neat way to pull chunks out of a file very fast and won’t stop in mid line, but rater at end of last known line. It pulled a 30+ million line 900meg file through in

    NOTE:
    $buf just hold current chunk of data to work with. If you try «$buf .=» (note ‘dot’ in from of ‘=’) to append $buff, script will come to grinding crawl around 100megs of data, so work with current data then move on!

    //File to be opened
    $file = «huge.file»;
    //Open file (DON’T USE a+ pointer will be wrong!)
    $fp = fopen($file, ‘r’);
    //Read 16meg chunks
    $read = 16777216;
    //\n Marker
    $part = 0;

    while(!feof($fp)) <
    $rbuf = fread($fp, $read);
    for($i=$read;$i > 0 || $n == chr(10);$i—) <
    $n=substr($rbuf, $i, 1);
    if($n == chr(10))break;
    //If we are at the end of the file, just grab the rest and stop loop
    elseif(feof($fp)) <
    $i = $read;
    $buf = substr($rbuf, 0, $i+1);
    break;
    >
    >
    //This is the buffer we want to do stuff with, maybe thow to a function?
    $buf = substr($rbuf, 0, $i+1);
    //Point marker back to last \n point
    $part = ftell($fp)-($read-($i+1));
    fseek($fp, $part);
    >
    fclose($fp);

    WARNING! fgets() and I presume any read() call to a file handle, e.g.

    while(!feof(STDIN)) <
    $line = fgets(STDIN);

    . do something useful with $line.
    >

    . will result in a timeout after a default time of 60 seconds on my install. This behavior is non standard (not POSIX like) and seems to me to be a bug, or if not a major caveat which should be documented more clearly.

    After the timeout fgets() will return FALSE (=== FALSE), however, you can check to see if the stream (file handle) has really closed by checking feof($stream), e.g.

    while(!feof(STDIN)) <
    $line = fgets(STDIN);

    . do something useful with $line.
    >

    One easy sample, how to use «fgets»:
    This sample shows how to read the Information from an .txt file:

    = fopen ( «protocol.txt» , «r» ); //r = read
    if( $pointer != false ) //Is it possible to open the File?!
    <
    //Repeats all Information from protocol.txt
    while(! feof ( $pointer )) //the loop runs till the Pointer is at the End of the File
    <
    $row = fgets ( $pointer ); // $row reads the Information from the row of the File
    echo «

    » ;
    >
    fclose ( $pointer ); //File must be closed
    >
    else
    <
    echo «

    It was not possible to open the File!

    For anyone who wants a proper non-blocking fgets for sockets, there is a tiny snippet that does just that (performance should be horrible compared to fgets though):

    function read_line_nb ( $handle )
    <
    static $buffer = » ;
    static $lastOffset = 0 ;

    $buffer .= fread ( $handle , 0x1000 );
    if ( preg_match ( ‘#\\R#’ , $buffer , $m , PREG_OFFSET_CAPTURE , $lastOffset )) <
    $line = substr ( $buffer , 0 , $m [ 0 ][ 1 ] + strlen ( $m [ 0 ][ 0 ]));
    $buffer = substr ( $buffer , $m [ 0 ][ 1 ] + strlen ( $m [ 0 ][ 0 ]));
    return $line ;
    >
    $lastOffset = strlen ( $buffer );
    return false ;
    >
    ?>

    This is a a simple function to detect end of line type for any file.

    function detectEndOfLine ( $file )
    <
    $handle = @ fopen ( $file , «r» );
    if ( $handle )
    <
    $char = 0 ;
    while (! $eol || feof ( $handle ))
    <
    $char ++;
    $line = fgets ( $handle , $char );
    $eol = preg_match ( «/(\r)+/» , $line )? «W» : «» ;
    if(! $eol ) $eol = preg_match ( «/(\n)+/» , $line )? «L» : «» ;
    >
    return $eol ;
    fclose ( $handle );
    >
    >
    ?>

    This goes out to Leigh Purdie (5 years ago) and also Dade Brandon (4 months ago)

    So i say Leigh posting and though omg i need to change all my fgets to stream_get_line. Then i ran the tests as shown in Leigh Purdie comment His results:

    $ time yes «This is a test line» | head -1000000 | php -r ‘$fp=fopen(«php://stdin»,»r»); while($line=stream_get_line($fp,65535,»\n»)) < 1; >fclose($fp);’

    real 0m1.482s
    user 0m1.616s
    sys 0m0.152s

    $ time yes «This is a test line» | head -1000000 | php -r ‘$fp=fopen(«php://stdin»,»r»); while($line=fgets($fp,65535)) < 1; >fclose($fp);’

    real 0m7.281s
    user 0m7.392s
    sys 0m0.136s

    $ time yes «This is a test line» | head -1000000 | php -r ‘$fp=fopen(«php://stdin»,»r»); while($line=stream_get_line($fp,65535,»\n»)) < 1; >fclose($fp);’

    real 0m0.341s
    user 0m0.352s
    sys 0m0.148s

    $ time yes «This is a test line» | head -1000000 | php -r ‘$fp=fopen(«php://stdin»,»r»); while($line=fgets($fp,65535)) < 1; >fclose($fp);’

    real 0m4.283s
    user 0m4.128s
    sys 0m0.448s

    My results do show the same issue his results show. But first off PHP has at least gotten about 2-5 times faster then when the tests were first run (or better hardware).

    Now to relate to Dade Brandon who states if you use a correct buffer size the perfomance is neck and neck.

    $ time yes «This is a test line» | head -1000000 | php -r ‘$fp=fopen(«php://stdin»,»r»); while($line=stream_get_line($fp,21,»\n»)) < 1; >fclose($fp);’

    real 0m0.336s
    user 0m0.412s
    sys 0m0.076s

    $ time yes «This is a test line» | head -1000000 | php -r ‘$fp=fopen(«php://stdin»,»r»); while($line=fgets($fp,21)) < 1; >fclose($fp);’

    real 0m0.312s
    user 0m0.364s
    sys 0m0.192s

    As you can see very close and fgets just coming just a little bit ahead. I suspect that fgets is reading backwards on the buffer or loads everything into its self then trys to figure it out where as a correct set buffer does the trick. Dade Brandon states that fgets lets you know how the line was delimited. stream_get_line lets you choose what you wanna call the delimiter using its 3rd option.

    fgets has one more option that is important, you dont have to set the length of the line. So in a case where you may not know the length of the line maybe in handling Http protocol or something else like log lines you can simply leave it off and still get great performance.

    $ time yes «This is a test line» | head -1000000 | php -r ‘$fp=fopen(«php://stdin»,»r»); while($line=fgets($fp)) < 1; >fclose($fp);’

    real 0m0.261s
    user 0m0.260s
    sys 0m0.232s

    This is better then with a buffer set.

    This goes out to Leigh Purdie (5 years ago) and also Dade Brandon (4 months ago)

    So i say Leigh posting and though omg i need to change all my fgets to stream_get_line. Then i ran the tests as shown in Leigh Purdie comment His results:

    $ time yes «This is a test line» | head -1000000 | php -r ‘$fp=fopen(«php://stdin»,»r»); while($line=stream_get_line($fp,65535,»\n»)) < 1; >fclose($fp);’

    real 0m1.482s
    user 0m1.616s
    sys 0m0.152s

    $ time yes «This is a test line» | head -1000000 | php -r ‘$fp=fopen(«php://stdin»,»r»); while($line=fgets($fp,65535)) < 1; >fclose($fp);’

    real 0m7.281s
    user 0m7.392s
    sys 0m0.136s

    $ time yes «This is a test line» | head -1000000 | php -r ‘$fp=fopen(«php://stdin»,»r»); while($line=stream_get_line($fp,65535,»\n»)) < 1; >fclose($fp);’

    real 0m0.341s
    user 0m0.352s
    sys 0m0.148s

    $ time yes «This is a test line» | head -1000000 | php -r ‘$fp=fopen(«php://stdin»,»r»); while($line=fgets($fp,65535)) < 1; >fclose($fp);’

    real 0m4.283s
    user 0m4.128s
    sys 0m0.448s

    My results do show the same issue his results show. But first off PHP has at least gotten about 2-5 times faster then when the tests were first run (or better hardware).

    Now to relate to Dade Brandon who states if you use a correct buffer size the perfomance is neck and neck.

    $ time yes «This is a test line» | head -1000000 | php -r ‘$fp=fopen(«php://stdin»,»r»); while($line=stream_get_line($fp,21,»\n»)) < 1; >fclose($fp);’

    real 0m0.336s
    user 0m0.412s
    sys 0m0.076s

    $ time yes «This is a test line» | head -1000000 | php -r ‘$fp=fopen(«php://stdin»,»r»); while($line=fgets($fp,21)) < 1; >fclose($fp);’

    real 0m0.312s
    user 0m0.364s
    sys 0m0.192s

    As you can see very close and fgets just coming just a little bit ahead. I suspect that fgets is reading backwards on the buffer or loads everything into its self then trys to figure it out where as a correct set buffer does the trick. Dade Brandon states that fgets lets you know how the line was delimited. stream_get_line lets you choose what you wanna call the delimiter using its 3rd option.

    fgets has one more option that is important, you dont have to set the length of the line. So in a case where you may not know the length of the line maybe in handling Http protocol or something else like log lines you can simply leave it off and still get great performance.

    $ time yes «This is a test line» | head -1000000 | php -r ‘$fp=fopen(«php://stdin»,»r»); while($line=fgets($fp)) < 1; >fclose($fp);’

    real 0m0.261s
    user 0m0.260s
    sys 0m0.232s

    Работа со строками: fgets() и fputs()

    Файловая система ввода/вывода С содержит две функции, которые могут читать или писать стро¬ки в поток — fgets() и fputs(). Они имеют следующие прототипы:

    int fputs(const char *str, FILE *fp);

    char *fgets(char *str, int длина, FILE *fp);

    Функция fputs() во многом подобна puts(), за тем исключением, что она записывает строку в указанный поток. Функция fgets() читает строку из указанного потока, пока не встретится сим¬вол новой строки или не будет прочитано (длина — 1) символов. Если прочитан символ новой строки, то он станет частью строки (в противоположность gets()). В обоих случаях результирую¬щая строка завершается нулевым символом. Функция возвращает str в случае успеха и нулевой указатель — в случае ошибки.
    Можно использовать fgets() как альтернативу gets(). Чтобы сделать это, надо просто указать stdin как указатель на файл. Например, следующая про¬грамма читает до 79 символов, полученных из стандартного ввода:

    #include
    int main(void)
    <
    char s[80];
    printf(«Enter a string: «);
    fgets(s, 80, stdin);
    printf («Here is your string: %s», s);
    return 0;
    >

    Преимущество использования fgets() над gets() состоит в том, что можно предотвратить перепол¬нение массива ввода. Массив может содержать символ новой строки.

    Fgetc — Считывает символ из файла

    fgetc, getc, getchar, ungetc

    ОБЗОР

    ОПИСАНИЕ

    Функция getc() похожа на fgetc(), но она может быть реализована как макрос, который определяет состояние stream более одного раза.

    Функция getchar() эквивалентна getc(stdin).

    Функция fgets() считывает максимум size -1 символов из stream и записывает их в буфер, на который указывает s. Чтение прерывается по достижении EOF или символа новой строки. Если получен символ новой строки, то он заносится в буфер. В конец буфера после последнего символа добавляется завершающий байт null (‘\0’).

    Функция ungetc() заносит c обратно в stream, преобразует в unsigned char, если это возможно для дальнейших операций чтения. Занесённые обратно символы будут возвращаться в обратном порядке; гарантируется только одно занесение символов.

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

    Неблокирующие аналоги смотрите в unlocked_stdio(3).

    ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ

    Функция fgets() возвращает s при удачном выполнении и NULL при ошибке или если достигнут конец файла, а символы остались несчитанными.

    При успешном выполнении функция ungetc() возвращает c или EOF при ошибке.

    АТРИБУТЫ

    Описание терминов данного раздела смотрите в attributes(7).

    Интерфейс Атрибут Значение
    fgetc(), fgets(), getc(),
    getchar(), ungetc()
    безвредность в нитях безвредно (MT-Safe)

    СООТВЕТСТВИЕ СТАНДАРТАМ

    Не рекомендуется чередовать вызовы функций ввода библиотеки stdio с низкоуровневыми вызовами read(2) для дескриптора файла, связанного с потоком ввода; результат этого будет неопределённым и, скорее всего, не тем, который ожидается.

    fgets, fgetws fgets, fgetws

    Получает строку из потока. Get a string from a stream.

    Синтаксис Syntax

    Параметры Parameters

    str str
    Место хранения данных. Storage location for data.

    numChars numChars
    Максимальное число считываемых символов. Maximum number of characters to read.

    вышестоящий stream
    Указатель на структуру FILE. Pointer to FILE structure.

    Возвращаемое значение Return Value

    Каждая из этих функций возвращает str. Each of these functions returns str. Возвращается значение NULL , указывающее на ошибку или условие конца файла. NULL is returned to indicate an error or an end-of-file condition. Чтобы определить, произошла ли ошибка, используйте feof или ferror . Use feof or ferror to determine whether an error occurred. Если str или Stream является пустым указателем, или numChars меньше или равен нулю, эта функция вызывает обработчик недопустимых параметров, как описано в разделе Проверка параметров. If str or stream is a null pointer, or numChars is less than or equal to zero, this function invokes the invalid parameter handler, as described in Parameter Validation. Если выполнение может быть продолжено , для параметра еинвал устанавливается значение, а функция возвращает значение NULL. If execution is allowed to continue, errno is set to EINVAL and the function returns NULL.

    Дополнительные сведения об этих и других кодах ошибок см. в разделе _doserrno, errno, _sys_errlist и _sys_nerr. See _doserrno, errno, _sys_errlist, and _sys_nerr for more information on these, and other, error codes.

    Примечания Remarks

    Функция fgets считывает строку из аргумента входного потока и сохраняет ее в str. The fgets function reads a string from the input stream argument and stores it in str. fgets считывает символы из текущей позиции в потоке в, включая первый символ новой строки, в конец потока или до тех пор, пока количество считываемых символов не будет равно numChars -1, в зависимости от того, что происходит первым. fgets reads characters from the current stream position to and including the first newline character, to the end of the stream, or until the number of characters read is equal to numChars — 1, whichever comes first. Результат, сохраненный в str , добавляется с нулевым символом. The result stored in str is appended with a null character. Считываемый символ новой строки (если такой есть) включается в строку. The newline character, if read, is included in the string.

    fgetws — это версия fgetsдля расширенных символов. fgetws is a wide-character version of fgets.

    fgetws считывает строку аргумента расширенных символов в виде строки многобайтовых символов или строки расширенных символов в зависимости от того, открыт ли поток в текстовом или двоичном режиме соответственно. fgetws reads the wide-character argument str as a multibyte-character string or a wide-character string according to whether stream is opened in text mode or binary mode, respectively. Дополнительные сведения об использовании текстового и двоичного режима в Юникоде и многобайтовом потоковом вводе-выводе см. в разделах Файловый ввод-вывод в текстовом и двоичном режиме и Ввод-вывод в поток в кодировке Юникод в текстовом и двоичном режиме. For more information about using text and binary modes in Unicode and multibyte stream-I/O, see Text and Binary Mode File I/O and Unicode Stream I/O in Text and Binary Modes.

    Сопоставления подпрограмм обработки обычного текста Generic-Text Routine Mappings

    Подпрограмма TCHAR.H TCHAR.H routine _UNICODE и _MBCS не определены _UNICODE & _MBCS not defined _MBCS определено _MBCS defined _UNICODE определено _UNICODE defined
    _fgetts _fgetts fgets fgets fgets fgets fgetws fgetws

    Требования Requirements

    Функция Function Обязательный заголовок Required header
    fgets fgets
    fgetws fgetws или or

    Дополнительные сведения о совместимости см. в разделе Совместимость. For additional compatibility information, see Compatibility.

    Илон Маск рекомендует:  Что такое код dbmfetch
Понравилась статья? Поделиться с друзьями:
Кодинг, CSS и SQL