Главная страница
Навигация по странице:

  • С-система обработки файлов

  • Функция fopen()

  • Функция fputc()

  • Функция fgetc()

  • Функция feof()

  • Функция fclose()

  • Использование функций fopen(), fgetc(), fputc() и fclose()

  • Шилдт c++_базовый_курс издание 3. Герберт Шилдт С базовый курс


    Скачать 9.37 Mb.
    НазваниеГерберт Шилдт С базовый курс
    АнкорШилдт c++_базовый_курс издание 3.pdf
    Дата13.02.2017
    Размер9.37 Mb.
    Формат файлаpdf
    Имя файлаШилдт c++_базовый_курс издание 3.pdf
    ТипКнига
    #2637
    страница30 из 33
    1   ...   25   26   27   28   29   30   31   32   33
    Функция scanf()
    Функция scanf() — это С-функция общего назначения ввода данных с консольного устройства. Она может считывать данные всех встроенных типов и автоматически преобразует числа в соответствующий внутренний формат. Ее поведение во многом обратно поведению функции printf(). Общий формат функции scanf() таков.
    int scanf (const char *fmt_string, ...);
    Управляющая строка, задаваемая параметром fmt_string, состоит из символов трех категорий:
    ■ спецификаторов формата;
    ■"пробельных" символов (пробелы, символы табуляции и пустой строки);
    ■ символов, отличных от "пробельных".
    Функция scanf() возвращает количество введенных полей, а при возникновении ошибки
    — значение EOF (оно определено в заголовке stdio.h).
    Спецификаторы формата — им предшествует знак процента (%) — сообщают, какого типа данное будет считано следующим. Например, спецификатор %s прочитает строку, а
    %d — целое значение. Эти коды приведены в табл. А.2.

    Пробельные символы в строке форматирования заставляют функцию scanf() пропустить один или несколько пробельных символов во входном потоке. Под пробельным символом подразумевается пробел, символ табуляции или символ новой строки. По сути, один пробельный символ в управляющей строке заставит функцию scanf() считывать, но не сохранять любое количество (пусть даже нулевое) пробельных символов до первого непробельного.
    "Непробельный" символ в строке форматирования заставляет функцию scanf() прочитать и отбросить соответствующий символ.
    Например, при использовании строки форматирования %d, %d функция scanf() сначала прочитает целое значение, затем прочитает и отбросит запятую и наконец прочитает еще одно целое. Если заданный символ не обнаружится, работа функции scanf() будет завершена.
    Все переменные, используемые для приема значений с помощью функции scanf(),
    должны передаваться посредством их адресов. Это значит, что все аргументы должны быть указателями на переменные. (С не поддерживает ссылки или ссылочные параметры.)
    Передача указателей позволяет функции scanf() изменять содержимое любого аргумента.
    Например, если нужно считать целочисленное значение в переменную count, используйте следующий вызов функции scanf().
    scanf("%d", &count);
    Строки обычно считываются в символьные массивы, а имя массива (без индекса)
    является адресом первого элемента в этом массиве. Поэтому, чтобы считать строку в символьный массив address, используйте такой код.
    char address[80];
    scanf("%s", address);
    В этом случае параметр address уже является указателем, и поэтому его не нужно предварять оператором "&".
    Элементы входного потока, считываемые функцией scanf(), должны быть разделены пробелами, символами табуляции или новой строки. Такие символы, как запятая, точка с запятой и тому подобное, не распознаются в качестве разделителей. Это означает, что инструкция:
    scanf("%d%d", &r, &с);
    Примет значения, введенные как 10 20, но наотрез откажется от "блюда", поданного в виде 10,20.
    Подобно printf(), в функции scanf() спецификаторы формата по порядку сопоставляются с переменными, перечисленными в списке аргументов.
    Символ стоящий "*" после знака "%" и перед кодом формата, прочитает данные заданного типа, но запретит их присваивание переменной. Следовательно, инструкция scanf("%d%*c%d", &х, &у);
    при вводе данных в виде 10/20 поместит значение 10 в переменную х, отбросит знак деления и присвоит значение 20 переменной у.
    Команды форматирования могут содержать модификатор максимальной длины поля. Он представляет собой целое число, располагаемое между знаком "%" и кодом формата,
    которое ограничивает количество символов, считываемых для любого поля. Например, если вы хотите прочитать в переменную str не более 20 символов, используйте следующую инструкцию.
    scanf ("%20s", str);
    Если входной поток содержит более 20 символов, то при последующем выполнении операции ввода считывание начнется с того места, в котором "остановился" предыдущий вызов функции scanf(). Например, если (при использовании данного примера) вводится такая строка символов
    ABCDEFGHIJKLMNOPQRSTUVWXYZ,
    то в переменную str будут приняты только первые 20 символов (до буквы 'Т'), поскольку команда форматирования здесь содержит модификатор максимальной длины поля.
    Это означает, что остальные символы, "UVWXYZ", не будут использованы вообще. В
    случае другого вызова функции scanf().
    scanf("%s", str);
    символы "UVWXYZ" поместились бы в переменной str. При обнаружении "пробельного"
    символа ввод данных для поля может завершиться до достижения максимальной длины поля. В этом случае функция scanf() переходит к считыванию следующего поля.
    Несмотря на то что пробелы, символы табуляции и новой строки используются в качестве разделителей полей, при считывании одиночного символа они читаются подобно любому другому символу. Например, если входной поток состоит из символов х у, то инструкция scanf ("%с%с%с", &а, &b, &с);
    поместит символ х в переменную а, пробел — в переменную b и символ у — в переменную с.
    Функцию scanf() можно также использовать в качестве набора сканируемых символов
    (scanset). В этом случае определяется набор символов, которые могут быть считаны функцией scanf() и присвоены соответствующему массиву символов. Функция scanf()
    продолжает считывать символы и помещать их в соответствующий символьный массив до тех пор, пока не встретится символ, отсутствующий в заданном наборе. После этого она переходит к следующему полю (если такое имеется).
    Для определения такого набора необходимо заключить символы, подлежащие сканированию, в квадратные скобки. Открывающая квадратная скобка должна следовать сразу за знаком процента. Например, следующий набор сканируемых символов говорит о том, что необходимо прочитать только символы X, Y и Z.
    %[XYZ]
    Соответствующая набору переменная должна быть указателем на массив символов. При возврате из функции scanf() этот массив будет содержать строку с завершающим нулем,
    состоящую из считанных символов. Например, следующая программа использует набор сканируемых символов для считывания цифр в массив s1. Если будет введен символ,
    отличный от цифры, массив s1 завершится нулевым символом, а остальные символы будут считываться в массив s2 до тех пор, пока не будет введен следующий "пробельный" символ.
    /* Простой пример использования набора сканируемых символов.
    */
    #include
    int main()
    {
    char s1 [80], s2 [80];
    printf("Введите числа, а затем несколько букв:\n");
    scanf("%[0123456789]%s", s1, s2);
    printf("%s %s", s1, s2);
    return 0;
    }
    Многие компиляторы позволяют с помощью дефиса задать в наборе сканируемых символов диапазон. Например, при выполнении следующей инструкции функция scanf()
    будет принимать символы от А до Z.
    % [А-Z]
    При этом в наборе сканируемых символов можно задать даже несколько диапазонов.
    Например, эта программа считывает сначала цифры, а затем буквы.
    /* Пример использования в наборе сканируемых символов нескольких диапазонов.
    */
    #include
    int main()
    {
    char s1[80], s2 [80];
    printf("Введите числа, а затем несколько букв:\n");
    scanf("%[0-9]%[a-zA-Z]", s1, s2);
    printf ("%s %s", s1, s2);
    return 0;
    }
    Если первый символ в наборе сканируемых символов является знаком вставки (^), то получаем обратный эффект: вводимые данные будут считываться до первого символа из заданного набора символов, т.е. знак вставки заставляет функцию scanf() принимать любые
    символы, которые не определены в наборе. В следующей модификации предыдущей программы знак вставки используется для запрещения считывания символов, тип которых указан в наборе сканируемых символов:
    /*
    Пример использования набора сканируемых символов для запрещения считывания указанных в нем символов.
    */
    #include
    int main()
    {
    char s1[80], s2[80];
    printf("Введите не цифры, а затем не буквы:\n");
    scanf("%[^0-9]%[^a-zA-Z]", s1, s2);
    printf ("%s %s", s1, s2);
    return 0;
    }
    Важно помнить, что набор сканируемых символов различает прописные и строчные буквы. Следовательно, если вы хотите сканировать как прописные, так и строчные буквы,
    задайте их отдельно.
    Некоторые спецификаторы формата могут использовать такие модификаторы, которые точно указывают тип переменной, принимающей данные. Чтобы прочитать длинное целое,
    поставьте перед спецификатором формата модификатор l, а чтобы прочитать короткое целое — модификатор h. Эти модификаторы можно использовать с кодами формата d, i, o,
    u, x и n.
    По умолчанию спецификаторы f, е и g заставляют функцию scanf() присваивать данные переменным типа float. Если поставить перед одним из этих спецификаторов формата модификатор l, функция scanf() присвоит прочитанное данное переменной типа double.
    Использование же модификатора L означает, что переменная, принимающая значение,
    имеет тип long double.
    Модификатор l можно применить и к спецификатору с, чтобы обозначить указатель на двухбайтовый символ с типом данных wchar_t (если ваш компилятор соответствует
    стандарту C++). Модификатор l можно также использовать с кодом формата s, чтобы обозначить указатель на строку двухбайтовых символов. Кроме того, модификатор l можно использовать для модификации набора сканируемых двухбайтовых символов.
    С-система обработки файлов
    Несмотря на то что файловая система в С отличается от той, что используется в C++,
    между ними есть много общего. С-система обработки файлов состоит из нескольких взаимосвязанных функций. Наиболее популярные из них перечислены в табл. А.З.
    Общий поток, который "цементирует" С-систему ввода-вывода, представляет собой
    файловый указатель (file pointer). Файловый указатель — это указатель на информацию о файле, которая включает его имя, статус и текущую позицию. По сути, файловый указатель идентифицирует конкретный дисковый файл и используется потоком, чтобы сообщить всем
    С-функциям ввода-вывода, где они должны выполнять операции. Файловый указатель — это переменная-указатель типа FILE, который определен в заголовке stdio.h.
    Функция fopen()
    Функция fopen() выполняет три задачи.
    1. Открывает поток.
    2. Связывает файл с потоком.
    3. Возвращает указатель типа FILE на этот поток.

    Чаще всего под файлом подразумевается дисковый файл. Функция fopen() имеет такой прототип.
    FILE *fopen(const char *filename, const char *mode);
    Здесь параметр filename указывает на имя открываемого файла, а параметр mode— на строку, содержащую нужный статус (режим) открытия файла. Возможные значения параметра mode показаны в приведенной табл. А.4. Параметр filename должен представлять строку символов, составляющих имя файла, которое допустимо в данной операционной системе. Эта строка может включать спецификацию пути, если действующая среда поддерживает такую возможность.
    Если функция fopen() успешно открыла заданный файл, она возвращает указатель FILE.
    Этот указатель идентифицирует файл и используется большинством других файловых системных функций. Он не должен подвергаться модификации кодом программы. Если файл не удается открыть, возвращается нулевой указатель.
    Как видно из табл. А.4, файл можно открывать либо в текстовом, либо в двоичном режиме. При открытии в текстовом режиме выполняются преобразования некоторых последовательностей символов. Например, символы новой строки преобразуются в последовательности символов "возврат каретки"/"перевод строки". В двоичном режиме подобные преобразования не выполняются.
    Если вам нужно открыть файл test для записи, используйте следующую инструкцию.
    fp = fopen("test", "w");
    Здесь переменная fp имеет тип FILE*. Однако зачастую для открытия файла используется такой код.
    if((fp = fopen ("test", "w"))==NULL) {
    printf ("Не удается открыть файл.");
    exit(1);
    }
    При таком методе выявляется любая ошибка, связанная с открытием файла (например,
    при использовании защищенного от записи или заполненного диска), и только после этого можно предпринимать попытку записи в заданный файл. NULL — это макроимя,
    определенное в заголовке stdio.h.
    Если вы используете функцию fopen(), чтобы открыть файл исключительно для выполнения операций вывода (записи), любой уже существующий файл с заданным именем будет стерт, и вместо него будет создан новый. Если файл с таким именем не существует, он будет создан. Если вам нужно добавлять данные в конец файла, используйте режим "a".
    Если окажется, что указанный файл не существует, он будет создан. Чтобы открыть файл для выполнения операций чтения, необходимо наличие этого файла. В противном случае функция возвратит значение ошибки. Наконец, если файл открывается для выполнения операций чтения-записи, то в случае его существования он не будет удален; но если его нет,
    он будет создан.
    Функция fputc()
    Функция fputc() используется для вывода символов в поток, предварительно открытый для записи с помощью функции fopen(). Ее прототип имеет следующий вид.
    int fputc(int ch, FILE *fp);
    Здесь параметр fp — файловый указатель, возвращаемый функцией fopen(), а параметр
    ch — выводимый символ. Файловый указатель сообщает функции fputc(), в какой дисковый файл необходимо записать символ. Несмотря на то что параметр ch имеет тип int, в нем используется только младший байт.
    При успешном выполнении операции вывода функция fputc() возвращает записанный в файл символ, в противном случае — значение EOF.
    Функция fgetc()
    Функция fgetc() используется для считывания символов из потока, открытого в режиме чтения с помощью функции fopen(). Ее прототип имеет следующий вид.
    int fgetc(FILE *fp);
    Здесь параметр fp — файловый указатель, возвращаемый функцией fopen(). Несмотря на то что функция fgetс() возвращает значение типа int, его старший байт равен нулю.
    При возникновении ошибки или достижении конца файла функция fgetc() возвращает значение EOF. Следовательно, для того, чтобы считать все содержимое текстового файла
    (до самого конца), можно использовать следующий код.
    ch = fgetc(fp);
    while(ch!=EOF) {
    ch = fgetc(fp);
    }
    Функция feof()
    Файловая система в С может также обрабатывать двоичные данные. Если файл открыт в режиме ввода двоичных данных, то не исключено, что может быть считано целое число,
    равное значению EOF. В этом случае при использовании такого кода проверки достижения конца файла, как ch != EOF, будет создана ситуация, эквивалентная получению сигнала о достижении конца файла, хотя в действительности физический конец файла может быть еще не достигнут. Чтобы решить эту проблему, в языке С предусмотрена функция feof(),
    которая используется для определения факта достижения конца файла при считывании двоичных данных. Ее прототип имеет такой вид.
    int feof(FILE *fp);
    Здесь параметр fp идентифицирует файл. Функция feof() возвращает ненулевое значение,
    если конец файла был-таки достигнут; в противном случае — нуль. Таким образом, при выполнении следующей инструкции будет считано все содержимое двоичного файла.
    while(!feof(fp)) ch = fgetc(fp);
    Безусловно, этот метод применим и к текстовым файлам.
    Функция fclose()
    Функция fclose() закрывает поток, который был открыт в результате обращения к функции fopen(). Она записывает в файл все данные, еще оставшиеся в дисковом буфере, и закрывает файл на уровне операционной системы. При вызове функции fclose()
    освобождается блок управления файлом, связанный с потоком, что делает его доступным для повторного использования. Вероятно, вам известно о существовании ограничения операционной системы на количество файлов, которые можно держать открытыми в любой момент времени, поэтому, прежде чем открывать следующий файл, рекомендуется закрыть все файлы, уже ненужные для работы.
    Функция fclose() имеет следующий прототип,
    int fclose(FILE *fp);
    Здесь параметр fp — файловый указатель, возвращаемый функцией fopen(). При успешном выполнении функция fclose() возвращает нуль; в противном случае возвращается значение EOF. Попытка закрыть уже закрытый файл расценивается как ошибка. При удалении носителя данных до закрытия файла будет сгенерирована ошибка, как и в случае недостатка свободного пространства на диске.
    Использование функций fopen(), fgetc(), fputc() и fclose()
    Функции fopen(), fgetc(), fputc() и fclose() составляют минимальный набор операций с файлами. Их использование демонстрируется в следующей программе, которая выполняет копирование файла. Обратите внимание на то, что файлы открываются в двоичном режиме и что для проверки достижения конца файла используется функция feof().

    /* Эта программа копирует содержимое одного файла в другой.
    */
    #include
    int main(int argc, char *argv[])
    {
    FILE *in, *out;
    char ch;
    if(argc!=3) {
    printf("Вы забыли ввести имя файла.\n");
    return 1;
    }
    if((in=fopen(argv[1], "rb")) == NULL) {
    printf("He удается открыть исходный файл.\n");
    return 1;
    }
    if((out=fopen(argv[2], "wb")) == NULL) {
    printf("He удается открыть файл-приемник.\n");
    return 1;
    }
    /* Код копирования содержимого файла. */
    while(!feof (in)) {
    ch = fgetc(in);
    if(!feof(in)) fputc (ch, out);
    }
    fclose(in);
    fclose(out);
    return 0;
    }
    1   ...   25   26   27   28   29   30   31   32   33


    написать администратору сайта