WWW.DISSERS.RU

БЕСПЛАТНАЯ ЭЛЕКТРОННАЯ БИБЛИОТЕКА

   Добро пожаловать!

Pages:     || 2 | 3 |
-- [ Страница 1 ] --

Министерство образования Республики Беларусь Учреждение образования «Белорусский государственный университет информатики и радиоэлектроники» Кафедра электронных вычислительных машин Ю.А. Луцик, А.М.

Ковальчук, И.В. Лукьянова ОБЪЕКТНО-ОРИЕНТИРОВАННОЕ ПРОГРАММИРОВАНИЕ НА ЯЗЫКЕ С++ УЧЕБНОЕ ПОСОБИЕ по курсу «Объектно-ориентированное программирование» для студентов специальности «Вычислительные машины, системы и сети» всех форм обучения Минск 2003 УДК 681.322 (075.8) ББК 32.97 я 73 Л 86 Р е ц е н з е н т :

заведующий кафедрой математики и информатики ЕГУ, канд. техн. наук В.И. Романов Луцик Ю.А.

Л 86 Объектно-ориентированное программирование на языке С++: Учеб.

пособие по курсу «Объектно-ориентированное программирование» для студ. спец. «Вычислительные машины, системы и сети» всех форм обуч. / Ю.А. Луцик, А.М. Ковальчук, И.В. Лукьянова. – Мн.: БГУИР, 2003. – 203 с.:ил.

ISBN 985-444-562-3.

В учебном пособии рассмотрены приемы и правила объектно ориентированного программирования с использованием языка С++. Изложены основные конструкции языка С++, а также общие принципы разработки объектно ориентированных программ.

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

УДК 681.322 (075.8) ББК 32.97 я © Луцик Ю.А., Ковальчук А.М., Лукьянова И.В., ISBN 985-444-562-3 © БГУИР, Содержание Введение................................................................................................................. Объектно-ориентированное программирование................................................ Абстрактные типы данных............................................................................... Базовые принципы объектно-ориентированного программирования......... Основные достоинства языка С++................................................................... Особенности языка С++.................................................................................... Ключевые слова............................................................................................. Константы и переменные.............................................................................. Операции........................................................................................................ Типы данных.................................................................................................. Передача аргументов функции по умолчанию........................................... Простейший ввод и вывод................................................................................ Объект cout.................................................................................................... Манипуляторы hex и oct............................................................................... Объект cin.................................................................................................... Операторы для динамического выделения и освобождения памяти (new и delete).................................................................................................... Базовые конструкции объектно-ориентированных......................................... программ............................................................................................................... Объекты............................................................................................................ Понятие класса................................................................................................. Конструктор explicit........................................................................................ Встроенные функции (спецификатор inline)................................................ Организация внешнего доступа к локальным компонентам класса (спецификатор friend)..................................................................................... Вложенные классы.......................................................................................... Static-члены (данные) класса.......................................................................... Указатель this................................................................................................... Компоненты-функции static и const............................................................... Ссылки.............................................................................................................. Параметры ссылки....................................................................................... Независимые ссылки................................................................................... Наследование (производные классы)............................................................ Конструкторы и деструкторы..................................................................... Виртуальные функции.................................................................................... Абстрактные классы........................................................................................ Множественное наследование........................................................................ Виртуальное наследование......................................................................... Перегрузка функций........................................................................................ Перегрузка операторов.................................................................................... Перегрузка бинарного оператора............................................................... Перегрузка унарного оператора................................................................. Дружественная функция operator............................................................... Особенности перегрузки операции присваивания................................... Перегрузка оператора [].............................................................................. Перегрузка оператора ().............................................................................. Перегрузка оператора ->............................................................................. Перегрузка операторов new и delete......................................................... Преобразование типа....................................................................................... Явные преобразования типов..................................................................... Преобразования типов, определенных в программе................................ Шаблоны........................................................................................................... Параметризированные классы.................................................................... Передача в шаблон класса дополнительных параметров........................ Шаблоны функций..................................................................................... Совместное использование шаблонов и наследования......................... Некоторые примеры использования шаблона класса............................ Задание свойств класса................................................................................. Пространства имен........................................................................................ Ключевое слово using как директива....................................................... Ключевое слово using как объявление.................................................... Псевдоним пространства имен................................................................. Организация ввода-вывода........................................................................... Состояние потока....................................................................................... Строковые потоки...................................................................................... Организация работы с файлами................................................................... Организация файла последовательного доступа.................................... Создание файла произвольного доступа................................................. Основные функции классов ios, istream, ostream........................................ Исключения в С++............................................................................................. Основы обработки исключительных ситуаций.......................................... Перенаправление исключительных ситуаций............................................ Исключительная ситуация, генерируемая оператором new...................... Генерация исключений в конструкторах.................................................... Задание собственной функции завершения................................................ Спецификации исключительных ситуаций................................................ Задание собственного неожиданного обработчика................................... Иерархия исключений стандартной библиотеки....................................... Стандартная библиотека шаблонов (STL)..................................................... Общее понятие о контейнере....................................................................... Общее понятие об итераторе........................................................................ Категории итераторов................................................................................... Основные итераторы..................................................................................... Вспомогательные итераторы........................................................................ Операции с итераторами............................................................................... Контейнерные классы................................................................................... Контейнеры последовательностей............................................................... Контейнер последовательностей vector................................................ Контейнер последовательностей list..................................................... Контейнер последовательностей deque................................................ Ассоциативные контейнеры......................................................................... Ассоциативный контейнер multiset..................................................... Ассоциативный контейнер set.............................................................. Ассоциативный контейнер multimap................................................... Ассоциативный контейнер map........................................................... Адаптеры контейнеров.................................................................................. Адаптеры stack......................................................................................... Адаптеры queue........................................................................................ Адаптеры priority_queue.......................................................................... Пассивные и активные итераторы............................................................... Алгоритмы...................................................................................................... Алгоритмы сортировки sort, partial_sort, sort_heap.............................. Алгоритмы поиска find, find_if, find_end, binary_search........................ Алгоритмы fill, fill_n, generate и generate_n...................................... Алгоритмы equal, mismatch и lexicographical_compare...................... Математические алгоритмы..................................................................... Алгоритмы работы с множествами......................................................... Алгоритмы swap, iter_swap и swap_ranges.............................................. Алгоритмы copy, copy_backward, merge, unique и reverse..................... Примеры реализации контейнерных классов............................................. Связанные списки...................................................................................... Реализация односвязного списка......................................................... Реализация двусвязного списка........................................................... Реализация двоичного дерева................................................................... Литература...................................................................................................... Введение Одна из важнейших задач программирования – разработка алгоритма.

Имеется два основных подхода к разработке программ. Первый из них называ ется процедурным программированием. Для создания программ на его основе необходимо следующее:

определить задачу, которую нужно решить;

продумать интерфейс программы с пользователем;

разбить программу на логически законченные этапы;

создать текст программы;

отладить программу;

тестировать программу.

Второй подход называется объектно-ориентированным программирова нием (ООП). Для разработки программ с использованием методики объектно ориентированного программирования необходимо:

определить задачу;

определить уникальные объекты в области решаемой задачи;

определить взаимосвязь между объектами;

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

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

объявить объекты данных классов;

определить начальное состояние системы;

скомпилировать, скомпоновать систему.

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

Материал пособия основывается на ряде изданий [1–4].

Объектно-ориентированное программирование Абстрактные типы данных Концепция абстрактных типов и абстрактных типов данных является ключевой в программировании. Абстракция подразумевает разделение и независимое рассмотрение интерфейса и реализации.

Интерфейс и внутренняя реализация являются определяющими свой ствами объектов окружающего нас мира. Интерфейс – это средство взаимодей ствия с некоторым объектом. Реализация – это внутреннее свойство объекта.

Наибольший интерес представляет эффективность реализации.

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

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

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

Различают процедурную абстракцию и абстракцию данных.

Процедурная абстракция требует раздельного рассмотрения цели проце дуры (например функции С/С++) и ее внутренней реализации.

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

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

Абстракция данных предполагает определение и рассмотрение абстракт ных типов данных (АТД), или, иначе, новых типов данных, введенных пользо вателем. АТД – это совокупность данных вместе с множеством операций, кото рые можно выполнять над этими данными.

Базовые принципы объектно-ориентированного программирования Объектно-ориентированное программирование основывается на трех ос новных концепциях: инкапсуляции, полиморфизме и наследовании.

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

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

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

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

Передача сообщений выражает основную методологию построения объ ектно-ориентированных программ. Программы представляются в виде набора объектов и передачи сообщений между ними.

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

определить объект для заданного класса;

построить новый класс, наследуя его из существующего класса;

изменить поведение нового класса (изменить существующие и добавить новые функции).

Построение нового класса, наследуя его из существующего, предполага ет:

добавление в новый класс новых компонент-данных;

добавление в новый класс новых компонент-функций;

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

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

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

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

Общий базовый класс Производный Производный Производный базовый класс базовый класс базовый класс Производный Производный Производный Простое (одиночное) наследование Множественное наследование Рис. 1. Виды иерархии классов Язык программирования называется объектно-ориентированным, если:

он поддерживает абстрактные типы данных (объекты с определенным интерфейсом и скрытым внутренним состоянием);

объекты имеют связанные с ними типы (классы);

поддерживается механизм наследования.

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

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

Необходимо четко представлять, что достоинство языка С++ состоит не в добавлении в С новых типов, операций и т.д., а в возможности поддержки объ ектно-ориентированного подхода к разработке программ.

Ключевые слова Язык С++ расширяет множество ключевых слов принятых в языке С следующими ключевыми словами:

class protected friend inline private new operator virtual public delete this template Константы и переменные В С++ односимвольные константы имеют тип char, в то же время в С++ поддерживается возможность работы с двухсимвольными константами типа int:

’aB’, ’\n\t’ При этом первый символ располагается в младшем байте, а второй – в старшем.

Операции В языке С++ введены следующие новые операции:

:: – операция разрешения контекста;

.* и ->* – операции обращения через указатель к компоненте класса;

new и delete – операции динамического выделения и освобождения памя ти.

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

Типы данных В С++ поддерживаются все типы данных, предопределенные в С. Кроме того, введены несколько новых типов данных: классы и ссылки.

Ссылки расширяют и упрощают передачу аргументов в функцию (по значению или по адресу).

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

#include "iostream.h" int sm(int i1, int i2, int i3=0, int i4=0) { cout<

return i1+i2+i3+i4;

} void main() { cout <<"сумма = "<< sm(1,2) << endl;

cout <<"сумма = "<< sm(1,2,3) << endl;

cout << "сумма = "<< sm(1,2,3,4) << endl;

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

1 2 0 0 сумма = 1 2 3 0 сумма = 1 2 3 4 сумма = Описание параметров по умолчанию должно находиться в конце списка формальных параметров (в заголовке функции). Задание параметров по умол чанию может быть выполнено только в прототипе функции или при его отсут ствии в заголовке функции.

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

Имеется четыре потока (связанных с ними объекта), обеспечивающих ввод и вывод информации и определенных в заголовочном файле iostream.h:

cout – поток стандартного вывода;

cin – поток стандартного ввода;

cerr – поток стандартной ошибки;

clog – буферизируемый поток стандартных ошибок.

Объект cout Объект cout позволяет выводить информацию на стандартное устройство вывода – экран. Формат записи cout имеет следующий вид:

сout << data [ << data];

data – это переменные, константы, выражения или комбинации всех трех типов.

Простейший пример применения cout – это вывод, например, символьной строки:

cout << ”объектно-ориентированное программирование”;

cout << ”программирование на С++”.

Надо помнить, что cout не выполняет автоматический переход на новую строку после вывода информации. Для перевода курсора на новую строку надо вставлять символ ’\n’ или манипулятор endl.

cout << ”объектно-ориентированное программирование \n”;

cout << ”программирование на С++”<

Для управления выводом информации используются манипуляторы.

Манипуляторы hex и oct Манипуляторы hex и oct используются для вывода числовой информации в шестнадцатеричном или восьмеричном представлении. Применение их можно видеть на примере следующей простой программы:

#include "iostream.h" void main() { int a=0x11, b=4, // целые числа шестнадцатеричное и десятичное c=051, d=8, // --//-- восьмеричное и десятичное i,j;

i=a+b;

j=c+d;

cout << i <<' ' <

cout <

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

21 15 25 31 31 49 Другие манипуляторы Манипуляторы изменяют значение некоторых переменных в объекте cout.

Эти переменные называются флагами состояния. Когда объект посылает данные на экран, он проверяет эти флаги.

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

#include "iostream.h" #include "iomanip.h" void main() { int a=0x11;

double d=12.362;

cout << setw(4) << a << endl;

cout << setw(10) << setfill('*') << a << endl;

cout << setw(10 ) << setfill(' ') << setprecision(3) << d << endl;

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

******** 12. В приведенной программе использованы манипуляторы setw(), setfill(' ') и setprecision(). Синтаксис их показывает, что это функции. На самом деле это компоненты-функции (рассмотрим позже), позволяющие изменять флаги со стояния объекта cout. Для их использования необходим заголовочный файл iomanip.h. Функция setw(4) обеспечивает вывод значения переменной a в 4 по зиции (по умолчанию выравнивание вправо). Функция setfil(’символ’) заполня ет пустые позиции символом. Функция setprecision(n) обеспечивает вывод чис ла с плавающей запятой с точностью до n знаков после запятой (при необходи мости производится округление дробной части). Таким образом, функции име ют следующий формат:

setw(количество_позиций_для_вывода_числа) setfil(символ_для_заполнения_пустых_позиций) setprecision (точность_при_выводе_дробного_числа) Наряду с перечисленными выше манипуляторами в С++ используются также манипуляторы setiosflags() и resetiosflags() для установки определенных глобальных флагов, используемых при вводе и выводе информации. На эти флаги ссылаются как на переменные состояния. Функция setiosflags() устанав ливает указанные в ней флаги, а resetiosflags() сбрасывает (очищает) их. В при веденной ниже таблице показаны аргументы для этих функций.

Таблица Значение Результат, если значение установлено ios::skipws Игнорирует пустое пространство при вводе ios::left Вывод с выравниванием слева ios::right Вывод с выравниванием справа ios::internal Заполнять пространство после знака или основания с/с ios::dec Вывод в десятичном формате ios::oct Вывод в восьмеричном формате ios::hex Вывод в шестнадцатеричном формате ios::boolalpha Вывод булевых значений в виде TRUE и FALSE ios::showbase Выводить основание с/с ios::showpoint Выводить десятичную точку ios::uppercase Выводить шестнадцатеричные числа заглавными буквами ios::showpos Выводить + перед положительными целыми числами ios::scientific Использовать научную форму вывода чисел ios::fixed Использовать форму вывода с фиксированной запятой ios::unitbuf Сброс после каждой операции вывода ios::sktdio Сброс после каждого символа Как видно из таблицы, флаги формата объявлены в классе ios.

Пример программы, в которой использованы манипуляторы:

#include "iostream.h" #include "iomanip.h" void main() { char s[]="БГУИР факультет КСиС";

cout << setw(30) << setiosflags(ios::right) << s << endl;

cout << setw(30) << setiosflags(ios::left) << s << endl;

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

БГУИР факультет КСиС БГУИР факультет КСиС Наряду с манипуляторами setiosflags() и resetiosflags(), для того чтобы ус тановить или сбросить некоторый флаг, могут быть использованы функции класса ios setf() или unsetf(). Например:

#include #include int main() { char *s="Я изучаю С++";

cout.setf(ios::uppercase | ios::showbase | ios::hex);

cout << 88 << endl;

cout.unsetf(ios::uppercase);

cout << 88 << endl;

cout.unsetf(ios::uppercase | ios::showbase | ios::hex);

cout.setf(ios::dec);

int len = 10 + strlen(s);

cout.width(len);

cout << s << endl;

cout << 88 << " hello C++ " << 345.67 << endl;

return 0;

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

0X 0x Я изучаю С++ 88 hello C++ 345. Объект cin Для ввода информации с клавиатуры используется объект cin. Формат записи cin имеет следующий вид:

cin [>>имя_переменной];

Объект cin имеет некоторые недостатки. Необходимо, чтобы данные вво дились в соответствии с форматом переменных, что не всегда может быть га рантировано.

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

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

calloc, malloc, realloc, free и другие. В С++ для выделения памяти можно также использовать встроенные операторы new и delete.

Оператор new имеет один операнд. Оператор имеет две формы записи:

[::] new [(список_аргументов)] имя_типа [(инициализирующее_значение)] [::] new [(список_аргументов)] (имя_типа) [(инициализирующее_значение)] В простейшем виде оператор new можно записать:

new имя_типа или new (имя_типа) Оператор new возвращает указатель на объект типа имя_типа, для которого выполняется выделение памяти. Например:

char *str;

// str – указатель на объект типа char str=new char;

// выделение памяти под объект типа char или str=new (char);

В качестве аргументов можно использовать как стандартные типы дан ных, так и определенные пользователем. В этом случае именем типа будет имя структуры или класса. Если память не может быть выделена, оператор new воз вращает значение NULL.

Оператор new позволяет выделять память под массивы. Он возвращает указатель на первый элемент массива в квадратных скобках. Например:

int *n;

// n – указатель на целое n=new int[20];

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

k=3;

int *p[]=new int[k][5];

// ошибка cannot convert from 'int (*)[5]' to 'int *[]' int (*p)[]=new int[k][5];

// верно При выделении памяти под объект его значение будет неопределенным.

Однако объекту можно присвоить начальное значение.

int *a = new int (10234);

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

class matr { int a;

float b;

public:

matr(){};

// конструктор по умолчанию matr(int i,float j): a(i),b(j) {} ~matr(){};

};

void main() { matr mt(3,.5);

matr *p1=new matr[2];

// верно р1 – указатель на 2 объекта matr *p2=new matr[2] (2,3.4) ;

// неверно, невозможна инициализация matr *p3=new matr (2,3.4);

// верно р3 – инициализированный объект } Следует отметить, что конструктор по умолчанию в примере требуется при использовании оператора new matr[2].

Использование знака :: перед оператором new указывает на вызов гло бальной версии оператора new. Оператор new вызывает функцию operator new(). Аргумент имя_типа используется для автоматического вычисления раз мера памяти sizeof(имя_типа), то есть инструкция типа new имя_типа приводит к вызову функции:

operator new(sizeof(имя_типа));

Далее, в подразделе «Перегрузка операторов», будет рассмотрен случай использования доопределенного оператора new для некоторого класса.

Доопределение оператора new позволяет расширить возможности выделения памяти для объектов (их компонент) данного класса.

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

При создании массива выполняется стандартный конструктор для каждо го элемента.

Отметим преимущества использования оператора new перед использова нием malloc():

оператор new автоматически вычисляет размер необходимой памяти. Не требуется использование оператора sizeof(). При этом он предотвращает выде ление неверного объема памяти;

оператор new автоматически возвращает указатель требуемого типа (не требуется использование оператора преобразования типа);

имеется возможность инициализации объекта;

можно выполнить перегрузку оператора new (delete) глобально или по отношению к тому классу, в котором он используется.

Для разрушения объекта, созданного с помощью оператора new, необхо димо использовать в программе оператор delete.

Оператор delete имеет две формы записи:

[::] delete переменная_указатель // для указателя на один элемент [::] delete [] переменная_указатель // для указателя на массив Единственный операнд в операторе delete должен быть указатель, воз вращенный оператором new. Если оператор delete применить к указателю, по лученному не посредством оператора new, то результат будет непредсказуем.

Использование оператора delete вместо delete[] по отношению к указате лю на массив может привести к логическим ошибкам. Таким образом, освобож дать память, выделенную для массива, необходимо оператором delete [], а для отдельного элемента – оператором delete.

#include class A { int i;

// компонента-данное класса А public:

A(){} // конструктор класса А ~A(){} // деструктор класса А };

void main() { A *a,*b;

// описание указателей на объект класса А float *c,*d;

// описание указателей на элементы типа float a=new A;

// выделение памяти для одного объекта класса А b=new A[3];

// выделение памяти для массива объектов класса А c=new float;

// выделение памяти для одного элемента типа float d=new float[4];

// выделение памяти для массива элементов типа float delete a;

// освобождение памяти, занимаемой одним объектом delete [] b;

// освобождение памяти, занимаемой массивом объектов delete c;

// освобождение памяти одного элемента типа float delete [] d;

// освобождение памяти массива элементов типа float } При удалении объекта оператором delete вначале вызывается деструктор этого объекта, а потом освобождается память. При удалении массива объектов с помощью операции delete[] деструктор вызывается для каждого элемента мас сива.

Базовые конструкции объектно-ориентированных программ Объекты Базовыми блоками ООП являются объект и класс. Объект С++ – абст рактное описание некоторой сущности, например, запись о человеке. Формаль но объект определить достаточно сложно. Grady Booch определил объект через свойства: состояние и поведение, которые однозначно идентифицируют объ ект. Класс – это множество объектов, имеющих общую структуру и поведение.

Рассмотрим некоторые конструкции языка С.

int a,b,c;

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

Рассмотрим пример описания структуры в языке С:

struct str{ char a[10];

double b;

};

str s1,s2;

Структура позволяет описать АТД (тип, определенный программистом), являющийся абстракцией, так как в памяти при этом место под структуру вы делено не будет. Таким образом, str – это класс.

В то же время объекты а, b, c и s1, s2 – это уже реальность, существую щая в пространстве (памяти ЭВМ) и во времени. Таким образом, класс можно определить как общее описание для множества объектов.

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

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

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

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

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

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

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

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

Основная идея класса как абстрактного типа заключается в разделении интерфейса и реализации.

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

Реализация – внутренняя особенность класса. Одно из требований к реа лизации – критерий изоляции кода функции от воздействия извне. Это достига ется использованием локальных компонент данных и функций.

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

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

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

#include class kls { int sm;

// по умолчанию предполагается private int m[5];

public:

void inpt(int i) // функция ввода данных в компоненту m класса { cin >> m[i];

} int summ();

// прототип функции summ };

int kls::summ() // описание функции summ { sm=0;

// инициализация компоненты sm класса for(int i=0;

i<5;

i++) sm+=m[i];

return sm;

} void main() { kls k1,k2;

// объявление объектов k1 и k2 класса kls int i;

cout<< ”Вводите элементы массива ПЕРВОГО объекта : ”;

for(i=0;

i<5;

k1.inpt(i++));

// ввод данных в первый объект cout<< ”Вводите элементы массива ВТОРОГО объекта : ”;

for(i=0;

i<5;

k2.inpt(i++));

// во второй объект cout << "\n Сумма элементов первого объекта (k1) = " << k1.summ();

cout << "\n Сумма элементов второго объекта (k2) = " << k2.summ();

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

Вводите элементы массива ПЕРВОГО объекта : 2 4 1 3 Вводите элементы массива ВТОРОГО объекта : 2 4 6 4 Сумма элементов первого объекта (k1) = Сумма элементов второго объекта (k2) = В приведенном примере описан класс, для которого задан пустой список объектов. В main() функции объявлены два объекта описанного класса. При описании класса в него включаются прототипы функций для обработки данных класса. Текст самой функции может быть записан как внутри описания класса (функция inpt()), так и вне его (функция summ()).

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

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

#include class kls { int max,a,b,c;

public:

void init(void);

void out();

private:

int f_max(int,int,int);

};

void kls::init(void) // инициализация компонент a, b, c класса { cout << “Введите 3 числа ";

cin >> a >> b >> c;

max=f_max(a,b,c);

// обращение к функции, описанной как private } void kls::out(void) { cout <<"\n MAX из 3 чисел = " << max <<' endl;

} int kls::f_max(int i,int j, int k) );

// функция нахождения наибольшего из { int kk;

// трех чисел if(i>j) if(i>k) return i;

else return k;

else if(j>k) return j;

else return k;

} void main() { kls k;

// объявление объекта класса kls k.init();

// обращение к public функциям ( init и out) k.out();

} Отметим ошибочность использования инструкции k.max=f_max(k.a,k.b,k.c);

в main функции, так как данные max, a, b, c и функция f_max класса kls являют ся частными и недоступны через префикс k из функции main(), не принадлежа щей классу kls.

В примере для работы с объектом k класса kls выполнялась инициализа ция полей a, b и c путем присвоения им некоторых начальных значений. Для этого использована функция init. В языке С++ имеется возможность одновре менно с описанием (созданием) объекта выполнять и его инициализацию. Эти действия выполняются специальной функцией, принадлежащей этому классу.

Эта функция носит специальное название: конструктор. Название этой функ ции всегда должно совпадать с именем класса, которому она принадлежит. При использовании конструктора функцию init в описании класса можно заме нить на kls(int A, int B, int C) {a=A;

b=B;

c=C;

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

Кроме отмеченной формы записи конструктора в программах на С++ можно встретить и форму записи конструктора в следующем виде:

kls(int A, int B, int C) : a(A), b(B), c(C) { } В этом случае после двоеточия перечисляются инициализируемые данные и в скобках – инициализирующие их значения (точнее, через запятую перечисля ются конструкторы объектов соответствующих типов). Возможна комбинация отмеченных форм.

Наряду с перечисленными выше формами записи конструктора сущест вует конструктор, либо не имеющий параметров, либо все аргументы которого заданы по умолчанию – конструктор по умолчанию:

kls(){ } это, для примера выше, аналогично kls() : a(), b(), c() { } kls(int=0, int=0, int=0){ } это аналогично kls() : a(0), b(0), c(0) { } Каждый класс может иметь только один конструктор по умолчанию. Бо лее того, если при объявлении класса в нем отсутствует явно описанный конст руктор, то компилятором автоматически генерируется конструктор по умолча нию. Конструктор по умолчанию используется при создании объекта без ини циализации его, а также незаменим при создании массива объектов. Если при этом конструкторы с параметрами в классе есть, а конструктора по умолчанию нет, то компилятор зафиксирует синтаксическую ошибку.

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

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

~kls(void){} или ~kls(){} // функция-деструктор Рассмотрим использование конструктора и деструктора на примере про граммы подсчета числа встреч некоторой буквы в символьной строке.

#include #include #define n class stroka { int m;

char st[20];

public:

stroka(char *st);

// конструктор ~stroka(void);

// деструктор void out(char);

int poisk(char);

};

stroka::stroka(char *s) { cout << "\n работает конструктор";

strcpy(st,s);

} stroka::~stroka(void) {cout << "\n работает деструктор";

} void stroka::out(char c) { cout << "\n символ " << c << " найден в строке "<< st<

} int stroka::poisk(char c) { m=0;

for(int i=0;

st[i]!='\0';

i++) if (st[i]==c) m++;

return m;

} void main() { char c;

// символ для поиска его в строке cout << "введите символ для поиска его в строке ";

cin >> c;

stroka str("abcadbsaf");

// объявление объекта str и вызов конструктора if (str.poisk(c)) // подсчет числа вхождений буквы с в строку str.out(c);

// вывод результата else cout << "\n буква"<

} В функции main(), при объявлении объекта str класса stroka, происходит вызов функции конструктора, осуществляющего инициализацию поля st этого объекта символьной строкой "abcadbsaf":

stroka str("abcadbsaf");

Все функции-компоненты класса stroka объявлены со спецификатором public и, следовательно, являются глобальными и могут быть вызваны из функ ции main(). Вызов функции осуществляется с использованием префикса str.

str.poisk(c);

str.out(c);

Поля данных класса stroka объявлены со спецификатором private по умолчанию и, следовательно, являются локальными по отношению к классу stroka. Обращение внутри любой функции-компоненты класса к полям этого же класса производится без использования префикса. За пределами видимости класса эти поля недоступны. Таким образом, обращение к ним из функции main(), например, str.st[1] или str.m, являются ошибочными.

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

#include #include #define n class stroka { public:

int m;

char st[20];

stroka(){} // конструктор по умолчанию stroka(char *);

// конструктор stroka(int M) : m(M) // конструктор { cout << "работает конструктор 2"<

} ~stroka(void);

// деструктор void out(char);

int poisk(int);

};

void stroka::stroka(char *s) { cout << "работает конструктор 1"<

strcpy(st,s);

} void stroka::~stroka(void) {cout << "работает деструктор"<

} void stroka::out(char c) { cout << "символ " << c << " встречен в строке "<

} int stroka::poisk(int k) { m=0;

for(int i=0;

st[i]!='\0';

i++) if (st[i]==st[k]) m++;

return m;

} void main() { int i;

cout << "введите номер (0-8) символа для поиска в строке"<

cin >> i;

stroka str1("abcadbsaf");

// описание и инициализация объекта str stroka str2(i);

// описание и инициализация объекта str if (str1.poisk(str2.m)) // вызов функции поиска символа в строке str1.out(str1.st[str2.m]);

// вызов функции вывода результата else cout << "символ не встречен в строке "<

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

#include class kls { int n1,n2;

public:

kls(int,int=2);

};

kls::kls(int i1,int i2) : n1(i1),n2(i2) { cout<

} void main() { kls k(1);

...

} Следует отметить, что компоненты-данные класса желательно описывать в private секции, что соответствует принципу инкапсуляции и запрещает не санкционированный доступ к данным класса (объекта).

Отметим основные свойства и правила использования конструкторов:

– конструктор – функция, имя которой совпадает с именем класса, в ко тором он объявлен;

– конструктор предназначен для создания объекта (массива объектов) и инициализации его компонент-данных;

– конструктор вызывается, если в описании используется связанный с ним тип:

class cls{... };

main() { cls aa(2,.3);

// вызывает cls :: cls(int,double) extern cls bb;

// объявление, но не описание, конструктор не вызывается } – конструктор по умолчанию не требует никаких параметров;

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

– если конструктор объявлен в private-секции, то он не может быть явно вызван (из main функции) для создания объекта класса.

Далее выделим основные правила использования деструкторов:

– имя деструктора совпадает с именем класса, в котором он объявлен с префиксом ~;

– деструктор не возвращает значения (даже типа void);

– деструктор не наследуется в производных классах;

– деструктор не имеет параметров (аргументов);

– в классе может быть только один деструктор;

– деструктор может быть виртуальным (виртуальной функцией);

– невозможно получить указатель на деструктор (его адрес);

– если деструктор отсутствует в описании класса, то он автоматически генерируется компилятором (с атрибутом public);

– библиотечная функция exit вызывает деструкторы только глобальных объектов;

– библиотечная функция abort не вызывает никакие деструкторы.

В С++ для описания объектов можно использовать не только ключевое слово class, но также применять ключевые слова struct и union. Различие между АТД class и struct, union состоит в том, что все компоненты struct и union по умолчанию имеют атрибут доступа public. Ниже приведен пример использова ния union и struct.

#include #include union my_union // объявления объединения { char str[14];

// компонента – символьный массив struct my_struct // компонета-структура { char str1[5];

// первое поле структуры char str2[8];

// второе поле структуры } my_s;

// объект типа my_struct my_union(char *s);

// прототип конструктора void print(void);

};

my_union::my_union(char* s) // описание функции конструктора { strcpy (str,s);

} void my_union::print(void) { cout<

// вывод второго поля объекта my_s my_s.str2[0]=0;

// вставка ноль-символа между полями cout<

// вывод первого поля (до ноль-символа) } void main(void) { my_union obj ("MinskBelarus");

obj.print();

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

Belarus Minsk Деструктор генерируется автоматически компилятором. Для размещения данных объекта obj выделяется область памяти размером максимального поля union (14 байт) и инициализируется символьной строкой. В функции print() ин формация, занесенная в эту область, выводится на экран в виде двух слов, при этом используется вторая компонента объединения – структура (точнее два ее поля).

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

– в С++ struct и union можно использовать так же, как класс;

– все компоненты struct и union имеют атрибут public;

– можно описать структуру без имени struct{…} s1,s2,…;

– объединение без имени и без списка описываемых объектов называется анонимным объединением;

– доступ к компонентам анонимного объединения осуществляется по их имени;

– глобальные анонимные объединения должны быть объявлены статическими;

скими;

– анонимные объединения не могут иметь компонент-функций;

– компоненты объединения нельзя специфицировать как private, public или protected, они всегда имеют атрибут public;

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

Ниже приведен текст программы с разработанным классом. В программе выполняются операции помещения символьных строк на вершину стека и чте ние их с вершины стека. Более подробно механизм работы со списками будет рассмотрен в разделах «Шаблоны» и «Контейнерные классы».

#include #include class stack // класс СТЕК { char *inf;

// компонента-данное (симв. строка) stack *nx;

// компонента-данное (указатель на элемент стека) public:

stack(){};

// конструктор ~stack(){};

// деструктор stack *push(stack *,char *);

// занесение информации на вершину стека char *pop(stack **);

// чтение информации с вершины стека };

// помещаем информацию (строку) на вершину стека // возвращаем указатель на вершину стека stack * stack::push(stack *head,char *a) { stack *PTR;

if(!(PTR=new stack)) { cout << "\nНет памяти";

return NULL;

} if(!(PTR->inf=new char[strlen(a)])) { cout << "\nНет памяти";

return NULL;

} strcpy(PTR->inf,a);

// инициализация созданной вершины PTR->nx=head;

return PTR;

// PTR – новая вершина стека } // pop удаляет информацию (строку) с вершины стека и возвращает // удаленную строку. Изменяет указатель на вершину стека char * stack::pop(stack **head) { stack *PTR;

char *a;

if(!(*head)) return '\0';

// если стек пуст, возвращаем \ PTR=*head;

// в PTR – адрес вершины стека a=PTR->inf;

// чтение информации с вершины стека *head=PTR->nx;

// изменяем адрес вершины стека (nex==PTR->next) delete PTR;

// освобождение памяти return a;

} void main(void) { stack *st=NULL;

char l,ll[80];

while(1) { cout <<"\n выберите режим работы:\n 1- занесение в стек" <<"\n 2- извлечь из стека\n 0- завершить работу"<

cin >>l;

switch(l) { case '0': return;

break;

case '1': cin >> ll;

if(!(st=st->push(st,ll))) return;

break;

case '2': cout << st->pop(&st);

break;

default: cout << " error " << endl;

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

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

#include #include #define N class tree // класс бинарное дерево { struct node // структура – узел бинарного дерева { char *inf;

// информационное поле int n;

// число встреч информационного поля в бинарном дереве node *l,*r;

};

node *dr;

// указатель на корень дерева public:

tree(){ dr=NULL;

} void see(node *);

// просмотр бинарного дерева int sozd();

// создание+дополнение бинарного дерева node *root(){return dr;

} // функция возвращает указатель на корень };

void main(void) { tree t;

int i;

while(1) { cout<<"вид операции: 1 – создать дерево"<

cout<<" 2 – рекурсивный вывод содержимого дерева"<

cout<<" 3 – нерекурсивный вывод содержимого дерева"<

cout<<" 4 – добавление элементов в дерево"<

cout<<" 5 – удаление любого элемента из дерева"<

cout<<" 6 – выход"<

cin>>i;

switch(i) { case 1: t.sozd();

break;

case 2: t.see(t.root());

break;

case 6: return;

} } } int tree::sozd() // функция создания бинарного дерева { node *u1,*u2;

if(!(u1=new node)) { cout<<"Нет свободной памяти"<

return 0;

} cout<<"Введите информацию в узел дерева ";

u1->inf=new char[N];

cin>>u1->inf;

u1->n=1;

// число повторов информации в дереве u1->l=NULL;

// ссылка на левый узел u1->r=NULL;

// ссылка на правый узел if (!dr) dr=u1;

else { u2=dr;

int k,ind=0;

// ind=1 – признак выхода из цикла поиска do { if(!(k=strcmp(u1->inf,u2->inf))) { u2->n++;

// увеличение числа встреч информации узла ind=1;

// для выхода из цикла do... while } else { if (k<0) // введ. строка < строки в анализируемом узле { if (u2->l!=NULL) u2=u2->l;

// считываем новый узел дерева else ind=1;

// выход из цикла do... while } else // введ. строка > строки в анализируемом узле { if (u2->r!=NULL) u2=u2->r;

// считываем новый узел дерева else ind=1;

// выход из цикла do... while } } } while(!ind);

if (k) // не найден узел с аналогичной информацией { if (k<0) u2->l=u1;

// ссылка в dr1 налево else u2->r=u1;

// ссылка в dr1 направо } } return 1;

} void tree::see(node *u) // функция рекурсивного вывода бинарного дерева { if(u) { cout<<"узел содержит: "<inf<<" число встреч "<n<

if (u->l) see(u->l);

// вывод левой ветви дерева if (u->r) see(u->r);

// вывод правой ветви дерева } } При небольшой модификации в функции main() можно создать несколько объектов класса tree и, например, используя указатель на объект класса tree, вы зывать методы класса для работы с каждым из созданных объектов (бинарных деревьев). Это преобразование предлагается выполнить самостоятельно.

Конструктор explicit В С++ компилятор для конструктора с одним аргументом может автоматически выполнять неявные преобразования. В результате этого тип, получаемый конструктором, преобразуется в объект класса, для которого определен данный конструктор.

#include "iostream.h" class array // класс массив целых чисел { int size;

// размерность массива int *ms;

// указатель на массив public:

array(int = 1);

~array();

friend void print(const array&);

};

array::array(int kl) : size(kl) { cout<<"работает конструктор"<

ms=new int[size];

// выделение памяти для массива for(int i=0;

i

i++) ms[i]=0;

// инициализация } array::~array() { cout<<"работает деструктор"<

delete [] ms;

} void print(const array& obj) { cout<<"выводится массив размерностью"<

for(int i=0;

i

i++) cout<

cout<

} void main() { array obj(10);

print(obj);

// вывод содержимого объекта obj print(5);

// преобразование 5 в array и вывод } В результате выполнения программы получим:

работает конструктор выводится массив размерностью 0 0 0 0 0 0 0 0 0 работает конструктор выводится массив размерностью 0 0 0 0 работает деструктор работает деструктор В данном примере в инструкции:

array obj(10) определяется объект obj и для его создания (и инициализации) вызывается конструктор array(int). Далее в инструкции:

print(obj);

// вывод содержимого объекта obj выводится содержимое объекта obj, используя friend-функцию print(). При выполнении инструкции:

print(5);

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

В некоторых случаях такие преобразования являются нежелательными или, возможно, приводящими к ошибке. В С++ имеется ключевое слово explicit для подавления неявных преобразований. Конструктор, объявленный как explicit:

explicit array(int = 1);

не может быть использован для неявного преобразования. В этом случае ком пилятором (в частности Microosft C++) будет выдано сообщение об ошибке:

Compiling...

error C2664: 'print' : cannot convert parameter 1 from 'const int' to 'const class array &' Reason: cannot convert from 'const int' to 'const class array' No constructor could take the source type, or constructor overload resolution was ambiguous Если необходимо при использовании explicit-конструктора все же создать массив и передать его в функцию print, то надо использовать инструкцию print(array(5));

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

class stroka { char str[100];

public:

……..

int size() { for(int i=0;

*(str+i);

i++);

return i;

} };

В описанном примере функция size() – встроенная. Если функция, объяв ленная в классе, а описанная за его пределами, должна быть встроенной, то она описывается со спецификатором inline:

class stroka { char str[100];

public:

……..

int size();

};

inline int stroka ::size() { for(int i=0;

str[i];

i++);

return i;

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

Организация внешнего доступа к локальным компонентам класса (спецификатор friend) В С++ одна функция не может быть компонентой двух различных клас сов. В то же время иногда возникает необходимость организации доступа к ло кальным данным нескольких классов из одной функции. Для реализации этого в С++ введен спецификатор friend. Если некоторая функция определена как friend функция для некоторого класса, то она:

– не является компонентой-функцией этого класса;

– имеет доступ ко всем компонентам этого класса (private, public и protected).

#include class kls { int i,j;

public:

kls(int i,int J) : i(I),j(J) {} // конструктор int max() {return i>j? i : j;

} // функция-компонента класса kls friend double fun(int, kls&);

// friend-объявление внешней функции fun };

double fun(int i, kls &x) { return (double)i/x.i;

} main() { kls obj(2,3);

cout << obj.max() << endl;

cout << fun(3,obj) << endl;

return 1;

} Функции со спецификатором friend, не являясь компонентами класса, не имеют и, следовательно, не могут использовать this указатель (будет рассмот рен несколько позже). Следует также отметить ошибочность следующей заго ловочной записи функции double kls :: fun(int i,int j), так как fun не является компонентой-функцией класса kls.

В общем случае friend-функция является глобальной независимо от сек ции, в которой она объявлена (public, protected, private), при условии, что она не объявлена ни в одном другом классе без спецификатора friend. Функция friend, объявленная в классе, может рассматриваться как часть интерфейса класса с внешней средой.

Вызов компоненты-функции класса осуществляется с использованием операции доступа к компоненте (.) или(->). Вызов же friend-функции произво дится по ее имени (так как friend-функции не являются его компонентами). Сле довательно, как это будет показано далее, в fried-функции не передается this указатель и доступ к компонентам класса выполняется либо явно (.), либо кос венно (->).

Компонента-функция одного класса может быть объявлена со специфика тором friend для другого класса:

class X{ ……….

void fun (….);

};

class Y{ ……….

friend void X:: fun (….);

};

В приведенном фрагменте функция fun() имеет доступ к локальным ком понентам класса Y. Запись вида friend void X:: fun (….) говорит о том, что функция fun принадлежит классу Х, а спецификатор friend разрешает доступ к локальным компонентам класса Y (так как она объявлена со спецификатором в классе Y).

Ниже приведен пример программы расчета суммы двух налогов на зар плату.

#include "iostream.h" #include "string.h" #include "iomanip.h" class nalogi;

// неполное объявление класса nalogi class work { char s[20];

// фамилия работника int zp;

// зарплата public:

float raschet(nalogi);

// компонента-функция класса work void inpt() { cout << "вводите фамилию и зарплату" << endl;

cin >> s >>zp;

} work(){} ~work(){};

};

class nalogi { float pd, // подоходный налог st;

// налог на соцстрахование friend float work::raschet(nalogi);

// friend-функция класса nalogi public:

nalogi(float f1,float f2) : pd(f1),st(f2){};

~nalogi(void){};

};

float work::raschet(nalogi nl) { cout << s << setw(6) << zp <

// доступ к данным класса work cout << nl.pd << setw(8) << nl.st <

// доступ к данным класса nalogi return zp*nl.pd/100+zp*nl.st/100;

} int main() { nalogi nlg((float)12,(float)2.3);

// описание и инициализация объекта work wr[2];

// описание массива объектов for(int i=0;

i<2;

i++) wr[i].inpt();

// инициализация массива объктов cout<

cout << wr[0].raschet(nlg) << endl;

// расчет налога для объекта wr[0] cout << wr[1].raschet(nlg) << endl;

// расчет налога для объекта wr[1] return 0;

} Следует отметить необходимость выполнения неполного (предваритель ного) объявления класса nalogi, так как в прототипе функции raschet класса work используется объект класса nalogi, объявляемого далее. В то же время полное объявление класса nalogi не может быть выполнено ранее (до объявле ния класса work), так как в нем содержится friend-функция, описание которой должно быть выполнено до объявления friend-функции. В противном случае компилятор выдаст ошибку.

Если функция raschet в классе work также будет использоваться со спе цификатором friend, то приведенная выше программа будет выглядеть следую щим образом:

#include "iostream.h" #include "string.h" #include "iomanip.h" class nalogi;

// неполное объявление класса nalogi class work { char s[20];

// фамилия работника int zp;

// зарплата public:

friend float raschet(work,nalogi);

// friend-функция класса work void inpt() { cout << "вводите фамилию и зарплату" << endl;

cin >> s >>zp;

} work(){} // конструктор по умолчанию ~work(){} // деструктор по умолчанию };

class nalogi { float pd, // подоходный налог st;

// налог на соцстрахование friend float raschet(work,nalogi);

// friend-функция класса nalogi public:

nalogi(float f1,float f2) : pd(f1),st(f2){};

~nalogi(void){};

};

float raschet(work wr,nalogi nl) { cout << wr.s << setw(6) << wr.zp <

// доступ к данным класса work cout << nl.pd << setw(8) << nl.st <

// доступ к данным класса nalogi return wr.zp*nl.pd/100+wr.zp*nl.st/100;

} int main() { nalogi nlg((float)12,(float)2.3);

// описание и инициализация объекта work wr[2];

for(int i=0;

i<2;

i++) wr[i].inpt();

// инициализация массива объктов cout<

cout << raschet(wr[0],nlg) << endl;

// расчет налога для объекта wr[0] cout << raschet(wr[1],nlg) << endl;

// расчет налога для объекта wr[1] return 0;

} Все функции одного класса можно объявить со спецификатором friend по отношению к другому классу следующим образом:

class X{ ………..

friend class Y;

………..

};

В этом случае все компоненты-функции класса Y имеют спецификатор friend для класса Х (имеют доступ к локальным компонентам класса Х).

#include class A { int i;

// компонента-данное класса А public:

friend class B;

// объявление класса В другом класса А A():i(1){} // конструктор ~A(){} // деструктор void f1_A(B &);

// метод, оперирующий данными обоих классов };

class B { int j;

// компонента-данное класса В public:

friend A;

// объявление класса А другом класса В B():j(2){} // конструктор ~B(){} // деструктор void f1_B(A &a){ cout<

} // метод, оперирующий // данными обоих классов };

void A :: f1_A(B &b) { cout<

} void main() { A aa;

B bb;

aa.f1_A(bb);

bb.f1_B(aa);

} Результат выполнения программы:

1 В объявлении класса А содержится инструкция friend class B, являющаяся и предварительным объявлением класса В, и объявлением класса В дружест венным классу А. Отметим также необходимость описания функции f1_A после явного объявления класса В (в противном случае не может быть создан объект b еще не объявленного типа).

Отметим основные свойства и правила использования спецификатора friend:

– friend-функции не являются компонентами класса, но имеют доступ ко всем его компонентам независимо от их атрибута доступа;

– friend-функции не имеют указателя this;

– friend-функции не наследуются в производных классах;

– отношение friend не является ни симметричным (то есть если класс А есть friend классу В, то это не означает, что В также является friend классу А), ни транзитивным (то есть если A friend B и B friend C, то не следует, что A friend C);

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

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

class ext_class { class int_cls { • • • };

public:

• • • };

Класс int_class является вложенным по отношению к классу ext_class (внешний).

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

#include "iostream.h" class cls1 // внешний класс { class cls2 // вложенный класс { int b;

// все компоненты private для cls1 и cls cls2(int bb) : b(bb){} // конструктор класса cls };

public: // public секция для cls int a;

class cls3 // вложенный класс { int c;

// private для cls1 и cls public: // public-секция для класса cls cls3(int cc): c(cc) {} // конструктор класса cls };

cls1(int aa): a(aa) {} // конструктор класса cls };

void main() { cls1 aa(1980);

// верно cls1::cls2 bb(456);

// ошибка cls2 cannot access private cls1::cls3 cc(789);

// верно cout << aa.a << endl;

// верно cout << cc.c << endl;

// ошибка 'c' : cannot access private member // declared in class 'cls1 :: cls3' } В приведенном тексте программы инструкция cls1 :: cls2 bb(456) является ошибочной, так как объявление класса cls2 и его компонента находятся в сек ции private. Для устранения ошибки при описании объекта bb необходимо из менить атрибуты доступа для класса cls2 следующим образом:

public:

class cls { int b;

// private-компонента public:

cls2(int bb) : b(bb){} };

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

#include "iostream.h" class cls1 // внешний класс { int a;

public:

cls1(int aa): a(aa) {} class cls3;

// неполное объявление класса void fun(cls1::cls3);

// функция получает объект класса cls class cls3 // вложенный класс { int c;

public:

cls3(int cc) : c(cc) {} friend void cls1::fun(cls1::cls3);

// ф-ция, дружественная классу cls int pp(){return c;

} };

};

void cls1::fun(cls1::cls3 dd) {cout << dd.c << endl << a;

} void main() { cls1 aa(123);

cls1:: cls3 cc(789);

aa.fun(cc);

} Внешний класс cls1 содержит public-функцию fun(cls1 :: cls3 dd), где dd есть объект, соответствующий классу cls3, вложенному в класс cls1. В свою очередь в классе cls3 имеется friend-функция friend void cls1 :: fun(cls1 :: cls3 dd), обеспечивающая доступ функции fun класса cls1 к локальной компоненте с класса cls3.

#include "iostream.h" #include "string.h" class ext_cls // ВНЕШНИЙ класс { int gd;

// год рождения double zp;

// з/плата class int_cls1 // ПЕРВЫЙ вложенный класс { char *s;

// фамилия public:

int_cls1(char *ss) // конструктор 1-го вложенного класса { s=new char[20];

strcpy(s,ss);

} ~int_cls1() // деструктор 1-го вложенного класса { delete [] s;

} void disp_int1() {cout << s<

} };

public:

class int_cls2 // ВТОРОЙ вложенный класс { char *s;

// фамилия public:

int_cls2(char *ss) // конструктор 2-го вложенного класса { s=new char[20];

strcpy(s,ss);

} ~int_cls2() // деструктор 2-го вложенного класса { delete [] s;

} void disp_int2() {cout << s << endl;

} };

// public функции класса ext_cls ext_cls(int god,double zpl):gd(god),zp(zpl){}// конструктор внешнего // класса int_cls1 *addr(int_cls1 &obj){return &obj;

} // возврат адреса объекта obj void disp_ext() { int_cls1 ob("Иванов");

// создание объекта вложенного класса addr(ob)->disp_int1();

// вывод на экран содержимого объекта ob cout <

} };

void main() { ext_cls ext(1980,230.5);

// ext_cls::int_cls1 in1("Петров");

// неверно, т.к. int_cls1 имеет // атрибут private ext_cls::int_cls2 in2("Сидоров");

in2.disp_int2();

ext.disp_ext();

// } В результате выполнения программы получим:

Сидоров Иванов 1980 230. В строке in2.disp_int2() (main функции) для объекта вложенного класса вызывается компонента-функция ext_cls :: int_cls2 :: disp_int2() для вывода со держимого объекта in2 на экран. В следующей строке ext.disp_ext() вызывается функция ext_cls::disp_ext(), в которой создается объект вложенного класса int_cls1. Затем, используя косвенную адресацию, вызывается функция ext_cls :: int_cls1 :: disp_int1(). Далее выводятся данные, содержащиеся в объек те внешнего класса.

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

#include "string.h" #include "iostream.h" enum boolean {fls,tru};

class cls { char *s;

public:

static int k;

// объявление static-члена в объявлении класса static boolean ind;

void inpt(char *,char);

void print(char);

};

int cls::k=0;

// явное определение static-члена в контексте файла boolean cls::ind;

void cls::inpt(char *ss,char c) { int kl;

// длина строки cin >> kl;

ss=new char[kl];

// выделение блока памяти под строку cout << "введите строку\n";

cin >> ss;

for (int i=0;

*(ss+i);

i++) if(*(ss+i)==c) k++;

// подсчет числа встреч буквы в строке if (k) ind=tru;

// ind==tru – признак того, что буква есть в строке delete [] ss;

// освобождение указателя на строку } void cls::print(char c) { cout << "\n число символов "<< c <<"строки " << k;

} void main() { cls c1,c2;

char c;

char *s;

cls::ind=fls;

cout << "введите символ для поиска в строках";

cin >> c;

c1.inpt(s,c);

c2.inpt(s,c);

if(cls::ind) c1.print(c);

else cout << "\n символ не найден";

} Объявление статических компонент-данных задает их имена и тип, но не инициализирует значениями. Присваивание им некоторых значений выполня ется в программе.

В функции main() использована возможная форма обращения к static компоненте cls::ind (имя класса :: идентификатор), которая обеспечивается тем, что идентификатор имеет видимость public. Это дальнейшее использование оператора разрешения контекста “::”.

Отметим основные правила использования статических компонент:

– статические компоненты будут одними для всех объектов данного клас са. То есть ими используется одна область памяти;

– статические компоненты не являются частью объектов класса;

– объявление статических компонент-данных в классе не является их опи санием. Они должны быть явно описаны в контексте файла;

– локальный класс не может иметь статических компонент;

– к статической компоненте st класса cls можно обращаться cls::st, неза висимо от объектов этого класса, а также используя операторы. и -> при ис пользовании объектов этого класса;

– статическая компонента существует даже при отсутствии объектов это го класса;

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

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

my_class ob1,ob2;

Вызовы компонент-функций имеют вид:

ob1.fun_1();

ob2.fun_2();

Пусть в обеих функциях содержится инструкция:

cout << str;

При объявлении двух объектов создаются две компоненты-данные str.

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

my_class *const this;

Таким образом, при объявлении объектов ob1 и ob2 создаются два this- указателя на эти объекты. Следовательно, любая функция, являющаяся компо нентой некоторого объекта, при вызове получает this-указатель на этот объект.

И приведенная выше инструкция в функции воспринимается как cout << this->str;

Однако эта форма записи избыточна. С другой стороны, явное использо вание указателя this эффективно при решении некоторых задач.

Рассмотрим пример использования this-указателя на примере упорядочи вания чисел в массиве.

#include #include class m_cl { int a[3];

public:

m_cl srt();

// функция упорядочивания информации в массиве m_cl *inpt();

// функция ввода чисел в массив void out();

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

m_cl m_cl::srt() // функция сортировки { for(int i=0;

i<2;

i++) for(int j=i;

j<3;

j++) if (a[i]>a[j]) {a[i]=a[i]+a[j];

a[j]=a[i]-a[j];

a[i]=a[i]-a[j];

} return *this;

// возврат содержимого объекта, на который } // указывает указатель this m_cl * m_cl::inpt() // функция ввода { for(int i=0;

i<3;

i++) cin >> a[i];

return this;

// возврат скрытого указателя this } // (адреса начала объекта) void m_cl::out() { cout << '\n';

for(int i=0;

i<3;

i++) cout << a[i] << ' ';

} main() { m_cl o1,o2;

// описание двух объектов класса m_cl o1.inpt()->srt().out();

// вызов компонент-функций первого объекта o2.inpt()->srt().out();

// вызов компонент-функций второго объекта return 1;

} Вызов компонент-функций для каждого из созданных объектов осущест вляется:

o1.inpt()->srt().out;

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

сначала вызывается функция inpt для ввода информации в массив данных объекта о1;

функция inpt возвращает адрес памяти, где расположен объект о1;

далее вызывается функция сортировки информации в массиве, возвра щающая содержимое объекта о1;

после этого вызывается функция вывода информации.

Ниже приведен текст еще одной программы, использующей указатель this.

#include #include class B;

// предварительное объявление класса В class A { char *s;

public:

A(char *S) { s=new char[50];

strcpy(s,S);

} ~A(){delete [] s;

} void pos_str(char *);

};

class B { char *ss;

public:

B(char *SS) { ss=new char[20];

strcpy(ss,SS);

} ~B(){delete [] ss;

} char *f_this(void){return this->ss;

} };

void A::pos_str(char *ss) { char *dd;

int ii;

dd=new char[strlen(s)+strlen(ss)+2];

strcpy(dd,s);

ii=strlen(s);

for(int i=0;

*(ss+i);

i++) *(dd+ii+i)=*(ss+i);

*(dd+ii+i)=0;

delete s;

s=new char[strlen(s)+strlen(ss)];

strcpy(s,dd);

delete [] dd;

cout << s << endl;

} void main(void) { A a1("aa bcc dd ee");

B b1("bd");

a1.pos_str(b1.f_this());

} Отметим основные правила использования this-указателей:

– каждому объявляемому объекту соответствует свой скрытый this- ука затель;

– this-указатель может быть использован только для нестатической функ ции;

– this указывает на начало своего объекта в памяти;

– this не надо дополнительно объявлять;

– this передается как скрытый аргумент во все нестатические (не имею щие спецификатора static) компоненты-функции своего объекта;

– указатель this – локальная переменная и недоступна за пределами объ екта;

– обращаться к скрытому указателю можно this или *this.

Компоненты-функции static и const В С++ компоненты-функции могут использоваться с модификатором static и const. Обычная компонента-функция, вызываемая object. function(a,b);

имеет явный список параметров a и b и неявный список параметров, состоящий из компонент данных переменной object. Неявные параметры можно предста вить как список параметров, доступных через указатель this. Статическая (static) компонента-функция не может обращаться к любой из компонент по средством указателя this. Компонента-функция const не может изменять неяв ные параметры.

#include "iostream.h" class cls { int kl;

// количество изделий double zp;

// зарплата на производство 1 изделия double nl1,nl2;

// два налога на з/пл double sr;

// кол-во сырья на изделие static double cs;

// цена сырья на 1 изделие public:

cls(){} // конструктор по умолчанию ~cls(){} // деструктор void inpt(int);

static void vvod_cn(double);

double seb() const;

};

double cls::cs;

// явное определение static-члена в контексте файла void cls::inpt(int k) { kl=k;

cout << "Введите з/пл и 2 налога";

cin >> nl1 >> nl2 >> zp;

} void cls::vvod_cn(double c) { cs=c;

// можно обращаться в функции только к static-компонентам;

} double cls::seb() const {return kl*(zp+zp*nl1+zp*nl2+sr*cs);

//в функции нельзя изменить ни один } // неявный параметр (kl zp nl1 nl2 sr) void main() { cls c1,c2;

c1.inpt(100);

// инициализация первого объекта c2.inpt(200);

// инициализация второго объекта cls::vvod_cn(500.);

// cout << "\nc1" << c1.seb() << "\nc2" << c2.seb() << endl;

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

void cls::vvod_cn(double c) { cs=c;

} Функции класса, объявленные со спецификатором const, могут быть вы званы для объекта со спецификатором const, а функции без спецификатора const – не могут.

const cls c1;

cls c2;

c1.inpt(100);

// неверный вызов c2.inpt(100);

// правильный вызов функции c1.seb();

// правильный вызов функции Для функций со спецификатором const указатель this имеет следующий тип:

const имя_класса * const this;

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

double cls::seb() const { ((cls *)this)->zp--;

// возможная модификация неявного параметра // zp посредством явной записи this-указателя return kl*(zp+zp*nl1+zp*nl2+sr*cs);

} Если функция, объявленная в классе, описывается отдельно (вне класса), то спецификатор const должен присутствовать как в объявлении, так и в описа нии этой функции.

Основные свойства и правила использования static- и const- функций:

– статические компоненты-функции не имеют указателя this, поэтому об ращаться к нестатическим компонентам класса можно только с использованием. или ->;

– не могут быть объявлены две одинаковые функции с одинаковыми име нами и типами аргументов, при этом одна статическая, а другая нет;

– статические компоненты-функции не могут быть виртуальными.

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

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

Формат объявления ссылки имеет вид:

тип & имя_ссылки = инициализатор.

Ссылку нельзя объявить без ее инициализации. Ниже приведен пример использования ссылки.

#include "iostream.h" #include "string" class A { char s[80];

int i;

public :

A(char *S,int I):i(I) { strcpy(s,S);

} ~A(){} void see() {cout<

} };

void main() { A a("aaaaa",3),aa("bbbb",7);

A &b=a;

// ссылка на объект класса А инициализирована значением а cout<<"компоненты объекта :";

a.see();

cout<<"компоненты ссылки :";

b.see();

cout <<"адрес a="<<&a << " адрес &b= "<< &b << endl;

b=aa;

// присвоение значений объекта aa ссылке b (и объекту a) cout<<"компоненты объекта :";

a.see();

cout<<"компоненты ссылки :";

b.see();

int i=4,j=2;

int &ii=i;

// ссылка на переменную i типа int cout << "значение i= "<

#include void fun1(int,int);

void fun2(int &,int &);

void main() { int i=1,j=2;

// i и j – локальные параметры cout << "\n адрес переменных в main() i = "<<&i<<" j = "<<&j;

cout << "\n i = "<

strcpy(naz,s1);

kl=i;

} book::~book() {cout << "\n работает деструктор класса book";

} avt::avt(char *s1,int i,char *s2) : book(s1,i) { cout << "\n работает конструктор класса avt";

strcpy(fm,s2);

} avt::~avt() {cout << "\n работает деструктор класса avt";

} void avt::see() { cout<<"\nназвание : "<

} rzd::rzd(char *s1,int i,razd tp) : book(s1,i) { cout << "\n работает конструктор класса rzd";

rz=tp;

} rzd::~rzd() {cout << "\n работает деструктор класса rzd";

} void rzd::see() { switch(rz) { case teh : cout << "\nраздел технической литературы";

break;

case hyd : cout << "\ nраздел художественной литературы ";

break;

case uch : cout << "\ nраздел учебной литературы ";

break;

} } void main() {avt av("Книга 1",123," автор1");

//вызов конструкторов классов book и avt rzd rz("Книга 1",123,teh);

//вызов конструкторов классов book и rzd av.see();

rz.see();

} На приведенном ниже примере показаны различные способы доступа к компонентам классов иерархической структуры, в которой классы A, B, C – ба зовые для класса D, а класс D, в свою очередь, является базовым для класса Е.

#include "iostream.h" class A { private: a_1(){cout<<"private-функция a_1"<< endl;

} protected: a_2(){cout<<"protected-функция a_2"<< endl;

} public: a_3(){cout<<"public-функция a_3"<< endl;

} };

class B { private: b_1(){cout<<"private-функция b_1"<< endl;

} protected: b_2(){cout<<"protected-функция b_2"<< endl;

} public: b_3(){cout<<"public-функция b_3"<< endl;

} };

class C { private: c_1(){cout<<"private-функция c_1"<< endl;

} protected: c_2(){cout<<"protected-функция c_2"<< endl;

} public: c_3(){cout<<"public-функция c_3"<< endl;

} };

class D : public A, protected B, private C { private: d_1(){cout<<"private-функция d_1"<< endl;

} protected: d_2(){cout<<"protected-функция d_2"<< endl;

} public: d_3();

};

D:: d_3() { d_1();

d_2();

// a_1();

//'a_1' cannot access private member declared in class 'A' a_2();

a_3();

// b_1();

//'b_1' cannot access private member declared in class 'B' b_2();

b_3();

// c_1();

//'c_1' cannot access private member declared in class 'C' c_2();

c_3();

return 0;

} class E : public D { public: e_1();

};

E:: e_1() {// a_1();

//'a_1' cannot access private member declared in class 'A' a_2();

a_3();

// b_1();

// b_1 cannot access private member declared in class 'B' b_2();

b_3();

// c_1();

// c_1 cannot access private member declared in class 'C' // c_2();

// c_2 cannot access private member declared in class 'C' // c_3();

// c_3 cannot access private member declared in class 'C' return 0;

} int main() { A a;

a.a_3();

B b;

b.b_3();

C c;

c.c_3();

D d;

d.a_3();

// d.b_3();

// b_3 cannot access public member declared in class 'B' // d.c_3();

// c_3 cannot access public member declared in class 'C' E e;

e.d_3();

e.e_1();

return 0;

} Конструкторы и деструкторы Инструкция avt av("книга 1",123," автор 1") в примере программы пре дыдущего пункта приводит к формированию объекта av и вызова конструктора avt производного класса и конструктора book базового класса (предыдущая программа):

void avt::avt(char *s1,int i,char *s2) : book(s1,i) При этом вначале вызывается конструктор базового класса book (выпол няется инициализация компонент-данных naz и kl), затем конструктор произ водного класса avt (инициализация компоненты fm). Поскольку базовый класс ничего не знает про производные от него классы, его инициализация (вызов его конструктора) производится перед инициализацией (активизацией конструкто ра) производного класса.

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

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

имя_конструктора(тип переменной_1 имя_переменной_1,…, тип переменной_n имя_переменной_n) :

имя_конструктора_базового_класса(имя_переменной_1,…, имя_переменной_k), компонента_данное_1(имя_переменной_m),…, компонента_данное_n(имя_переменной_n);

#include "iostream.h" class A // БАЗОВЫЙ класс { protected:double pr1,pr2;

// protected для видимости pr в классе B public:

A(double prc1,double prc2): pr1(prc1),pr2(prc2) {};

void a_prnt(){cout << "% налога = " << pr1 << " и " << pr2 << endl;

} };

class B : public A // ПРОИЗВОДНЫЙ класс { int sm;

public:

B(double prc1,double prc2,int sum): A(prc1,prc2),sm(sum) {};

void b_prnt() { cout << " налоги на сумму = " << sm << endl;

cout << "первый = " << pr1 <<"\n втрой = " << pr2 << endl;

} double rashet() {return pr1*sm/100+pr2*sm/100;

} };

void main() { A aa(9,5.3);

// описание объекта аа (базового класса) и инициа- // лизация его компонент с использованием // конструктора А() B bb(7.5,5,25000);

// описание объекта bb (производного класса) // и инициализация его компонент (вызов конструк- // тора B() и конструктора А() (первым)) aa.a_prnt();

bb.b_prnt();

cout << "Сумма налога = " << bb.rashet() << endl;

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

public: A(double prc1,double prc2): pr1(prc1),pr2(prc2) {};

public: B(double prc1,double prc2,int sum): A(prc1,prc2),sm(sum) {};

Конструктор А считывает из стека 2 double значения prc1 и prc2, кото рые далее используются для инициализации компонент класса А pr1(prc1),pr2(prc2). Аналогично конструктор В считывает из стека 2 double значения prc1 и prc2 и одно значение int, после чего вызывается конструктор класса A(prc1,prc2), затем выполняется инициализация компоненты sm класса В.

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

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

#include #include class st // описание класса – элемент стека операций { public :

char c;

st *next;

public:

st(){} // конструктор ~st(){} // деструктор };

class cl : public st { char *a;

// исходная строка (для анализа) char outstr[80];

// выходная строка public :

cl() : st() {} // конструктор ~cl(){} // деструктор st *push(st *,char);

// занесение символа в стек char pop(st **);

// извлечение символа из стека int PRIOR(char);

// определение приоритета операции char *ANALIZ(char *);

// преобразование в польскую запись };

char * cl::ANALIZ(char *aa) { st *OPERS;

// OPERS=NULL;

// стек операций пуст int k,p;

a=aa;

k=p=0;

while(a[k]!='\0'&&a[k]!='=') // пока не дойдем до символа '=' { if(a[k]==')') // если очередной символ ')' { while((c=pop(&OPERS))!='(') // считываем из стека в выходную outstr[p++]=c;

// строку все знаки операций до символа // ‘(‘ и удаляем из стека ‘(‘ } if(a[k]>='a'&&a[k]<='z') // если символ – буква, то outstr[p++]=a[k];

// заносим ее в выходную строку if(a[k]=='(') // если очередной символ '(', то OPERS=push(OPERS,'(');

// помещаем его в стек if(a[k]=='+'||a[k]=='-'||a[k]=='/'||a[k]=='*') { // если следующий символ – знак операции, то while((OPERS!=NULL)&&(PRIOR(c)>=PRIOR(a[k]))) outstr[p++]=pop(&OPERS);

// переписываем в выходную строку все // находящиеся в стеке операции с большим // или равным приоритетом OPERS=push(OPERS,a[k]);

// записываем в стек очередную операцию } k++;

// переход к следующему символу выходной строки } while(OPERS!=NULL) // после анализа всего выражения outstr[p++]=pop(&OPERS);

// переписываем операции из стека outstr[p]='\0';

// в выходную строку return outstr;

} st *cl::push(st *head,char a) // функция записи символа в стек и возврата { st *PTR;

// указателя на вершину стека if(!(PTR=new st)) { cout << "\n недостаточно памяти для элемента стека";

exit(-1);

} PTR->c=a;

// инициализация элемента стека PTR->next=head;

return PTR;

// PTR – вершина стека } char cl::pop(st **head) // функция удаления символа с вершины стека { st *PTR;

// возвращает символ (с вершины стека) и коррек- // тирует указатель на вершину стека char a;

if(!(*head)) return '\0';

// если стек пуст, то возвращается ‘\0' PTR=*head;

// адрес вершины стека a=PTR->c;

// считывается содержимое с вершины стека *head=PTR->next;

// изменяем адрес вершины стека (nex==PTR->next) delete PTR;

return a;

} int cl::PRIOR(char a) // функция возвращает приоритет операции { switch(a) { case '*':case '/':return 3;

case '-':case '+':return 2;

case '(':return 1;

} return 0;

} void main() { char a[80];

// исходная строка cl cls;

cout << "\nВведите выражение (в конце символ '='): ";

cin >> a;

cout << cls.ANALIZ(a) << endl;

} В результате работы программы получим:

Введите выражение (в конце символ '=') : (a+b)-c*d= ab+cd*- Виртуальные функции Один из основных принципов объектно-ориентированного программиро вания предполагает использование идеи «один интерфейс – множество методов реализации». Эта идея заключается также в том, что базовый класс обеспечива ет все элементы, которые производные классы могут непосредственно исполь зовать, плюс набор функций, которые производные классы должны реализовать путем их переопределения. Наряду с механизмом перегрузки функций это дос тигается использованием виртуальных (virtual) функций. Виртуальная функция – это функция, объявленная с ключевым словом virtual в базовом классе и пере определенная в одном или нескольких производных от этого классах. При вы зове объекта базового или производных классов динамически (во время выпол нения программы) определяется, какую из функций требуется вызвать, основы ваясь на типе объекта.

Рассмотрим пример использования виртуальной функции.

#include "iostream.h" #include "iomanip.h" #include "string.h" class grup // БАЗОВЫЙ класс { protected:

char *fak;

// наименование факультета long gr;

// номер группы public:

grup(char *FAK,long GR) : gr(GR) { if (!(fak=new char[20])) { cout<<"ошибка выделения памяти"<

return;

} strcpy(fak,FAK);

} ~grup() { cout << "деструктор класса grup " << endl;

delete fak;

} virtual void see(void);

// объявление виртуальной функции };

class stud : public grup // ПРОИЗВОДНЫЙ класс { char *fam;

// фамилия int oc[4];

// массив оценок public:

stud(char *FAK,long GR,char *FAM,int OC[]): grup(FAK,GR) { if (!(fam=new char[20])) { cout<<"ошибка выделения памяти"<

return;

} strcpy(fam,FAM);

for(int i=0;

i<4;

oc[i]=OC[i++]);

} ~stud() { cout << "деструктор класса stud " << endl;

delete fam;

} void see(void);

};

void grup::see(void) // описание виртуальной функции { cout << fak << gr << endl;

} void stud::see(void) // { grup ::see();

// вызов функции базового класса cout <

for(int i=0;

i<4;

cout << oc[i++]<<’ ’);

cout << endl;

} int main() { int OC[]={4,5,5,3};

grup gr1("факультет 1",123456), gr2("факультет 2",345678), *p;

stud st("факультет 2",150502,"Иванов",OC);

p=&gr1;

// указатель на объект базового класса p->see();

// вызов функции базового класса объекта gr (&gr2)->see();

// вызов функции базового класса объекта gr p=&st;

// указатель на объект производного класса p->see();

// вызов функции производного класса объекта st return 0;

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

факультет 1 факультет 2 факультет 2", Иванов 4 5 5 Объявление virtual void see(void) говорит о том, что функция see может быть различной для базового и производных классов. Тип виртуальной функ ции не может быть переопределен в производных классах. Исключением явля ется случай, когда возвращаемый тип виртуальной функции является указате лем или ссылкой на порожденный класс, а виртуальная функция основного класса – указателем или ссылкой на базовый класс. В производных классах функция может иметь список параметров, отличный от параметров виртуаль ной функции базового класса. В этом случае эта функция будет не виртуальной, а перегруженной. Вызов функций должен производиться с учетом списка пара метров.

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

Если функция вызывается с использованием ее полного имени grup::see(), то виртуальный механизм игнорируется. Игнорирование этого может привести к серьезной ошибке:

void stud::see(void) { see();

.... } В этом случае инструкция see() приводит к бесконечному рекурсивному вызову функции see().

Заметим, что деструктор может быть виртуальным, а конструктор нет.

Замечание. В чем разница между виртуальными функциями (методами) и переопределением функции?

Что изменилось, если бы функция see() не была бы описана как виртуаль ная? В этом случае решение о том, какая именно из функций see() должна быть выполнена, будет принято при ее компиляции.

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

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

func(cls obj) { obj.vvod();

// вызов компоненты-функции obj::vvod } func1(cls &obj) { obj.vvod();

// вызов компоненты-функции в соответствии } // с типом объекта, на который ссылается obj Виртуальные функции позволяют принимать решение в процессе выпол нения.

#include "iostream.h" #include "iomanip.h" #include "string.h" #define N class base // БАЗОВЫЙ класс { public:

virtual char *name(){ return " noname ";

} virtual double area(){ return 0;

} };

class rect : public base // ПРОИЗВОДНЫЙ класс (прямоугольник) { int h,s;

public:

virtual char *name(){ return " прямоугольника ";

} rect(int H,int S): h(H),s(S) {} double area(){ return h*s;

} };

class circl : public base // ПРОИЗВОДНЫЙ класс (окружность) { int r;

public:

virtual char *name(){ return " круга ";

} circl(int R): r(R){} double area(){ return 3.14*r*r;

} };

int main() { base *p[N],a;

double s_area=0;

rect b(2,3);

circl c(4);

for(int i=0;

i

i++) p[i]=&a;

p[0]=&b;

p[1]=&c;

for(i=0;

i

i++) cout << "плошадь" << p[i]->name() << p[i]->area() << endl;

return 0;

} Массив указателей p хранит адреса объектов базового и производных классов и необходим для вызова виртуальных функций этих классов. Вирту альная функция базового класса необходима тогда, когда она явно вызывается для базового класса или не определена (не переопределена) для некоторого производного класса.

Если функция была объявлена как виртуальная в некотором классе (базо вом классе), то она остается виртуальной независимо от количества уровней в иерархии классов, через которые она прошла.

class A {...

public: virtual void fun() {} };

class B : public A {...

public: void fun() {} };

class C : public B {...

public:

... // в объявлении класса С отсутствует описание функции fun() };

main() { A a,*p=&a;

B b;

C c;

p->fun();

// вызов версии виртуальной функции fun для класса А p=&b;

p->fun();

// вызов версии виртуальной функции fun для класса B p=&c;

p->fun();

// вызов версии виртуальной функции fun для класса С (из А) } Если в производном классе виртуальная функция не переопределяется, то используется ее версия из базового класса.

class A {...

public: virtual void fun() {} };

class B : public A {...

public: void fun() {} };

class C : public B {...

public: void fun() {} };

main() { A a,*p=&a;

B b;

C c;

p->fun();

// вызов версии виртуальной функции fun для класса А p=&b;

p->fun();

// вызов версии виртуальной функции fun для класса B p=&c;

p->fun();

// вызов версии виртуальной функции fun для класса А } Основное достоинство данной иерархии состоит в том, что код не нужда ется в глобальном изменении, даже при добавлении вычислений площадей но вых фигур. Изменения вносятся локально и благодаря полиморфному характеру кода распространяются автоматически.

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

class A { public :

virtual void f() { return;

} void fn() { f();

} // вызов функции f };

class B : public A { public:

void f() { return;

} void fn() { f();

} // вызов функции f };

main() { A a,*pa=&a;

B b,*pb=&b;

pa = &b;

pa->fn();

// вызов виртуальной функции f класса В через A::fn() pb->fn();

// вызов виртуальной функции f класса В через B::fn() } В инструкции pa->fn() выполняется вызов функции fn() базового класса А, так как указатель pa – указатель на базовый класс и компилятор выполняет вызов функции базового класса. Далее из функции fn() выполняется вызов вир туальной функции f() класса B, так как указатель pa инициализирован адресом объекта B.

Перечислим основные свойства и правила использования виртуальных функций:

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

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

– виртуальные функции можно объявить только в классах (class) и струк турах (struct);

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

– виртуальные функции можно объявить со спецификатором friend для другого класса;

– виртуальными функциями могут быть только неглобальные функции (то есть компоненты класса);

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

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

– при использовании полного имени при вызове некоторой виртуальной функции (например, grup ::see();

), виртуальный механизм не применяется.

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

virtual прототип функции = 0;

Чисто виртуальная функция используется для того, чтобы отложить ре шение о реализации функции. То, что функция объявлена чисто виртуальной, требует, чтобы эта функция была определена во всех производных классах от класса, содержащего эту функцию. Если класс имеет хотя бы одну чисто вирту альную функцию, то он называется абстрактным. Для абстрактного класса нельзя создать объекты и он используется только как базовый класс для других классов. Если base – абстрактный класс, то для инструкций base a;

base *p= new base;

компилятор выдаст сообщение об ошибке. В то же время вполне можно использовать инструкции вида rect b;

base *p=&b;

base &p=b;

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

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

class base { компоненты-данные public:

virtual ~base() = 0;

компоненты-функции } base ::~base() {реализация деструктора} Объект класса base создать невозможно, в то же время деструктор его определен и будет вызван при разрушении объектов производных классов.

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

В примере мир будет иметь различные формы взаимодействия жизни с исполь зованием абстрактного базового класса living. Его интерфейс унаследован раз личными формами жизни. Создадим fox (лис) – хищника, rabbit (кролик) – жертву и grass – (траву).

#include "iostream.h" #include "conio.h" // моделирование хищник – жертва с использованием // иерархии классов const int N=6, // размер квадратной площади (мира) STATES=4, // кол-во видов жизни DRAB=5,DFOX=5, // кол-во циклов жизни кролика и лиса CYCLES=10;

// общее число циклов моделирования мира enum state{EMPTY,GRASS,RABBIT,FOX};

class living;

// forvard объявление typedef living *world[N][N];

// world- модель мира void init(world);

void gener(world);

void update(world,world);

void dele(world);

class living {protected:

int row,col;

// местоположение в модели void sums(world w,int sm[]);

// public:

living(int r,int c):row(r),col(c){} virtual state who() = 0;

Pages:     || 2 | 3 |



© 2011 www.dissers.ru - «Бесплатная электронная библиотека»

Материалы этого сайта размещены для ознакомления, все права принадлежат их авторам.
Если Вы не согласны с тем, что Ваш материал размещён на этом сайте, пожалуйста, напишите нам, мы в течении 1-2 рабочих дней удалим его.