Виртуальные функции 4.5.1. Понятие о “позднем” связывании

4.5 Виртуальные функции 4.5.1. Понятие о “позднем” связывании

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

4.5.2. Описание виртуальных функций

Функция-компонента класса объявляется как виртуальная указанием ключевого слова virtual. Функции-компоненты в производных классах, заменяющие виртуальную функцию базового класса должны объявляться с тем же именем, тем же списком параметров и типом возвращаемого значения, что и соответствующая функция базового класса. Если из производного класса не образуется новых производных классов, ключевое слово virtual в описании функции можно опустить.

Если в производном классе нет объявления функции с тем же именем, что и виртуальная функция базового класса, будет вызываться функция базового класса.

Виртуальная функция может быть объявлена в форме:

virtual void print ( ) = 0;

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

Виртуальные функции особенно полезны, когда к методом класса требуется обращаться через указатель на экземпляр класса, а сам этот указатель имеет тип указателя на базовый класс. Пусть, например, в классе TBase объявлена чистая виртуальная функция print:

class TBase //базовый класс для массивов всех типов

{int size, //размер элемента

count, //текущее число элементов

maxCount, //размер выделенной памяти в байтах

delta; //приращение памяти в байтах

char *pmem; //указатель на выделенную память

int changeSize(); //перераспределение памяти

protected:

 void* getAddr( ){return (void*) pmem;};

void addNewItem(void*); //добавление в конец массива

void error(const char* msg){cout <<msg<<endl;};

public:

int getCount() {return count;};

TBase(int s,int m,int d);

TBase();

TBase(TBase&);

~TBase();

virtual void print ( ) = 0; // Чистая виртуальная функция

};

Тогда в производных классах должна быть объявлена замещающая ее функция print, выполняющая реальные действия:

class TIntArray : public TBase

{ /* Другие методы */

virtual void print ( );

}

class TRealArray : public TBase

{ /* Другие методы */

virtual void print ( );

}

В программе, использующей объекты классов TIntArray и TRealArray могут создаваться экземпляры этих классов с возможностью обращения к ним через указатель на базовый класс:

TBase *pb;

TIntArray aint(5,3);

TRealArray areal(4,2);

Тогда для печати массивов могут применяться операторы

pb = &aint; pb->print(); //Печать массива aint

pb = &areal; pb->print(); // Печать массива areal

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

Программа:

#include <iostream.h>

struct Pet // Базовый класс

{ char *name;

virtual void speak() = 0;

Pet( char *nm){name=nm;}

}

struct Dog : public Pet

{ virtual void speak( ) { cout<<name<<“ говорит “”<<“ Ав - ав”<<endl; };

Dog(char *nm): Pet(nm) { };

};

struct Cat : public Pet

{ virtual void speak( ) { cout<<name<<“ говорит “

<<“ Мяу-Мяу”<<endl;

Cat(char *nm): Pet(nm) { };

}

int main ()

{ Pet *mypets[ ] = { new Dog(“Шарик”),

 new Cat(“Мурка”),

new Dog(“Рыжий “)}; // Список животных

const int sz = sizeof( mypets)/ sizeof( mypets [ 0 ]);

for ( int k = 0: k < sz; k++)

mypets [ k ]->speak();

return 0;

} 4.6. “Дружественные” (friend) функции

Функция, объявленная в производном классе, может иметь доступ только к защищенным (protected) или общим (public) компонентам базового класса.

Функция, объявленная вне класса, может иметь доступ только к общим (public) компонентам класса и обращаться к ним по имени, уточненному именем объекта или указателя на объект.

Чтобы получить доступ к личным компонентам объектов некоторого класса Х в функции, не имеющей к ним доступа, эта функция должна быть объявлена дружественной в классе X:

class X

{ friend void Y:: fprv( int, char*);

/* Другие компоненты класса X */

}

Можно объявить все функции класса Y дружественными в классе X;

class Y;

class X

{ friend Y;

/* Другие компоненты класса X */

}

class Y

{ void fy1(int, int);

int fy2( char*, int);

/* Другие компоненты класса Y */

}

Дружественной может быть и функция, не являющаяся компонентой какого-либо класса, например,

class XX

{ friend int printXX ( );

/* Другие компоненты класса ХХ */

}

Здесь функция printXX имеет доступ ко всем компонентам класса XX, независимо от закрепленного за ними уровня доступа.

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

4.7. Статические компоненты класса

Описатель static в С++ имеет различное назначение в зависимости от контекста, в котором он применен.

Переменные и функции, объявленные вне класса и вне тела функции с описателем static, имеют область действия, ограниченную файлом, в котором они объявлены.

Переменные, объявленные как static внутри функции, видимы только внутри этой функции, но сохраняют свои значения после выхода из функции и инициализируются только при первом обращении к функции.

Компоненты класса также могут объявляться с описателем static, такие компоненты - данные являются общими для всех экземпляров объектов этого класса и размещаются в памяти отдельно от данных объектов класса. Доступ к static - компонентам класса возможен по имени, уточненному именем класса (именем типа) или именем объекта этого класса, причем к static - компонентам класса можно обращаться до создания экземпляров объектов этого класса. Статическое данное - член класса должно быть обязательно инициализировано вне описания класса:

class TBase //базовый класс для массивов всех типов

{ static int nw;

 int size, //размер элемента

 count, //текущее число элементов

 maxCount, //размер выделенной памяти

 delta; //приращение памяти

/* Другие компоненты класса TBase */

 }

 int TBase::nw =1; /* Инициализация статической компоненты класса */

Статические компоненты - функции могут вызываться до создания экземпляров объектов этого класса и поэтому имеют доступ только к статическим данным класса:

class X

{ static int sx1,sx2;

static void fsx ( int k);

 int x1,x2;

 /* Другие компоненты класса X */

}

int X::sx1 = 1;

 int X::sx2 = 2;

int main ()

{ ..........

X:: fsx( 3 );

..............

} 4.8. Переопределение (перегрузка) операций

В языках программирования определена семантика операций, выполняемых над базовыми (предопределенными) типами данных, например, если x, y и z - переменные типа float, то запись x = y + z; предполагает интуитивно очевидные действия, сложение x и y и присваивание переменной z полученной суммы.

Желательно было бы и для типов, определяемых в программе, в том числе для классов, определить семантику и алгоритмы операций сложения, вычитания, умножения и т.д., чтобы иметь возможность вместо вызова соответствующих функций записывать просто x + y и в случае, когда x и y являются объектами некоторых классов. В C++ это достигается переопределением имеющихся в языке операций для других типов данных.

Переопределенная операция объявляется так:

тип_результата operator знак_операции (формальные параметры)

{ описание_алгоритма_выполнения_операции }

Например:

class TPoint

{ int x,y;

public:

TPoint& operator+=( const TPoint& adder );

TPoint& operator-=( const TPoint& subber );

friend TPoint operator - ( const TPoint& one, const TPoint& two);

friend TPoint operator + ( const TPoint& one, const TPoint& two);

friend int operator == ( const TPoint& one, const TPoint& two);

friend int operator != ( const TPoint& one, const TPoint& two);

};

Полное определение этих операций для объектов класса TPoint имеет вид:

inline TPoint& TPoint::operator += ( const TPoint& adder )

{ x += adder.x; y += adder.y; return *this;}

 inline TPoint& TPoint::operator -= ( const TPoint& subber )

 { x -= subber.x; y -= subber.y; return *this;}

Остальные операции определяются аналогичным образом.

Пусть в программе имеются объявления:

TPoint x(12,3), y(21,30), z(18,30);

Тогда можно записать:

x +=y; y-=z; TPoint r = x + z:

Общие правила переопределения операций сводятся к следующему:

- Двуместные операции должны иметь два параметра, одноместные - один параметр, причем, если операция объявлена как компонента класса, то неявным первым операндом является экземпляр объекта (следовательно при определении двуместной операции будет задаваться один параметр, одноместная операция объявляется с пустым списком параметров). Если операция переопределяется вне класса (с описателем friend ), то для двуместной операции должны быть заданы два параметра, для одноместной операции - один параметр.

- При переопределении сохраняется приоритет исходной операции т.е. операция + будет выполняться раньше операции = и т.д.

- При переопределении не наследуются свойства коммутативности и ассциативности, т.е. результат выражения х + y - z может отличаться от результата выражения y - z + x и зависит от того, как определены соответствующие операции.

- Не допускается переопределение операций . (точка), .* ( точка -звездочка, обращение к указателю на компоненту класса или структуры), :: (разрешение контекста), а также операции # и ##, используемые при препроцессорной обработке.

- Переопределяемые операции = (присваивание), () (функция), [ ] (индекс), -> (обращение к компоненте класса по указателю) всегда должны быть компонентами класса и не могут быть static.

- Переопределяемые операции new и delete должны быть static - компонентами класса.

В остальном к переопределяемым операциям предъявляются те же требования, что и к функциям.

5. Шаблоны функций и классов 5.1. Шаблоны функций

Часто встречаются функции, реализующие одни и те же действия для аргументов различных типов. Например, сортировка массива по возрастанию его элементов может выполняться одним и тем же методом и для данных типа int и для данных типа double. Различие состоит только в типах параметров и некоторых внутренних переменных.

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

template < class имя_класса >

Заголовок функции

{ /* Тело функции */ }

Имя класса является параметром и задается идентификатором, локализованным в пределах определения функции. Хотя бы один из параметров функции должен иметь тип, соответствующий этому идентификатору.

Параметризованное определение функции сортировки массива методом перестановок может быть построено следующим образом:

template <class T >

void sort ( T a[ ], int n )

{ T temp;

int sign;

for ( int k = 0; k > n; k++)

{ sign = 0;

for ( i = 0; i <n - k; i++)

if ( a [ i ] > a [ i + 1])

{ temp = a [ i ];

a[ i ] = a[ i + 1 ];

a[ i + 1 ] = temp; sign++;

}

if ( sign == 0 ) break;

}

return;

}

Если в программе будут объявлены массивы

int aint [10];

double afl [20]; и установлены значения элементов этих массивов, то вызов функции

sort ( aint, 10 ); обеспечит вызов sort для упорядочения массива целых, а вызов функции

sort ( afl , 20 ) обеспечит вызов sort для упорядочения массива с элементами типа double.

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

В описателе template можно указывать несколько параметров вида class имя_типа, а также параметры базовых типов. Например, функция

template < class T1, class T2 >

void copy ( T1 a[ ], T2 b[ ], int n)

{ for ( int i = 0; i <n; i++)

a[ i ] = b [ i ] ;

} копирует первые n элементов массива b типа T2 в первые n элементов массива a типа T1. Разумеется, программист несет ответственность за то, чтобы такое копирование было возможным. 5.2. Шаблоны классов

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

template <class T >

class описание класса

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

В качестве примера приведем описание класса stack, предназначенного для построения стеков фиксированного максимального размера с элементами произволного типа.

enum BOOLEAN ( FALSE, TRUE );

template <class Type >

class stack

{ private:

enum ( EMPTY = -1 );

Type* s; /* Указатель на массив стека */

int max_len; /* Максимальная длина стека */

int top; /* Индекс элемента в вершине стека */

public:

stack ( ) : max_len ( 100 ) /* конструктор без параметров */

{ s = new Type [ 100 ]; top = EMPTY; }

stack ( int size ) : max_len( size ) /* Второй конструктор */

{ s = new Type [ size ]; top = EMPTY; }

~stack ( ) { delete [ ] s; } /* Деструктор */

void reset ( ) { top = EMPTY; } /* Очистить стек */

void push ( Type c ) { s [ ++top ] = c; }

Type pop ( ) { return (s [top—] }

Type top_of ( ) { return ( s [top ] }

BOOLEAN empty ( ) { return BOOLEAN ( top == EMPTY ) }

BOOLEAN full ( ) { return BOOLEAN ( top == max_len ) }

};

Следует отметить, что в этом примере с целью сокращения исходного текста не предусмотрен контроль выхода за пределы стека в методах push и pop.

Чтобы создать экземпляр параметризованного объектного типа, нужно уточнить имя типа значением параметра в угловых скобках:

stack < int > stack_of_int (50); /* Стек на 50 элементов типа int */

stack < myClass > stmc (20); /* Стек на 20 элементов типа myClass */

В приведенном примере все компоненты-функции определены в описании класса. Когда полное определение функции-члена класса задается вне описания класса, оно должно уточняться описателем template. Например, если бы метод top_of был определен вне описания класса, определение имело бы вид:

template < class Type >

Type top_of ( ) { return s [ top ];}

Отметим некоторые специфические черты описаний параметризованных классов.

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

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

6. Классы для ввода-вывода потоков 6.1. Система классов ввода-вывода

Система ввода-вывода С++ основывается на концепции потоков данных, поток представляет собой, с одной стороны, последовательность данных, с другой стороны поток рассматривается как переменная некоторого объектного типа. Это позволяет вынести общие свойства и операции процессов ввода-вывода в определения базовых классов. Ввод-вывод из файлов и консоли, как правило, выполняется с использованием буфера и получение данных программой или вывод данных сводится к пересылке данных из одной области памяти в другую. Реальное обращение к внешним устройствам происходит только при исчерпании данных в буфере (при вводе) или при заполнении буфера (при выводе).

Система классов ввода-вывода С++ использует два базовых класса: класс ios и класс streambuf.

В классе ios определены данные, характеризующие состояние потока, и функции, позволяющие получить доступ к информации о состоянии потока или изменить его состояние. Состояние потока определяется набором битовых флагов, для обращения к отдельным флагам в классе ios описаны перечислимые константы:

- биты состояния (статуса) потока

enum io_state { goodbit = 0x00, // никакие биты не установлены, все хорошо

eofbit = 0x01, // конец файла

failbit = 0x02, // ошибка в последней операции ввода/вывода

badbit = 0x04, // попытка выполнить неверную операцию

hardfail = 0x80 // неисправимая ошибка

};

- биты режима использования потока (режима ввода/вывода)

enum open_mode { in = 0x01, // поток открыт для чтения

out = 0x02, // поток открыт для записи

ate = 0x04, // перейти в конец файла при открытии

app = 0x08, // режим добавления в конец файла

trunc = 0x10, // усечение существующего файла

nocreate = 0x20, // ошибка открытия файла, если он не существует

noreplace = 0x40, // ошибка открытия, если файл существует

binary = 0x80 // двоичный (не текстовый) файл

};

- флаги направления позиционирования в потоке

enum seek_dir { beg=0, cur=1, end=2 };

- флаги - манипуляторы управления вводом/выводом

enum { skipws = 0x0001, // пропускать пробелы при вводе

left = 0x0002, // выравнивание влево при выводе

right = 0x0004, // выравнивание вправо при выводе

internal = 0x0008, // пробел после знака или основания системы счисления

dec = 0x0010, // преобразование в десятичную систему счисления

oct = 0x0020, // преобразование в восьмеричную систему счисления

 hex = 0x0040, // шестнадцатеричное преобразование

showbase = 0x0080, // использовать индикатор системы счисления при выводе

showpoint = 0x0100, // указывать десятичную точку при выводе

//(в числах с плавающей точкой)

uppercase = 0x0200, // прописные буквы при шестнадцатеричном выводе

showpos = 0x0400, // добавлять '+' для положительных целых

scientific= 0x0800, // применять нотацию вида 1.2345E2

 fixed = 0x1000, // применять нотацию вида 123.45

 unitbuf = 0x2000, // очищать все потоки после вставки в поток

stdio = 0x4000, // очищать stdout, stderr после вставки в поток

boolalpha = 0x8000 // вставлять/извлекать булевы как текст или цифры

};

Поскольку эти перечислимые константы объявлены как компоненты класса ios, для доступа к ним требуется уточнение контекста, например, ios::in.

Класс streambuf обеспечивает создание и использование буфера ввода-вывода и содержит компоненты-данные для управления буфером и методы доступа к данным в буфере. Объект класса ios содержит указатель на связанный с ним объект streambuf.

Классы istream и ostream являются производными от класса ios, в них определены функции, выполняющие ввод (istream) и вывод (ostream) данных базовых типов и строк.

В классе istream определены операции бесформатного ввода (без преобразования вводимых данных)и операции форматного ввода с преобразованием из внешнего представления во внутреннее.

Функции get() читают из потока данные типа char в массив, определяемый первым параметром, второй параметр задает максимальное число вводимых символов (l), третий параметр устанавливает символ-ограничитель, ограничивающий ввод. За последним введенным символом в массив пишется символ ‘\0’.

istream _FAR & _RTLENTRY get( char _FAR *, int l, char = '\n');

istream _FAR & _RTLENTRY get( signed char _FAR *, int l, char = '\n');

istream _FAR & _RTLENTRY get( unsigned char _FAR *, int l, char ='\n');

Функции read() выполняют чтение из потока и занесение в массив указанного числа символов

istream _FAR & _RTLENTRY read( char _FAR *, int l);

istream _FAR & _RTLENTRY read( signed char _FAR *, int l);

istream _FAR & _RTLENTRY read(unsigned char _FAR *, int l);

Для ввода строки, заканчивающейся символом-ограничителем, служит функция getline() при этом символ-ограничитель также заносится в массив

istream _FAR & _RTLENTRY getline( char _FAR *, int, char = '\n');

istream _FAR & _RTLENTRY getline( signed char _FAR *, int, char= '\n');

istream _FAR & _RTLENTRY getline(unsigned char _FAR *, int, char= '\n');

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

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

Другие варианты функции get() обеспечивают извлечение одного символа

istream _FAR & _RTLENTRY get( char _FAR &);

istream _FAR & _RTLENTRY get( signed char _FAR &);

istream _FAR & _RTLENTRY get(unsigned char _FAR &);

int _RTLENTRY get(); // возвращает значение символа

int _RTLENTRY peek(); // возвращает следующий символ без удаления его из потока

int _RTLENTRY gcount(); // число символов, извлеченных из потока

// возвращение указанного символа в поток ввода

istream _FAR & _RTLENTRY putback(char);

Пропуск символов с остановкой по ограничителю выполняет функция

istream _FAR & _RTLENTRY ignore(int = 1, int = EOF);

Форматный ввод релизуется на основе переопределения операций ввода

istream _FAR & _RTLENTRY operator>> (bool _FAR &);

istream _FAR & _RTLENTRY operator>>

(istream _FAR & (_RTLENTRY *_f)(istream _FAR &));

istream _FAR & _RTLENTRY operator>>

(ios _FAR & (_RTLENTRY *_f)(ios _FAR &) );

istream _FAR & _RTLENTRY operator>> ( char _FAR *);

istream _FAR & _RTLENTRY operator>> ( signed char _FAR *);

istream _FAR & _RTLENTRY operator>> (unsigned char _FAR *);

istream _FAR & _RTLENTRY operator>> ( char _FAR &);

istream _FAR & _RTLENTRY operator>> ( signed char _FAR &);

istream _FAR & _RTLENTRY operator>> (unsigned char _FAR &);

istream _FAR & _RTLENTRY operator>> (short _FAR &);

istream _FAR & _RTLENTRY operator>> (int _FAR &);

istream _FAR & _RTLENTRY operator>> (long _FAR &);

istream _FAR & _RTLENTRY operator>> (unsigned short _FAR &);

istream _FAR & _RTLENTRY operator>> (unsigned int _FAR &);

istream _FAR & _RTLENTRY operator>> (unsigned long _FAR &);

istream _FAR & _RTLENTRY operator>> (float _FAR &);

istream _FAR & _RTLENTRY operator>> (double _FAR &);

istream _FAR & _RTLENTRY operator>> (long double _FAR &);

Извлечение из istream и вставка в объект типа streambuf выполняет оператор-функция

istream _FAR & _RTLENTRY operator>> (streambuf _FAR *);

Макрос FAR управляет способом представления указателей, макрос RTLENTRY определяет применение стандартной билиотеки времени выполнения.

Аналогичные операции для вывода определены в классе ostream:

// вставить символ в поток

ostream _FAR & _RTLENTRY put( char);

ostream _FAR & _RTLENTRY put(signed char);

ostream _FAR & _RTLENTRY put(unsigned char);

// вставить в поток строку

ostream _FAR & _RTLENTRY write(const char _FAR *, int l);

ostream _FAR & _RTLENTRY write(const signed char _FAR *, int l);

ostream _FAR & _RTLENTRY write(const unsigned char _FAR *, int l);

Операции форматированного вывола

Вывод "true" или "false" для данных типа bool

ostream _FAR & _RTLENTRY ostream::operator<< (bool);

Вывод ланных типа char

ostream _FAR & _RTLENTRY operator<< ( char);

ostream _FAR & _RTLENTRY operator<< ( signed char);

ostream _FAR & _RTLENTRY operator<< (unsigned char);

Вывод числовых данных с преобразованием во внешнее представление

ostream _FAR & _RTLENTRY operator<< (short);

ostream _FAR & _RTLENTRY operator<< (unsigned short);

ostream _FAR & _RTLENTRY operator<< (int);

ostream _FAR & _RTLENTRY operator<< (unsigned int);

ostream _FAR & _RTLENTRY operator<< (long);

ostream _FAR & _RTLENTRY operator<< (unsigned long);

ostream _FAR & _RTLENTRY operator<< (float);

ostream _FAR & _RTLENTRY operator<< (double);

ostream _FAR & _RTLENTRY operator<< (long double);

Вывод строк, оканчивающихся нулевым байтом

ostream _FAR & _RTLENTRY operator<< (const char _FAR *);

ostream _FAR & _RTLENTRY operator<< (const signed char _FAR*);

ostream _FAR & _RTLENTRY operator<< (const unsigned char _FAR*);

Вывод значения указателя в символьном формате

ostream _FAR & _RTLENTRY operator<< (void _FAR *);

Извлечение данных их объекта streambuf и вставка в тот же ostream

ostream _FAR & _RTLENTRY operator<< (streambuf _FAR *);

Вывод значений манипуляторов

ostream _FAR & _RTLENTRY operator<<

(ostream _FAR & (_RTLENTRY *_f)(ostream _FAR &));

ostream _FAR & _RTLENTRY operator<<

(ios _FAR & (_RTLENTRY *_f)(ios _FAR &));

Имеется также класс iostream, производный от класса ios и объединяющий возможности классов istream и ostream.

Для рассмотренных выше классов отсутствуют конструкторы копирования и операция присваивания, точнее, они объявлены, но не определены. Для тех случаев, когда конструктор копирования и операция присваивания необходимы, предусмотрены классы istream_withassign, ostream_withassign и iostream_withassign. Как экземпляры объектов этих классов всегда объявляется объект cin (экземпляр istream_withassign), обычно предназначенный для ввода с клавиатуры, и объекты cout, cerr и clog (экземпляры ostream_withassign), обычно предназначенные для вывода на экран.

Ввод-вывод для дисковых файлов обепечивается классами, описания которых содержатся в файле fstream.h.

Класс filebuf, производный от streambuf, предназначен для добавления в streambuf дополнительных средств управления буфером ввода-вывода.

Класс fstreambase, производный от класса ios, служит базой для остальных классов, обеспечивающих файловый ввод-вывод, в нем определены методы:

void _RTLENTRY open(const char _FAR *, int, int = filebuf::openprot);

void _RTLENTRY attach(int);

void _RTLENTRY close();

void _RTLENTRY setbuf(char _FAR *, int);

Назначение этих методов очевидным образом следует из их названий.

Для непосредственной работы с файлами служат классы ifstream, ofstream и fstream, базой для них служат классы fstreambase и, соответственно, istream, ostream и iostream.

6.2. Вывод в файл. Ввод из файла

Для вывода данных в дисковый файл в программе должна присутствовать директива препроцессора

#include <fstream.h> подключающая описания необходимых классов.

Прежде чем выводить данные необходимо создать объект типа ofstream, для которого имеется несколько конструкторов:

_RTLENTRY ofstream(); // Пустой объект, без привязки к файлу

// С привязкой к файлу, полное имя которого задается первым аргументом:

_RTLENTRY ofstream(const char _FAR *, int = ios::out,

int = filebuf::openprot);

// С привязкой к ранее открытому файлу, заданному своим дескриптором

_RTLENTRY ofstream(int);

// То же, что и предыдущий вариант, но задается новый буфер вывода

_RTLENTRY ofstream(int __f, char _FAR *, int);

Наиболее часто оказывается полезным второй вариант конструктора, в котором указывается только первый параметр - полное имя файла. Этот конструктор создает объект типа ofstream, открывает указанный файл и присоединяет его к потоку вывода.

Собственно операции вывода реализуются вызовом методов put, write или с использованием переопределенных операций <<.

Аналогичным способом обеспечивается и ввод из файла: создается объект типа ifstream и для ввода применяются методы get, read или переопределенные операции >>.

Для типа ifstream имеется набор аналогичных конструкторов:

_RTLENTRY ifstream();

_RTLENTRY ifstream(const char _FAR *,int = ios::in,

int = filebuf::openprot);

_RTLENTRY ifstream(int);

_RTLENTRY ifstream(int __f, char _FAR *, int);

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

#include <fstream.h>

#include <process.h> // Для вызова exit

int main ( int argc, char* argv [ ] )

{ char ch;

if ( argc != 3 ) // Проверка числа аргументов

{ cerr << “ Вызов dcopy файл1 файл2 \n” ; exit ( 1 ) ; }

ifstream source( argv [ 1 ] ) ; // Входной поток

if ( ! source )

{ cerr << “ Нельзя открыть входной файл “ << argv [ 1 ] ;

exit ( 1 ); }

ofstream dest ( argv [2 ] ) ;

if ( ! dest )

{ cerr << “ Нельзя открыть выходной файл “ << argv [ 2 ] ;

exit ( 1 ); }

while ((ch = source.get ( ) ) != EOF )

dest.put( ch );

close ( source ); close ( dest );

return 0 ;

} 6.3. Ввод-вывод данных объектных типов

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

Для вывода объекта в файл в определение класса может быть включена функция-компонента с параметром ссылкой на объект типа ostream. Часто такой функции назначают имя print или printon. Более изящным считается переопределение оператора << для вывода объектного данного. Если компоненты-данные объекта имеют уровень доступа protected или private, а оператор << не является компонентой класса, его следует объявить как friend-метод.

Пусть, например, в программе определен класс complex:

class complex

{ double re, im ;

public:

complex (double r =0, double i =0 ): re ( r ), im ( i )

{ } // конструктор

double real ( ) {return ( re ); }

double image ( ) { return ( im ); }

/* другие методы */

}

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

ostream& operator << ( ostream& s, complex c )

{ int old_precision = s.precision ( 4 ); // установка числа дробных цифр

s << “(“ << c.real( ) <<

“, “ << c.image( ) << “)” ;

s.precision ( old_precision ) ; // восстановление числа дробных цифр

return ( s );

}

В данном случае в переопределении << нет обращения к личным переменным класса Complex. Если не использовать методы real и image, переопределение << нужно было бы включить в описание класса Complex с описателем friend.

Ввод объектного данного из файла или стандартного потока организуется аналогично: либо в определение класса включается функция-компонента для инициализации компонент данных их входного потока, либо переопределяется операция >> для ввода компонент-данных из потока. В некоторых случаях оказывается более удобным включить в описание класса дополнительный конструктор с параметром-ссылкой на объект типа istream, при этом все базовые классы должны иметь аналогичные конструкторы.

Пусть в описание класса Complex включена переопределенная операция >>:

class complex

{ double re, im ;

public:

complex (double r =0,double i=0 ): re( r ), im( i ) { } // конструктор

double real ( ) {return ( re ); }

double image ( ) { return ( im ); }

friend istream& operator >> ( istream& , Complex& );

/* другие методы */

}

Если предположить, что комплексные числа поступают из потока либо в виде вещественного числа, возможно заключенного

в скобки, либо в виде пары чисел, разделенных запятой и заключенной в скобки,

то переопределяемую операцию ввода можно описать следующим образом:

istream& operator >> ( istream& s, Complex& c )

{ double re_n = 0, im_n = 0;

char ch = 0;

s >> ch ;

if ( ch == ‘(‘ )

{ s >> re_n >> ch ;

if ( ch == ‘,’ ) s >> im_n >> ch;

if ( ch != ‘)’) s.clear ( ios::failbit ); //Установка признака ошибки

}

else { s.putback ( ch ); s >> re_n ; }

if ( s ) { c.re = re_n; c.im = im_n; } // Если не было ошибки

return ( s );

}

Рассмотренные выше примеры сохранения объектов

в потоке и восстановления их из потока иллюстрируют наиболее простые варианты

этих операций. Проблема сохранения объектов в потоке существенно усложняется,

когда требуется сохранять в одном потоке объекты разных типов, когда между

объектами разных типов имеются ссылки и некоторый объект содержит указатель

на объект другого типа, причем на один и тот же объект могут ссылаться

несколько других объектов. В этой ситуации требуется для каждого сохраняемого

в потоке объекта заносить в поток идентификатор типа объекта, гарантировать,

что каждый объект, на который имеются ссылки из других объектов, будет

помещен в поток только один раз. Средства для разрешения этих проблем имеются

в библиотеке классов-контейнеров classlib, содержащей

файл objstrm.h с определениями необходимых

классов и макросов.

Приложение 1. Задачи по программированию на Си

1. Составить функцию для подсчета числа серий положительных, отрицательных чисел и нулей длиной не менее К в одномерном массиве целых чисел. Серией называется последовательность элементов массива, принадлежащих одному классу:

int series ( int n, int *mas, int *kzero, int *kplus, int *kminus, int k);

2. Составить функцию для слияния двух упорядоченных по возрастанию массивов целых чисел:

int merge (int n, int m, int *mas1, int *mas2, int *res);

3. Составить функцию для построения списка индексов (номеров), строк упорядоченного по возрастанию элементов заданного (k-го) столбца матрицы. Элементы матрицы - целые числа:

void sort (int n, int *mas, int k, int* index);

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

a[k,l] = max min{ a[i,j] } = min max { a[i,j] }

i<=n,j<=m j<=m,i<=n

Если седловой точки нет, установить k=l=-1

5. Составить функцию для подсчета количества различных чисел в массиве, содержащем n целых чисел.

int count(int *a, int n);

6. Составить функцию для разделения текста, заданного строкой литер, на отдельные слова и подсчета числа слов. Под словом понимается последовательность литер, отличных от пробела, ограниченная слева началом строки или пробелом и справа - пробелом, знаком препинания или концом строки.

int kwords(char* ss, char * sm, int kmax);

ss - исходная строка,

sm - массив строк длиной до 30 литер каждая (для размещения выделенных слов),

kmax - максимальное количество выделенных слов.

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

7. Составить функцию для определения

а) наибольшего простого числа, не превосходящего заданное целое n,

б) наименьшего простого числа, превосходящего заданное n.

int simple (int n);

8. Составить функцию для разложения заданного целого числа на простые множители. Результатом функции должен быть массив, содержащий простые множители, и целое число - количество множителей.

 int simplefactor(int n, int *masfactor);

9. Составить функцию для вычисления числа сочетаний из n злементов по m (n и m - целые):

Cnm = n! / ((n-m)! * m!)

Результатом функции должно быть целое число, если Cnm < 32767 и булевское значение true, или вещественное число, если Cnm >=32767 и булевское значение false.

Boolean binom (int n, int m, int *cnm, double *dcnm);