Ооп. 
Объектно-ориентированное программирование

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

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

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

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

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

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

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

Введение

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

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

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

Класс является типом данных, определяемым пользователем. Тип задает внутреннее представление данных в памяти компьютера, множество значений, которое могут принимать величины этого типа, а также операции и функции, применяемые к этим величинам. Все это можно задать и в классе. Например, тип int определяет, что величина этого типа (int i) занимает 4 байта, принимает значения от -2³¹ до 2³¹-1 и ее можно складывать, вычитать, и т. д. Создаваемый тип данных (квадрат) определяет, что объект этого типа (конкретный квадрат) будет занимать столько байт, сколько необходимо для размещения отдельных данных (положение, размер, ориентация (угол поворота), цвет). Размещение и размер квадрата ограничены пределами экрана, угол поворота — от 0 до 90 градусов. Квадрат можно переместить, повернуть, сменить цвет, прочертить.

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

Объектно-ориентированное программирование (ООП) — основная методология программирования 90-х. Она берет начало в Simula 67 и продолжается в (ранних) Smalltalk, LISP, Clu и (более поздних) Actor, Eiffel, Objective C, Java и C++.

[Буч]: ООП — это методология программирования, основанная на представлении программы в виде совокупности объектов, каждый из которых является экземпляром определенного класса, а классы образуют иерархию наследования.

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

ООП использует в качестве базовых элементов объекты, а не алгоритмы;

каждый объект является экземпляром какого-либо определенного класса;

классы организованы иерархически.

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

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

Inheritance — наследование.

Фазы трансляции Программа на C++ состоит из:

одного или нескольких исходных файлов (с расширением .cpp);

нуля и более заголовочных файлов (с расширением .h).

Каждый этих файлов содержит некоторую часть текста программы.

Трансляция включает в себя три фазы (см. рис. 2):

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

Рис. 1. Трансляция программы на C++

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

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

Директивы препроцессора указывают действие, которое нужно выполнить препроцессору. Все директивы начинаются с символа #.

Директива макроопределения.

#define идентиф замещающий_текст.

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

#define IDI_ICON1 101.

#define HIWORD (l) ((WORD)(((DWORD)(l) >> 16) & 0xFFFF)).

#define CASE break; case.

#define FOREVER for (;;).

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

Директива #include.

#include «path-spec» .

#include.

Директивы включения могут быть вложенными (до 10 уровней).

#undef идентиф.

#pragma токен-стринг #pragma vtordisp (off).

Область видимости (scope).

Каждое имя (не только имя переменной) в C++ может использоваться только в определенной области программы. Эта область называется областью видимости имени.

Существует 5 областей видимости: локальная о.в., о.в. функции, о.в. файла, о.в. класса, о.в. прототипа.

Локальная область видимости. Имя, объявленное внутри блока, доступно только в этом блоке и в содержащихся в нем блоках, и только после точки объявления. Замещение имен.

Область видимости функции. Такую о.в. имеют только метки для оператора goto. Метки могут использоваться в любом месте функции, но не за ее пределами.

Область видимости файла. Любое имя, объявленное вне какого бы то ни было блока или класса, имеет о.в. файла. Имя доступно после точки объявления до конца файла. Доступ через унарный оператор: i.

Область видимости класса. Имена членов класса имеют о.в. класса. Доступ через объект (. ->) и через бинарный оператор classname: i.

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

Связывание (linkage).

Программа состоит из нескольких единиц трансляции, связываемых вместе. Способ, которым имена объектов и функций совместно используются в различных ед. трансляции, называется связыванием. Существует 3 типа связывания: внутреннее (static int a;), внешнее (int a; extern int a;) и отсутствие связывания (typedef, enum).

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

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

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

Класс памяти (storage class).

Класс памяти управляет продолжительностью жизни и связыванием объектов (переменных) в C++. (auto, register, static и extern).

Свободная память Унарные операторы new и delete служат для управления свободной памятью. Свободная память — это предоставляемая системой область памяти для объектов, время жизни которых напрямую управляется программистом. Программист создает объект с помощью ключевого слова new, а уничтожает его, используя delete. Это важно при работе с динамическими структурами данных, такими как списки и деревья. Еще один пример — создание объектов, которые используются после возвращения из функции, в которой они были созданы.

Оператор new принимает следующие формы:

new имя_типа.

new имя_типа инициализатор

new имя_типа [выражение].

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

int *p, *q;

p=new int (5);

q=new int[10];

delete выражение.

delete [] выражение Структуры Массив — набор элементов одинакового типа.

Структура — набор элементов произвольных типов. Элемент структуры называется членом.

struct human{.

char *name;

int age;

}; //точка с запятой после '}'.

void f (){.

human vova;

vova.name="Vova" ;

vova.age=70;

human piter={" Петя", 100};

human *pp=&vova;

pp->age+=1;

}.

Имя структуры (human) называется теговым именем и является типом. Можно объявлять переменные типа human (vova, piter). Их можно присваивать, передавать в качестве аргументов и возвращать в качестве значения функции.

Инициализация структуры (см. прог.).

Для доступа к членам структуры используется оператор «точка» — «.» (vova.name). Конструкция вида переменная_структуры.имя_члена используется как простая переменная.

Оператор указателя структуры. К объектам типа структуры часто обращаются посредством указателей с помощью оператора «->» :

указатель_на_структуру->имя_члена Это эквивалентно.

(*указатель_на_структуру).имя_члена Структура — тип данных, определяемый пользователем.

Определим тип стека.

const int max_len=1000;

struct stack{.

int top;

char s[max_len];

};

void reset (stack *stk){stk->top=0;}.

void push (stack *stk, char c){stk->s[stk->top++]=c;}.

char pop (stack *stk){return stk->s[—stk->top]; }.

bool is_empty (const stack *stk){return stk->top==0;}.

bool is_full (const stack *stk){return stk->top==max_len;}.

void use_stack ().

{.

stack s;

char str[]="Using Stack!!!" ;

int i=0;

cout<

reset (&s);

while (str[i]) push (&s, str[i++]);

while (!is_empty (&s))cout<

cout<

// pop (&s);

}.

Напечатается строка в прямом и обратном порядках.

КЛАССЫ В C++ существуют два вида типов: встроенные и типы классов. Встроенные типы включают в себя: char, int, double. Типы классов включают в себя, например: string, vector, istream, CFile, CDialog.

Свои типы классов может создавать и программист. Если они хорошо написаны, то их также легко использовать, как и встроенные типы.

Класс применяется для определения типов, соответствующих концепциям приложения.

Функции-члены класса Концепция struct расширена в C++ так, что функции могут быть членами структур. Объявление функции включается в объявление структуры и эта функция вызывается с использованием методов доступа, которые определены для членов структуры. Идея заключается в том, что функциональность, необходимая для работы с типом данных struct, должна быть прямо включена в объявление структуры.

Перепишем стек: (сначала определим функции в пределах struct).

struct stack2.

{.

enum{ max_len=100};

int top;

char s[max_len];

void reset ();

void push (char c);

char pop ();

bool is_empty ()const;

bool is_full ()const;

};

void stack2: reset () {top=0;}.

void stack2: push (char c){s[top++]=c;}.

char stack2: pop (){return s[—top]; }.

bool stack2: is_empty ()const {return top==0;}.

bool stack2: is_full ()const {return top==max_len;}.

Эти функции отличаются тем, что могут обращаться к именам членов класса (top, s) «как есть», непосредственно.

void use_stack2().

{.

stack2 s;

char str[]="Using Stack!!!" ;

int i=0;

cout<

s.reset ();

while (str[i]).

s.push (str[i++]);

while (!s.is_empty ()).

cout<

cout<

// pop (&s);

}.

При вызове функций-членов применительно к конкретному объекту типа stack2 они действуют на указанные члены именно этого (своего) объекта: операционный программирование пользовательский интерфейс.

stack2 data, operands;//создаются 2 отдельных объекта со своими.

//top и s[].

//но функции не отдельные, а одни и те же.

data.reset ();//data.top=0;

operands.reset ();//operands.top=0;

stack2 *pstack=&operands;

pstack->push ('A');//operands.s[operands.top++]='A'.

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

Используется оператор разрешения области видимости «:» .

Управление доступом Понятие структуры расширено в С++ так, что появилась возможность вводить закрытые (private) и открытые (public) члены. Это касается как членов данных, так и функций-членов структуры.

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

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

struct primer{.

public:

int a; //public member.

double b (int); //public member.

private:

int c; //private member.

double d (int); //private member.

};

double primer: b (int p).

{.

a=7; //ok, can access all members.

b (3); //ok.

c=2; //ok.

return d (1); //ok.

}.

double primer: d (int p).

{.

a=7; //ok, can access all members.

b (3); //ok.

c=2; //ok.

return d (1); //ok.

}.

double use (int p).

{.

primer pr;

pr.a=7; //ok, public member.

pr.b (3); //ok, public member.

// pr. c=2; //error: cannot access private member.

// return pr. d (1);//error: cannot access private member.

return 1;

}.

Переменная primer: c может быть изменена с помощью вызова функции primer: b (), но не непосредственно.

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

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

Другое преимущество — локализация ошибок. Неправильное значение закрытого члена данных может быть вызвано только неверным кодом функций-членов. Классы являются формой структуры, у которой право доступа по умолчанию закрытое. Таким образом, struct и class взаимозаменяемы при условии надлежащего определения прав доступа.

class a{.

int b;//private.

}.

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

Конструкторы — это специальные функции-члены, которые определяют, как инициализируются объекты.

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

class stack3.

{.

public:

stack3(); //конструктор по умолчанию.

stack3(char);//stack that contains 1 element.

void push (char c);

char pop ();

bool is_empty ()const;

bool is_full ()const;

private:

enum{ max_len=100};

int top;

char s[max_len];

};

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

void use_stack3().

{.

stack3 s; //выполняется конструктор по умолчанию.

stack3 s1('d');//выполняется конструктор с одним аргументом.

stack3 *ps=new stack3();//выполняется конструктор по умолч.

stack3 *ps1=new stack3('d');//выполн. конструктор c 1 арг.

delete ps;

delete ps1;

}.

Определение конструктора.

stack3:stack3():top (0){}.

stack3:stack3(char c)//stack that contains 1 element.

:top (1).

{.

s[0]=c;

}.

В определении конструктора используется новый для вас синтаксис. Между символом «:» и открывающей фигурной скобкой ({) находится ряд инициализаторов конструктора (constructor initializers), в данном случае 1 инициализатор. Инициализаторы конструктора велят компилятору инициализировать заданные члены значениями, указанными в соответствующих круглых скобках. В частности, top устанавливается равным 0. Второй конструктор иниц.1 и выполняет присваивание.

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

• 1. C++ - среда выделяет память для хранения объекта.
• 2. C++ - среда инициализирует объект в соответствии со списком инициализации конструктора.
• 3. C++ - среда выполняет тело конструктора.

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

Пример с 2 инициализаторами конструктора.

class complex{.

complex (double real, double imag);

complex (double real);

};

complex:complex (double real, double imag).

{re=real; im=imag;}.

complex:complex (double real).

{re=real; im=0;}.

Использование:

complex c3(2,3); //инициализация Конструктор не имеет возвращаемого значения (даже void).

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

Деструкторы Некоторым классам требуется функция, которая гарантированно вызывается при уничтожении объекта (для закрытия файла, снятия блокировки и т. д.). Такие функции называются деструкторами. Имя деструктора — это имя конструктора с предшествующим символом «тильда»:

~stack3(){delete[] s};

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

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

имя_класса: идентификатор Здесь используется оператор разрешения области видимости.

Пример:

<�сначала how_many_,.

затем how_many (),.

затем const max_len_>

//stat.h.

class stack_stat.

{.

public:

stack_stat ();

~stack_stat ();

bool is_full ()const;

static int how_many ();

private:

static const int max_len_=100;

int top;

char s[max_len_];

static int how_many_;

};

//stat.cpp.

#include «stat.h» .

#include.

int stack_stat:how_many_=0;

stack_stat:stack_stat ():top (0){++how_many_;}.

stack_stat:~stack_stat (){—how_many_;}.

bool stack_stat:is_full ()const {return top==max_len_;}.

int stack_stat:how_many (){return how_many_;}.

//use.cpp.

#include «stat.h» .

#include.

using namespace std;

void use_stack_stat ().

{.

stack_stat *ps=new stack_stat ();

stack_stat s;

// cout<<<' ';

cout<

// ps->~stack_stat ();

char str[]="Using Stack!!!" ;

int i=0;

cout<

while (str[i]).

ps->push (str[i++]);

//*ps=reverse_order (*ps);

while (!ps->is_empty ()).

cout.

cout<

// s. pop ();

delete ps;

cout<

}.

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

Функции-члены типа static и const.

C++ позволяет использовать функции-члены типа static и const. Синтаксически статическая функция-член содержит модификатор static, предшествующий возвращаемому типу функции внутри объявления класса. Определение вне класса не должно включать этот модификатор:

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

Обычная функция-член может и читать, и изменять члены данных объекта.

Константная функция-член может читать, но не может изменять члены данных объекта. То есть такая функция не изменяет состояние объекта.

Статической функции-члену недоступны члены данных объекта, но доступны статические члены класса.

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

class complex{.

double re, im;

public:

double real ()const{return re;}.

double real_bad_version (){return re;}.

}.

void f (){.

const complex c1(1,0);

complex cx (2,3);

cout<<

cout<

cout<

}.

Эффективные типы, определяемые пользователем Для типа, определяемого пользователем, характерен набор операций:

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

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

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

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

Перегруженные операторы — функции, обеспечивающие привычную (удобную) форму записи.

class complex{.

public:

complex (double re=0,double im=0).

:_re (re),_im (im){}.

double real ()const{return _re;}.

double imag ()const{return _im;}.

void add (complex);

private:

double _re,_im;

};

complex plus (complex a, complex b);

void print (complex a);

bool operator==(complex a, complex b);//перегруженный оператор Способы использования объектов Объект может быть создан в качестве:

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

void f (complex c){complex c1(2,3);}.

Объекта в свободной памяти, создаваемого при помощи оператора new и уничтожаемого оператором delete.

complex *pc=new complex (2,3);

Нестатического члена-объекта, который создается и уничтожается тогда, когда создается и уничтожается содержащий его объект.

class X{.

complex _c;

stack _s;

public:

X (complex &).

};

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

X:X (complex &c).

:_c©,_s (100)//список инициализации.

{}.

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

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

complex cmas[10];

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

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

{static complex c=sin (3);}.

Глобального объекта, объекта в пространстве имен или статического объекта класса, которые создаются один раз «во время запуска программы» и уничтожаются один раз, при ее завершении.

complex c (1,0);

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

k=plus (c1,complex (1,2)).imag (); return c1;

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

Члена объединения union, который не может иметь ни конструктора, ни деструктора.

union economy{ rec c; double d};

Копирование объектов класса Объекты можно копировать.

Существует 2 вида копирования объектов:

инициализация при помощи копирования.

stack s2=s1;

присваивание.

s2=s1;

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

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

class stack{.

int cap;

int top;

char *s;//копирование по умолчанию создает.

//стеки-сиамские близнецы.

public:

stack (int capacity=10):cap (capacity), top (0),.

s (new char[capacity]){}.

~stack (){delete[] s;}.

stack (const stack&);

stack& operator=(const stack&);//returns value for s1=s2=s3;

};

Использование:

stack a (100), c;a.push (`a');

stack b=a;с=a;

Для правильного копирования объектов данного класса копирующие функции нужно определить так:

#include //for memcpy.

stack:stack (const stack& st).

:cap (st.cap), top (st.top), s (new char[st.cap]){.

//for (int i=0;i.

memcpy (s, st. s, cap);

}.

stack& stack: operator=(const stack&st){.

if (this≠&st){.

delete[] s;

s=new char[cap=st.cap];

//for (int i=0;i.

memcpy (s, st. s, cap);

top=st.top;

}.

return *this;

}.

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

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

x+y*z.

Для переменных cx, cy, cz определенного нами ранее типа complex аналогичные действия мы выполняем так:

complex cx, cy, cz;

cy.mul (cz);

cx.add (cy);

Если же мы запишем.

cx+cy*cz.

то компилятор выдаст ошибку, т.к. встроенные операции «+» и «*» применимы только ко встроенным типам.

Однако C++ позволяет определить смысл многих операций (в том числе сложения и умножения) для определяемых пользователем типов, например:

class complex{.

public:

complex operator+(complex);

complex operator*(complex);

private:

double re, im;

};

complex complex: operator +(complex a).

{.

return complex (re+a.re, im+a.im);

}.

complex complex: operator *(complex a).

{.

return complex (re*a.re-im*a.im, re*a.im+im*a.re);

}.

Если cy и cz имеют тип complex, то cy+cz означает cy. operator+(cz).

Теперь мы можем записывать действия над комплексными числами в форме, близкой к общепринятой:

complex c1(r1,i1), c2(r2,i2);

c2=с2+c1*complex (2,3);

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

Выполняются обычные правила приоритета операций, поэтому в приведенной операции сначала выполняется умножение, затем сложение.

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

+ - * / % = += -= *= ++ —, -> [] () new delete.

и других (всего 42).

Следующие операторы не могут быть определены пользователем:

: (разрешение области видимости).

. (выбор члена класса или структуры).

.* (выбор через указатель на член класса).

?: (тернарный оператор) Допускается переопределять существующие операторы, но нельзя создавать новые (например ** для степени).

Бинарные и унарные операторы.

Операторы — функциональные компоненты выражения. Аргументами операторов являются операнды. В зависимости от количества операндов операторы бывают бинарными (два операнда):

Например: a+b, a*=b, a.

и унарными (один операнд) Например: -a, —a, &a, a++

Унарные операторы, в свою очередь, делятся на префиксные (-a, ++a) и постфиксные (a++).

Есть также один тернарный оператор, a? b:c, но переопределять его действие нельзя.

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

a*b+c>d (((a*b)+c)>d)

Порядок, в котором выполняются операторы, определяется их приоритетом. Например, приоритет оператора * выше, чем оператора +.

Кроме того, некоторые операторы изменяют (или могут изменять) свои операнды

++a, a++, a*=b, a=b

а некоторые — не изменяют

a+b, a-b, -a.

Правила опеределения операторных функций Для любого бинарного оператора @ выражение aa@bb интерпретируется либо как а) нестатическая функция-член с одним аргументом

aa.operator@(bb)

либо как б) функция-не-член с двумя аргументами

operator@(aa, bb)

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

class X{

public:

void operator+(int);

X (int);

};

void operator+(X, X);

void operator+(X, double);

void f (X a)

{

a+1; //a.operator+(1)

1+a; //:operator+(X (1), a)

a+1.0;//:operator+(a, 1.0)

}

Унарные префиксные операторы Для любого префиксного оператора @ выражение @aa интерпретируется либо как а) нестатическая функция-член без аргументов

aa.operator@()

либо как б) функция-не-член с одним аргументом

operator@(aa)

Унарные постфиксные операторы Для любого постфиксного оператора @ выражение aa@ интерпретируется либо как а) нестатическая функция-член с аргументом типа int

aa.operator@(int)

либо как б) функция-не-член следующего вида:

operator@(aa, int).

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

class X{//члены

X* operator&();//префиксный унарный оператор & (чей-то адрес)

X operator&(X); //бинарный оператор & (И)

X operator++(int); //постфиксный инкремент

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

X operator/(); //ошибка: унарный оператор /

};

//функции-не-члены

X operator-(X); //префиксный унарный ;

X operator-(X, X); //бинарный ;

X operator—(X&, int); //постфиксный декремент

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

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

X operator%(X); //ошибка: унарный оператор %

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

Конструирование. Мы должны обеспечить создание объекта-комплексного числа следующими способами:

complex c1,//1

c2(1),

c3=2,

c4(3,4),

c5=complex (5,6);

Для этого мы определяем набор конструкторов:

class complex{

public:

complex ():re (0), im (0){}//1.0

complex (double real):re (real), im (0){}

complex (double real, double imag):re (real), im (imag){}

private:

double re, im;

}

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

complex (double real=0,double imag=0):re (real), im (imag){}//1

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

c1+=c4;//2

c2+=7;

Для этого мы определяем оператор +=. У нас есть выбор: определить его в классе или как функцию-не-член класса. Так как нам нужен доступ к представлению класса (re, im), то объявляем в классе:

complex& operator+=(const complex& a);//2

Обратите внимание на объявление аргумента const complex& a. В этом случае формальный параметр a является ссылкой на фактический параметр. При этом в функцию передается адрес фактического параметра (4 байта). Альтернативой было бы сделать объявление следующим образом:

complex& operator+=(complex a);

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

complex& operator+=(const complex *a);

Но дело в том, что данная оператор-функция вызовется только в случае, когда правый операнд — адрес, т. е.:

c1+=&c4;

Но такой синтаксис — это не то, что мы хотели бы использовать. Поэтому в качестве формального параметра применяем все-таки ссылку.

Для добавления действительного числа объявляем функцию-член класса

complex& operator+=(double a);//2

Определяем эти функции-операторы в .cpp — файле.

complex& complex: operator+=(const complex& a)//2

{

re+=a.re;//добавление действительной части аргумента к действительной части данного объекта

im+=a.im;//добавление мнимой части

return *this;//возврат значения

}

В данной функции выполняется два действия: 1) выполняется операция добавления и 2) выполняется возврат значения. Возврат значения нужен, чтобы результат оператора += можно было использовать в качестве операнда. Например:

с1=(с2+=с3)+7;

Результатом оператора += должно быть значение его левого операнда (в примере — c2) после того, как к нему добавлен правый операнд (в примере c3). Когда вызывается функция complex: operator+=, левый операнд для нее доступен как объект, для которого она вызвана. Таким образом, эта функция должна вернуть значение самого объекта. Это можно сделать, разименовав указатель this.

Почему же мы возвращаем ссылку, а не объект? Потому, что для типа int следующее выражение должно увеличить значение переменной a, а не копии переменной a:

(a+=b)++;// после того, как к a добавили b, увеличить a на 1.

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

Реализация второго оператора += несколько проще, так как добавление идет только к действительной части комплексного числа:

complex complex: operator+=(double a){

re+=a;

return *this;

}

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

c1=3+c5;//3

c1=c5+3;

c1=c4+c5;

Для этого определим оператор +. Опять у нас есть выбор: определить его как член класса или как не-член-класса. В пользу последнего решения есть два довода. Во-первых, мы не можем определить оператор-член-класса так, чтобы он был вызван для случая 3+c5, т.к. левый операнд не является объектом. Во-вторых, для выполнения сложения не требуется иметь доступ к представлению класса complex. Итак, определяем функции-не-члены класса:

complex operator+(const complex& a, const complex& b);//3.1

complex operator+(const complex& a, double b);//3.2

complex operator+(double a, const complex& b);

Эти три формы оператора учитывают все интересующие нас комбинации типов операндов. Определения этих функций используют оператор += для добавления к локальной переменной:

complex operator+(const complex& a, const complex& b){

complex r=a;

return r+=b;

}

complex operator+(const complex& a, double b){

complex r=a;

return r+=b;

}

complex operator+(double a, const complex& b){

complex r=b;

return r+=a;

}

И опять, как и в случае с +=, сложение complex с double проще, чем сложение двух complex. Сравнение. Мы должны иметь возможность сравнивать комплексные числа друг с другом и с double в виде, принятом для встроенных типов, например:

c2==c4;//4

c2==8;

3==c2;

Для этого определим оператор ==. Как и в случае с оператором +, мы не можем определить оператор == как функцию-член, т.к. она не может быть вызвана для случая 3==с2. Следовательно, это должна быть функция-не-член. Сравнение двух комплексных чисел:

bool operator==(const complex& a, const complex& b);//4.2

Модификаторы const используются для указания того, что функция не изменяет аргументы. Этой функции требуется доступ к представлению класса (re, im), однако представление класса имеет модификатор private: и к нему нельзя получить доступ из этой функции напрямую.

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

public:

double real ()const{return re;}

double imag ()const{return im;}

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

bool operator==(const complex& a, const complex& b){

return a. real ()==b.real ()&&a.imag ()==b.imag ();

}

Для выполнения сравнения complex с double и double с complex мы могли бы определить еще два оператора ==:

bool operator==(const complex& a, const double& b){

return a. real ()==b && a. imag ()==0;

}

bool operator==(const double& a, const complex& b){

return a==b.real () && 0==b.imag ();

}

Следует заметить, что в этих функциях выполняются те же действия, что и в первом варианте оператора==, но вместо действительной части используется сам аргумент типа double, а вместо мнимой части — 0. То есть сравнение производится с комплексным числом, у которого вместо действительной части — аргумент типа double, а мнимая часть равна 0. Если бы мы могли из действительного числа получить комплексное указанным способом, мы могли бы работу двух последних операторов == возложить на первый оператор ==. Оказывается, такой механизм преобразования у нас уже имеется — это конструктор complex, в случае, когда он вызывается с одним аргументом типа double. Поэтому определять две последние функции operator== мы не будем. А для того, чтобы их работа была выполнена первым оператором ==, нам не нужно ничего определять дополнительно. Компилятор сам в нужных местах вызовет конструктор, чтобы из double получить complex. Например:

c2==c4;//operator==(c2,c4)

c2==8;//operator==(c2,complex (8))

3==c2;//operator==(complex (3), c2)

Ввод-вывод. И, наконец, мы хотим выводить комплексные числа принятым в C++ способом:

std:cout<

Для этого определим оператор вывода для комплексного числа:

std:ostream& operator<<(std:ostream& os, const complex& a)

{

return os<<'('<<<','<<<')';

}

Теперь запись std: cout<

operator<<(operator<<(operator<<(std:cout, c1), c2), c3);

Класс Matrix. Перегрузку операторов вызова функции и индексирования рассмотрим на примере класса Matrix. Этот класс предоставляет динамически размещаемые двумерные массивы.

class Matrix{

public:

Matrix (size_t, size_t);

Matrix (const Matrix&);

~Matrix ();

private:

size_t d1, d2;

int* m;

};

Определение класса содержит количество элементов d1 по первой и d2 по второй размерности массива. Тип size_t — это тип значения, возвращаемого оператором sizeof. В конструкторе выделяется память для хранения всех элементов данного массива, а базовый адрес выделенной памяти является инициализирующим значением для указателя m.

Matrix:Matrix (size_t dim1, size_t dim2)

:d1(dim1), d2(dim2), m (new int[size ()]){}

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

Деструктор выполняет delete[] для освобождения памяти, выделенной оператором new[] в конструкторе.

Matrix:~Matrix (){delete[] m;}

В конструкторе используется вспомогательная функция-член size (), возвращающая количество элементов массива. Так как эта функция используется только внутри класса, мы помещаем ее в раздел private:

private:

size_t size () const {return d1*d2;}

Создание матрицы размером 2×3 выглядит следующим образом:

Matrix m (2,3);

Мы хотим заполнять матрицу в цикле, например, так:

for (size_t i=0;i

for (size_t j=0;j

m (i, j)=rand ();

Здесь функции-селекторы dim1() и dim2() возвращают размеры массива по соответствующим размерностям. Эти функции определены в пределах класса:

size_t dim1() const {return d1;}

size_t dim2() const {return d2;}

Обратите внимание на то, в какой форме записано обращение к элементу матрицы — m (i, j). К имени объекта справа приписаны скобки, что означает вызов функции с именем m с двумя параметрами (i, j). Оказывается, вызов функции — это тоже оператор C++. Чтобы запись m (i, j) действительно означала обращение к элементу матрицы, мы должны перегрузить этот оператор. Оператор (), а также операторы =, [] и -> можно перегружать только как нестатические функции-члены класса. Это ограничение гарантирует, что левый операнд указанных операторов будет объектом. Перегружаем оператор ():

int& Matrix: operator ()(size_t dd1, size_t dd2){//1

assert (dd1

assert (dd2

return m[dd1*dim2()+dd2];

}

int Matrix: operator ()(size_t dd1, size_t dd2) const{//2

assert (dd1

assert (dd2

return m[dd1*dim2()+dd2];

}

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

Тела обеих функций operator () одинаковы: выполняется проверка на допустимость индексирующих значений, после чего вычисляется позиция элемента в одномерном массиве m. Затем первая функция возвращает ссылку на данный элемент, а вторая — значение данного элемента. Именно возврат ссылки, а не значения позволяет изменять значение элемента массива, записывая m (i, j)=rand ().

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

void print (const Matrix& m){

for (size_t i=0;i

for (size_t j=0;j

std:cout<<<',';

}

std:cout<

}

}

Параметр функции print является ссылкой на константную матрицу. Так как функция print не может изменить матрицу, компилятор выберет версию оператора () с модификатором const. Возврат значения обходится дешевле, чем возврат ссылки, т.к. ссылку требуется разименовывать, а значение — нет, а объем передаваемой памяти одинаков (4 байта).

int* Matrix: operator[](size_t dd1) const{

assert (dd1

return &m[dd1*dim2()];

}

Вызов: m[3][4]

(m.operator[](3))[4]

Matrix& Matrix: operator=(const Matrix& t){

if (this≠&t){

delete[] m;

m=new int[(d1=t.dim1())*(d2=t.dim2())];

copy (t);

}

return *this;

}

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

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

for (size_t i=0;i

for (size_t j=0;j

m (i, j)=rand ();

Для этого мы организовали два вложенных цикла. При этом нам понадобилось использовать две индексные переменные, вызывать две функции, а также следить за тем, чтобы переменная, наращиваемая до dim1() (это i), была первым индексом в m (i, j), а переменная, наращиваемая до dim2() (здесь это j), была вторым индексом.

Однако перебор элементов можно организовать с помощью специального объекта — итератора. Имея в своем распоряжении итератор, мы можем сделать две вещи:

• а) получить доступ к текущему элементу,
• б) перейти к следующему элементу.

Изменим класс Matrix, добавив в него определение итератора и две функции:

typedef int* iterator;

iterator begin ()const{return m;}

iterator end ()const{return m+size ();}

Функции begin () и end () возвращают значения, которые являются «границами» матрицы для итератора. Теперь заполнение массива мы можем организовать так:

for (Matrix:iterator p=m.begin ();p≠m.end ();++p)

*p=rand ();

Здесь с помощью итератора p мы

• а) получаем доступ к текущему элементу путем разименования указателя,
• б) переходим к следующему элементу, производя инкремент указателя.

Следуя идиоме итерационного перебора, напишем функцию, печатающую матрицу:

void print_iter (const Matrix& m){

for (Matrix:iterator p=m.begin ();p≠m.end ();++p)

std:cout<<*p<<',';

}

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

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

Так как этот класс используется исключительно с классом Matrix, то определим этот класс внутри класса Matrix

class Matrix{

class reverse_iterator{

public:

reverse_iterator (int *p):_p (p){}

int& operator*(){return *_p;}

void operator++(){—_p;}

bool operator≠(reverse_iterator r) const{return _p≠r._p;}

private:

int *_p;

};

};

Функции-члены класса Matrix, возвращающие граничные значения для данного итератора:

reverse_iterator rbegin ()const{return m+size ()-1;}

reverse_iterator rend ()const{return m-1;}

Теперь перебор в обратном порядке выглядит так:

for (Matrix:reverse_iterator r=m.rbegin ();r≠m.rend ();++r)

*r=rand ();

Недостатки приведенной концепции: необходимо определять по две дополнительные функции-члены контейнера (begin, end) для каждого типа итератора.

Другая идиома для итератора, не имеющая этих недостатков:

class m_iter{

public:

m_iter (Matrix& m):_begin (m.m),_end (m.m+m.size ()){}

void First (){_p=_begin;}

bool NotDone ()const{return _p≠_end;}

int& CurrentItem ()const{return *_p;}

void Next (){++_p;}

private:

int *_begin, *_end, *_p;

};

Использование:

m_iter mi (m);

for (mi.First ();mi.NotDone ();mi.Next ())

mi.CurrentItem ()=rand ();

Однако класс такого итератора должен иметь доступ к представлению контейнера, поэтому его нужно сделать другом контейнера:

class Matrix{

friend class m_iter;

};

Дружественные функции

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

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

class Matrix;

class Vector{

float v[4];

//…

friend Vector operator*(const Matrix&, const Vector&);

};

class Matrix{

Vector v[4];

//…

friend Vector operator*(const Matrix&, const Vector&);

};

Vector operator*(const Matrix& m, const Vector& v)

{

Vector r;

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

r.v[i]=0;

for (int j=0;j<4;j++)r.v[i]+=m.v[i]. v[j]*v.v[j];

}

return r;

}

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

Многие полезные типы являются вариантами других, и часто бывает утомительно создавать для каждого из них один и тот же код. Производный класс наследует описание базового класса; затем он может быть изменен добавлением новых членов, изменением существующих функций-членов и изменением прав доступа. Эта концепция полезна так же, как полезна таксономическая классификация: и слон и мышь являются млекопитающими. Информация о том, что млекопитающие — теплокровные высшие позвоночные, подробно изложена лишь однажды — в базовом понятии. В понятиях «слон» и «мышь» даются лишь характерные особенности этих животных.

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

class имя_класса: (public|protected|private)_opt имя_базового_класса

{

объявления членов

};

Ключевое слово class как всегда можно заменить словом struct, если подразумевается, что все члены открыты.

Ключевые слова public, protected и private используются для указания того, насколько члены базового класса будут доступны для производного. Ключевое слово protected — промежуточная форма доступа между public и private.

Рассмотрим пример:

//inheritance.h

class employee

{

public:

employee (char *name, double salary);

void print ()const;

private:

char nm[30];

double slry;

};

enum language {ASSEMBLER, BASIC, PASCAL, C, CPP, SMALLTALK};

class programmer1

{

public:

programmer1(char *name, double salary, language lang);

void print ()const;

private:

char nm[30];

double slry;

language lng;

};

class programmer2: public employee

{

public:

programmer2(char *name, double salary, language lang);

void print ()const;

private:

language lng;

};

//inheritance.cpp

#include «inheritance.h»

employee:employee (char *name, double salary)

:slry (salary)

{

strcpy (nm, name);

}

void employee: print ()const

{

cout<<" Name: «<<», Salary: «<<» $" ;

}

programmer1:programmer1(char *name, double salary, language lang)

:slry (salary), lng (lang)

{

strcpy (nm, name);

}

void programmer1: print ()const

{

cout<<" Name: «<<», Salary: «<<» $, Language:" ;

switch (lng){

case C: cout<<" C" ;break;

case CPP: cout<<" C++" ;break;

default:cout<<" Another language" ;break;

}

}

programmer2:programmer2(char *name, double salary, language lang)

:employee (name, salary), lng (lang)

{}

void programmer2: print ()const

{

employee:print ();//печать информации о работнике

// должен использоваться оператор, потому что

// print () была замещена в programmer2

// ошибка:

// cout<<" Name: «<<», Salary: «<<» $, Language:" ;

// нельзя обратиться к закрытым членам базового класса

cout<<", Language:" ;//печать информации, относящейся

switch (lng){ // только к программисту

case C: cout<<" C" ;break;

case CPP: cout<<" C++" ;break;

default:cout<<" Another language" ;break;

}

}

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

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

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

employee e1(«John», 80), e2(«Ben», 90);

v.print ();p.print ();

programmer1 p1(«Ron», 200, BASIC);

p1.print ();

programmer2 p2(«Michael», 500, C);

p2.print ();

Как видите, использование классов programmer1 (без наследования) и programmer2 (с наследованием) здесь не отличается. Однако наследование имеет преимущество. Определение класса programmer2 как производного от employee делает его подтипом employee. Это значит, что объектом programmer2 можно пользоваться везде, где допустим employee. Например:

print_in_report (const employee& e){ e. print (); }

print_in_report (e1);

//print_in_report (p1); //error

print_in_report (p2); //OK

Копирование и срезка

employee arr_emp[3]={e1,p2,e2};

mas[0]=v;

// mas[0]=p1;//error

for (int i=0;i<3;++i)mas[i]. print ();

programmer2 p;

employee r=p;//срезка Копируется только employee-часть programmer2. Этот эффект называют срезкой. Часто он является нежелательным. Одной из причин использования указателей и ссылок на объекты в иерархии является желание избежать срезки. Например:

employee *rptr=&r;//адрес работника

rptr=&p;//адрес программиста. Срезка отсутствует Производные классы (Derived* можно использовать как Base*)

Функции-члены (замещение, обращение к ф-членам базового кл.)

Конструкторы и деструкторы (инициализация членов базового класса через конструктор базового класса)

UML

UML расшифровывается как Unified Modeling Language — унифицированный язык моделирования. Он является визуальным языком и предназначен для создания моделей программ. Под моделями программ понимается графическое представление программ в виде различных диаграмм, отражающих связи между объектами в программном коде.

Виды диаграмм:

• 1. Диаграммы прецедентов
• 2. Диаграммы видов деятельности
• 3. Диаграммы взаимодействий (подвид — диаграмма последовательностей)
• 4. Диаграммы классов
• 5. Диаграммы состояний
• 6. Диаграммы развертывания

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

Для чего используется язык UML

Прежде всего UML — язык общения с самим собой, членами команды и клиентами.

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

Диаграмма классов Описывает классы и отражает отношения, существующие между ними.

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

• · Имя класса
• · Имена методов (функций) класса
• · Имена данных-членов класса

Модификаторы доступа обозначаются знаками + public, # protected, — private.

Возможны следующие типы отношений между классами.

• · Отношение «is-a» — в этом случае один класс является подвидом другого класса
• · Отношение «has-a» — когда один объект одного класса «содержит» объект другого класса в качестве элемента данных.

Кардинальность (или кратность) элементов отношения показывают количество включаемых объектов.

Иерархия классов Базовый класс (employee) может иметь несколько производных классов (teacher, manager, …):

class teacher: public employee{…};

class manager: public employee{…};

Производный класс (teacher), в свою очередь, сам может быть базовым классом (для english_teacher):

class english_teacher: public teacher{…};

Такой набор связанных классов называется иерархией классов. Иерархия имеет вид дерева (если не использовать множественное наследование).

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

Код используется повторно. Тип programmer2 использует существующий, хорошо проверенный код из employee;

Иерархия отражает взаимоотношения, свойственные проблемной области;

Различные полиморфные механизмы позволяют клиентскому коду рассматривать programmer2 в качестве подтипа employee, что упростит клиентский код.

Преобразование типов Указатель на производный класс может быть преобразован в указатель на базовый класс. У нас есть объект programmer2:

employee r («Vasya», 80),*pr;

pr=&r;

pr->print ();//employee:print

programmer2 p («Alex», 300, CPP), *pp;

pr=pp=&p;//преобразование

pp->print ();//programmer2:print

pr->print ();//employee:print

Тот факт, что указатель теперь указывает на объект p типа programmer2, в данном случае в расчет не принимается.

Поля типа Для того, чтобы через указатель на базовый класс вызывать подходящие функции (programmer2:print или employee: print), мы должны решить, какому типу на самом деле принадлежит объект, на который указывает указатель?

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

class employee{

public:

enum Rab_type{R, P};

Rab_type type;

employee ():type®{}

void print ()const;

};

class programmer: public employee{

public:

programmer (){type=P;}

void print ()const;

};

void employee: print ()const{

cout<<" employee: print" <

}

void programmer: print ()const{

cout<<" programmer: print" <

}

void print (employee* pr){

switch (pr->type){

case employee: R:

pr->print ();

break;

case employee: P:

const programmer* p=static_cast (pr);

p->print ();

break;

}

}

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

в базовом классе employee в перечислимый тип добавляется новая константа;

пишется производный класс (аналогично programmer);

в функцию: print добавляется новая ветвь.

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

class employee_v{

public:

virtual void print ()const;

};

При этом определение виртуальной функции синтаксически такое же, как и у обычной невиртуальной функции-члена:

void employee_v:print ()const{

cout<<" employee_v:print" <

}

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

class programmer_v:public employee_v{

public:

virtual void print ()const;

};

void programmer_v:print ()const{

cout<<" programmer_v:print" <

}

Вызов виртуальной функции синтаксически такой же, как и обычной функции:

employee_v r1;

programmer_v p1;

r1.print ();//employee_v:print

p1.print ();//programmer_v:print

В этих двух случаях вызовутся функции print соответствующих классов. Так было бы и в случае невиртуальных функций print (т.е. без ключевого слова virtual).

void print_v (employee_v* pr){

pr->print ();//employee_v:print или programmer_v:print

}

В этом случае мы вызываем функцию-член (print) по указателю pr на employee_v. В случае, если бы функция-член print была объявлена невиртуальной, то однозначно вызвалась бы функция employee_v:print (что определяется типом указателя). Однако, так как функция print виртуальна, вызывается либо employee_v:print, либо programmer_v:print, в зависимости от того, указывает pr на объект типа employee_v либо на объект типа programmer_v. Например:

employee_v r1, r2;

programmer_v p1, p2;

print_v (&r1);// employee_v:print

print_v (&p1);// programmer_v:print

Теперь мы можем запомнить указатели на различные объекты в массиве и вызвать print_v в цикле:

employee_v *record[4]={&r1,&p1,&r2,&p2};

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

print_v (record[i]);

}

Вызовутся функции в таком порядке: employee_v:print, programmer_v:print, employee_v:print, programmer_v:print.

Так как наша функция print_v выродилась в единственный вызов функции-члена print, мы можем написать непосредственно

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

record[i]->print ();

}

В случае, если мы используем виртуальные функции, добавление нового производного от employee класса не требует изменений ни в базовом классе, ни в коде, использующем виртуальные функции (в нашем случае этот код — приведенный выше цикл). Заметьте, что это будет работать, даже если указанный цикл был написан и откомпилирован до того, как производный класс programmer_v:print был вообще задуман! Данный факт служит краеугольным камнем объектно-ориентированных проектов и придает стабильность развивающейся программе.

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

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

class figure{

public:

void move_to (int x, int y){_x=x; _y=y;}

virtual void draw (HDC);

virtual void rotate (double);//angle measured in degrees

protected:

figure (int x, int y):_x (x),_y (y){}

int _x,_y;

};

Производные от figure классы переопределяют виртуальные функции и добавляют специфические члены данных.

class circle: public figure{

public:

circle (int x, int y, int r)

:figure (x, y),_r®{}

virtual void draw (HDC);

virtual void rotate (double){};

private:

int _r;

};

class line: public figure{

public:

line (int x0, int y0,

int x1, int y1)

:figure (x0,y0),_dx (x1-x0),_dy (y1-y0)

{}

virtual void draw (HDC);

void rotate (double);

private:

int _dx,_dy;

};

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

void figure: draw (HDC){

assert (false);//этот код не должен быть вызван

}

void figure: rotate (double){

assert (false);//этот код не должен быть вызван

}

Попытка создания фигуры допустима, но неразумна:

figure f1(200,200);//фигура с центром, но без формы

circle c1(100,100,10);

line l1(120,100,130,105);

figure* mas[2]={&c1,&l1};

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

mas[i]->draw (hdc);

mas[i]->move_to (100,110);

mas[i]->draw (hdc);

mas[i]->move_to (100,140);

mas[i]->rotate (40);

mas[i]->draw (hdc); }

Включение Виды включения: композиция и агрегация.

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

Допустим у нас есть класс stack3, который реализует концепцию стека символов (char).

class stack3

{

public:

stack3();

void push (char c);

char pop ();

bool is_empty ()const;

bool is_full ()const;

private:

enum{ max_len=100};

int top;

char s[max_len];

};

Функции реализованы следующим образом:

stack3:stack3():top (0){}

void stack3: push (char c){

assert (top

s[top++]=c;

}

char stack3: pop (){

assert (top>0);

return s[—top];

}

bool stack3: is_empty ()const {return top==0;}

bool stack3: is_full ()const {return top==max_len;}

Мы можем использовать объекты этого класса следующим образом:

stack3 reverse_order (stack3 s){

stack3 tmp;

while (!s.is_empty ()){

tmp.push (s.pop ());

}

return tmp;

}

Пример шаблона класса:

template class stack4

{

public:

stack4(); //конструктор

void push (T c);

T pop ();

bool is_empty ()const;

bool is_full ()const;

private:

enum{ max_len=100};

int top;

T s[max_len];

};

templatestack4:stack4():top (0){}

templatevoid stack4: push (T c){

assert (top

s[top++]=c;

}

templateT stack4: pop (){

assert (top>0);

return s[—top];

}

templatebool stack4: is_empty ()const {return top==0;}

templatebool stack4: is_full ()const

{return top==max_len;}

Префикс template указывает, что объявлен шаблон (template), и что в объявлении на месте T будет указан фактический тип. T — имя типа, а не обязательно класса.

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

stack4 sc;

stack4 si;

stack4 sd;

Без использования шаблонов для реализации этого примера пришлось бы писать три определения классов, а с использованием шаблона — только одно определение шаблона.

Функция, работающая со стеком stack4:

stack4 reverse_order (stack4 s){

stack4 tmp;

while (!s.is_empty ()){

tmp.push (s.pop ());

}

return tmp;

}

Шаблон функции, работающий с любым стеком:

template STACK reverse_order (STACK s){

STACK tmp;

while (!s.is_empty ()){

tmp.push (s.pop ());

}

return tmp;

}

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

stack4 sc;//генерируется 5 функций

stack4 si1, si2;// генерируется 5 функций

//(количество создаваемых объектов не играет роли)

stack4 sd;//не генерируется новых функций, так как инстанцирование stack4 уже было выше В нашем классе stack функции push и pop зависят от параметра шаблона, поэтому их генерирование необходимо. Так, функция push, сгенерированная для параметра char, работает не так, как функция push, сгенерированная для параметра int. В то же время функции is_empty и is_full от параметра шаблона не зависят. Функция is_empty для char абсолютно идентична функции is_empty для int. Для того, чтобы избежать генерирования лишних (полностью идентичных) функций, применяют следующий прием. Шаблонный класс создают производным от класса, не являющегося шаблоном. При этом в базовый класс помещают функции, не зависящие от параметра шаблона.

Применим данный прием для нашего стека:

class stack5_base

{

public:

stack5_base ();

bool is_empty ()const;

bool is_full ()const;

protected:

enum{ max_len=100};

int top;

};

stack5_base:stack5_base ()

:top (0)

{}

bool stack5_base:is_empty ()const {return top==0;}

bool stack5_base:is_full ()const {return top==max_len;}

template class stack5: public stack5_base

{

public:

void push (T c);

T pop ();

private:

T s[max_len];

};

templatevoid stack5: push (T c){

assert (top

s[top++]=c;

}

templateT stack5: pop (){

assert (top>0);

return s[—top];

}

Для нашего случая количество сгенерированных функций уменьшается до минимально необходимого:

//к этому моменту сгенерировано 3 функции для stack5_base

stack5 sc;//генерируются 2 функции

stack5 si1, si2;// генерируются 2 функции

//(количество создаваемых объектов не играет роли)

stack5 sd;//не генерируется новых функций, так как инстанцирование stack4 уже было выше Шаблоны с параметрами-значениями В шаблонах stack3 и stack4 для хранения элементов используется массив на 100 элементов. В некоторых случаях указанное значение избыточно, и память расходуется нерационально. В некоторых случаях этого количества недостаточно и тогда шаблоны stack3 и stack4 не подходят для решения задачи. Как же спроектировать шаблон так, чтобы при необходимости получить заданное количество элементов не нужно было писать новый шаблон? Это можно сделать (по крайней мере) двумя путями.

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

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

class stack6_base

{

public:

stack6_base ();

bool is_empty ()const;

protected:

int top;

};

stack6_base:stack6_base ()

:top (0)

{}

bool stack6_base:is_empty ()const {return top==0;}

template class stack6_n:public stack6_base

{

public:

bool is_full ()const;

};

template bool stack6_n:is_full ()const {return top==N;}

template class stack6: public stack6_n

{

public:

void push (T c);

T pop ();

private:

T s[N];

};

template void stack6: push (T c){

assert (top

s[top++]=c;

}

template T stack6: pop (){

assert (top>0);

return s[—top];

}

Инстанцирование шаблона выглядит следующим образом:

stack6 sc;//стек char на 100 элементов

stack6 si1, si2;//стек int на 10 элементов

stack6 sd;//стек char на 5 элементов Следует заметить, что шаблон функции reverse_order, приведенный выше, будет работать также и с классами, сгенерированными по шаблону stack6:

reverse_order (sс);

Стандартная библиотека Ни одна программа приличных размеров не пишется с использованием только «голых» конструкций языка. Обычно используются различные готовые библиотеки, в которых другие программисты уже написали код, облегчающий работу в данной предметной области. Существуют различные библиотеки для различных целей. Например, библиотека MFC используется для облегчения программирования для Win32 по сравнению с «чистым» программированием под Win32 API. Win32 API предполагает процедурный интерфейс к Windows, а MFC — объектно-ориентированный. Компания Borland предоставляет для тех же целей библиотеку OWL.

C Run-Time Library — предоставляет функции и макросы для многих аспектов программирования. Эта бибилиотека разрабатывалась достаточно давно, поэтому она ориентирована на использование в программах на языке C (как видно из ее названия). Так как C++ совместим с C, то C Run-Time Library можно использовать и в C+±программах. Функции этой бибилиотеки (в том виде, в котором она существует в Microsoft Visual С++) разбиты на 19 категорий, среди которых:

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

выделение памяти (malloc, calloc и др.);

контроль жизненным циклом процесса (exec, exit);

операции с памятью (memcpy, …);

классификация символов (isalpha);

преобразование данных (atoi, _itoa, tolower);

отладка (_ASSERT, _CrtCheckMemory);

операции с каталогами (_chdir);

операции с файлами (_filelength);

математические функции и поддержка операций с плавающей точкой (sin, cos, abs, floor, ldexp (mant, exponent));

ввод-вывод потоковый ввод-вывод (getc, fwrite)

низкоуровневый ввод-вывод (_open, _write)

ввод-вывод с/на консоль и из/в порт (_cprintf, _inp)

время и дата в стиле C (clock, difftime)

алгоритмы поиска и сортировки (bsearch, qsort)

обработка ошибок в стиле С

функции над строками в стиле C (strcmp, strcpy) ,

Часть из этих функций стандартизирована ANSI и POSIX, часть — включена компанией Microsoft (все функции, начинающиеся с подчеркивания).

Существует также так называемая стандартная библиотека. Эта библиотека включена в стандарт C++.

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

Строки и потоки ввода-вывода;

Контейнеры (такие как vector, list и map) и алгоритмы, их использующие (сортировка, слияние, поиск и др.)

Поддержка численных расчетов (комплексные числа, вектора с арифметическими операциями и др.)

Стандартная библиотека C (поддержка операций с плавающей точкой, работа с C-строками и др.)

Поддержка средств языка времени выполнения (определение типа во время выполнения и др.)

Стандартная библиотека определена в пространстве имен std. Это сделано для того, чтобы избежать возможного конфликта между идентификаторами библиотеки и идентификаторами, определенными в программе. Поэтому нужно каждый идентификатор стандартной библиотеки предварять префиксом std, либо перед их использованием написать using namespace std; (в последнем случае теряется преимущество от определения библиотеки в отдельном пространстве имен).

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

Ввод-вывод Требуемый заголовочный файл — .

Стандартный поток вывода — cin, ввода — cout. Ввод-вывод определен для всех встроенных типов. При выводе в поток с помощью операторов <> осуществляется два действия: преобразование значений в последовательность символов, и вывод этой последовательности символов с помощью низкоуровневых операций вывода.

void f (){

cout<<10<<13.7<<�"abcd";

double d; int i;

cin>>d>>i;

}

Здесь последовательность символов: 1,0,1,3,., 7, a, b, c, d.

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

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

Когда преобразование не желательно и мы хотим напрямую работать с последовательностями символов, мы используем функции неформатного ввода-вывода put и get.

cout.put ('s');

char ch;

cin.get (ch);

Форматирование.

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

cout<<123.4567;

cout.setf (ios_base:showpos);

cout<<123.4567<<<123.4567;

Строки В ст. библ. имеется тип string, который дополняет строковые литералы, использовавшиеся ранее. Тип string обеспечивает множество полезных операций над строками, например, конкатенацию.

string s1="Hello", s2="world" ;

string s3=s1+", «+s2+'!';

cout<

Сложение (+) строк означает конкатенацию. Можно складывать строку со строкой, строковым литералом и символом. Оператор += добавляет что-либо в конец строки:

s3+=' ';

Строки могут сравниваться друг с другом и со строковыми литералами:

if (s1==s2){ }

if (s3=="Привет, мир!"){ }

Другие операции:

string s4=s3.substr (0,4);//взятие подстроки

s4.insert (0," Road to «);//вставка

s4.replace (s4.find («Hell»), 4," Heaven");//поиск и замена

TextOut (hdc, 1,1,s4.c_str (), s4. size ());//преобразование в C-строку и число символов строки Того же эффекта можно добиться, используя C-строки, но это будет более громоздко. Кроме того строки string можно передавать в функции как аргументы по значению и возвращать из функции по значению, предоставив системе заботиться о распределении памяти.

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

Вектор Существуют

string

vector

list

ostream, istream, ofstream, ifstream, ostringstream.

Проектирование программ Понятия — объекты — сообщения — атрибуты — классы — методы — общность (наследование).

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

Пример. Несколько рекомендаций для C++ из [5]:

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

В [5]приводятся обоснования, примеры использования и выгоды от пименения этих правил.

Паттерны проектирования. (Design Patterns)

Другой перевод — шаблоны проектирования (не путать с template).

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

Пример. Концепция Document-View в MFC.

Document хранит представление, а View (Вид) определяет отображение документа на экране. Между документом и его видом в MFC установлен протокол взаимодействия «подписка/оповещение». Вид должен гарантировать, что внешнее представление отражает состояние документа. При каждом изменении внутренних данных документ оповещает все зависящие от него виды, в результате чего вид обновляет себя. Такой подход позволяет присоединить к одному документу несколько видов, обеспечив тем самым различные представления. Можно создать новый вид, не переписывая документ.

Несколько паттернов из [6].

• · Faзade (Фасад) Предоставление единого интерфейса для набора различных интерфейсов в системе.
• · Adapter (Адаптер) Преобразование стандартного интерфейса класса в интерфейс, более подходящий для нужд клиента
• · Итератор