Функции для обмена с потоками

   
На этом шаге мы рассмотрим дополнительные функции, используемые для обмена с потоками.

   
Кроме операции включения (записи) в поток << и извлечения (чтения) из потока >>, в классах библиотеки
ввода-вывода есть весьма полезные функции, обеспечивающие программиста альтернативными средствами для обмена с потоками.

   
При выводе в качестве основного класса, формирующего выходные потоки, используется класс ostream. В нем определены (ему принадлежат)
две функции для двоичного вывода данных:

    ostream& ostream::put (char  cc);
    ostream& ostream::write (const  signed char  *array,  int n); 
    ostream& ostream::write (const unsigned char  *array, int n);

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

   
В этом случае эквивалентны операторы:

    cout << 'Z';
        и
    cout.put('Z');

   
Функция write() имеет два параметра - указатель array на участок памяти, из которого выполняется вывод, и целое значение n,
определяющее количество выводимых из этого участка символов (байт).

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

   
Так как функции put() и write() возвращают ссылки на объект того класса, для которого они выполняются, то
можно организовать цепочку вызовов:

    char  ss[] = "Merci";
    cout.put('\n').write(ss,sizeof(ss)-l).put('!').put('\n');

   
На экране (в потоке cout) появится:

    Merci!

Если необходимо прочитать из входного потока строку символов, содержащую пробелы, то с помощью операции извлечения
>> это делать неудобно - каждое чтение строки выполняется до пробела, а ведущие (левые) пробельные символы игнорируются.
Если мы хотим, набрав на клавиатуре строку: "Qui vivra verra - будущее покажет (лат.)", ввести ее в символьный массив,
то с помощью операции извлечения >> это сделать несколько хлопотно, все слова будут читаться отдельно (до пробела). Гораздо
удобнее воспользоваться функциями бесформатного (двоичного) чтения.

   
Функции двоичного (бесформатного) чтения данных принадлежат потоку istream. Прежде чем перечислить их,
отметим основное свойство двоичного чтения данных. Данные читаются без преобразования их из двоичного представления в текстовое. Например,
если во входном потоке размещено представление вещественного числа 1.3E-3, то это будет воспринято как последовательность из шести байт, и читать
эту последовательность с помощью функций двоичного ввода можно только в символьный массив.

   
Итак, функции чтения. Во-первых, это 6 перегруженных функций get(). Две из них имеют следующие прототипы:

    istream& get(signed  char   *array,   int max_len,   char='\n'); 
    istream& get(unsigned  char   *array,   int  max_len,   char='\n');

   
Каждая из этих функций выполняет извлечение (чтение) последовательности байтов из стандартного входного потока и перенос
их в символьный массив, задаваемый первым параметром. Второй параметр определяет максимально допустимое количество прочитанных байтов.
Третий параметр определяет ограничивающий символ (байт), при появлении которого во входном потоке следует завершить чтение. По умолчанию
третий параметр имеет значение '\n' - переход на следующую строку, однако при обращении к функции его можно задавать и по-другому.
Значение этого третьего параметра из входного потока не удаляется, он в формируемую строку (символьный массив) не переносится, а вместо
него автоматически-добавляется "концевой" символ строки ' \0'. Если из входного потока извлечены ровно maxlen - 1 символов,
однако ограничивающий символ (например, по умолчанию '\n') не встретился, то концевой символ помещается после введенных символов.
Массив, в который выполняется чтение, должен иметь длину не менее max_len символов. Если из входного потока не извлечено ни одного
символа, то устанавливается код ошибки. Если до появления ограничивающего символа и до извлечения max_len - 1 символов встретился конец
файла EOF, то чтение прекращается как при появлении ограничивающего символа.

   
Функция с прототипом

    istream& get (streambuf& buf, char = ' \n ' ) ;

извлекает из входного потока символы и помещает их в буфер, определенный первым параметром. Чтение продолжается до появления
ограничивающего символа, которым по умолчанию является '\n', но он может быть установлен явно любым образом.

   
Три следующие варианта функции get() позволяют прочесть из входного потока один символ. Функции

    istream& get(unsigned char&  cc); 
    istream& get(signed char& cc);

присваивают извлеченный символ фактическому параметру и возвращают ссылку на поток, из которого выполнено чтение.

   
Функция

    int get();

получает код извлеченного из потока символа в качестве возвращаемого значения. Если поток пуст, то возвращается код конца файла EOF.
Функции "ввода строк":

    istream& getline (signed char *array, int len, char='\n'); 
    istream& getline (unsigned char *array, int len, char='\n');

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

   
Функция

    int peek();

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

    char cim;
    while (cin.peek() != '\n')
    { cin.get(cim); cout.put(cim); }

   
Принадлежащая классу istream функция

    istream& putback(char cc);

не извлекает ничего из потока, а помещает в него символ cc, который становится текущим и будет следующим извлекаемым из потока
символом. Аналогичным образом функция

    int gcount();

подсчитывает количество символов, которые были извлечены из входного потока при последнем обращении к нему.

   
Функция

    istream&  ignore (int n =  1,   int = EOF) ;

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

   
Функции

    istream&  read (signed char *array,   int numb); 
    istream&  read (unsigned char *array,   int numb);  

выполняют чтение заданного количества numb символов в массив array.

   
Полезны следующие функции того же класса istream:

istream& seekg (long pos) ;
устанавливает позицию чтения из потока в положение, определяемое значением параметра;
istream& seekg (long pos, seek_dir dir);
выполняет перемещение позиции чтения вдоль потока в направлении, определенном параметром dir, принимающим значения
из перечисления enum seek_dir { beg, cur, end }. Относительная величина перемещения (в байтах) определяется значением параметра
long pos. Если направление определено как beg, то смещение от начала потока; cur - от текущей позиции; end - от конца потока;
long tellg();
определяет текущую позицию чтения из потока.

   
Подобные перечисленным функции класса ostream:

long tellp();
определяет текущую позицию записи в поток;
ostream& seekp(long pos, seek_dir dir);
аналогична функции seekg(), но принадлежит классу ostream и выполняет относительное перемещение позиции записи в поток;
ostream& seekp(long pos);
устанавливает абсолютную позицию записи в поток.

   
Со следующего шага мы начнем рассматривать строковые потоки.



Вы можете оставить комментарий, или Трекбэк с вашего сайта.

Оставить комментарий