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

Таблица 1 – Результат заполнения массива при использовании некоторых компиляторов

Как видно, результаты вычислений зависят от используемого компилятора – один и тот же код дает различающиеся результаты для разных компиляторов. Стоит, однако, отметить компилятор Microsoft Visual C++ 2005 Express, который дал ожидаемый по написанному коду результат для всех рассмотренных случаев.

Рассмотрим теперь примеры, демонстрирующие использование функций с переменным количеством параметров. Здесь также могут возникать неоднозначности. Как известно, количество параметров можно задать двумя способами [2]: передать это количество вызываемой функции явным образом через обязательный аргумент; просто договориться о некотором специальном признаке конца списка аргументов.

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

int summa1(int n, …)

{ int s=0; int *a=&n;

while (n–) s+=*(++a);

return s; }

int main()

{ cout<<”Сумма элементов 1, 5, 7, 3: “<<summa1(4, 1, 5, 7, 3)<<endl;

cout<<”Сумма элементов 4, 11, 5, 3, 4: “<<summa1(5, 4, 11, 5, 3, 4);

getch(); return 0; }

Здесь используется указатель для перебора суммируемых аргументов; его значение инициализируется адресом обязательного первого аргумента (адресом начала списка аргументов) и затем в цикле наращивается для получения доступа к следующему аргументу.

Рассмотрим теперь реализацию второго способа на примере той же задачи.

double summa2(double x, …)

{ double s=0.0; double *a=&x;

while (*a) s+=*(a++);

return s; }

int main()

{ cout<<”Сумма элементов 4.1,1.0,-5.1,7.3: “<<summa2(4.1,1.0,-5.1,7.3,0.0)<<endl;

cout<<”Сумма элементов 5.2,4.3,11.1,5.1,3.1: “<<summa2(5.2,4.3,11.1,5.1,3.1,0.0);

getch(); return 0;}

В этом случае цикл суммирования перебирает аргументы до тех пор, пока не встретит нулевой элемент, который должен быть обязательно использован при вызове функции summa2. Разные компиляторы также дают для приведенного здесь кода (для второго способа реализации) разные результаты в зависимости от префиксной или постфиксной формы записи (таблица 2). Первый способ реализации для обсуждаемых в статье компиляторов при этом дает одинаковый результат (таблица 3).

Таблица 2 – Результат работы функции с переменным количеством параметров (способ 2)

Таблица 3 – Результат работы функции с переменным количеством параметров (способ 1)

Результат работы компилятора wxDev-C++ 7.4, на первый взгляд, не совсем ясен. Также отмечу, что если при описании приведенной здесь функции summa2 тип double везде поменять на тип float, то программа будет работать некорректно (при использовании все того же компилятора wxDev-C++ 7.4).

Функцию summa1, реализующую первый способ передачи количества параметров, можно несколько видоизменить, чтобы она позволяла работать с аргументами типа double – измененный текст программы приведен ниже.

double summa1(int n, double k, …)

{ double s=0. ;

double *a=&k;

while (n–) s+=*(a++);

return s; }

int main()

{ cout<<”Сумма эл-в 1.15, 10.5, 2.7, 5.3: “<<summa1(4, 1.15, 10.5, 2.7, 5.3)<<endl;

cout<<”Сумма эл-в 4, 1.11, 5.1, 2.23, 4.7: “<<summa1(5, 4., 1.11, 5.1, 2.23, 4.7);

getch(); return 0; }

Представленный здесь код при использовании компилятора wxDev-C++ 7.4 снова дает неправильный результат. Очевидно, это связано с преобразованием типов и моделью памяти, принимаемым в данном компиляторе. Вот код того же примера, который будет нормально работать с компилятором wxDev-C++ 7.4.

long double summa1(int n, long double k, …)

{ long double s=0. ;

long double *a=&k;

while (n–) s+=*a++;

return s; }

int main()

{ cout<<”Сумма эл-в 1.15,10.5,2.7,5.3: “<<summa1(4,1.15L,10.5L,2.7L,5.3L)<<endl;

cout<<”Сумма эл-в 4,1.11,5.1,2.23, 4.7: “<<summa1(5,4.L,1.11L,5.1L,2.23L,4.7L);

getch(); return 0; }

Этот код также будет нормально работать и с компилятором Microsoft Visual C++ 2005 Express, однако с компилятором Borland C++ 5.02 будет приводить к ошибке.

Перейдем теперь к неоднозначностям, имеющим место при работе с потоками ввода-вывода. При вводе данных операция >> читает всё, начиная с первого символа (не являющегося символом-разделителем) до следующего символа, который не соответствует типу объекта назначения. Поэтому наиболее распространенной ошибкой при использовании потоков istream является ошибка, связанная с вводом данных, не соответствующих указанному формату. В таких случаях нужно или проверять состояние потока ввода перед использованием считанных данных, или использовать механизм исключений [3, 4]. Рассмотрим, например, следующий фрагмент кода:

float a, b;

cin>>a>>b;

cout<<a<<” “<<b;

Если при вводе данных указать, например, 1.234w, то значение переменной a будет равно 1.234, но значение переменной b будет неопределенно, т.к. сразу после ввода 1.234w программа перейдет к строке с инструкцией cout. Дело в том, что как только в потоке встретится символ w, являющийся некорректным с точки зрения ожидаемого формата вводимых данных, последним принятым символом будет 4. Символ w останется во входном потоке, и следующая операция >> начнет чтение с этой точки, что и приводит к неопределенности. Поэтому следующий фрагмент кода

float a;

char b;

cin>>a>>b;

cout<<a<<” “<<b;

будет работать верно при вводе строки 1.234w.

Может случиться так, что самое первое введенное значение будет ошибочным с точки зрения формата. В этом случае операция >> оставит значение переменной без изменений и вернет значение 0 (false), что позволит проверить, отвечал ли ввод требованиям установленного формата данных для переменной. Ниже представлен фрагмент программы, в котором вводятся числа и ведется подсчет их суммы до тех пор, пока вводятся корректные значения для переменной.

float a, s=0.;

while(cin>>a) s+=a;

cout<<”nЗначение переменной а: “<<a;

cout<<”nСумма чисел: “<<s<<endl;

Пусть в процессе ввода часть чисел вводятся через нажатие клавиши “Enter”, причем это будут корректные данные; затем, в следующей строке, вводится последовательность чисел через символ-разделитель (пробел):

1.37

2.45

1.23 4 13.4 2.2b 3.4 5.6

Результатом работы фрагмента программы будет:

Значение переменной a: 2.2

Сумма чисел: 24.65

Ввод cin буферизуется, поэтому третья строка значений, введенных с клавиатуры, не будет пересылаться программе до тех пор, пока не будет нажата клавиша “Enter” для каждой из выше расположенных строк. Цикл прекратит работу, как только встретится символ “b” (третья строка), так как он не соответствует формату вещественного числа: несоответствие символа “b” ожидаемому формату приводит к тому, что выражение

cin>>a;

будет оценено как false.

Компилятор Borland C++ 5.02 и Microsoft Visual C++ 2005 Express, как и ожидалось, дали в примере выше для переменной a один и тот же результат: 2.2. Однако компилятор wxDev-C++ 7.4 сбрасывает значение переменной a в ноль. Последнее противоречит принципу, принятому в С++: если попытаться прочитать в некоторую переменную и операция не выполняется, значение переменной должно остаться неизменным.

Приведенные примеры показывают, что стабильных правильных результатов среди рассмотренных компиляторов можно добиться только при использовании компилятора Microsoft Visual C++ 2005 Express и выше. Результаты, которые получаются с использованием компиляторов Borland C++ 5.02 и wxDev C++7.4, сильно зависят от содержания исходного кода программы.

Класс istream определяет оператор >> (“прочесть из”) для организации ввода встроенных типов. По умолчанию операция >> используется также в качестве битовой операции сдвига, однако это не имеет отношения к вводу: класс istream переопределяет операцию >> для организации ввода, причем эта операция перегружена и может применяться со всеми базовыми типами C++. Класс istream вводит оператор >> для каждого из этих типов данных, причем оператор >> возвращает ссылку на объект istream.

При вводе данных операция >> читает всё, начиная с первого символа (не являющегося символом-разделителем) до следующего символа, который не соответствует типу объекта назначения. Поэтому наиболее распространенной ошибкой при использовании потоков istream является ошибка, связанная с вводом данных, не соответствующих указанному формату. В таких случаях нужно или проверять состояние потока ввода перед использованием считанных данных, или использовать механизм исключений [4-6].

Рассмотрим, например, следующий фрагмент кода:

float a, b;

cin>>a>>b;

cout<<a<<” “<<b;

Если при вводе данных указать, например

1.234w

то значение переменной a будет равно 1.234, но значение переменной b будет неопределенно, т.к. сразу после ввода 1.234w программа перейдет к строке с инструкцией cout. Дело в том, что как только в потоке встретится символ w, являющийся некорректным с точки зрения ожидаемого формата вводимых данных, последним принятым символом будет 4. Символ w останется во входном потоке, и следующий оператор >> начнет чтение с этой точки, что и приводит к неопределенности. Поэтому следующий фрагмент кода

float a; char b;

cin>>a>>b;

cout<<a<<” “<<b;

будет работать верно при вводе строки 1.234w.

Может случиться так, что самое первое введенное значение будет ошибочным с точки зрения формата. В этом случае операция >> оставит значение переменной без изменений и вернет значение 0 (false), что позволит проверить, отвечал ли ввод требованиям установленного формата данных для переменной. Ниже представлен фрагмент программы, в котором вводятся числа, и ведется подсчет их суммы до тех пор, пока вводятся корректные значения для переменной.

float a, s=0.;

while(cin>>a) s+=a;

cout<<”nЗначение переменной а: “<<a;

cout<<”nСумма чисел: “<<s<<endl;

Пусть в процессе ввода часть чисел вводятся через нажатие клавиши “Enter“, причем это будут корректные данные; затем, в следующей строке, вводится последовательность чисел через символ-разделитель (пробел):

1.37

2.45

1.23 4 13.4 2.2b 3.4 5.6

Результатом работы фрагмента программы будет:

Значение переменной a: 2.2

Сумма чисел: 24.65

Ввод cin буферизуется, поэтому третья строка значений, введенных с клавиатуры, не будет пересылаться программе до тех пор, пока не будет нажата клавиша “Enter” для каждой из выше расположенных строк. Цикл прекратит работу, как только встретится символ “b” (третья строка), так как он не соответствует формату вещественного числа: несоответствие символа “b” ожидаемому формату приводит к тому, что выражение cin>>a будет оценено как false.

Компилятор Borland C++ 5.02 и Microsoft Visual C++ 2005 Express, как и ожидалось, дали в примере выше для переменной a один и тот же результат: 2.2. Однако компилятор wxDev-C++ 7.4 сбрасывает значение переменной a в ноль. Последнее противоречит принципу, принятому в С++: если попытаться прочитать в некоторую переменную и операция не выполняется, значение переменной должно остаться неизменным [1].

Объекты cin и cout содержат член данных, который описывает состояние потока. Состояние потока определяется тремя элементами класса ios_base: eofbit, badbit, failbit. Значение каждого такого элемента может принимать значения 0 (сброшен) или 1 (установлен). Так, когда cin достигает конца файла, eofbit устанавливается в значение 1. Если cin не может прочитать ожидаемый формат данных (как в примерах выше) или производится попытка чтения недоступного файла, то failbit устанавливается в значение 1. Элемент badbit устанавливается в 1, если происходит не поддающийся диагностике сбой, который может привести к повреждению потока. Стоит отметить, что различие между состояниями failbit и badbit очень незначительно. Можно сказать, что если поток в состоянии failbit, но не в badbit, то он не испорчен (при этом символы могут быть потеряны); однако если имеет место состояние badbit, то ни о чем с уверенностью сказать нельзя. Считается, что с потоком все в порядке, если все три первых бита состояния установлены в 0. Таким образом, состояние потока представляется в виде набора флагов (кроме перечисленных выше трех флагов есть еще флаг goodbit, но он выступает просто как другой способ выражения состояния 0).

Класс ios_base предоставляет также некоторые методы, которые позволяют сообщать о состоянии потока, или изменять его. Эти методы представлены в таблице 1.

Таблица 1. Методы управления состояниями потоков

Если для потока установилось состояние good(), то предыдущая операция выполнилась успешно, и можно выполнять следующий ввод; в противном случае ввод не выполнится.

Метод clear() устанавливает состояние в соответствии со значением переданного аргумента. Например, вызов

cin.clear();

использует аргумент по умолчанию (0), поэтому очищаются все три бита состояния (устанавливаются в 0). Однако вызов

cin.clear(eofbit);

устанавливает флаг eofbit в 1, а остальные два бита оставшихся флагов очищаются.

Метод setstate(), в отличие от clear(), касается только тех бит, которые установлены для его аргумента. Поэтому, например, вызов

cin.setstate(eofbit);

устанавливает только флаг eofbit в значение 1, а остальные биты не изменяются.

Наиболее частой причиной использования сброса состояния потока является необходимость осуществления повторного ввода после получения данных не того формата, что ожидалось. Установка битов состояния потока очень важна: если введенные данные не соответствуют ожидаемому формату, то поток закрывается для дальнейшего ввода или вывода до тех пор, пока соответствующий бит не будет очищен. Например, следующий код не будет работать (повторно ввести значение для a не удастся):

float a, s=0.;

void *p;

while((p=cin>>a) && a !=0) s+=a;

cout<<”nЗначение переменной а: “<<a;

cout<<”nСумма чисел: “<<s<<endl;

if (p==0) {cout<<”Обнаружена ошибка ввода. ”

<<”Повторите ввод: “;

cin>>a;

s+=a;

cout<<”nЗначение переменной а: “<<a;

cout<<”nСумма чисел: “<<s; }

Чтобы фрагмент программы продолжил читать ввод после возникновения ошибки, необходимо сбросить биты состояния потока в нормальное состояние. Это можно сделать, используя метод clear(). Однако только одного сброса состояния потока недостаточно, т.к. некорректный ввод все также остается во входной очереди, и будет вновь прочитан. Здесь можно предложить по крайней мере три способа решения проблемы.

Во-первых, можно продолжить чтение до очередного символа-разделителя (по умолчанию – “пробел”), для чего использовать функцию isspace():

float a, s=0.;

void *p;

while((p=cin>>a) && a!=0) s+=a;

cout<<”nЗначение переменной а: “<<a;

cout<<”nСумма чисел: “<<s<<endl;

if (p==0) {cout<<”Обнаружена ошибка ввода. ”

<<”Повторите ввод: “;

cin.clear(); // сброс состояния потока

while(!isspace(cin.get())); // продолжаем //считывать до символа-разделителя

cin>>a; s+=a;

cout<<”nЗначение переменной а: “<<a;

cout<<”nСумма чисел: “<<s; }

Введем в качестве данных, например, следующие:

2.45

1.23 4 13.4 2.2b 3.4 5.6

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

Значение переменной а: 2.2

Сумма чисел: 23.28

Обнаружена ошибка ввода. Повторите ввод:

Значение переменной а: 3.4

Сумма чисел: 26.68

Во-вторых, можно отбросить остаток строки буфера, а не очередные символы из него:

float a, s=0.;

void *p;

while((p=cin>>a) && a!=0) s+=a;

cout<<”nЗначение переменной а: “<<a;

cout<<”nСумма чисел: “<<s<<endl;

if (p==0) {cout<<”Обнаружена ошибка ввода. ”

<<”Повторите ввод: “;

cin.clear(); // сброс состояния потока

while(cin.get() != ‘n’); //отбрасываем остаток строки

cin>>a; s+=a;

cout<<”nЗначение переменной а: “<<a;

cout<<”nСумма чисел: “<<s; }

Возможно отбросить остаток строки буфера еще двумя способами:

• Воспользоваться функцией-членом ignore() класса istream, которая извлекает из потока символы и отбрасывает их. Функция имеет два аргумента: количество n отбрасываемых символов и символ-признак, после которого отбрасывание прекращается. Таким образом, функция ignore() отбрасывает либо n символов, либо все символы до первой встречи символа-признака. Так как нам нужно отбросить весь остаток строки в буфере, то в коде выше вместо строки
  

while(cin.get() != ‘n’);

необходимо написать строку:

cin.ignore(numeric_limits<streamsize>::max(), ‘n’);

При этом также необходимо подключить файл limits. Способ не применим к компилятору Borland C++ 5.02.

• Воспользоваться функцией-членом rdbuf() класса istream для обращения к буферу ввода. Чтобы узнать, сколько символов в нем содержится, нужно вызвать функцию in_avail() этого буфера – это количество символов мы будем игнорировать. Поэтому в коде выше вместо строки
  

while(cin.get() != ‘n’);

необходимо написать строку:

cin.ignore(cin.rdbuf()->in_avail());

Данный способ не стал работать с компилятором wxDev-C++ 7.4; компиляторы Borland C++ 5.02 и Microsoft Visual C++ 2005 Express дали при этом одинаковый верный результат.

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

float a, s=0.; void *p;

while((p=cin>>a) && a!=0) s+=a;

cout<<”nЗначение переменной а: “<<a;

cout<<”nСумма чисел: “<<s<<endl;

if (p==0) {cout<<”Обнаружена ошибка ввода. ”

<<”Повторите ввод: “;

cin.clear(); // сброс состояния потока

cin.sync();

cin>>a; s+=a;

cout<<”nЗначение переменной а: “<<a;

cout<<”nСумма чисел: “<<s; }

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

Рассмотрим еще небольшой фрагмент кода, позволяющий подсчитывать сумму вещественных чисел последовательности, признаком конца которой является 0. При этом код обрабатывает ситуации с некорректно введенными данными. В качестве тренировки предлагаем читателю изменить ниже расположенный код таким образом, чтобы из подсчета полностью исключалось некорректно введенное число.

float a, s=0.;

void *p;

do { p=cin>>a;

if (p==0) { cin.clear(); cin.sync(); }

else s+=a; } while(a!=0);

cout<<”nСумма чисел: “<<s;

После изучения представленного выше материала с целью оценки уровня усвоения учащимися учебного материала может оказаться удобным использование всевозможных программ-тестов [2, 3], в том числе в дистанционной форме.

При обучении программированию на С++ необходимо уделять достаточно внимания работе с потоками ввода-вывода [1], так как практически любая программа использует ввод и вывод. Однако почти всегда изучение этой темы ограничивается лишь стандартным использованием операций ввода и вывода на основе cin и cout. Другие особенности и возможности потоков остаются так и не затронутыми, и неизвестными для учащихся (обычно в дальнейшем особо заинтересованные учащиеся изучают их самостоятельно).

В данной статье рассматриваются некоторые вопросы, связанные с перегруженной операцией << и отдельными методами класса ostream. Предполагается, что учащиеся уже имеют базовые представления о языке программирования C++.

Вывод в С++ рассматривается как поток байтов, и на самом деле представляет собой преобразование объектов некоторого типа в последовательность символов. Это связано с тем, что многие виды данных (даже стандартных типов) организованы в более крупные единицы, чем байт. Поэтому наиболее важной задачей, стоящей перед классом ostream, является задача преобразования типов, таких как int, float, double и других, в поток символов. Для выполнения таких преобразований в классе ostream предусмотрено несколько методов [1, 4-6].

Как понимать утверждение “объект представляет собой поток”? Например, когда в файле iostream объявляется объект cout для программы, то этот объект получает данные-члены, содержащие информацию относительно вывода (ширина поля вывода, количество знаков после десятичной точки, адрес объекта streambuf, и др.)

Рассмотрим, что происходит, когда в программе встречается инструкция cout [4]:

cout<<”Введите строку данных”;

Данная инструкция помещает символы из строки “Введите строку данных” в буфер, управляемый cout через объект streambuf. Буфер (buffer) – это блок оперативной памяти, выполняющий роль посредника, который используется средствами ввода-вывода для промежуточного (временного) хранения данных, передаваемых между программой и устройством хранения.

Буфер помогает, например, согласовать обмен данными между программами и приводами дисков: программы очень часто обрабатывают данные по одному байту за раз, а приводы дисков обычно передают информацию блоками размером по 512 байт и более. Кроме того, если считывать данные из файла по одному символу, то такое чтение требует больших аппаратных затрат, и достаточно медленно. Буферизованный подход заключается в том, что достаточно большая порция данных читается с диска и сохраняется в буфере. Затем можно производить чтение данных из буфера по одному символу – это будет намного быстрее, так как в таком случае производится чтение байтов из памяти. После того, как программа в процессе чтения и обработки данных достигнет конца буфера, она может считать следующую порцию данных с диска. Аналогично, при выводе программа может сначала наполнить буфер данными, а затем целиком передать этот блок данных на жесткий диск; затем буфер используется для приема новых данных.

При вводе данных с клавиатуры программа, в принципе, не нуждается в буфере, так как клавиатурный ввод даёт один символ за раз. Однако буферизированный ввод с клавиатуры обеспечивает возможность исправить введенные данные до того, как они поступят в программу. Программа на С++ обычно сбрасывает содержимое такого буфера в программу после нажатия на клавишу “Enter“. При выводе на экран буфер обычно сбрасывается при встрече символа новой строки.

Так как вывод из буфера для cout по умолчанию направляется на стандартный вывод (экран), то один конец потока подключается к программе, а второй – к устройству стандартного вывода – экрану. Таким образом, объект cout с помощью объекта типа streambuf управляет движением байт в потоке.

Класс ostream определяет оператор << (“записать в”) для управления выводом встроенных типов (иногда операцию << называют операцией вставки). По умолчанию операция << используется также в качестве битовой операции сдвига, однако это не имеет отношения к выводу: класс ostream переопределяет операцию << для организации вывода, причем эта операция перегружена и может применяться со всеми базовыми типами C++. Класс ostream предлагает определение функции operator<<() для каждого из этих типов данных, причем эта функция возвращает ссылку на объект ostream, для которого она вызывалась. Именно поэтому к ней можно применить другой operator<<() и может быть организован сцепленный вывод данных:

cout<<”Значение элемента a["<<i<<"] равно “<<a[i];

По той же причине строка кода

cout<<”a = “<<a<<endl;

будет интерпретироваться (не для компилятора Borland C++ 5.02) как

operator<< (cout, “a = “).operator<< (a)<<endl;

Для вывода типов, определенных пользователем, операцию << необходимо перегрузить соответствующим образом. После этого перегруженным оператором << можно будет пользоваться точно так же, как и оператором << для встроенных типов.

Кроме функций operator<<(), класс ostream предоставляет еще и следующие методы: метод put() для отображения символов и метод write() для отображения строк. Методы реализованы в виде шаблонов, а вызываются с применением обычной нотации вызова метода класса:

cout.put(‘P’);

Функция-член put() класса ostream возвращает ссылку на вызывающий объект, поэтому можно использовать сцепленный вывод:

cout.put(‘P’).put(‘u’).put(‘t’)<<endl;

Фактически вызов функции cout.put(‘P’) возвращает cout, который, в свою очередь, снова вызывает метод put().

Так как метод put() выводит символ, а сам метод реализован в виде шаблона, то можно применять put() и с аргументами числовых типов. При этом будет выведен символ с соответствующим числовым ASCII-кодом:

cout.put(97); // a

cout.put(117.234); // u

Некоторые старые компиляторы ошибочно перегружали метод put() для типов аргументов char, unsigned char и signed char, что в результате приводило к неоднозначности. Поэтому в таких случаях было необходимо указывать явное преобразование типов. Например, чтобы предыдущий код работал в компиляторе Borland C++ 5.02, его нужно видоизменить, включив явное преобразование типов:

cout.put((char)97); // a

cout.put((char)117.234); // u

Рассмотрим теперь метод write(). Он имеет два аргумента, первый из которых представляет собой адрес строки, которую необходимо отобразить, а второй – указывает, сколько символов нужно отобразить. Тип возвращаемого функцией write() значения есть ostream &, поэтому вызов cout.write() возвращает объект cout.

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

Ниже приведен фрагмент кода, в котором показано использование метода write().

const char *s1 = “Москва”;

const char *s2 = “Стерлитамак”;

int n=strlen(s1);

for(int i=1; i<=n; cout.write(s1,i++)<<endl);

cout.write(s1,30)<<endl;

В результате работы цикла for этого фрагмента на экран будут выданы следующие строки:

М

Мо

Мос

Моск

Москв

Москва

Результат работы следующей после цикла for строки будет зависеть от используемого компилятора. Так, для компиляторов Borland C++ 5.02 и wxDev-C++ 7.4, скорее всего, будет выдана строка “Москва”, после которой сразу же – строка “Стерлитамак” и еще часть символов (до 30). Таким образом, отмеченные выше компиляторы располагают строки рядом, в соседних ячейках памяти. Этого нельзя сказать о компиляторе Microsoft Visual C++ 2005 Express, – он чаще всего не располагает строки в соседних ячейках памяти.

Как и метод put(), метод write() можно использовать с числовыми данными. Но в данном случае методу write() нужно передать адрес числа, приведя его тип к char*:

long a1 = 97, a2 = 24929, a3 = 6381921;

cout.write((char*) &a1, sizeof(long))<<endl;

cout.write((char*) &a2, sizeof(long))<<endl;

cout.write((char*) &a3, sizeof(long))<<endl;

Такой вывод не отобразит число в корректные символы, но передаст битовое представление того, что находится в памяти. Так, например, приведенный фрагмент кода программы выдаст на экран следующие строки:

a

aa

aaa

Полученный результат легко объясняется с точки зрения его интерпретации как ASCII-кода символа в двоичном представлении, что показано ниже в таблице 1. Таким образом, в некоторых случаях имеет смысл использовать метод write() для отображения числовых данных.

Таблица 1. Интерпретация результата работы метода write() для числовых данных типа long

После изучения представленного выше материала с целью оценки уровня усвоения учащимися учебного материала может оказаться удобным использование всевозможных программ-тестов [2, 3], в том числе в дистанционной форме.