Производные классы

Дружественные функции и перегрузка операций.

Функции-друзья. Перегрузка бинарных и унарных операций. Перегруженные операции индексирования, вызова функций, инкремента и декремента префиксных и постфиксных. Перегрузка new, delete. Преобразование типов, определяемых пользователем с помощью конструкторов и операций преобразования. Неявное преобразование типов. Друзья-функции и друзья-классы.

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

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

class A{

int x; // Личная часть класса

...

friend class B; // Функции класса B дружественны A

// (имеют доступ к приватной части A)

friend void C::fun(A&);// Элемент-функция fun класса C имеет

// доступ к приватной части A

friend void xxx(A&,int);// Функция xxx дружественна классу A

friend void C::operator+(А&);

// Переопределяемая в классе C операция

}; // <объект C>+<объект A> дружественна

// классу A

class B // Необходим доступ к личной части A

{

public: int fun1(A&);

void fun2(A&);

};

class C

{

public: void fun(A&);

void operator+(A&);

};

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

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

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

+ - * / % ^ & | ~!

= < > += -= *= /= %= ^= &=

|= << >> >>= <<= ==!= <= >= &&

|| ++ -- [] () new delete

Последние четыре - это индексирование, вызов функции, выделение свободной памяти и освобождение свободной памяти. Изменить приоритеты перечисленных операций невозможно, как невозможно изменить и синтаксис выражений. Нельзя, например, определить унарную операцию % или бинарную!. Невозможно определить новые лексические символы операций, но в тех случаях, когда множество операций недостаточно, вы можете использовать запись вызова функции. Используйте например, не **, а pow(). Эти ограничения могут показаться драконовскими, но более гибкие правила могут очень легко привести к неоднозначностям. Например, на первый взгляд определение операции **, означающей возведение в степень, может показаться очевидной и простой задачей, но подумайте еще раз. Должна ли ** связываться влево (как в Фортране) или вправо (как в Алголе)? Выражение a**p должно интерпретироваться как a*(*p) или как (a)**(p)? Имя функции операции есть ключевое слово operator (то есть, операция), за которым следует сама операция, например, operator<<. Функция операция описывается и может вызываться так же, как любая другая функция. Использование операции - это лишь сокращенная запись явного вызова функции операции. Например:

void f(complex a, complex b)

{

complex c = a + b; // сокращенная запись

complex d = operator+(a,b); // явный вызов

}

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

operator операция(список_параметров-операндов)

Имя функции состоит из ключевого слова operator и символа данной операции в синтаксисе языка Си. Список формальных параметров функции соответствует списку операндов, определяя их типы и способы передачи. Результат функции (тип, способ передачи) является одновременно результатом переопределенной операции.

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

· если функция задается как обычная функция-элемент класса, то первым операндом операции является объект класса, указатель на который передается неявным параметром this;

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

Естественно, что полное имя такой функции не содержит имени класса.

Бинарная операция может быть определена или как функция член, получающая один параметр, или как функция друг, получающая два параметра. Таким образом, для любой бинарной операции @ aa@bb может интерпретироваться или как aa.operator@(bb), или как operator@(aa,bb). Если определены обе, то aa@bb является ошибкой. Унарная операция, префиксная или постфиксная, может быть определена или как функция член, не получающая параметров, или как функция друг, получающая один параметр. Таким образом, для любой унарной операции @ aa@ или @aa может интерпретироваться или как aa.operator@(), или как operator@(aa). Если определена и то, и другое, то и aa@ и @aa являются ошибками. Рассмотрим следующие примеры:

class X {

// друзья

friend X operator-(X); // унарный минус

friend X operator-(X,X); // бинарный минус

friend X operator-(); // ошибка: нет операндов

friend X operator-(X,X,X); // ошибка: тернарная

// члены (с неявным первым параметром: this)

X* operator&(); // унарное & (взятие адреса)

X operator&(X); // бинарное & (операция И)

X operator&(X,X); // ошибка: тернарное

};

Необходимо отметить также и тот факт, что для каждой комбинации типов операндов в переопределяемой операции необходимо ввести отдельную функцию, то есть транслятор не может производить перестановку операндов местами, даже если базовая операция допускает это. Например, при переопределении операции сложения объекта класса dat с целым необходимо две функции dat+int и int+dat.

В качестве примера рассмотрим доопределение стандартных операций над датами:

static int days[]={ 0,31,28,31,30,31,30,31,31,30,31,30,31};

class dat {

int day,month,year;

public:

void next(); // Элемент-функция вычисления следующего дня

dat operator++(); // Операция ++

dat operator+(int);// Операция "дата + целое" с передачей

// первого операнда через this

friend dat operator+(int,dat);// Операция с явной передачей всех

//аргументов по значению

dat(int=0,int=0,int=0);

dat(char *); //

~dat(); //

}; //

//------ Функция вычисления следующего дня -----------------

// Используется ссылка на текущий объект this,

// который изменяется в процессе операции

void dat::next()

{

day++;

if (day > days[month])

{

if ((month==2) && (day==29) && (year%4==0)) return;

day=1; month++;

if (month==13)

{

month=1; year++;

}

}

}

//------ Операция инкремента даты -------------------------

// 1. Первый операнд по указателю this

// 2. Возвращает копию входного объекта (операнда)

// до увеличения

// 3. Соответствует операции dat++ (увеличение после

// использования)

// 4. Замечание: для унарных операций типа -- или ++

// использование их до или после операнда не имеет

// значения (вызывается одна и та же функция).

dat dat::operator++()

{ // Создается временный объект

dat x = *this; // В него копируется текущий объект

dat::next(); // Увеличивается значение текущего объекта

return(x); // Возвращается временный объект по

} // значению

//------ Операция "дата + целое" --------------------------

// 1. Первый операнд по указателю this

// 2. Входной объект не меняется, результат возвращается

// в виде значения автоматического объекта x

dat dat::operator+(int n)

{

dat x;

x = *this; // Копирование текущего объекта в x

while (n--!=0) x.next();// Вызов функции next для объекта x

return(x); // Возврат объекта x по значению

}

//------ Операция "целое + дата" -------------------------

// 1. Дружественная функция с полным списком операндов

// 2. Второй операнд класса dat - передается по значению,

// поэтому может модифицироваться без изменения исходного

// объекта

dat operator+(int n, dat p)

{

while (n--!=0) p.next(); // Вызов функции next для p

return(p); // Возврат копии объекта p

}

void main()

{

int i;

dat a, b(17,12,1990), c(12,7), d(3), e;

dat *p = new dat[10];

e = a++;

d = b+15;

for (i=0; i<10; i++) p[i] = p[i] + i;

delete[10] p;

}

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

//------ Операция "дата + целое" --------------------------

// 1. Функция с неявным первым операндом по указателю this

// 2. Меняется значение текущего объекта

// 3. Результат - ссылка на текущий объект

dat& dat::operator+(int n)

{

while (n--!=0) next(); // Вызов next с текущим объектом

return(*this); // Возврат ссылки на объект this

}

//------ Операция "дата + целое" -------------------------

// 1. Дружественная функция с полным списком аргументов

// 2. Первый операнд класса dat - ссылка, меняется при

// выполнении операции

// 3. Результат - ссылка на операнд

dat& operator+(dat& p,int n)

{

while (n--!=0) p.next(); // Вызов next для объекта p,

// заданного ссылкой

return(p); // Возврат ссылки на p

}

//----- Операция "целое + дата" --------------------------

// 1. Дружественная функция с полным списком аргументов

// 2. Второй операнд класса dat - ссылка, меняется при

// выполнении операции

// 3. Результат - ссылка на операнд

//--------------------------------------------------------

dat& operator+(int n, dat& p)

{

while (n--!=0) p.next(); // Вызов next для объекта p,

// заданного ссылкой

return(p); // Возврат ссылки на p

}

void main()

{

dat a,b; // "Арифметические" эквиваленты

a + 2 + 3; // a = a + 2; a = a + 3;

5 + b + 4; // b = 5 + b; b = b + 4;

}

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

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

//------ Операция "дата + целое" --------------------------

// 1. Функция с неявным первым операндом по указателю this

// 2. Изменяется автоматический объект - копия операнда

// 3. Результат - значение автоматического объекта

dat dat::operator+(int n)

{

dat tmp = *this; // Объект - копия операнда

while (n--!=0) tmp.next();// Вызов next с объектом tmp

return(tmp); // Возврат значения объекта tmp

}

//------ Операция "дата + целое" -------------------------

// 1. Дружественная функция с полным списком аргументов

// 2. Первый параметр класса dat передается по значению,

// является копией первого операнда и меняется при

// выполнении операции

// 3. Результат - значение формального параметра

dat operator+(dat p,int n)

{

while (n--!=0) p.next(); // Вызов next для объекта p,

// копии операнда

return(p); // Возврат значения

} // формального параметра

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

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

class string

{

char *Str;

int size;

public:

string &operator =(string&);

};

string &string::operator=(string& right)

{

if (Str!=NULL) delete Str;// Освободить динамическую память

size = Str.right.size; // Резервировать память

Str = new char[size];

strcpy(Str,right->Str); // Копировать строки

}

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

//------Переопределение операций [] и ()

#include <string.h>

class string // Строка переменной длины

{

char *Str; // Динамический массив символов

int size; // Длина строки

public:

string operator()(int,int); // Операция выделения подстроки

char operator[](int); // Операция выделения символа

int operator[](char*); // Операция поиска подстроки

};

//------ Операция выделения подстроки -------------------

string string::operator()(int n1, int n2) {

string tmp = *this;

delete tmp.Str;

tmp.Str = new char[n2-n1+1];

strncpy(tmp.Str, Str+n1, n2-n1); }

Пример переопределения операции инкремента приведен выше. Переопределение декремента производится аналогично. Заметим только, что когда операции ++ и -- перегружены, префиксное использование и постфиксное в классическом С++ различить невозможно. В современной версии языка (Microsoft Visual C++ 6.0) принято соглашение, что перегрузка префиксных операций ++ и -- ничем не отличаются от перегрузки других унарных операций, то есть дружественные функции operator++() и operator--() с одним параметром некоторого класса определяют префиксные операции ++ и --. Операции - члены класса без параметров определяют те же префиксные операции. При расширении действия постфиксных операций ++ и – операции-функции должны иметь еще один дополнительный параметр типа int. Если для перегрузки используется операция - член класса, то она должна иметь один параметр типа int. Если операция определена как дружественная функция, то ее первый параметр должен иметь тип класса, а второй - тип int. Когда в программе используется соответствующее постфиксное выражение, то операция - функция вызывается с нулевым целым параметром.

Рассмотрим пример применения разных операций - функций для постфиксной и префиксной операций ++ и --.

class pair // класс «пара чисел»

{ int N; // целое

double x; // вещественное

friend pair& operator ++ (pair&); //дружественная для префикса

friend pair& operator ++(pair&,int);//дружественная для постфикса

public:

pair (int n, double xn) //конструктор

{ N = n; x = xn; }

void display () //вывод значения

{ printf (”N = % d x = % f\n”, N, x); }

pair & operator –- () //член для префикса

{ N /= 10; x /= 10; return *this; }

pair & operator –- (int k) //член для постфикса

{ N /= 2; x /= 2; return *this; }

};

pair & operator ++ (pair & P) // дружественная для префикса

{ P.N *= 10; P.x *= 10; return P; }

pair & operator ++ (pair & P, int k)// дружественная для постфикса

{ P.N = P.N * 2 + k; P.x = P.x * 2 + k; return P; }

void main ()

{ pair Z (10, 20.0); //вызов конструктора

Z.display(); //N = 10 x = 20

++Z; Z.display(); //N = 100 x = 200

--Z; Z.display(); //N = 10 x = 20

Z++; Z.display(); //N = 20 x = 40

Z--; Z.display(); //N = 10 x = 20

}

Для демонстрации полной независимости смысла перегруженной операции от ее традиционного значения в операциях - функциях для префиксных операций ++ соответствует увеличению в 10 раз, а –- уменьшению в 10 раз. Для постфиксных операций ++ определена как увеличение в 2 раза, а -- уменьшение в 2 раза. Попытки использовать в постфиксных операциях значение дополнительного параметра int k подтверждают его равенство 0.

Вопрос №4 Перегрузка new, delete. Операции создания и уничтожения объектов в динамической памяти могут быть переопределены следующим образом

void *operator new(size_t size);

void operator delete (void *);

где void * - указатель на область памяти, выделяемую под объект, size - размер объекта в байтах, size_t - тип размерности области памяти, int или long.

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

Операции, не допускающие перегрузки. В С++ существует несколько операций, не допускающих перегрузки:

. прямой выбор члена объекта класса;

.* обращение к члену через указатель на него;

?: условная операция;

:: операция указания области видимости;

sizeof операция вычисления размера в байтах;

# препроцессорная операция.

Вопрос №5 Преобразование типов, определяемых пользователем с помощью конструкторов и операций преобразования. При работе со стандартными типами данных в Си имеют место явные и неявные преобразования их типов. По аналогии для классов также могут быть определены такие операции - они ассоциируются с конструированием объектов класса. Так, если в программе встречается преобразование типа (класса) "yyy" к типу (классу) "xxx", то для его осуществления в классе "xxx" необходим конструктор вида xxx(yyy &);

Сами преобразования типов происходят в тех же самых случаях, что и обычные преобразования базовых типов данных:

· при использовании операции явного преобразования типов;

· при выполнении операции присваивания, если она не переопределена в виде "xxx=yyy" (транслятором создается временный объект класса "xxx", для которого вызывается указанный конструктор и который затем используется в правой части операции присваивания);

· при неявном преобразовании типа формального параметра функции при передаче его по значению (вместо конструктора копирования);

· при неявном преобразовании типа результата функции при передаче его по значению (вместо конструктора копирования);

· при определении объекта класса "xxx" одновременно с его инициализацией объектом класса "yyy" (вместо конструктора копирования)

yyy b;

xxx a = b;

При конструировании объекта класса "xxx" с использованием объекта класса "yyy" естественно должна быть обеспечена доступность необходимых данных последнего (например, через дружественность).

В качестве примера рассмотрим обратное преобразование базового типа long к типу dat - количество дней от начала летоисчисления преобразуется к дате. Здесь же рассмотрим другой класс - man, в котором одним из элементов личной части является дата. Значение этого объекта копируется при преобразовании типа man в тип dat.

static int days[]={0,31,28,31,30,31,30,31,31,30,31,30,31};

class man;

class dat

{

int day,month,year;

public:

dat(long); // Преобразование long в dat

dat(man&); // Преобразование man в dat

dat() {}

};

class man

{

friend class dat;

dat WasBorn; // объект класса dat в объекте класса man

public:

man(dat&); // Преобразование dat в man

};

dat::dat(man& p)

{ *this = p.WasBorn; }

man::man(dat& p)

{ WasBorn = p; }

dat::dat(long p)

{

year = p / 365.25; // Число лет с учетом високосных

p-=(year-1)*365L - year/4; // Остаток дней в текущем году

year++; // Начальный год - 0001

for (month=1; p > 0; month++)

{ // Вычитание дней по месяцам

p -= days[month];

if (month == 2 && year % 4 == 0) p--;

}

month--; // Восстановление последнего

p += days[month]; // месяца

if (month == 2 && year % 4 == 0) p++;

day = p + 1;

}

Преобразование объектов класса имеет место при выполнении операций явного приведения типов, присваивания, а также при определении объектов с инициализацией их объектами приводимого класса

long l=1000;

dat a = l, b; // Вызов конструктора dat(long)

man c = a; // Вызов конструктора man(dat&)

man f(man a)

{ return(a); }

void main()

{

a = 2000L; // Вызов конструктора dat(long)

(dat)3000L; // Вызов конструктора dat(long)

c = b; // Вызов конструктора man(dat&)

b = f(b); // Вызов конструктора dat(man&)

}

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

Вопрос №6 Неявное преобразование типов. Рассмотрим неявное преобразование объекта класса dat к базовым типам данных int и long. Сущность его заключается в вычислении полного количества дней в дате, заданной входным объектом (long) и количества дней в текущем году в этой же дате (int). Для задания этих операции необходимо переопределить в классе dat одноименные операции int и long. Переопределяемые операции задаются соответствующими функциями-элементами без параметров. Тип результата совпадает с базовым типом, к которому осуществляется приведение и поэтому не указывается:

#include <stdio.h>

static int days[]={0,31,28,31,30,31,30,31,31,30,31,30,31};

class dat

{

int day,month,year;

public:

operator int(); // Преобразование dat в int

operator long(); // Преобразование dat в long

long operator -(dat &p); // Операция dat-dat вычисляет

dat(); // разность дат в днях

dat(char *);

};

dat::operator int()

{

int r; // Текущий результат

int i; // Счетчик месяцев

for (r=0, i=1; i<month; i++) // Число дней в прошедших

r += days[month]; // месяцах

if ((month>2) && (year%4==0)) r++; // Високосный год

r += day; // Дней в текущем месяце

return(r);

}

dat::operator long()

{

long r; // Текущий результат

r = 365 * (year-1); // Дней в предыдущих полных годах

r += year / 4; // Високосные года

r += (int)(*this); // Дней в текущем году

return(r);

}

long dat::operator-(dat& p)

{return((long)(*this) - (long)p);}

void main()

{

dat a("12-05-1990"); // Дата, заданная строкой

dat b; // Текущая дата

int c;

long d;

printf("С 12-05-1990 прошло %4ld дней\n",(long)b-(long)a);

printf("В этом году прошло %3d дней\n",(int)b);

c = b;

d = b - a; // Операция dat-dat

printf("С 12-05-1990 прошло %4ld дней\n",d);

printf("В этом году прошло %3d дней\n",c);

}

Вопрос №7 Друзья-функции и друзья-классы. Теперь, наконец, можно обсудить, в каких случаях для доступа к закрытой части определяемого пользователем типа использовать члены, а в каких - друзей. Некоторые операции должны быть членами: конструкторы, деструкторы и виртуальные функции (см. следующую главу), но обычно это зависит от выбора. Рассмотрим простой класс X:

class X {

//...

X(int);

int m();

friend int f(X&);

};

Внешне не видно никаких причин делать f(X&) другом дополнительно к члену X::m() (или наоборот), чтобы реализовать действия над классом X. Однако член X::m() можно вызывать только для "настоящего объекта", в то время как друг f() может вызываться для объекта, созданного с помощью неявного преобразования типа. Например:

void g()

{

1.m(); // ошибка

f(1); // f(x(1));

}

Поэтому операция, изменяющее состояние объекта, должно быть членом, а не другом. Для определяемых пользователем типов операции, требующие в случае фундаментальных типов операнд lvalue (=, *=, ++ и т.д.), наиболее естественно определяются как члены. И наоборот, если нужно иметь неявное преобразование для всех операндов операции, то реализующая ее функция должна быть другом, а не членом. Это часто имеет место для функций, которые реализуют операции, не требующие при применении к фундаментальным типам lvalue в качестве операндов (+, -, || и т.д.).

Если никакие преобразования типа не определены, то оказывается, что нет никаких существенных оснований в пользу члена, если есть друг, который получает ссылочный параметр, и наоборот. В некоторых случаях программист может предпочитать один синтаксис вызова другому. Например, оказывается, что большинство предпочитает для обращения матрицы m запись m.inv(). Конечно, если inv() действительно обращает матрицу m, а не просто возвращает новую матрицу, обратную m, ей следует быть другом.

При прочих равных условиях выбирайте, чтобы функция была членом: никто не знает, вдруг когда-нибудь кто-то определит операцию преобразования. Невозможно предсказать, потребуют ли будущие изменения изменить статус объекта. Синтаксис вызова функции члена ясно указывает пользователю, что объект можно изменить; ссылочный параметр является далеко не столь очевидным. Кроме того, выражения в члене могут быть заметно короче выражений в друге. В функции друге надо использовать явный параметр, тогда как в члене можно использовать неявный this. Если только не применяется перегрузка, имена членов обычно короче имен друзей.

Производные классы.

Наследование классов и производные классы. Конструкторы, деструкторы и наследование. Множественное наследование. Виртуальные базовые классы. Иерархия классов. Виртуальные функции. Полиморфизм. Абстрактные классы и чистые виртуальные функции.

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

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

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

Иерархия классов позволяет определять новые классы на основе уже имеющихся. Имеющиеся классы обычно называют базовыми (иногда порождающими), а новые классы, формируемые на основе базовых, - производными (порожденными), иногда классами-потомками или наследниками. Производные классы «получают наследство» - данные и методы своих классов - и, кроме того, могут пополняться собственными компонентами (данными и собственными методами). Наследуемые компоненты не перемещаются в производный класс, а остаются в базовых классах. Сообщение, обработку которого не могут выполнить методы производного класса, автоматически передается в базовый класс. Если для обработки сообщения нужны данные, отсутствующие в производном классе, то их пытаются отыскать автоматически и незаметно для программиста в базовом классе.

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

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

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

При наследовании классов важную роль играет статус доступа (статус внешней видимости) компонентов. Для любого класса все его компоненты лежат в области его действия. Тем самым любая принадлежащая классу функция может использовать любые компонентные данные и вызывать любые принадлежащие классу функции. Вне класса в общем случае доступны только те его компоненты, которые имеют статус public.

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

· Собственные (private) методы и данные доступны только внутри того класса, где они определены.

· Защищенные (protected) компоненты доступны внутри класса, в котором они определены, и дополнительно доступны во всех производных классах.

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

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

Еще раз отметим, что на доступность компонентов класса влияет не только явное использование спецификаторов доступа (служебных слов) - private ( собственный ), protected(защищенный), public ( общедоступный), но и выбор ключевого слова class, struct, union, с помощью которого объявлен класс.

Определение производного класса. В определении и описании производного класса приводится список базовых классов, из которых он непосредственно наследует данные и методы. Между именем вводимого (нового) класса и списком базовых классов помещается двоеточие. Например, при таком определении

class S: X, Y, Z {...};

класс S порожден классами X, Y, Z, откуда он наследует компоненты. Наследование компонента не выполняется, если его имя будет использовано в качестве имени компонента в определении производного класса S. Как уже говорилось, по умолчанию из базовых классов наследуются методы и данные со спецификаторами доступа - public (общедоступные) и protected (защищенные).

В порожденном классе эти унаследованные компоненты получают статус доступа private, если новый класс определен с помощью ключевого слова class, и статус доступа public, если новый класс определен как структура, т.е. с помощью ключевого слова struct. Таким образом при определении класса struct J: X, Z {... }; любые наследуемые компоненты классов X, Z будут иметь в классе J статус общедоступных (public). Пример:

class B { protected: int t;

public: char u;

};

class E: B {... }; // t, и наследуются как private

class S: B {... }; // t, и наследуются как public

Явно изменить умалчиваемый статус доступа при наследовании можно с помощью спецификаторов доступа - private, protected и public. Эти спецификаторы доступа указываются в описании производного класса непосредственно перед нужными именами базовых классов. Если класс B определен так, как показано выше, то можно ввести следующие производные классы:

class M: protected B {... }; // t, и наследуется как protected

class P: public B {... }; // t - protected, и - public

class D: private B {... }; // t, и наследуется как private

struct F: private B {... }; // t, и наследуется как private

struct G: public B {... }; t - protected, и - public

Конструктор базового класса всегда вызывается и выполняется до конструктора производного класса.

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

имя_класса

У деструктора не может быть параметров (даже типа void), и деструктор не имеет возможности возвращать какой-либо результат, даже типа void. Статус доступа деструктора по умолчанию public (т.е. деструктор доступен во всей области действия определения класса). В несложных классах деструктор обычно определяется по умолчанию.

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

В любом классе могут быть в качестве компонентов определены другие классы. В этих классах будут свои деструкторы, которые при уничтожении объекта охватывающего (внешнего) класса выполняются после деструктора охватывающего класса.

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

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

Вопрос №10, 11 Множественное наследование и виртуальные базовые классы. Класс называют непосредственным (прямым) базовым классом (прямой базой), если он входит в список базовых при определении класса. В то же время для производного класса могут существовать косвенные или непрямые предшественники, которые служат базовыми для классов, входящих в список базовых. Если некоторый класс А является базовым для В и В есть база для С, то класс В является непосредственным базовым классом для С, а класс А - непрямой базовый класс для С. Обращение к компоненту ха, входящему в А и унаследованному последовательно классами В и С, можно обозначить в классе С либо как А::ха, либо как В::ха. Обе конструкции обеспечивают обращение к элементу ха класса А.

Производные классы принято изображать ниже базовых. Именно в таком порядке их объявления рассматривает компилятор и их тексты размещаются в листинге программы. Класс может иметь несколько непосредственных базовых классов, т.е. может быть порожден из любого числа базовых классов, например,

class X1 {... };

class X2 {... };

class X3 {... };

class Y1: public X1, public X2, public X3 {... };

Наличие нескольких прямых базовых классов называют множественным наследованием.

Определения базовых классов должны предшествовать их использованию в качестве базовых. При множественном наследовании никакой класс не может больше одного раза использоваться в качестве непосредственного базового. Однако класс может больше одного раза быть непрямым базовым классом:

class X {...; f ();... };

class Y: public X {... };

class Z: public X {... };

class D: public Y, public Z {... };

В данном примере класс Х дважды опосредовано наследуется классом D.

Проиллюстрированное дублирование класса соответствует включению в производный объект нескольких объектов базового класса. В нашем примере существуют два объекта класса Х, и поэтому для устранения возможных неоднозначностей вне объектов класса D нужно обращаться к конкретному компоненту класса Х, используя полную квалификацию: D::Y::X::f() или D::Z::X::f(). Внутри объекта класса D обращения упрощаются Y::X::f() или Z::X::f(), но тоже содержат квалификацию.

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

class X {... f();... };

class Y: virtual public X {... };

class Z: virtual public X {... };

class D: public Y, public Z {... };

Теперь класс D будет включать только один экземпляр Х, доступ к которому равноправно имеют классы Y и Z.

Обратите внимание, что размеры производных классов при отсутствии виртуальных базовых равны сумме длин их компонентов и длин унаследованных базовых классов. «Накладные расходы» памяти здесь отсутствуют.

При множественном наследовании один и тот же базовый класс может быть включен в производный класс одновременно несколько раз, причем и как виртуальный, и как не виртуальный.

class X {... };

class Y: virtual public X {... };

class Z: virtual public X {... };

class B: virtual public X {... };

class C: virtual public X {... };

class E: public X {... };

class D: public X {... };

class A: public D, public B, public Y, public Z, public C, public E {... };

В данном примере объект класса А включает три экземпляра объектов класса Х: один виртуальный, совместно используемый классами B, Y, C, Z, и два не виртуальных относящихся соответственно к классам D и E. Таким образом, можно констатировать, что виртуальность класса в иерархии производных классов является не свойством класса как такового, а результатом особенностей процедуры наследования.

Возможны и другие комбинации виртуальных и невиртуальных базовых классов. Например:

class BB {... };

class AA: virtual public BB {... };

class CC: virtual public BB {... };

class DD: public AA, public CC, public virtual BB {... };

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

class X { public: int d;... };

class Y { public: int d;... };

class Z: public X, public Y,

{ public:

int d;

...

d=X::d + Y::d;

...

};

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

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

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

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

Если в базовом классе определена некоторая компонентная функция, то такая же функция (с тем же именем, того же типа и с тем же набором и типами параметров) может быть введена в производном классе. Рассмотрим следующее определение классов:

// BASE.DIR - определения базового и производного классов

class base { public:

void fun (int i)

{ printf("\nbase::i =",i); }

};

class dir: public base

{ public: void fun (int i)

{ printf("\nbase::i =",i); }

};

В данном случае внешне одинаковые функции void fun (int)определены в базовом классе baseи в производном классе dir.

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

В программе, где определены и доступы оба класса baseи dir, обращения к функциям fun()могут быть выполнены с помощью указателей на объекты соответствующих классов:

// одинаковые функции в базовом и производном классах

# inclube <stdio.h>

# inclube «base.dir» // Определения классов

void main (void)

{ base B, *bp = &B;

dir D, *dp = &D;

base *pbd = &D;

bp->fun (1); // Печатает: base::i = 1

dp->fun (5); // Печатает: dir::i = 5

pbd->fun (4); // Печатает: base::i = 4

}

В программе введены три указателя на объекты разных классов. Следует обратить внимание на инициализацию указателя pbd. В ней адрес объекта производного класса (объекта D) присваивается указателю на объект его прямого базового класса (base *). При этом выполняется стандартное преобразование указателей, предусмотренное синтаксисом языка Си++. Обратное образование, т.е. преобразование указателя на объект базового класса в указатель на объект производного класса, невозможно (запрещено синтаксисом). Обращения к функциям классов baseи dir с помощью указателей bpи dp не представляют особого интереса. Вызов pbd->fun() требуется прокомментировать. Указатель pbd имеет тип base*, однако его значение - адрес объекта D класса dir.

Какая же из функций base::fun()или dir::fun() вызывает при обращении pbd->fun()? Результат выполнения программы показывает, что вызывается функция из базового класса. Именно такой вызов предусмотрен синтаксисом языка Си++, т.е. выбор функции (не виртуальной) зависит только от типа указателя, но не от его значения. «Настроив» указатель базового класса на объект производного класса, не удается с помощью этого указателя вызвать функцию из производного класса.

Пусть в этом классе определена компонентная функция void show(). Доступ к функции show() производного класса возможен только с помощью явного указания области видимости:

имя_производного_класса:: show()

либо с использованием имени конкретного объекта:

имя_объекта_производного_класса. show()

В обоих случаях выбор нужной функции выполняется при написании исходного текста программы и не изменяется после компиляции. Такой режим называется ранним или статическим связыванием.

Большую гибкость (особенно при использовании уже готовых библиотек классов) обеспечивает позднее (отложенное), или динамическое связывание, которое предоставляется механизмом виртуальных функций. Любая нестатическая функция базового класса может быть сделана виртуальной, если в ее объявлении использовать спецификатор virtual. Прежде чем объяснить преимущества динамического связывания, приведем пример. Опишем в базовом классе виртуальную функцию и введем два производных класса, где определим функции с такими же прототипами, но без спецификатора virtual.

// виртуальные функции в базовом и производном классах

# inclube <stdio.h>

class base { public: virtual void vfun (int i)

{ printf("\nbase::i =",i); }

};

class dir1: public base { public: void vfun (int i)

{ printf("\ndir1::i =",i); }

};

class dir2: public base { public: void vfun (int i)

{ printf("\nbase::i =",i); }

};

void main (void)

{ base B, *bp = &B;

dir1 D1, *dp1 = &D1;

dir2 D2, *dp2 = &D2;

base *pbd = &D;

bp->vfun (1); // Печатает: base::i = 1

dp1->vfun (2); // Печатает: dir1::i = 2

dp1->vfun (3); // Печатает: dir2::i = 3

bp =&D1; bp->vfun (4); // Печатает: dir1::i = 4

bp =&D2; bp->vfun (5); // Печатает: dir1::i = 5

}

Заметим, что доступ к функциям vfun() организован через указатель bp на базовый класс. Когда он принимает значение адреса объекта базового класса, то вызывается функция из базового класса. Когда указателю присваиваются значения ссылок на объекты производных классов &D1, &D2, выбор соответствующего экземпляра функции определяется именно объектом. Таким образом, интерпретация каждого вызова виртуальной функции через указатель на базовый класс зависит от значения этого указателя, то есть от типа объекта, для которого выполняется вызов. Для невиртуальной функции ее вызов через указатель интерпретируется взависимости от типа указателя.

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

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

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

// особенности виртуальных функций

# inclube <stdio.h>

class base { public:

virtual void f1 (void){ printf("\nbase::f1"); }

virtual void f2 (void){ printf("\nbase::f2"); }

virtual void f3 (void){ printf("\nbase::f3"); }

};

class dir: public base { public:

void f1 (void){ printf("\ndir::f1"); } // виртуальная

//int f2 (void){ printf("\ndir::f2"); } // ошибка в типе

void f3(int i){printf("\ndir::f3:%d",i);} //невиртуальная

};

void main (void)

{ base B, *bp = &B; dir D, *dp = &D;

bp->f1(); // Печатает: base::f1

bp->f2(); // Печатает: base::f2

bp->f3(); // Печатает: base::f3

dp->f1(); // Печатает: dir::f1

dp->f2(); // Печатает: base::f2

//dp->f3(); // Не печатает - вызов без параметра

dp->f3(3); // Печатает: dir::f3::3

dp = &D;

bp->f1(); // Печатает: dir::f1

bp->f2(); // Печатает: base::f2

bp->f3(); // Печатает: base::f3

bp->f3(3); // Не печатает - лишний параметр

}

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

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

class base { public:

virtual int f (int j) { return j * j; }

};

class dir: public base { public:

int f (int i){return base::f (i * 2); }

};

Вопрос №15 Абстрактные классы. Абстрактным классом называется класс, в котором есть хотя бы одна чистая (пустая) виртуальная функция. Чистой виртуальной называется компонентная функция, которая имеет следующее определение:

virtual тип имя_функции (список_формальных_параметров) = 0;

В этой записи конструкция «= 0» называется «чистый спецификатор». Пример описания чистой виртуальной функции:

virtual void fpure (void) = 0;

Чистая виртуальная функция «ничего не делает» и недоступна для вызовов. Ее назначение - служить основой для подменяющих ее функций в производных классах. Исходя из этого становится понятной невозможность создания самостоятельных объектов абстрактного класса. Абстрактный класс может использоваться только в качестве базового для производных классов. При создании объектов такого производного класса в качестве подобъектов создаются объекты базового абстрактного класса. Пример:

class B { protected:

virtual void f (int) = 0;

void s(int);

};

class D: public B {

...

void f (int);

};

class E: public B { void s (int);

};

Здесь B - абстрактный, D - нет, поскольку f - переопределена, а s - наследуется, E - абстрактный, так как s - переопределена, а f - наследуется.

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

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

Классы потоков С++.

Заголовочные файлы. Предопределенные объекты и потоки. Операции помещения и извлечения. Форматирование. Флаги форматирования. Манипуляторы. Ошибки потоков. Файловый ввод-вывод с применением потоков С++. Конструкторы файловых потоков. Открытие файлов в разных режимах. Ввод-вывод в файлы.

Вопрос №16 Заголовочные файлы. В Си имеется общая технология, которая касается как организации модульных программ, так и библиотек. Любой модуль, который претендует на дальнейшее использование через обращение к собственным внешним переменным и вызов собственных внешних функций, должен иметь некоторое описание своего интерфейса. Оно заключается в составлении заголовочного файла (файла с расширением - ".h"), который используется другими модулями. Заголовочный файл должен включать в себя:

· определение используемых типов данных в формальных параметрах и результатах функций с использованием оператора typedef;

· объявления внешних переменных и функций модуля, к которым возможно обращение.

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

#include <alloc.h> - заголовочный файл из системного каталога

#include "myhead.h" - заголовочный файл из текущего (явно указанного) каталога

Процесс подготовки библиотеки включает в себя следующие шаги

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

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

· включение объектного модуля в библиотеку.

Вопрос №17 Предопределенные объекты и потоки. В стандартной библиотеке ввода/вывода стандартного Си (заголовочный файл библиотеки - <stdio.h>) имеются внешние переменные-указатели на дескрипторы файлов - стандартных устройств ввода-вывода.

extern FILE *stdin, *stdout, *stderr, *stdaux, *stdprn;

стандартный ввод

стандартный вывод

регистрация ошибок

дополнительное устройство

устройство печати

Эти файлы открываются библиотекой автоматически перед выполнением функции main и по умолчанию назначаются на терминал (stdin - клавиатура, stdout, stderr - экран), последовательный порт (stdaux) и принтер (stdprn). stdin и stdout могут быть переназначены в командой строке запуска программы на любые другие файлы

>test.exe <a.dat >c:\xxx\b.dat

файл stdout

файл stdin

В Си++ существуют классы потоков ввода-вывода, которые являются объектно-ориентированным эквивалентом (stream.h) стандартной библиотеки ввода-вывода (stdio.h):

ios базовый потоковый класс

streambuf буферизация потоков

istream потоки ввода

ostream потоки вывода

iostream двунаправленные потоки

iostream_withassign поток с переопределенной операцией присваивания

istrstream строковые потоки ввода

ostrstream строковые потоки вывода

strstream двунаправленные строковые потоки

ifstream файловые потоки ввода

ofstream файловые потоки вывода

fstream двунаправленные файловые потоки

Стандартные потоки (istream,ostream,iostream) служат для работы с терминалом.

Строковые потоки (istrstream, ostrstream, strstream) служат для ввода-вывода из строковых буферов, размещенных в памяти.

Файловые потоки (ifstream, ofstream, fstream) служат для работы с файлами.

Следующие объекты-потоки заранее определены и открыты в программе перед вызовом функции main:

extern istream cin; // Стандартный поток ввода с клавиатуры

extern ostream cout; // Стандартный поток вывода на экран

extern ostream cerr; // Стандартный поток вывода сообщений об ошибках (экран)

extern ostream cerr;// Стандартный буферизованный поток вывода сообщений об ошибках (экран).

Вопрос №18 Операции помещения и извлечения. Для начала рассмотрим пример:

#include <stream.h>

main()

{

cout << "Hello, world\n";

}

Строка #include <stream.h> сообщает компилятору, чтобы он включил стандартные возможности потока ввода и вывода, находящиеся в файле stream.h. Без этих описаний выражение cout << "Hello, world\n" не имело бы смысла. Операция << ("поместить в") пишет свой первый аргумент во второй (в данном случае, строку "Hello, world\n" в стандартный поток вывода cout). Программирующим на C << известно как операция сдвига влево для целых. Такое использование << не утеряно, просто в дальнейшем << было определено для случая, когда его левый операнд является потоком вывода.

Ввод производится с помощью операции >> ("извлечь из") над стандартным потоком ввода cin. Описания cin и >>, конечно же, находятся в <stream.h>. Операцию вывода << можно применять к ее собственному результату, так что несколько команд вывода можно записать одним оператором:

cout << inch << " in = " << inch*2.54 << " cm\n";

Операция вывода используется, чтобы избежать той многословности, которую дало бы использование функции вывода. Но почему <<? Возможности изобрести новый лексический символ нет. Операция присваивания была кандидатом одновременно и на ввод, и на

вывод, но оказывается, большинство людей предпочитают, чтобы операция ввода отличалась от операции вывода. Кроме того, = не в ту сторону связывается (ассоциируется), то есть cout=a=b означает cout=(a=b).

Делались попытки использовать операции < и >, но значения "меньше" и "больше" настолько прочно вросли в сознание людей, что новые операции ввода/вывода во всех реальных случаях оказались нечитаемыми. Помимо этого, "<" находится на большинстве клавиатур как раз на ",", и у людей получаются операторы вроде такого:

cout < x, y, z;

Для таких операторов непросто выдавать хорошие сообщения об ошибках.

Операции << и >> к такого рода проблемам не приводят, они асимметричны в том смысле, что их можно проассоциировать с "в" и "из", а приоритет << достаточно низок, чтобы можно было не использовать скобки для арифметических выражений в роли операндов.

Например:

cout << "a*b+c=" << a*b+c << "\n";

Естественно, при написании выражений, которые содержат операции с более низкими приоритетами, скобки использовать надо. Например:

cout << "a^b|c=" << (a^b|c) << "\n";

Операцию левого сдвига тоже можно применять в операторе вывода:

cout << "a<<b=" << (a<<b) << "\n";

В С++ нет выражений с символьными значениями, в частности, '\n' является целым (со значением 10, если используется набор символов ASCII), поэтому

cout << "x = " << x << '\n';

напечатает число 10, а не ожидаемый символ новой строки. Эту и аналогичные проблемы можно сгладить, определив несколько макросов (в которых используются стандартные имена символов ASCII):

#define sp << " "

#define ht << "\t"

#define nl << "\n"

Теперь предыдущий пример запишется в виде:

cout << "x = " << x nl;