Ввод и вывод в языке С++
Содержание
Введение
. Ввод и вывод в языке С
.1 Ввод/вывод файлов
.2 Стандартный ввод/вывод
. Ввод и вывод в языке С++
.1 Файловый ввод/вывод с использованием разных классов
.2 Стандартный ввод/вывод в С++
Заключение
Библиографический список
Введение
Приложению, написанному на любом языке программирования, необходимо
взаимодействовать с пользователем и окружающим миром. Иначе пользы от такого
приложения может и не быть. Как правило, такое взаимодействие осуществляется
посредством ввода-вывода информации на терминал или в файл.
Стоит, конечно, отметить, что есть множество программ, которые не
используют файловый или консольный ввод-вывод: это программы, осуществляющие
низкоуровневое взаимодействие с аппаратной частью компьютера и периферией (ядро
ОС, драйверы и пр.).
В стандартном C++ существует два основных пути ввода-вывода информации:
- посредством традиционной системы ввода-вывода, унаследованной
от языка C;
- с помощью потоков, реализованных в STL (Standard Template
Library).
Однако при ближнем рассмотрении оказывается, что и потоки, и традиционная
система ввода-вывода для осуществления необходимых действий используют вызовы
операционной системы.
. Ввод и
вывод в языке С
Ввод/вывод в языке С осуществляется с помощью функций из стандартных
библиотек. Чтобы ими пользоваться, в программу надо включить соответствующие h-файлы: stdio.h, stdlib.h, conio.h и др. Главная библиотека, в которой
содержатся основные функции ввода/вывода, в том числе и обеспечивающие
стандартный ввод/вывод, - stdio.h.
1.1 Ввод/вывод
файлов
Чтобы работать с файлом, его сначала следует открыть: связать со
специальной структурой с именем FILE,
которая описана в библиотеке stdio.h и в которой задаются характеристики
файла (размер буфера ввода/вывода, состояние файла, последняя прочитанная
запись и т. п.). Связь эта выполняется с помощью функции fopen(), которая тоже входит в библиотеку stdio.h и возвращает указатель на структуру FILE. Поэтому в программе, прежде всего, следует задать
указатель на структуру FILE,
а затем записать оператор открытия файла:
FILE *fp;
fp = fopen(<имя файла>, <способ
открытия файла> );
Функция fopen() имеет два параметра: имя
открываемого файла и способ открытия файла. Способ открытия файла определяет,
как пользователь будет работать с файлом: читать его, писать в него данные или
делать что-то еще. Способы открытия файла и их коды могут быть следующие:
- r - файл открывается только для чтения данных из него;
- w - файл открывается только для записи в него (если файл не
существует, он создается автоматически и открывается для записи);
- a - файл открывается для дозаписи данных в конец файла (если
файл не существует, он создается для записи);
- r+ - существующий файл открывается для обновления: можно и
читать из файла, и записывать в него данные;
- w+ - создается новый файл для обновления: можно и читать, и
записывать в него данные;
- a+ - файл открывается для дозаписи данных в конец файла (если
файл не существует, он создается автоматически и открывается для записи).
Если по какой-либо причине открытия файла не произошло (например, в
режиме r+ задано имя несуществующего файла),
то функция fopen() возвращает значение NULL. Поэтому при открытии файла следует
осуществлять проверку:
if((fp = fopen(name, mode)) == NULL)
{ операторы обработки ошибки открытия }
{ остальные операторы программы }
После того как программа с данным файлом отработала, следует
"отвязать" структуру FILE
от файла или, как говорят, закрыть файл. Это осуществляет функция fclose(fp). Она не только разрывает связь структуры с файлом, но и
записывает в память оставшееся содержимое буфера ввода/вывода, через который и
организуется ввод/вывод. Только после закрытия файла с ним можно выполнять
какие-либо действия, т. к. он "свободен", "не привязан".
Например, его можно удалить или заново открыть в другом режиме открытия и т.д.
После того как файл открыт, то для чтения или записи данных используют
специальные функции.
. Функция fputc()
Формат функции: fputc(c, fp);
Функция выводит символ в файл: с - выводимый символ, fp - указатель на файл.
. Функция fputs()
Формат функции: fputs(s, fp);
Функция выводит строку в файл: s - выводимая строка, fp -
указатель на файл.
. Функция fgetc()
Формат функции: char c = fgetc(fp);
Читает один символ из файла с указателем fp. В случае ошибки или достижения конца файла возвращает EOF.
. Функция fgets()
Формат функции: fgets(s, maxline, fp);
Читает строку в s, где
s - массив символов или указатель типа
char (предварительно должна быть выделена
память для чтения с использованием указа- теля), maxline - максимальное число символов, которое требуется
читать из файла с указателем fp. В
случае ошибки или достижения конца файла возвращает NULL.
. Функция fread()
Формат функции: fread(buf, m, n, fp);
Эта функция читает из файла c указателем fp первые n элементов данных, каждый из которых
имеет длину m байт. Чтение происходит в буфер, на
который указывает указатель buf,
например, char buf[50] или char *buf (но в последнем случае
предварительно надо выделить память для буфера). Общее количество байт чтения
составит (n*m). Функция возвращает количество прочитанных элементов, а по
достижении конца файла или возникновении ошибки чтения возвращает NULL.
. Функция fwrite()
Формат функции: fwrite(ptr, m, n, fp);
Функция добавляет n
элементов в файл с указателем fp,
каждый элемент длиной в m
байт. Данные записываются из буфера, на который указывает указатель ptr (этот указатель указывает на
некоторый объект, например, на структуру). Общее количество записанных байтов
равно (n * m). В случае ошибки записи функция возвращает ноль, в
противном случае - количество записанных элементов.
. Функция fseek()
Формат функции: fseek(fp, n, m);
Эта функция устанавливает указатель в файле fp в позицию, отстоящую на n байт от текущей, а направление перемещения (вперед или
назад) определяется параметром m, который
может быть задан одним из трех значений: 0, 1, 2 или одной из трех
символических констант, определенных в файле stdio.h:
- SEEK_SET =
0 - к началу файла;
- SEEK_CUR =
1 - указатель на текущую позицию в файле;
- SEEK_END =
2 - к концу файла.
Функция fseek() используется для ввода/вывода
потоком. Для работы не с потоковыми данными следует использовать функцию lseek(). После функции fseek() можно выполнять операции
обновления в файлах, открытых для обновления. При удачном завершении работы fseek() возвращает ноль, в противном
случае функция возвращает код ошибки. Тогда глобальная переменная errno принимает одно из следующих
значений:
- EBADF - неверный указатель файла;
- EINVAL - неверный аргумент функции;
- ESPIPE - поиск на устройстве запрещен.
. Функция ftell()
Формат функции: long int i = ftell(fp);
Возвращает текущее значение указателя файла fp (т. е. номер текущей позиции) в виде значения типа long int. Отсчет идет в байтах от начала файла. Возвращаемое
значение может быть использовано затем в функции fseek(). Если обнаружены ошибки, функция возвращает
значение -1L и присваивает глобальной переменной errno положительное значение.
. Функция fscanf()
Формат функции: fscanf(fp, Control, arg1, arg2, ...
, argn);
Функция читает данные из файла c указателем fp, преобразует их
по форматам, записанным в управляющей строке Control, и отформатированные данные записывает в аргументы arg1, ... , argn.
. Функция fprintf()
Формат функции: fprinf(fp, Control, arg1, arg2, ...
, argn);
Выводит данные в файл c
указателем fp, преобразует аргументы arg1, ... , argn к форматам, которые записаны в управляющей строке Control, и отформатированные данные
записывает в файл.
Формат функции: rewind(fp);
Устанавливает указатель позиционирования в файле с указателем fp на начало потока. Вызов функции rewind(fp) эквивалентен вызову функции fseek(fp, 0L, SEEK_SET)
за исключением того, что rewind()
сбрасывает индикатор конца файла и индикаторы ошибок, а fseek() сбрасывает только индикатор конца
файла. После функции rewind()
можно выполнять операции обновления для файлов, открытых для обновления.
Функция не возвращает никакого значения.
. Функция remove()
Формат функции: remove(FILENameString);
Функция удаляет файл с именем FILENameString. Перед удалением файл должен быть закрыт. Строка FILENameString должна содержать полный путь к
файлу. При нормальном завершении задачи функция возвращает ноль, а в случае
ошибки - 1. При этом глобальная переменная errno принимает следующие значения:
- EACCES - запрещено удалять;
- ENOENT - нет такого файла или директории.
. Функция FILElength()
Формат функции: long FILElength(fp);
Функция возвращает длину файла с указателем fp в байтах. Для работы функции требуется подключить файл io.h. В случае ошибки функция возвращает −1, и глобальная
переменная errno принимает значение EBADF - неверный указатель файла.
. Функция ferror()
Формат функции: ferror(fp);
Функция тестирует поток на ошибки чтения-записи. Если индикатор ошибки
устанавливается, то он остается в таком положении, пока не будут вызваны
функции clearerr() или rewind(), или до того момента, пока поток не закроется. Если
в файле была обнаружена ошибка, то функция ferror() возвращает ненулевое значение.
. Функция freopen()
Формат функции: FILE *freopen(const char *FILEname,
const char *mode, FILE *stream);
Функция подставляет файл, заданный в первом параметре, вместо уже
открытого потока. Она закрывает поток независимо от того, открыт ли он. Эта
функция полезна для замены файла, связанного со стандартными устройствами
ввода/вывода stdin, stdout или stderr.
Способы открытия файла аналогичны функции fopen(). При успешном завершении функция возвращает
указатель типа FILE (как и
функция fopen()), при неуспешном - NULL.
. Функция feof()
Формат функции: feof(fp);
Обнаруживает конец файла с указателем fp: тестирует поток на возникновение индикатора конца файла
(который наступает после прочтения последней записи). Как только индикатор
установлен, операции чтения файла возвращают индикатор до тех пор, пока не
выполнена функция rewind() -
"перемотка" в начало файла, или пока файл не будет закрыт. Индикатор
конца файла переустанавливается с каждой операцией ввода. Функция возвращает
ненулевую величину, если индикатор конца файла был обнаружен при последней
операции чтения, в противном случае - ноль.
. Функция ferror()
Формат функции: ferror(FILE *fp);
Функция выдает ненулевое значение, если операция с файловым потоком
завершается с ошибкой (например, возникает ошибка чтения файла). Для обработки
ошибок ввода/вывода следует записать эту функцию перед блоком работы с файлом в
виде:
if (ferror(fp)) { команды обработки ошибок ввода/вывода }
Как только произойдет ошибка, выполнится эта функция, и начнут работать
команды обработки ошибок.
. Функция exit()
Формат функции: exit(int status);
Эта функция используется для срочного завершения работы программы при
обработке ошибок открытия файла, а также для прерывания работы программы по
каким-либо причинам. Перед завершением все файлы закрываются, остатки данных,
находящиеся в буфере вывода, записываются в память и вызываются функции
обработки ошибок, предварительно зарегистрированные специальной функцией atexit().
1.2 Стандартный
ввод/вывод
файл операционный система ввод
При запуске любой программы автоматически открываются сразу три файла:
- файл стандартного ввода. Его указатель называется stdin;
- файл стандартного вывода. Его указатель называется stdout;
- файл стандартного вывода ошибок. Его указатель называется stderr.
При работе с файлами мы можем использовать эти указатели, чтобы
направлять данные в стандартные потоки, в которых по умолчанию ввод идет с
клавиатуры, а вывод - на экран. Например, чтобы ввести строку с клавиатуры,
можно применить функцию fgets()
в виде: fgets(s, maxline, stdin); а для вывода строки на экран -
функцию fputs()в виде: fputs(s, stdout); Из приведенного ранее перечня
функций, обслуживающих ввод/вывод, можно увидеть, что существуют функции getc(fp), putc(c,fp), которые соответственно вводят один символ из файла с
указателем fp и пишут один символ в файл с
указателем fp. Если вместо указателя fp, который имеет тип FILE, в эти функции поместить указатели
стандартного потока, то они станут соответственно вводить один символ с
клавиатуры и выводить его на экран.
В языке С стандартный ввод можно перенаправлять на ввод из файла: если
некоторая программа с именем p1.exe использует функцию getchar(), то с помощью выполнения командной
строки:
p1.exe < anyFILE1
получим ввод не с клавиатуры, а из файла anyFILE1. Командную строку в С можно выполнить с помощью
системной функции system() в виде:
system("P1.EXE < ANYFILE1");
причем символы должны быть в верхнем регистре, т.к. выполняется команда DOS. Точно так же, как и для ввода,
можно перенаправить стандартный вывод в файл. Если имеем программу p2.exe, которая использует стандартный вывод, то с помощью
выполнения командной строки:
p2.exe > anyFILE2
получим вывод в файл anyFILE2.
Рассмотрим основные функции стандартного ввода/вывода языка C.
. Функция getchar()
Формат функции: getchar();
Функция вводит с клавиатуры один символ и возвращает его. Обращаться к
этой функции можно так:
char c; // или int
c; = getchar();
. Функция putchar()
Формат функции: putchar(c);
Выводит значение переменной с (один символ) на стандартное выводное
устройство.
. Функция printf()
Формат функции: printf(Control, arg1, arg2, ... ,
argn);
Это функция форматного вывода. Выводит на экран содержимое arg1, arg2, ... , argn и возвращает количество выводимых байт. Control - управляющая символьная строка, в которой находятся
форматы вывода на экран для соответствующих аргументов arg1, arg2,
... , argn, т. е. первый формат - для вывода arg1, второй - для arg2 и т. д. Все символы, находящиеся
между форматами, выводятся один к одному, т. е. не форматируются. Это дает
возможность вывода дополнительного текста для улучшения читаемости результата
вывода. Форматы вывода задаются так: любой формат начинается с символа '%' и
заканчивается одним из символов форматирования:
- d - аргумент преобразуется к десятичному виду (с учетом
знака);
- x - аргумент преобразуется в беззнаковую шестнадцатеричную
форму;
- U - аргумент преобразуется в беззнаковую десятичную форму;
- с - аргумент рассматривается как отдельный символ;
- s - аргумент рассматривается как строка символов; символы
строки печатаются до тех пор, пока не будет достигнут нулевой символ или не
будет напечатано количество символов, указанное в спецификации точности;
- е - аргумент рассматривается как переменная типа float или double и преобразуется в десятичную форму в экспонентном
виде;
- f - аргумент рассматривается как переменная типа float или double иr преобразуется в десятичную форму;
- n - указатель на целое со знаком;
- p - входной аргумент выводится как указатель.
Между границами формата вывода (от знака % до символа-спецификатора типа
выводимого аргумента) находятся:
[флажки][ширина][.точность][F|N|h|l|L]
. Функция scanf()
Формат функции: scanf(Control, arg1, arg2, ... ,
argn);
Это функция форматного ввода с клавиатуры. Осуществляет посимвольный ввод
данных с клавиатуры, преобразует их в соответствии с форматом для каждого
значения, указанном в управляющей (форматной) символьной строке Control, и результат преобразования
записывает в аргументы arg1, arg2, ..., argn. Смысл строки Control тот же, что и для функции printf(). Так как arg1, arg2, ..., argn - это выходные параметры функции, то при обращении к
функции они должны задаваться своими адресами: имена массивов задаются именами,
т. к. имя массива - это указатель на его первый элемент, а те аргументы,
которые не являются указателями, задаются как &arg. Форматная строка Control - это символьная строка, содержащая три типа
объектов: незначащие символы, значащие символы и спецификации формата.
Незначащие символы - это пробел, знак табуляции (\t), символ перехода на новую строку (\n). Как только функция встречает незначащий символ в строке
формата, она считывает, но не сохраняет все последующие незначащие символы до
тех пор, пока не встретится первый значащий символ (т. е. пропускает незначащие
символы). Значащие символы - это все символы кода ASCII, кроме символа '%'. Если функция встречает в
форматной строке значащий символ, она его считывает, но не сохраняет.
Спецификация формата функции имеет вид:
%[*][ширина][F/N] [h/l] символ_формата
. Функция sprintf()
Формат функции такой:
sprintf(string, Control, arg1, arg2, ... , argn);
Эта функция аналогична printf(),
за исключением того, что результат своей работы она выводит не на стандартное
устройство вывода, а в строку string.
Это позволяет собирать в одну строку данные совершенно разных типов. Функция sscanf() Формат функции: sscanf(string, Control,
arg1, arg2, ... , argn); Эта функция аналогична scanf(),
за исключением того, что входные данные для ее работы поступают не со
стандартного устройства ввода, а из строки string. Это позволяет выделять в строке различные группы
данных совершенно разных типов и помещать их в отдельные переменные.
. Функция cprintf()
Параметры аналогичны параметрам printf(). Но для обеспечения работы этой функции следует подключить к программе
файл conio.h, выполнив #include
Если функция printf() выводит данные туда, куда назначен
stdout, то функция cprintf() всегда выводит данные на консоль (на это указывает
символ 'с' в начале ее имени), т.е. на экран. В отличие от printf(), функция cprintf() не переводит символ '\n' в пару "\r\n" - возврат каретки и перевод
строки (вместо '\n' надо указывать
оба этих символа). Кроме того, символы табуляции '\t' не преобразуются в пробелы. Эту функцию не рекомендуется
использовать для приложений Win32
или Win32 GUI. Но ее можно использовать для выдачи на экран цветных
сообщений. Для этого надо воспользоваться функциями textcolor() (установить цвет текста) и textbackground() (установить цвет фона).
. Функция gets()
Формат функции: gets(s);
Вводит строку символов с клавиатуры и записывает ее в строку s, которая может быть объявлена как char *s или char s[].
. Функция puts()
Формат функции: puts(s);
Выводит содержимое строки s на
устройство стандартного вывода (экран). Строка s может быть объявлена как char *s или char s[].
. Функция cputs()
Формат функции: сputs(s);
Выводит содержимое строки s на
экран (s может быть объявлена как char *s или char s[]). Эту функцию
можно использовать для вывода на экран цветных текстов. Цвет выводимых символов
задается с помощью функции textcolor(), а цвет фона - функцией textbackground(). Для работы функции надо подключить файл conio.h.
10. Функция gotoxy()
Формат функции: gotoxy(x, y);
Переводит курсор в точку с координатами (x, y) в текущем окне
на экране, где х - номер столбца экрана, y - номер строки экрана. Обе переменные должны быть описаны
как int (не в пикселах). Для работы функции
надо подключить файл conio.h.
11. Функция clrscr()
Формат функции: clrscr();
Очищает экран и закрашивает его цветом, заданным функцией textbackground().
2. Ввод и
вывод в языке С++
Ввод и вывод в С++ организован с помощью так называемых поточных классов,
содержащих данные и методы работы с файлами по вводу/выводу. Поточные классы
происходят от общего предка - класса ios и потому наследуют его функциональность. Чтобы начать писать программу с
использованием ввода/вывода на языке С++, следует обязательно выполнить в
программе:
#include <fstream>
Класс fstream является потомком классов istream и ostream. Эти же классы являются родителями классов ifstream и оfstream. Класс fstream
используется для организации ввода/вывода (т. е. чтения-записи) в один и тот же
файл. Классы ifstream, оfstream - для организации соответственно ввода (чтения) файла
и вывода (записи в файл). В свою очередь, экземплярами классов istream, ostream являются cin, cout, cerr, с помощью которых осуществляется так называемый
стандартный ввод/вывод - ввод со стандартного вводного устройства, которым по
умолчанию является клавиатура, и вывод на стандартное выводное устройство,
которым по умолчанию является экран. Таким образом, включения в программу
класса fstream оказывается достаточным для
организации как стандартного, так и файлового ввода/вывода. Файловый ввод/вывод
организован с помощью переопределенных в поточных классах операций включения
(<>).
Чтобы работать с файлом, его сначала следует открыть - связать со
специальной структурой, в которой задаются характеристики файла (размер буфера
ввода/вывода, состояние файла, последняя прочитанная запись и т. п.). Связь эта
выполняется с помощью функции open(),
входящей в один из классов, который определяет ввод/вывод (fstream, istream, ostream).
Поэтому, чтобы выполнить такую функцию, следует сначала создать экземпляр
соответствующего класса, чтобы получить доступ к этой функции. Если мы,
например, хотим выполнять вывод в файл (т. е. запись в него), то следует
создать экземпляр класса ostream:
ostream exp; и затем выполнить функцию
exp.open().
В скобках должны быть указаны параметры этой функции: имя открываемого
файла и способ открытия файла, в котором задаются сведения о том, как
пользователь собирается работать с файлом: читать его, писать в него или делать
что-то еще. После того как файл открыт для чтения или записи, используют
операции включения извлечения (<>). Если использовать пример с
экземпляром exp класса ostream, то можно записать, например:
exp
<< "строка текста" << i << j
<< endl;
Здесь i, j - некоторые переменные (например, int i; float j;), endl - конец вывода и переход на новую строку. После того
как работа с файлом закончена, следует закрыть файл, чтобы разорвать связь с
той структурой, с которой файл был связан при его открытии. Это необходимо,
чтобы дать возможность другим файлам "открываться". Этот акт
выполняется с помощью метода close()
того же экземпляра класса, который мы создавали, чтобы выполнить функцию open(). В нашем случае следовало бы написать:
exp.close();
2.1 Файловый
ввод/вывод с использованием разных классов
Поточные классы - это поставщики инструментов для работы с файлами. В
поточных классах хранятся:
- структуры, обеспечивающие открытие/закрытие файлов;
- функции (методы) открытия/закрытия файлов;
- другие функции и данные, обеспечивающие собственно
ввод/вывод.
При использовании поточных классов языка С++ в основной программе
требуется писать директиву:
using namespace::std;
В противном случае программа не пройдет компиляцию. В листинге 1
приводится пример использования директив пространства имен.
Листинг
1.
#include <vcl.h>
#include <iostream>
#include <conio.h>F
{x = 9;
}G
{namespace F;y = 2.0;INNER_G
{z = 10.01;
}
}main()
{namespace G;namespace G::INNER_G;x = 19.1;::cout <<
"x = " << x << std::endl;::cout << "y = "
<< y << std::endl;::cout << "z = " << z
<< std::endl;();
return
0;
}
В результате на экране появится:
x =
19.1
y = 2
z =
10.01
std::cout - это стандартный вывод. Здесь
показано, что объект cout
принадлежит пространству имен std.
1. Работа с классом fstream
Члены этого класса позволяют открыть файл, записать в него данные, пере-
местить указатель позиционирования в файле (указатель, показывающий, на каком
месте в файле мы находимся) в то или иное место, прочитать данные.
Этот класс имеет следующие основные функции (методы):
open()
- открывает файл;
close()
- закрывает файл;
is_open() - если файл открыт, то возвращает true, иначе - false;
rdbuf()
- выдает указатель на буфер ввода/вывода.
Формат функции open(): open(char* file_name,
open_mode);
где file_name - имя открываемого файла, open_mode -
способ открытия файла. Способ открытия файла задается значением перечислимой
переменной: enum open_mode {app, binary, in, out, trunc, ate};
Эта переменная определена в базовом классе ios, поэтому обращение к перечислимым значениям в классе fstream, с экземпляром которого мы работаем,
должно идти с указанием класса-родителя: ios::app, ios::binary и т. д.
Назначение способов открытия файла:
app -
открыть файл для дозаписи в его конец;
binary
- открыть файл в бинарном виде (такие файлы были записаны по определенной
структуре данных и поэтому должны читаться по этой же структуре);
in -
открыть файл для чтения;
out -
открыть файл для записи в его начало. Если файл не существует, он будет создан;
trunc
- уничтожить содержимое файла, если файл существует (очистить файл);
ate -
установить указатель позиционирования файла на его конец.
При задании режимов открытия файла можно применять оператор логического
ИЛИ (|), чтобы составлять необходимое сочетание режимов открытия. Приведем
пример программы работы с классом fstream (листинг 2). Результат работы показан на рисунке 1.
Листинг
2.
#include <vcl.h>
#include <iostream>
#include <fstream>
#include <stdio.h>main()
{namespace std;inout;.open("fstream.out",
ios_base::in | ios_base::out | ios_base::trunc);<< "This is the
story1 of a man" << endl;<< "This is the story2 of a
man" << endl;<< "This is the story3 of a man"
<< endl;p[100];.seekg(0);.getline(p, 100);<< endl <<
"String1 :" << endl;<< p;::pos_type pos =
inout.tellg();.getline(p, 100);<< endl << "String2 :"
<< endl;<< p;.getline(p, 100);<< endl << "String3
:" << endl;<< p;.seekp(pos);<< "This is the story2
of a man" << endl;<< "This is the story3 of a man"
<< endl;.seekg(0);<< endl << endl <<
inout.rdbuf();.close();("DEL FSTREAM.OUT");();
}
Рисунок 1.
2. Работа с классом ofstream
Класс ofstream предназначен для организации работ
по выводу (записи) в файл с помощью методов этого класса:
open()
- открывает файл для записи в него информации;
is_open() - возвращает true, если файл открыт, и false - в противном случае;
put()
- записывает в файл один символ;
write()
- записывает в файл заданное число символов;
skeep()
- перемещает указатель позиционирования в заданное место файла;
tellp()
- выдает текущее значение указателя позиционирования;
close()
- закрывает файл;
rdbuf()
- выдает указатель на буфер вывода (этот буфер находится в структуре, с которой
связывается файл при его открытии).
В листинге 3 приведен пример использования класса ofstream.
Листинг
3.FILE;.open("a.txt");(FILE == NULL) return(0);(int i = 0; i < 2;
i++)<< "string " << i << endl;.close();
. Работа с классом ifstream
Класс ifstream предназначен для организации работ
по вводу (чтению) из файла с помощью методов этого класса:
open()
- открывает файл для чтения из него информации;
is_open() - возвращает true, если файл открыт, и false - в противном случае;
get()
- читает из файла один символ;
read()
- читает из файла заданное число символов;
eof()
- возвращает ненулевое значение, когда указатель позиционирования в файле
достигает конца файла;
peek()
- выдает очередной символ потока, но не выбирает его (не сдвигает указатель
позиционирования данного в файле);
seekg()
- перемещает указатель позиционирования в заданное место файла;
tellg()
- выдает текущее значение указателя позиционирования;
close()
- закрывает файл;
rdbuf()
- выдает указатель на буфер ввода (этот буфер находится в структуре, с которой
связывается файл при его открытии).
Пример использования класса приведен в листинге 4.
Листинг
4.FILE;p[100];.open("a.txt");(FILE == NULL) return(0);(!FILE.eof())
{>> p;<< p << endl;
}.close();
2.2 Стандартный
ввод/вывод в С++
Стандартный ввод/вывод является частным случаем файлового ввода/вывода.
При файловом вводе/выводе мы объявляли экземпляры соответствующих поточных
классов и затем пользовались методами и операциями << и >>. Но классы
istream, ostream, лежащие в основе поточных классов, содержат
стандартные объекты-экземпляры классов с именами cout (экземпляр класса для стандартного ввода), cin (экземпляр класса для стандартного
вывода) и сerr (экземпляр класса для стандартного
вывода сообщений об ошибках).
При запуске любой программы на языке С+ + эти стандартные потоки
определены (открыты) и по умолчанию назначены на стандартное вводное устройство
- клавиатуру (cin), на стандартное выводное устройство
- экран (cout и cerr). Причем все эти устройства синхронно связаны с
соответствующими указателями stdin,
stdout, stderr. Так что работа со стандартным вводом/выводом
сводится к тому, что вместо задаваемых пользователем имен экземпляров
соответствующих классов задаются имена стандартных экземпляров классов: cin, cout. Открывать ничего не нужно, надо только использовать
операции <> и операции форматирования. Если мы пишем имена переменных, из
которых выводятся или в которые вводятся данные, то по умолчанию для
ввода/вывода используются определенные форматы. Например, запишем:
cout
<< i;
В этом случае значение i
выведется на экран в формате, определенном по умолчанию для типа i и в минимальном поле.
Запишем: >> i >> j
>> s;
где i, j, s описаны
соответственно как int, float, char. В записи мы не видим форматов, но при вводе значений
этих переменных с клавиатуры (после ввода каждого значения надо нажимать
клавишу ) их форматы будут учтены.
. Объект cout
Объект cout направляет данные в буфер-поток,
связанный с объектом stdout,
объявленным в файле stdio.h. По умолчанию стандартные потоки С и
С++ синхронизированы. При выводе данные могут быть отформатированы с помощью
функций-членов класса или манипуляторов. Перечень их приведен в таблице 1.
Таблица 1.
Манипуляторы
|
Функции-члены класса
|
Описание
|
showpos
|
setf(ios::showpos)
|
Выдает знак плюс у выводимых положительных чисел
|
noshowpos
|
unsetf(ios::showpos)
|
-
|
showbase
|
setf(ios::showbase)
|
Выдает базу системы счисления в выводимом числе в виде
префикса
|
noshowbase
|
unsetf(ios::showbase)
|
-
|
uppercase
|
setf(ios::uppercase)
|
Заменяет символы нижнего регистра на символы верхнего
регистра в выходном потоке
|
nouppercase
|
unsetf(ios::uppercase)
|
-
|
showpoint
|
setf(ios::showpoint)
|
Создает символ десятичной точки в сгенерированном потоке с
плавающей точкой (в выводимом числе)
|
noshowpoint
|
unsetf(ios::showpoint)
|
-
|
setf(ios::boolalpha)
|
Переводит булевый тип в символьный
|
noboolalpha
|
unsetf(ios::boolalpha)
|
-
|
unitbuf
|
setf(ios::unitbuf)
|
Сбрасывает буфер вывода после каждой операции вывода
|
nounitbuf
|
unsetf(ios::unitbuf)
|
-
|
internal
|
setf(ios::internal,
ios::adjustfield)
|
Добавляет символы-заполнители к определенным внутренним
позициям выходного потока (речь идет о выводе числа в виде потока символов).
Если такие позиции не определены, поток не изменяется
|
left
|
setf(ios::left, ios::adjustfield)
|
Добавляет символы-заполнители с конца числа (сдвигая число
влево)
|
right
|
setf(ios::right, ios::adjustfield)
|
Добавляет символы-заполнители с начала числа (сдвигая число
вправо)
|
dec
|
setf(ios::dec, ios::basefield)
|
Переводит базу вводимых или выводимых целых чисел в
десятичную (введенные после этого манипулятора данные будут выводиться как
десятичные)
|
hex
|
setf(ios::hex, ios::basefield)
|
Переводит базу вводимых или выводимых целых чисел в
шестнадцатеричную (введенные после этого манипулятора данные будут выводиться
как шестнадцатеричные)
|
oct
|
setf(ios::oct, ios::basefield)
|
Переводит базу вводимых или выводимых целых чисел в
восьмеричную (введенные после этого манипулятора данные будут выводиться как
восьмеричные)
|
fixed
|
setf(ios::fixed, ios::floatfield)
|
Переводит выход с плавающей точкой в выход с фиксированной
точкой
|
scientific
|
setf(ios::scientific,
ios::floatfield)
|
Выдает числа с плавающей точкой в виде, используемом в
научных целях: например, число 23450000 будет записано как: 23.45e6
|
fill(c)
|
setfill(char_type c)
|
Задает символ заполнения при выводе данных
|
precision(n)
|
setprecision(int n)
|
Задает точность вывода данных (количество цифр после точки)
|
setw(int n)
|
width(n)
|
Задает ширину поля для выводимых данных (количество
символов)
|
endl
|
|
Вставляет символ новой строки ('\n') в выходную последовательность символов и
сбрасывает буфер ввода
|
ends
|
|
Вставляет символ '\0' в выходную последовательность
символов
|
flush
|
flush()
|
Сбрасывает буфер вывода
|
ws
|
|
Задает пропуск пробелов при вводе
|
Пример программы с применением объекта cout приведен на листинге 5. Результат работы представлен
на рисунке 2.
Листинг 5.
#include <vcl.h>
#include <iostream>
#include <conio.h>
#include <iomanip>
#include <stdio.h>main()
{namespace std;i;f;<< "Enter i and f >"
<< endl;>> i >> f;<< i << endl;<< f
<< endl;<< hex << i << endl;<< oct << i
<< dec << i << endl;<< showpos << i <<
endl;<< setbase(16) << i << endl;<< setfill('@')
<< setw(20) << left << dec << i;<<
endl;.fill('@');.width(20);.setf(ios::left, ios::adjustfield);.setf(ios::dec,
ios::basefield);<< i << endl;<< scientific <<
setprecision(10) << f << endl;.precision(6);<< f <<
fixed << endl;();
}
Рисунок 2.
2. Стандартный ввод cin
Объект (экземпляр класса) cin
управляет вводом из буфера ввода, связанного с объектом stdin, объявленным в файле stdio.h. По умолчанию стандартные потоки в языках С и С++
синхронизированы. При вводе используется часть тех функций и манипуляторов,
которые определены для cout.
Это такие манипуляторы, как dec, hex, oct, ws и
др.
Пример программы с использованием объекта cin приведен в листинге 6. Результат работы представлен
на рисунке 3.
Листинг 6.
#include <vcl.h>
#include <iostream>
#include <iomanip>
#include <stdio.h>main()
{namespace std;i;f;c;<< "Enter i,f,c and then
input the string >" << endl;>> i >> f >>
c;<< i << endl << f << endl << c <<
endl;p[50];>> ws >> p;<< p <<
endl;.seekg(0);.getline(p,50);<< p << endl;();
}
Рисунок 3.
Заключение
Специалисты C++ рекомендуют использовать для ввода-вывода только потоки
STL и отказаться от использования традиционного ввода-вывода в духе C. Однако,
ничего не мешает, по крайней мере пока, использовать традиционную систему ввода-вывода.
Более того, предусмотрена специальная функция для синхронизации ввода-вывода,
выполненного посредством потоков и посредством старых функций.
Какой механизм использовать - вопрос предпочтений программиста, если
работодателем явно не предписано использование конкретного механизма. В любом
случае для физического ввода-вывода используются вызовы операционной системы.
Всё остальное - обёртка, набор более или менее удобных функций или классов для
взаимодействия с ОС.
Библиографический список
1. Ахо Альфред
В., Хопкрофт В., Ульман Джеффри Д. Структуры данных и алгоритмы - М.: Вильямс,
2016.
. Кортмен
Т.Х Алгоритмы: построение и анализ - М.: Вильямс, 2013
. Миков
А. И., Королев Л.Н., Информатика. Введение в компьютерные науки. - Абрис,
Высшая школа, 2012.
. Мейерс
С. Эффективное использование C++.
55 верных советов улучшить структуру и код ваших программ: Пер. с англ. - 3-е
изд. - М.: ДМК пресс, 2006.
. Страуструп
Б. Язык программирования C++:
Пер. с англ. - 3-е спец. изд. - М.: Бином, 2003.
. Джосьютис
Н. М. C++. Стандартная библиотека. Для
профессионалов: Пер. с англ. - СПб.: Питер, 2004.
. Керниган
Б. В., Ритчи Д. М. Язык программирования Си: Пер. с англ. - 3-е изд. - СПб.:
Невский Диалект, 2001.