Примеры постфиксной операции:
int a = 3;
a++;
a--;
То есть, здесь знак операции ставится после имени идентификатора.
Для использования постфиксных операций с пользовательскими типами данных нужно совсем немного:
public:
void operator++ ()
{
counter += 1;
}
void operator++ (int)
{
counter += 1;
}
Единственным отличием префиксной операции от постфиксной - ключевое слово int в списке аргументов. Но int - это не аргумент! Это слово говорит, что перегружается постфиксная операция. Теперь операцию ++ можно использовать как перед идентификатором объекта, так и после:
Counter a;
++a;
++a;
a++;
a++;
Перегрузка бинарных операцій.
Перегрузка операций с двумя аргументами очень похожа на перегрузку бинарных операций:
Counter operator+ (Counter t)
{
Counter summ;
summ.counter = counter + t.counter;
return summ;
}
Counter c1,c2,c3;
c1.counter = 3;
c2.counter = 2;
c3 = c1 + c2;
В перегруженных бинарных операциях всегда вызывается метод левого операнда. В данном случае метод operator+ вызывает объект c1. В метод мы передаём аргумент. Аргументом всегда является правый операнд. Кроме того, в данном случае операция + должна вернуть какой-то результат, чтобы присвоить его объекту c3. Мы возвращаем объект Counter. Возвращаемое значение присваивается переменной c3. Конечно же нужно добавить этот метод для операции «=» к классу Counter:
Counter operator= (Counter t)
{
Counter assign;
counter = t.counter;
assign.counter = t.counter;
return assign;
}
Внутри метода мы создали дополнительную переменную assign. Данная переменная используется, чтобы можно было работать вот с таким кодом:
Counter c1(5),c2,c3;
c3 = c2 = c1;
5. Классы ввода-вывода в C++. Иерархия классов. Виды потоков ввода-вывода.
Системы ввода-вывода С и С++ основываются на понятии потока – абстрактном понятии, относящемся к переносу информации от источника к приемнику.
В языке С++ реализованы 2 иерархии классов, обеспечивающих операции ввода-вывода, базовыми классами которых являются streambuf и ios:
streambuf:
-filebuf
-strstreambuf
-conbuf
Существуют перегруженные операции для всех типов данных (в том числе и для пользовательских), тем самым необходимость проверки соответствия типов отпадает. Компилятор самостоятельно выбирает нужную операцию в соответствии с типом данных.
Для обеспечения работы с потоками ввода-вывода необходимо включить файл iostream, содержащий описание набора классов ввода-вывода.
Классы потокового ввода:
Istream - Универсальный класс ввода, или родительский класс для других производных потоковых классов ввода.
Ifstream - Ввод из файлов.
istream_withassign - Ввод из потока cin.
Istrstream — ввод их строки.
Классы потокового вывода:
Ostream - Универсальный класс вывода, или родительский класс для других производных потоковых классов вывода.
Ofstream - Вывод в файлы.
ostream_withassign - Вывод в потоки cout, cerr и clog.
Ostrstream — вывод в строку.
Классы потокового ввода/вывода:
iostream - Универсальный класс ввода/вывода, или родительский класс для других производных потоковых классов ввода/вывода.
Fstream - Ввод/вывод в файлы.
Stdiostream - Стандартный поток ввода/вывода.
Strstream - Ввод/вывод в строку.
Классы буферизованных потоков:
Streambuf - Родительский класс для производных буферизованных классов.
Filebuf - Буферизованный поток для файлов.
Stdiobuf - Буферизованный поток для стандартного файлового ввода/вывода.
Strstreambuf - Буферизованный поток для строк.
Класс streambuf используется для потокового буферизованного ввода/вывода.
В следующей программе описываются два элемента типа filebuf, после этого открываются текстовые файлы, затем каждый элемент filebuf связывается с соответствующим объектом. Далее выполняется печать из входного потока в выходной.
#include <fstream.h>
#include <fcntl.h>
void main()
{
char ch;
long linecount=0; //объявление буферов
filebuf inbuf,outbuf; //открытие входного файла
inbuf.open(“infile.dat”,_O_RDONLY | _O_TEXT);
if(inbuf.is_open()==0)
{
cerr<<”cant open input file”;
return;
} //объявление входного потока
istream is(&inbuf); //открытие выходного файла
outbuf.open(“outfile.dat”,_O_WDONLY | _O_TEXT);
if(outbuf.is_open()==0)
{
cerr<<”cant open output file”;
return;
} //объявление выходного потока
ostream os(&outbuf);
while(is)
{
//чтение из потокаis.get(ch);
//запись в потокos.put(ch);
if(ch==’\n’)linecount++;
}
//закрытие файлов
inbuf.close();
outbuf.close();
cout<<”\nYou had: “<<linecount<<” lines”;
Все буферизованные объекты используют фиксированный буфер памяти. Его можно разделить на get область и put область. Они могут накладываться друг на друга. Программа может манипулировать этими областями при помощи защищенных методов класса.
#include <strstrea.h>
void main()
{
chat c;
strstreambuf mybuf(1024); //объявление потока
//запись в поток
mubuf.sputc(‘A’); //чтение из потока
c=mybuf.sgetc();
cout<<c;
}
Двоичные файлы или потоки содержат последовательности байтов; никаких преобразований символов не выполняется. Для указания двоичного режима в конструктор необходимо добавить описатель ios::binary:
6. Форматный и бесформатный вывод. Методы форматирования и манипуляторы форматирования.
Форматирование данных при обмене с потоками:
При применении операций ввода – вывода к стандартным потокам по умолчанию устанавливаются стандартные форматы внешнего представления пересылаемых данных.
Например, при выводе данные занимают ровно столько позиций, сколько надо для их представления.
Форматы представления могут быть изменены программистом с помощью:
флагов форматирования класса ios
компонентных функций для управления форматами класса ios
с помощью манипуляторов потоков без параметров и с параметрами
Флаги – представляют собой отдельные фиксированные биты чисел типа long . Эти фиксированные биты входят в компонент класса ios типа long:
Long x_flags; //переменная, представляющая флаги – форматы
//наследуется всеми производными потоковыми классами
//флаги наследуются всеми потоками
Эта переменная анализируется при обменах, ее значение влияет на преобразование информации.
Флаги объединяются с помощью логических битовых операций, по- разному комбинируя свойства потока.
Компонентные функции класса ios : flags( ) и setf( ) предназначены для проверки значений флагов, для их установки и для их сбрасывания в исходные умалчиваемые значения.
Флаги могут обрабатываться как по отдельности, так и группами, когда отдельные флаги связаны побитовой логической операцией – дизъюнкцией ( ‘ | ’).
Рассмотрим флаги:
skipws = 0x0001 //пропуск (игнорирование) при операции извлечении из потока обобщенные пробельные символы (действует по умолчанию)
left=0x0002 //вывод с левым выравнивание
right=0x0004 //вывод с правым выравниванием
internal=0x0008 //принятый в качестве заполнителя символ помещается между числом и знаком числа или признаком системы счисления.
dec=0x0010 //десятичная система счисления
oct=0x0020 //восьмеричная система счисления
hex =0x0040 //шестнадцатеричная система счисления
showbase=0x0080 //выводить признак системы счисления (0x и 0)
showpoint=0x0100 //печатать обязательно десятичную точку и следующие за ней нули, даже для числа имеющего нулевую дробную часть
uppercase=0x0200 //при выводе чисел использовать буквы верхнего регистра (0X , E, ABCDEF)
scientific = 0x0800 – представление чисел в формате с плавающей точкой мантисса имеет одну ненулевую цифру перед точкой
fixed =0x1000 //представление в формате с фиксированной точкой, причем количество цифр после запятой определяется заданной по умолчанию точностью;
unitbuf = 0x2000 – очищает все потоки (сбрасывает содержимое буферов) после каждого вывода и т. д .
Можно использовать имена флагов, естественно с указанием их принадлежности классу ios ( ios::left ) или непосредственно значения флагов.
Как установить и проверить значения флагов рассмотрим ниже.
Компонентные функции класса ios для форматирования:
char fill(); //возвращает символ заполнения пустых позиций вывода
char fill(char) ; //замещает символ заполнения пустых позиций вывода,возвращает предыдущий символ заполнения
Значение символа (кода символа) заполнения хранится в компонентной переменной класса int x_fill.
long flags(); //возвращает текущий набор битов флагов форматирования
long flags(long) //устанавливает флаги в соответствии со значением параметра, возвращает предыдущее значение флагов
int precision() ; //возвращает текущее значение точности вывода вещественных чисел
int precision ( int n) ; //устанавливает по значению параметра точность представления вещественных чисел, т.е. количество цифр дробной части при выводе, передает значение в переменную int x_precision, возвращает предыдущее значение точности
long setf ( long ) ; //устанавливает набор флагов в соответствии с параметром, возвращает значение старого набора;
long setf ( long setbits , long field ) ; //устанавливает флаги в соответствии со значением параметра setbits ; биты, которые дает параметр field ,сбрасываются и устанавливаются новые биты
int width (); //возвращает текущее значение ширины поля вывода
int width (int ); //устанавливает значение ширины поля вывода, в соответствие со значением параметра, значение сохраняется в переменной int x_width , функция возвращает старое значение и т. д.
В классе ios имеются три компонента:
статические константы общие для всех объектов класса
статические константы обращение:ios::имя
статические константы объединяющие несколько флагов
static const long adjustfield ; // left |right | internal
static const long basefield ; // dec | oct | hex
static const long floatfield; // scientific | fixed
Используются в качестве второго параметра в функции setf ( ) для сбрасывания флагов.
Обращения к функциям.
void main()
{
clrscr();
cout.width(15); // ширины вывода
cout.fill('*'); // установка символа заполнителя
cout.setf(ios::internal); // заполнить между знаком и значением
cout<<-5.35<<endl; // -**********5.35
cout.setf(ios::left,ios::adjustfield); //сбросили правое выравнивание, установили левое
cout.width(15);
cout<<-32767<<endl; //-32767*********
cout.setf(ios::hex,ios::basefield); //сбросили старую систему, установили новую систему счисления
cout.width(15);
cout<<32767<<endl; // 7fff***********
cout.setf(0x0200|0x0080);//показать признаки системы и верхн. рег.
cout.width(15);
cout<<32767<<endl; // 0X7FFF*********
cout.setf(ios::right,ios::adjustfield); //правое выравнивание
cout.width(15);
cout<<32767<<endl; // *********0X7FFF
cout.fill('.');
cout.setf(ios::internal,ios::adjustfield);
cout.width(15);
cout<<32767<<endl; // 0X………7FFF
cout.fill('+');
cout.setf(ios::right,ios::adjustfield);
cout.width(15);
cout<<32767<<endl; // +++++++++0X7FFF
}
7. Манипуляторы. Манипуляторы с параметрами и без параметров.
Более простой способ форматирования – это использования манипуляторов.
Манипуляторы – это специальные функции позволяющие изменять флаги потока. Имена манипулятора, если манипулятор без параметров, и вызовы функции-манипулятора с параметрами можно использовать в качестве правого операнда операции ввода-вывода. Манипуляторы можно включать в цепочки включений в поток и извлечений из потока. Манипуляторы изменяют состояние потока.
Манипуляторы без параметров:
dec - действует при вводе и выводе, устанавливает флаг десятичной системы
hex - действует при вводе и выводе , устанавливает флаг шестнадцатеричной системы
oct - действует при вводе и выводе, устанавливает флаг восьмеричной системы
endl - действует только при выводе, обеспечивает включение в поток символа новой строки и сбрасывает буфер
ends - действует только при выводе, обеспечивает включение в поток нулевого признака конца строки
flush - действует только при выводе, обеспечивает сбрасывание буфера
ws - действует только при вводе, обеспечивает извлечение из входного потока пробельных символов (пробел, ' \t’, ‘\v’ , ‘\n’, ‘\r’, ‘\f’)
hex, oct, dec изменяют состояние потока до следующего явного изменения.
Манипуляторы с параметрами (определены в файле iomanip.h):
setbase ( int n) - устанавливает основание системы счисления cout << setbase (8) << 255 <<setbase (16)
resetiosflags (long L) -сбрасывает отдельные флаги
setiosflags (long L) - устанавливает отдельные флаги cout<<setw(5)<< setiosflags( ios::left)<<5<<»\n»<<setw(5)<<resetiosflags( ios::left) <<5;
setfill( int n) - значение параметра – код заполнителя for (int i=0; i<3; i++) cout <<setfill(46)<<setw(5+i)<<i+1<<»\n»;
setprecision( int n) -определяет точность представления числа при вводе–вывода вещественного числа , количество цифр дробной части for(int i =0 ; i< 4; i++) cout<<setprecicion(i)<<1.2345<<»\n»
setw( int n) - параметр задает поле вывода
При использовании манипулятора setw как и член – функции width необходимо указывать требуемую ширину отдельно для каждого выводимого значения.
cout << setiosflags(ios::scientific)<< 0.000123; 1.23e-04
cout << setiosflags(ios::fixed)<< 0.000123; 0.000123
8. Консольные потоки, в т.Ч. Стандартные.
В начале выполнения программы автоматически открываются три потока. Это stdin (стандартный поток ввода), stdout (стандартный поток вывода) и stderr (стандартный поток ошибок). Обычно эти потоки направляются к консоли, но в средах, которые поддерживают перенаправление ввода/вывода, они могут быть перенаправлены операционной системой на другое устройство.
Так как стандартные потоки являются указателями файлов, то они могут использоваться системой ввода/вывода языка С также для выполнения операций ввода/вывода на консоль. Например, putchar() может быть определена таким образом:
int putchar(char c)
{
return putc(c, stdout);
}
Вообще говоря, stdin используется для считывания с консоли, a stdout и stderr — для записи на консоль.
В роли указателей файлов потоки stdin, stdout и stderr можно применять в любой функции, где используется переменная типа FILE *. Например, для ввода строки с консоли можно написать примерно такой вызов fgets():
char str[255];
fgets(str, 80, stdin);
При использовании gets() не исключена возможность, что массив, который используется для приема вводимых пользователем символов, будет переполнен. Это возможно потому, что gets() не проводит проверку на отсутствие нарушения границ. Полезной альтернативой gets() является функция fgets() с аргументом stdin, так как эта функция может ограничивать число читаемых символов и таким образом не допустить переполнения массива. Единственная проблема, связанная с fgets(), состоит в том, что она не удаляет символ новой строки, поэтому его приходится удалять "вручную", как показано в следующей программе:
#include <stdio.h>
#include <string.h>
int main(void)
{
char str[80];
int i;
printf("Введите строку: ");
fgets(str, 10, stdin);
/* удалить символ новой строки, если он есть */
i = strlen(str)-1;
if(str[i]=='\n') str[i] = '\0';
printf("Это Ваша строка: %s", str);
return 0;
}
Связь с консольным вводом / выводом.
Функции консольного ввода/вывода на самом деле направляют результаты своих операций на один из потоков — stdin или stdout, и по сути, каждая из них является специальной версией соответствующей файловой функции.
Ввод/вывод на консоль можно выполнять с помощью любой файловой функции языка С. Однако, операции ввода/вывода на дисковых файлах можно выполнять с помощью функции консольного ввода/вывода, например, printf(). Все функции консольного ввода/вывода выполняют свои операции с потоками stdin и stdout. В средах, поддерживающих перенаправление ввода/вывода, это равносильно тому, что stdin или stdout могут быть перенаправлены на устройство, отличное от клавиатуры или экрана.
Например:
#include <stdio.h>
int main(void)
{
char str[80];
printf("Введите строку: ");
gets(str);
printf(str);
return 0;
}
Предположим, что эта программа называется TEST. При ее нормальном выполнении на экран выводится подсказка, затем читается строка, введенная с клавиатуры, и, наконец, эта строка выводится на экран. Однако в средах, в которых поддерживается перенаправление ввода/вывода, один из потоков stdin или stdout (или оба одновременно) можно перенаправить в файл.
Когда С-программа завершается, то все перенаправленные потоки возвращаются в состояния, которые были установлены по умолчанию.
Перенаправление стандартных потоков: функция freopen()
Для перенаправления стандартных потоков можно воспользоваться функцией freopen(). Эта функция связывает имеющийся поток с новым файлом. Так что она вполне может связать с новым файлом и стандартный поток. Вот прототип этой функции:
FILE *freopen(const char *имя_файла, const char *режим, FILE *поток);
где имя_файла — это указатель на имя файла, который требуется связать с потоком, на который указывает указатель поток. Файл открывается в режиме режим; этот параметр может принимать те же значения, что и соответствующий параметр функции fopen(). Если функция freopen() выполнилась успешно, то она возвращает поток, а если встретились ошибки, — то NULL.
В следующей программе показано использование функции freopen() для перенаправления стандартного потока вывода stdout в файл с именем OUTPUT.
#include <stdio.h>
int main(void)
{
char str[80];
freopen("OUTPUT", "w", stdout);
printf("Введите строку: ");
gets(str);
printf(str);
return 0;
}
9. Файловые и строковые потоки.
Строковые потоки (обмены в оперативной памяти).
Классы istrstream, ostrstream, strstream предназначены для создания потоков, связанных с участками основной памяти. Такие участки определяются часто как символьные массивы. Объекты (потоки) названных классов называют строковыми потоками.
Определение :
Определяется строковый поток и одновременно связывается с участком ОП с помощью конструктора с параметром (по правилу создания объекта с помощью вызова конструктора с параметрами)
<Имя класса> < имя потока(объекта)> ( параметры конструктора)
Входные строковые потоки (из которых читают) создаются с помощью вызова следующего конструктора: istrstream in (char *str );
параметр str указывает на существующий участок памяти
Пример:
char buf [80] ;
istrstream in (buf);
Входной строковый поток in связан с участком памяти, выделенным под массив buf. Теперь используя поток in и операцию >> можно из массива buf считывать значения, в какие либо данные.
Пример:
#include <strstream.h>
void main()
// выделяем область памяти для обмена
char*stroka=”1436.7 Auda!”
istrstream instr ( stroka );
char mas[10];
float b;
instr>> b>> mas; //распаковка строки
cout << b << “ “ << mas << endl;
Операция >> извлекает информацию от первого не пробельного символа до первого пробела. Чтобы считывать с пробелами, надо использовать функции get( ) и getline ( ). С помощью этих функций при использовании строковых потоков, можно организовать копирование строк.
Безымянные входные потоки – это создание безымянного объекта
Вызывается конструктор без имени
char* stroka = “ … “
char array [50];
istrstream ( stroka)>>array; // введет до первого пробела
… istrstream ( stroka).getline(array , 50 , ‘\0’)// введет всю строку опять с ее
//начала
Выходные строковые потоки ( связывается с участком ОП для вывода данных) создается вызовом конструктора с параметрами ostrstream outstr ( char*str, int n , int mod ).
Первый параметр адресует существующий участок памяти, куда выводятся данные. Второй параметр определяет размеры этого участка памяти .Третий параметр определяет режим обмена.
ios:: out-строковый поток создается для вывода, запись информации ведется с начала строки, выбирается по умолчанию.
#include < strstrea.h>
void main( )
{ char buf [80];
char al [ ]=«\nБез включения разделителей «
char ol [ ] =« текст\n\»сливается\» .\n»
ostrstream ( buf, sizeof(buf) ).write(al , sizeof(al));
ostrstream ( buf, sizeof(buf) , ios :: ate).write(ol , sizeof(ol));
cout << buf<<endl;
Функция write( ) вызывается для безымянного потока.
Используем для вывода операцию включения в поток <<.
Будем использовать для разнообразия именованный поток .
…
{
ostrstream outstr( stroka, sizeof(stroka), ios::out | ios::ate ) // мода для до-
//полнения строки
outstr<<”\nБез включения разделителей»<<« текст\n\»сливается\» .\n»<< 12345<<-4.67<<+1.456<<ends;…
cout<< stroka;
}
Двунаправленные потоки.
Конструктор строковых потоков для чтения и для записи имеет вид:
strstream outstr ( char*buf, int n , int mod )
buf – указатель на участок памяти ( буфер потока);
n – размер в байтах участка памяти
Третий параметр – это дизъюнкция флагов
ios:: in ios::out – определяет направление потока
ios::ate ios app –влияют на размещение указателя позиции чтения или записи в буфере.
Пример 1:
#include <strstrea.h>
void main ()
{ char buf [100];
char s [80];
// объявляем двунаправленный строковый поток, связанный с массивом buf[]
strstream iostr ( buf, sizeof(buf) , ios:in |ios::out );
iostr<< “Строковый поток связан с участком ОП.” <<ends;
//позиция записи сместилась в конец потока, позиция чтения на начале //потока
iostr>>s; cout<<’\n’<< s; // читает до пробела
iostr>>s; cout<<’\n’<< s; // читает следующее слово
// установим позицию чтения на начало потока и прочитаем весь буфер
iostr.seekg ( 0L, ios::beg );
iostr.getline( s, sizeof(s), ‘\0’ ); // копирование из буфера потока buf в s
cout<<’\n’<<s;
Работа с файлами.
Функции С++ позволяют читать данные из файлов в ОП, получать их с устройств, и записывать данные из ОП в файл или выводить их на различные устройства.
Средства ввода-вывода языка С++ можно разделить на три группы:
0 ввод-вывод верхнего уровня – потоковый
а) библиотека функций Си - интерфейс в файле stdio.h
б) библиотека классов С++ -интерфейс в файле fstream.h
1 ввод-вывод нижнего уровня (системный ввод- вывод)-файл io.h
2 ввод-вывод для консоли и портов – интерфейс в файле conio.h
Библиотека ввода-вывода С++ включает средства для работы с последовательными файлами, представляющими собой именованную последовательность байтов, имеющую начало и конец. Чтение из файла или запись в файл ведутся байт за байтом, позиции в файле, откуда производится чтение, или куда ведется запись, определяются указателем позиции файла. Указатель позиции записи или чтения устанавливается либо автоматически, либо с помощью функций управления положением его можно установить на нужный байт.
Ввод-вывод нижнего уровня.
Функции ввода – вывода низкого уровня позволяют пользоваться средствами ввода-вывода операционной системы непосредственно. При этом не выполняется буферизация и форматирование данных при обмене. При низкоуровневом открытии файла с ним связывается целое значение - дескриптор файла (логический номер файла, идентификатор файла), которое назначается операционной системой.
Дескриптор файла характеризует его размещение во внутренних файловых таблицах операционной системы.
Основные функции нижнего уровня:
0 open( ) / close( ) – открыть / закрыть файл
1 creat( ) – создать файл
2 read ( )/ write( ) – читать / писать данные
3 eof ( ) – проверить достижение конца файла
4 lseek( ) – изменить текущую позицию в файле
5 tell ( ) – получить значение текущей позиции в файле
Текстовой и бинарный файлы.
Работа с текстовым файлом организуется построчно.
Бинарный файл – это линейная последовательность байтов, соответствующая внутреннему представлению данных без разделения на строки
Создание файла.
( на нижнем уровне)
Функция по заданному имени (path) создает новый файл или очищает и подготавливает к работе уже существующий файл.
int creat (const char *path , int mode); // прототип в файле < io.h >
Параметр mode определен в файле <sys\stat.h>
Файл создается для работы в режиме обмена либо текстовом (по умолчанию) либо бинарном.
Таким образом файл может создаваться для текстового режима обмена данными или для двоичного. Для установления режима обмена при создании файла надо глобальной системной переменной _fmode , определенной в файлах fcntl.h и stdlib.h надо задать соответствующее значение
Функция creat() возвращает индивидуальный логический номер файла , идентификатор файла, дескриптор файла при создании файла и –1 при неуспешном завершении.
Открытие и закрытие файлов.
int open (const char *path , int mode); // прототип в файле < io.h >
int fd=open( имя файла, флаги); // вызов функции
Первый параметр задает имя файла
Параметр mode определяет режим открытия файла, представляет результат битовой дизъюнкции флагов обмена, определенных в файлах <sys\stat.h> или
fcntl.h
Режим открытия должен устанавливаться явно , т.к. умолчания нет.
Вызов функции creat ( ) эквивалентен вызову:
open( имя файла ,O_CREAT|O_TRUNC|O_WRONLY).
Для закрытия файлов функция:
int close( дескриптор файла)
Возвращает 0 при успешном закрытии и -1 в случае ошибки.
Чтение и запись данных.
int read( int fd, char* buffer, unsigned int count)
– читает count байт из файла, с дескриптором fd в буфер buffer.
Возвращает число байт, помещенных в буфер;
0 – при достижении конца файла; - 1 – при возникновении ошибки чтения.
Чтение идет с текущей позиции в файле. В текстовом режиме идет преобразование двух символов к одному ‘\n’ и в возвращаемом значении вместо двух символов учитывается один.
int write( int fd, char* buffer, unsigned int cout)
- записывает count байт из буфера buffer в файл, открытый с дескриптором fd .
Запись идет с текущей позиции. Возвращает количество реально записанных байтов.