chast2

_______________________________________________________________________________________

41.Основные принципы ООП.

_______________________________________________________________________________________

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

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

Иерархия понятия ООП включает 2 уровня: -уровень классы -уровень объекты

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

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

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

Основу ООП составляют 3 принципа:

1.Инкапсуляция Это объединение в одно целое данных и алгоритмов обработки этих данных. Носителями данные являются

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

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

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

2.Наследование Это свойство классов порождать своих потомков. Класс-потомок автоматически наследует от класса-

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

Типичный прием разработки программы таков:

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

3.Полиморфизм Это свойства объектов родственных классов (родителя и потомка) решать схожие по смыслу задачи разными

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

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

________________________________________________________________________________________

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

________________________________________________________________________________________

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

Поля как уникальные так и общие являются носителями данных,а методы носителями алгоритмов обработки данных.

В качестве собирательно термина для полей и методов используется термин "элемент".

Синтаксис определения класса предполагает задание заголовка и тела класса.

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

<ключ класса> <тело класса>

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

Пример структуры определения класса: class TVektClass//заголовок класса

{private://спецификатор доступа,после него перечисляются частные (скрытые) эл <определение приватных элементов>

public://спецификатор доступа,после него перечисляются общедоступные (открытые) эл <общедоступные элементы> };//конец определения классов

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

Области видимости элементов определяются спецификаторами доступа.

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

Элементы под спецификатором public общедоступны, т.е. они видны вне класса. Эти элементы образуют интерфейс класса.

Помимо public т private может применяться спецификатор protected. Однако его применение имеет смысл только при объявлении классов с наследованием.

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

В теле класса может быть несколько секций public и private, и они могут чередоваться.

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

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

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

class TVektClass{//(1) private://(2) приватное поле

double FVekt[10]//(3) храним компоненты вектора double FSvertka;//(4) храним свертку вектора public;//(5) общедоступные поля

int FKol;//(6)

double GetVekt (int Nomer)//(7) встроенный методдля чтения элементов поля массива по индексу элемента. индекс задется Nomer

{return FVekt[Nomer];}//(8) тело метода определено внутри класса

void SetVekt (int Nomer, double Value)//(9) встроенный метод для записи элементов поля массива

{FVekt [Nomer]=Value;}//(10)

void ProAddToVekt (int Nomer, double Value);//(11) прототип метода void ProFormSvertka (int Nomer, double Wes);//(12) прототип метода double GetSvertka()//(13) метод обработкидвух полей

{return FSvertka/FKol;}//(14) };//(15) конец определения класса

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

Метод предназначенный для изменения компонента вектора по индексу компонента. void TVektClass::ProAddToVekt (int Nomer, double Value)//(16) {FVekt[Nomer]=FVekt[Nomer]+Value*Value;}//(17)

Метод для включения определенного компонентавектора заданного индексом Nomer в свертку с определенным весом (Wes). При этом поле FKol предназначено для подсчета количества компонентов участвующих в формировании свертки.

void TVektClass::ProFormSvertka (int Nomer,double Wes)//(18) {FSvertka+=FVekt[Nomer]*Wes;//(19)

FKol++;}//(20)

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

-в локальном классе можно использовать внешние (extern) переменные,внешние функции, а так же объявленные в данномблоке, т.е. локально, статические (static) переменные и элементы перечислений (enum). Но недопустимо использовать локальные переменные явно или неявно объявленные со спецификатором auto.

-локальный класс не может иметь статических полей и методов. -методы локального класса должны быть только встроенными.

-если 1 класс вложен в другой (отношение вложения рассмотрим позже), то эти 2 класса не имеют особых прав доступа к элементам друг друга.

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

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

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

_______________________________________________________________________________________

43.Определение объектов.Роль конструктора и деструктора.Обращение к элементам объекта и класса в целом спомощью операций "."и "->".Суть концепции скрытия информации.

________________________________________________________________________________________

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

Пример определенного объекта рассмотренного выше класса. TVektClass Vect;//(1)

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

Замечание.

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

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

Правила доступа объекта к элементу объявленного в секции public подобек доступу к полям структуры,т.е. доступы осуществляются либо с помощью операции "." при обращении к элементам непосредственно от имени объекта,либо с помощью -> при обращении к эл через указатель на объект.

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

Пример обращения объекта Vect к своим полям и пример обращения к методам класса (см. строки 9-10 п. 2.1)

Спомощью метода SetVect в цикле заполняем значениями эл закрытого поля массива FVect. for(i=0;i<10;i++) {Vect.SetVect(i,i+1);}//(2)

Спомощью метода GetVect в цикле читаем элементы поля FVect

for(i=0;i<10;i++) {cout<<" "<<Vect.GetVect(i);}//(3) cout<<endl;//(4)

Спомощью метода ProAddToVect меняем некоторые эл поля FVect for(i=3;i<8;i++) {Vect.ProAddToVect(i,i-2);}//(5)

Спомощью метода ProFormSvertka формируем свертку первых 6 эл поля FVect. Резудьтат сохраняем в закрытом поле FSvertka. В поле FKol сохраняем количество эл формирующих свертку (стр.18-20 п. 2.1) for(i=0;i<6;i++) {Vect.ProFormSvertka(i,0.1);}//(6)

Читаем свертку (стр.13-14) cout<<"свертка="<<Vect.GetSvertka()<<endl;//(7)

Читаем непосредственно общедоступное поле FKol cout<<"FKol="<<Vect.FKol<<endl;//(8)

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

const TVectClass CVect;//(9)

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

Рекомендации.

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

__________________________________________________________________________________

44.Конструкторы - основные понятия.Виды конструкторов.

__________________________________________________________________________________

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

<имя класса>(<список параметров>)<инициализатор конструктора>//(1) {операторы тела конструктора}//(2)

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

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

Два способа инициализации:

1. В теле конструктора без задействования инициализатора.

Значения полей обычно вычисляются по значениюпараметров конструктора.

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

Сиснаксис оформления этого списка:

:<имя поля>(список выражений),...,<имя поля>(список выражений)//(3) ":"-обязательно

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

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

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

-выделяется память на объект

-выполняется инициализация полей с помощью инициализатора

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

Согласно синтаксису языка С++:

-конструктор не возвращает никакого значениядаже типа void

-нельзя получить адрес конструктора

-параметры конструктора могут иметь любой тип за исключением того класса для которого определяетсяконструктор

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

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

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

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

Класс может иметь несколько конструкторов имеющих разное назначение. Их формально-синтаксическое различие строется на механизме перегрузки функции.

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

Программист должен четко знать правила по которым:

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

-в тексте программы вызываются конструкторы

-конструктуры инициализируют поля объекта

Рассмотрим эти правила подробней.

В начале проведем формальную классификацию видов конструкторов.

если программист явно не опредилил ни одного конструктора,то компелятор автоматически создет два конструктора сл видов:

-конструктор без параметров

-конструктор копирования

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

-либо конструктор без параметров

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

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

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

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

Помимо конструкторов

-без параметров

-копирования

-общего вида выделяют конструкторы

-привидения (преобразования) типов

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

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

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

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

__________________________________________________________________________________

45.вызовы конструкторов в процессе работы программы.

________________________________________________________________________________

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

Для иллюстрации будем использовать определенный в п.2.1 класс TVektClass.

Если класс определен как в п.2.1 т.е. без явного определения конструкторов, то компелятор неявно создает 2 конструктора: без параметров и копирования.

Конструктор без параметров вызывается при следующих форматах определения объекта класса: <имя класса><имя объекта>;//(4)

<имя класса><имя массива объекта>[<размер массива объекта>];//(5) <укзатель на объекты класса>=new<имя класса>;//(6)

<укзатель на объекты класса>=new<имя класса>[<размер>];//(7)

Для рассматриваемого примера эти форматы реализуются например так: TVektClass V;//(8)

TVektClass Vmass[3];//(9)

TVektClass* PtrV=new TVektClass;//(10) TVektClass* PtrVmass=new TVektClass[5];//(11)

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

Пример

TVektClass(){for(int i=0;i<10;i++){FVekt[i]=1;}}//(12)имя конструктора которое совпадает с именем класса

В данном примере мы даем конкретное значение только FVekt а остальные поля FSvertka и FKol явно не инициализируются. В результате, если оператор в форме ст12 будет задан глобально то элементы поля массива FVekt получат значения указанные в конструкторе, а поля FSvertka и FKol получат значения 0. Если же строка 12 размещена локально,то поля FSvertka и FKol будут иметь случайные значения.

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

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

double FVektmass[10];// это глобальный массив,инициализирован нулями,далее будем его использовать для определения значения по умолчанию первогопараметра конструктора. TVektClass(double*mass=FVektmass,int nVekt=10,double fsv=0,int fk=0)//(14)заголовокконструктора :FSvertka(fsv),FKol(sk) //(15)инициализатор

{for(i=0;i<nVekt;i++){FVekt[i]=mass[i];}}//(16)

В этом примере поля базисных типов, т.е. FSvertka и FKol инициализируются с помощью инициализатора (см ст15), а поле-массив FVekt инициализируется в теле конструктора. При этом и в том и в другом случае инициализирующие значения передаются через параметры конструктора. Реальная длина массива (вектора) задается через дополнительный параметр nVekt.

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

Очевидно что в одном классе нельзя одновременно определить и конструктор без параметров (как в ст12) и конструктор со всеми параметрами имеющими значение по умолчанию (ст 14-16). Будут нарушены правила создания перегружаемой функции.

Пользяюсь приведенными примерами объясним семантику термина "конструктор умолчания". Обратите внимание что в строках 8-11 в операторах определения объектов нет абсолютно никаких внешних синтаксических признаков конструктора класса. Именно этот факт умолчания признаков и делает логичным термин "конструктор умолчания", который относят либо к явно или не явно создаваемым конструкторам без параметров, либо к создаваемому явно конструктору общего вида с параметрами имеющими значение по умолчанию, поскольку именно эти конструкторы вызываются по умолчанию.

____________________________________________________________________________________

typedef double odn_mass[3];// Мы определили тип данных который будет предназначен для координат точки и ее вектора скорости.

odn_mass AR0={0,0,10};// массив AR0 который будетсодержать дежурный вариант координат точки odn_mass AV0={0,0,1};// начальная скорость

enum color{green,red,white};//перечисляемый тип (начинается с 0)

class TTochka_v_pole{ //класс для описания моделируемой системы: поле, поверхность,точка. private: // объявляем закрытое поле

double FR0[3];// начальные координаты точки double FV0[3];// начальный вектор скорости

double VminVmax[3][2];//допустимые диапозоны модулей начальных скоростей для точек разных цветов. VminVmax[i][0]-минимально допустимый модуль точки итого цвета, ...[i][1]-мксимально допустимый модуль. double FMp;// масса точки

color FMcolor;// цвет точки int Fnum;//номер точки

double Fg;// ускорение свободного падения

static int Fcounter;// статическое поле счетчик количества созданных точек public: // далее идут общедоступные поля и методы

double FV0modul;//модульначального вектора скорости double FmaxZ;//максимальная высота подъема точки

double FT_maxZ;//первый момент выхода на максимальную высоту

double FT_Z0;// первый момент столкновения с подстилающей поверхностью

Далее определяется прототип конструктора номер1 общего вида со всеми умалчиваемыми параметрами, т.е. одновременно это конструктор умолчания.

TTochka_v_pole(odn_mass R0=AR0,odn_mass V0=AV0,int Mp=1,color c=green,double g=10);

Объявляем прототип конструктора №2 (привидение типов)

TTochka_v_pole(color c,odn_mass R0=AR0,odn_mass V0=AV0 int Mp=1);

Объяявляем прототип встроенного метода выводящего в консольное окно значения полей. int Vivod_v_consol();

Далее прототипы методы рассчета максимальной высоты подъема точка, первого момента выхода наэту высоту и первого момента времени столкновнния точки с подстилающей поверхностью

int Krit_point();

};//конец определения класса

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

Определение конструктора №1 вне класса. Инициализатор не используется. Инициализация полей осуществляется в теле конструктора через параметры конструктора.

TTochka_v_pole::TTochka_v_pole(odn_mass R0,odn_mass V0,int Mp,color c,double g) {FV0modul=0;

for(int i=0;i<3;i++){FR0[i]=R0[i];FV0[i]=V0[i]; FV0modul=FV0modul+V0[i]*V0[i];} FV0modul=sqrt(FV0modul);//заканчиваем рассчет модуля скорости FMp=Mp;// значение парметра Mp передаем полю FMp FMcolor=c;

Fcounter++;

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