Парадигми імперативного стилю.Парадигми процедур-ності.

Парадигми імперативного стилю.Парадигми процедур-ності.

Парадигма-це метод міркувань який застосовується для роз-в’язання цілого класу задач

1950-1960-парадигма алгоритмізації, 1960-1970-пара-дигма локалізації,1970-1980

парадигма абстрактних типів

даних (атд),1980-..ооп.

Мова пр-ня підтримує стиль пр-ня якщо в ній присутні засоби які роблять зручним використан-ня цього стилю. П-д:Паскаль®

Структурне пр-ня (мо-дульність),Фортран®Модуль-ність,С++®контроль типів.

Мова пр-ня підтримує парадиг-му пр-ня якщо вона підтримує відповілний стиль, якщо мова побудована таким чином що во-на контролює ненавмисне від-хилення від парадигмів.

Парадигма алгоритмізації. Складність алгоритмів набагато більша складності данних.Якщо задача велика, то треба її роз-бити на підзадачі (методом "Роз-діляй і пануй").Якою складною б небула програма та алгоритм, для її написання достатньо таких алгоритмічних конструк-цій:

- слідування

- розгалудження

- цикл

Мотив винекнення цієї пара-дигми це необхідність декомпо-зиції алгоритмів що виникають в наслідок розв"язання.

Мовні засоби:

1.процедури з механізмами їх визову, передачі та повертання параметрів процедури.

2.Конструкції структурного пр-ня:

- послідовність

- розгалудження

- цикл

Мови яким притаманні таки засоби:

1.Алгол-60

2.Паскаль(68-70р.)

(не підтримують модульність)

П-д:

Double sqrt (double x)

{

//…

return result;

}

Девіз: використовуйте найкраще із алгоритмів, декомпозицію задачі виконуйте за допомогою процедур

 

 

Парадигма модульності.

Алго- дані

ритм

Ця задача має невелику алго-ритмічну складність.Причина модульності: структура даних. Задачу ділимо методом "Розді-ляй і пануй". треба розбити задачу так, щоб дані однієї зада-чі не заважали іншій.При роз-битті задачі на модулі описання даних виявляється локалізова-ним тобто створеним в межах одного модуля. П-д мови: Форт-ран(54 р.),Турбо-Паскаль, С++. Мовні звсоби: окрема трансляція програмних одиниць.П-д:

Реалізація стека

1)стек повинен мати уніфіко-ваний інтерфейс

2)запобігти способам доступу до стека в обхід інтерфейсних ф.

3)реініціализація до першого використання

// stack. h

#define stack_size 100

//задаем размер стека

void push(char c);

char pop();

//stack. c -файл що містить модуль стека

#include "stack. h"

static

char st[stack_size];

char * sp=st+stack_size;

//int sp=stack_size;

void push(char c)

{*(--sp)=c;}

//{st[--sp]=c;}

char pop()

{*(sp++)}

//{ return st[sp++];}

//головна програма

#include "stack. h"

void main()

{ push('c');

if ('c'!=pop()) error;}

недолік парадигми модульности: 1)выдсутність зручної можливо-сті розмноження екземплярів ти-пу модуль

2)на етапі виконання програми

відсутній контроль за ініціалі-зацією та присвоєнням. П-д:

char c;

char * pc;

c = pc;

Помилки які характерні для цього стилю пр-ня:

1)"забули створити екземпляр" 2)"забули знищити екземпляр"

3)"спроба використання після знищення"

Парадигма АТД

У модульності не можливе тира-жування екземплярів, досягти цієї можливості дозволяє пара-дигма АТД.П-д в С++:Typedef; на ПаскалІ:Type MyType=…; на Фортрані: встроєний тип Complex;

Тип даних: 1)область допусти-мих значень

2)множина допустимих опера-цій.

П-д:

class Comple //ім’я типу;

{ float Re,Im;

public

friend

Cmplex operator+ (Complex a, Copmlex b);

Cmplex operator*(Complex a, Copmlex b);

Cmplex operator-(Complex a, Copmlex b);

Complex();{RE=0; Im=0;}

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

Complex(float r){Re = r; Im=0;}

Complex (float r,float i){Re = r; Im = i;}

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

ostream& operator <<(operator& 0,Complex c);

конструктор це член кл. за допо-могою якого створюється ек-земпляр зміних даного типу.

П-д:

void f()

{complex a;

complex b=1;

complex c=complex (2,3);//c-const

complex d=a+b;

…

cout<<d;

}

мотив:винекненя випливає з фреймів т.т. об'еднання в одній рамці данних та операцій над ними.

Мовні засоби:оператор class. Описувачі обмежування доступу до кл., можливість переван-таження імен ф. та символів операцій. Мови:С++,Object Pascal, парадигми підтримують стиль:Turbo Pascal,C.

П-д:

complex complex::operator+(complex a, complex b);

{return complex(a.Re+b.Re,a.Im+b.Im);

}

П-д:(бібліотека гафічних примітивів:точка,відрізок,коло…)

Class shape

{ int x,y;int color;

int hidden;int kind;

….

Public:

Shape () {…};

Shape (…) {…};

Void show();

Void hide ();

Void drow();//нарисо-

вать

Void move (int x,int y); };

Void shape::draw()

{if (kind==1)

{//draw circle};

else if (kind==2)

{//draw dot}

else {//draw square}

}

void main()

{

shape circle;

shape dot;

circle.show();

dot.hide();

circle.drow();

dot.drow();

}

Проблема застосування АТД полягає в тому, що при необ-хідності розширити функціона-льність розробленої системи ми змушенні редагувати її на рівні вихідного текста. Це в свою чер-гу має два недоліки:

1.ускладнює розробку і підви-щує ймовірність помилок

2. таке не можливо взагалі, якщо вихідний текст відсутній.

Парадигма ООП.

Мови які підтримують цю парадигму:C++,Object Pascal, Small Talk…

Предметна галузь, що моделю-ється складається з сукупності об’єктів які діють один на одно-го.Кожен об’єкт має власні влас-тивості та поведінку.Взаємодія між об’єктами здійснюється шляхом так званих повідомлень. Повідлмлення-виклик метода.

Підтримуються такі об’єктно орієнтовані можливості:

1.Інкапсуляція(АТД)

2.Поліморфізм(можливість виз-начити до чого належить об’єкт)

3.Наслідування(властивості од-ного об’єкта переносять на ін-ший)

Базовий типпохідний тип

П-д:

Class shape

{int x,y;int color;int hidden;

public:

virtual void draw();

…

};

наслідування дає таку можли-вість

#include "shape.h"

class circle:public shape

{int radius;

public:

virtual void draw();

};

//головна програма

void main()

{circle c1,c2;

star s1,s2,s3;

c1.draw();

s1.move();

s1.draw();

}

 

void shape::move(int x1,int y1)

{hide();//погасити об"єкт

x=x1;//змінити координати

y=y1;

draw();//показати

}

описувач virtual дає можливість з’ясувати власника методу (ф.) навіть тоді коли неможна визначити з синтаксичних мір-кувань у даному місці програми.

Узагальнене програмування це стиль в якому алгоритми не за-лежать від типу даних.

 

6.Поняття про кл. в С++.Кл. та принципи ООП.Обмеження доступу до членів кл.

Кл. в С++ це тип сконструйо-ваний користувачем.

Принципи ООП:

1.Все що $ у предметній області це деякі об’єкти

2.Об'єкти виконують якісь взає-модії один з одним за допомо-гою повідомлень.

3.Кожен об’єкт має власну пам'ять (незалежну), яка скла-дається з інших об'єктів.

4.Кожен клас задає поведінку об'єктів свого типу за допо-могою методів чи ф.-членів кл.

5.Кожен об'єкт є представником або екземпляром певного кл.Кл. відображує загальні властивості своїх представників.

6.Кл. можуть об'єднуватись в ієрархію т.т. в таку деревовидну структкру, яка називається ієра-рхією наслідування.

Основний зміст наслідування полягає в тому що вл. і пове-дінка кл. що належать до ієра-рхій наслідувань є доступними для кл. що розташовані нижче.

Class C

{private://забороняє доступ зовні для ф.не членів кл.,крім friend

protected://дозволяє доступ нащадкам і членам кл.

public://дозволяє доступ будь-кому

}

class C

{private:

int i;

friend void f_f(C);

protected:

int j;

public:

int k;

};

class D:public C

{

void g(C);

};

void f(C c)

{ c.k=0;//ok

c.j=0;//err

c.i=0;//err

}

friend void f_f(C c)

{c.k=0;//ok

c.j=0;//ok

c.i=0;//ok

}

void D::g(C c)

{c.k=0;//ok

c.j=0;//err

c.i=0;//ok

k=0;//ok

j=0;//ok

i=0;//ok

}

void C::h(C c)

{c.k=0;//ok

c.j=0;//ok

c.i=0;//ok

k=0;//ok

j=0;//ok

i=0;//ok

}

 

Констуктори та деструктори.

Конструювання масивів.

Class C

{…};

void f()

{ C Carr[10];//10 разів виклика-ти конструктор

C*Carr;

Vector M[10];}

Деструктор це ф. член кл. яка не має параметрів,не повертає нія-кого значення,її ім'я –ім-я кл. з символом "~"

class C

{ public:

~C();}

Деструктор викається для виrонання певних операцій при знищенні екземпляра.П-д:

Void f()

{c C;

…..

//~C }

class Vector

{ int *V;int size;

~Vector()

{ delete V[size];}};

Наслідування класів.

А - базовий клас

­

С-похідний клас

­

Д

class A

{ int i;

public:

void Af();};

class B:public A

{ int j;

public:

void Bf (); };

Опишемо

Void f()

{ B b1;

b1.j=0;

b1.i=0;// змінна і через наслідування доступна

b1.Af();}

при наслідуванні до екземпляру пам"яті В додається підекземрляр пам"яті А.При конструюванні В спочатку відбувається виділення пам"яті для базового класу А,а потім довиділення В. Спочатку викликається конструктор базового класу,а потім конструктор даного типу.Причому у тій послідовності в якій ієрархії ці класи знаходяться

П-д:нехай $ об"єкти двох типів: службовці і менеджери

class employee //базовий клас

{ char*name;

public:

……};

class manager:public

employer //похідний клас

{ int level;

public:

…..};

void f()

{ employer *x;

manager *y;

employer E;

x=&E;

x ®name;

//другий варіант

x=new employee;

x = y; //ok!

y = x; //err!

y®level=0;//ok!

x®level=0//err!

Кожний manager є

employer,але не кожен employer є manager.

Наслідування-принцип при якому знання про більш загальну категорію можна використати в знаннях про більш вузьку категорію.Базовий клас-клас який розпространяє свої властивості(родитель);

похідний клас -подклас(ребенок);

абстрактний клас-клас який не має

екземпляра.

Статичні члени класу.

class C

{int a;};

c C1,C2;

int common;

class C

{ public:

void f()

{ (common=2;}};

Недоліки:

1)програміст може забути ініціалізувати таку змінну; 2)спільна для екземплярів кл. змінна common є спільною і для небажаних доступів.

Через це є статичні дані кл.,які виділяються специфікатором static

class taskList

//одне звено у цьому списку

•®•®•®…®•

public:

static taskList *chain;};

статичні властивості не дуб-лю-ються вони є спільними для всіх

taskList* taskList:: chain = 0;

taskList TL;

TL.info = ptr;

Конструктор не виділяє пам’ять до статичних змінних,але він може робити ініціалізацію по відношенню до статичної змін-ної:

Void f()

{ int i;

static c C;//(1)екземпляр кл. С-статична змінна

if (i)

{static c C;}}//(2)

при вході в блок f ініціалізація С буде один єдиний раз,тобто

(2) відбувається,а(1)ні

class C

{ public:

static void f(); };//ця ф-ія не буде приймати участь

 

 

--------- 13 ---------------------

 

//tmp->right=right; //тількипереприсвоїли покажчик

if (left) tmp->left->copy(left)

if(right) tmp->right->copy(right)

return tmp;};

 

------- 13 -------------------------

 

Віртуальні функції.

П-д:

Class A

{ public:

void f()

{ cout <<"клас А"}};

Class B:public A

{ public:

void f()

{ cout <<"клас B"}};

void g();

{ A a; B b; a.f();b.f();

g1(&a); g1(&b);}

void g1(A*pa)

{ pa®f(); }

З кожнисм класом які мають віртіальні ф-ії пов"язується таблиця.(vtbl).З кожним екземпляром класу пов"язується один покажчик

Покажчик на екземпляр ®

екземпляр ®покажчик на vtbl ® покажчик на ф-ію.

1)ефективність використання з точки зору обчислювальної складності;

2) ефективність використання з точки зору швидкості виконання;

3) розподілу пам"яті.

 

Множинне наслідування.

Приведення показчиків при множинному наслідуванні.

С

¯ ¯

А В

¯ ¯

L L

Неявні перетворення:

С*pc = newC;

L*pl;

pl=pc; //err! так як не зрозуміло до якого класу перетворювати

pl=(A*)pc; // ok!

Pl=(L*)(A*)pc; // ok!

Явні перетворення:

//"manageremployer"

// pm=(manager *)pl;

pc=pl; // err!

a=(C*)pl; //err!через неоднозначність

pc=(C*)(B*)pl; //ok!

Усунення неоднозначності при визові ф-ій базового класу при множинному наслідуванні:

info{L,A,B,C}::f();

info*C::f()

{info*pi1=A::f();

info*pi2=B::f();

return merge(pi1,pi2);}

//info-інформація що повертає ф-ія,merge- злиття інформації

class employer

{ public: void f();}

class manager:public

employer

{public: vod f();}

void manager::f()

{ employer:: f();

….};

Приклад змінної ієрархії:

class foreman:: public

employer

{ public: void f();};

class manager:public

foreman

{ public: void f();};

class foreman:public

employer

{ typedef employer

inherited;

public:

void f ()

{interited:: f();

……}};

class manager:public foreman

{ typedef employer

inherited;

public:

void f ()

{interited:: f();

……}};

interited введений для того щоб коли додасться ще один клас можна було змінити лише foreman

 

Віртуальні базові класи.

V

­ ­

V A B

­ ­ ­

D¾C

Virtual -фактичний

class A:public virtual V;

class A:public virtual V;

class A:public virtual V;

Віртуальні базові класи потрібні для того щоб можна було спільну інформацію для класів А і В розділяти не використовуючи

virtual.Це можна зробити так:

class A

{ friend class V;};

class V

{ friend class A;};

Або використати глобальні змінні.

Завдяки віртуальності можна добитися того щоб базовий клас входив один раз

 

Перевантаження функцій.

Для будь-якого типу Т,типи Т, constT,T& мають одну і ту саму мн-ну ініціалізуючих значень.

Int i; void f (int i);

Const int i; void f(int &i); int f i –винекне помилка або не мож-ливість відрізнити.

Для будь-якого типу Т,типи Т&,const T&,volatile T& є різними.У ланцюжку наслідува-ння класів одне і те саме ім’я ф. в різних кл. не перевантажуєть-ся,а перекривається.

Class X1

{void f(int f);}

classX9:public X8

{void f(double);}

void q(X9*p)

{p->f(2);}

 

П алгоритми

search

for (p=Beg; p!=End; p++) if (*p==Patem)…Ok!

sort

Ітератори – те, що звязує алгоритми і структури даних.

Контейнер – структура даних, яка містить в собі послідовність елементів одного типу.

Ітератор – це узагальнений показжчик на ел-т контейнера, який має властивості:

1) itor ++ перехід до наступного елемента контейнера

2) * розіменування – перехід від зн-ня покоз­жчика до зн-ня ел-та ко­нтейнера, на який показ­чик показує.

Ітератор-об’єкт-покажчик,за до-помогою якого можна перебира-ти елементи контейнера. Т.я. доступ до контейнера робиться через покажчик,то треба опера-ції для такого покажчика;ітера-тори:++,--,==,!=,*.

Ітератор дає універсальний дос-туп до першого об’єкта і до ос-таннього елемента.Коли задаєть-ся діапазон через стандартний ітератор,то end вказує на позаос-танній елемент(уявний).

 

 

29.Елементи узагальненого програмування. Контейнерно-ітераторна модель на основі поліморфізму.

Інтрузивний контейнер – це контейнер всі ел-ти якого мають типи, що є похідними від одного базового типу.

int sum (Iter *beg, Iter *end)

{Iter *i=beg;

int s-0;

for (; (*i)!=(*end); (*i)++) s+= **i

}

При розіменуванні іт-ра не відомо наперед який тип ел-та ко-ра мусить розглядатися.

class Iter

{protected:

void *curr;

virtual

void operator ++(int){}

virtual

int operator *(){}

virtual

int operator!=(Iter i)

};

class List

{struct ListElem

{ListElem *next;}

Tobject *item;

ListElem *head;

Public:

…

friend class ListIter

};

class ListIter: p ublic Iter

{public:

void operator ++(int x)

{curr=((ListElem*)

curr)->next;

}

int operator *()

{return ((ListElem)

curr)->item;

}

int operator!= (Item i)

{return curr!= i.curr;}

}

Class Tobject

{public:

virtual

snt operator *()=0;}

class MyInt1: public Tobject

{int i;

public:

int operator *()

{return i;}

};

class MyInt2: public Tobject

{int i1, i2;

public:

int operator *()

{return i1+i2;}

};

Void main()

{vector v(10);

for (int i=0; i,10;i++) v[i]=i;

int sv=sum(&v.Beg(),&v.End());

List L;

for (i=0;s,10;s++) L.insert(i);

int sl=sum(&L.beg(),&L.end());

cout<<…<<sl<<endl;

}

Парадигми імперативного стилю.Парадигми процедур-ності.

Парадигма-це метод міркувань який застосовується для роз-в’язання цілого класу задач

1950-1960-парадигма алгоритмізації, 1960-1970-пара-дигма локалізації,1970-1980

парадигма абстрактних типів

даних (атд),1980-..ооп.

Мова пр-ня підтримує стиль пр-ня якщо в ній присутні засоби які роблять зручним використан-ня цього стилю. П-д:Паскаль®

Структурне пр-ня (мо-дульність),Фортран®Модуль-ність,С++®контроль типів.

Мова пр-ня підтримує парадиг-му пр-ня якщо вона підтримує відповілний стиль, якщо мова побудована таким чином що во-на контролює ненавмисне від-хилення від парадигмів.

Парадигма алгоритмізації. Складність алгоритмів набагато більша складності данних.Якщо задача велика, то треба її роз-бити на підзадачі (методом "Роз-діляй і пануй").Якою складною б небула програма та алгоритм, для її написання достатньо таких алгоритмічних конструк-цій:

- слідування

- розгалудження

- цикл

Мотив винекнення цієї пара-дигми це необхідність декомпо-зиції алгоритмів що виникають в наслідок розв"язання.

Мовні засоби:

1.процедури з механізмами їх визову, передачі та повертання параметрів процедури.

2.Конструкції структурного пр-ня:

- послідовність

- розгалудження

- цикл

Мови яким притаманні таки засоби:

1.Алгол-60

2.Паскаль(68-70р.)

(не підтримують модульність)

П-д:

Double sqrt (double x)

{

//…

return result;

}

Девіз: використовуйте найкраще із алгоритмів, декомпозицію задачі виконуйте за допомогою процедур

 

 

Парадигма модульності.

Алго- дані

ритм

Ця задача має невелику алго-ритмічну складність.Причина модульності: структура даних. Задачу ділимо методом "Розді-ляй і пануй". треба розбити задачу так, щоб дані однієї зада-чі не заважали іншій.При роз-битті задачі на модулі описання даних виявляється локалізова-ним тобто створеним в межах одного модуля. П-д мови: Форт-ран(54 р.),Турбо-Паскаль, С++. Мовні звсоби: окрема трансляція програмних одиниць.П-д:

Реалізація стека

1)стек повинен мати уніфіко-ваний інтерфейс

2)запобігти способам доступу до стека в обхід інтерфейсних ф.

3)реініціализація до першого використання

// stack. h

#define stack_size 100

//задаем размер стека

void push(char c);

char pop();

//stack. c -файл що містить модуль стека

#include "stack. h"

static

char st[stack_size];

char * sp=st+stack_size;

//int sp=stack_size;

void push(char c)

{*(--sp)=c;}

//{st[--sp]=c;}

char pop()

{*(sp++)}

//{ return st[sp++];}

//головна програма

#include "stack. h"

void main()

{ push('c');

if ('c'!=pop()) error;}

недолік парадигми модульности: 1)выдсутність зручної можливо-сті розмноження екземплярів ти-пу модуль

2)на етапі виконання програми

відсутній контроль за ініціалі-зацією та присвоєнням. П-д:

char c;

char * pc;

c = pc;

Помилки які характерні для цього стилю пр-ня:

1)"забули створити екземпляр" 2)"забули знищити екземпляр"

3)"спроба використання після знищення"

Парадигма АТД

У модульності не можливе тира-жування екземплярів, досягти цієї можливості дозволяє пара-дигма АТД.П-д в С++:Typedef; на ПаскалІ:Type MyType=…; на Фортрані: встроєний тип Complex;

Тип даних: 1)область допусти-мих значень

2)множина допустимих опера-цій.

П-д:

class Comple //ім’я типу;

{ float Re,Im;

public

friend

Cmplex operator+ (Complex a, Copmlex b);

Cmplex operator*(Complex a, Copmlex b);

Cmplex operator-(Complex a, Copmlex b);

Complex();{RE=0; Im=0;}

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

Complex(float r){Re = r; Im=0;}

Complex (float r,float i){Re = r; Im = i;}

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

ostream& operator <<(operator& 0,Complex c);

конструктор це член кл. за допо-могою якого створюється ек-земпляр зміних даного типу.

П-д:

void f()

{complex a;

complex b=1;

complex c=complex (2,3);//c-const

complex d=a+b;

…

cout<<d;

}

мотив:винекненя випливає з фреймів т.т. об'еднання в одній рамці данних та операцій над ними.

Мовні засоби:оператор class. Описувачі обмежування доступу до кл., можливість переван-таження імен ф. та символів операцій. Мови:С++,Object Pascal, парадигми підтримують стиль:Turbo Pascal,C.

П-д:

complex complex::operator+(complex a, complex b);

{return complex(a.Re+b.Re,a.Im+b.Im);

}

П-д:(бібліотека гафічних примітивів:точка,відрізок,коло…)

Class shape

{ int x,y;int color;

int hidden;int kind;

….

Public:

Shape () {…};

Shape (…) {…};

Void show();

Void hide ();

Void drow();//нарисо-

вать

Void move (int x,int y); };

Void shape::draw()

{if (kind==1)

{//draw circle};

else if (kind==2)

{//draw dot}

else {//draw square}

}

void main()

{

shape circle;

shape dot;

circle.show();

dot.hide();

circle.drow();

dot.drow();

}

Проблема застосування АТД полягає в тому, що при необ-хідності розширити функціона-льність розробленої системи ми змушенні редагувати її на рівні вихідного текста. Це в свою чер-гу має два недоліки:

1.ускладнює розробку і підви-щує ймовірність помилок

2. таке не можливо взагалі, якщо вихідний текст відсутній.

Парадигма ООП.

Мови які підтримують цю парадигму:C++,Object Pascal, Small Talk…

Предметна галузь, що моделю-ється складається з сукупності об’єктів які діють один на одно-го.Кожен об’єкт має власні влас-тивості та поведінку.Взаємодія між об’єктами здійснюється шляхом так званих повідомлень. Повідлмлення-виклик метода.

Підтримуються такі об’єктно орієнтовані можливості:

1.Інкапсуляція(АТД)

2.Поліморфізм(можливість виз-начити до чого належить об’єкт)

3.Наслідування(властивості од-ного об’єкта переносять на ін-ший)

Базовий типпохідний тип

П-д:

Class shape

{int x,y;int color;int hidden;

public:

virtual void draw();

…

};

наслідування дає таку можли-вість

#include "shape.h"

class circle:public shape

{int radius;

public:

virtual void draw();

};

//головна програма

void main()

{circle c1,c2;

star s1,s2,s3;

c1.draw();

s1.move();

s1.draw();

}

 

void shape::move(int x1,int y1)

{hide();//погасити об"єкт

x=x1;//змінити координати

y=y1;

draw();//показати

}

описувач virtual дає можливість з’ясувати власника методу (ф.) навіть тоді коли неможна визначити з синтаксичних мір-кувань у даному місці програми.

Узагальнене програмування це стиль в якому алгоритми не за-лежать від типу даних.

 

6.Поняття про кл. в С++.Кл. та принципи ООП.Обмеження доступу до членів кл.

Кл. в С++ це тип сконструйо-ваний користувачем.

Принципи ООП:

1.Все що $ у предметній області це деякі об’єкти

2.Об'єкти виконують якісь взає-модії один з одним за допомо-гою повідомлень.

3.Кожен об’єкт має власну пам'ять (незалежну), яка скла-дається з інших об'єктів.

4.Кожен клас задає поведінку об'єктів свого типу за допо-могою методів чи ф.-членів кл.

5.Кожен об'єкт є представником або екземпляром певного кл.Кл. відображує загальні властивості своїх представників.

6.Кл. можуть об'єднуватись в ієрархію т.т. в таку деревовидну структкру, яка називається ієра-рхією наслідування.

Основний зміст наслідування полягає в тому що вл. і пове-дінка кл. що належать до ієра-рхій наслідувань є доступними для кл. що розташовані нижче.

Class C

{private://забороняє доступ зовні для ф.не членів кл.,крім friend

protected://дозволяє доступ нащадкам і членам кл.

public://дозволяє доступ будь-кому

}

class C

{private:

int i;

friend void f_f(C);

protected:

int j;

public:

int k;

};

class D:public C

{

void g(C);

};

void f(C c)

{ c.k=0;//ok

c.j=0;//err

c.i=0;//err

}

friend void f_f(C c)

{c.k=0;//ok

c.j=0;//ok

c.i=0;//ok

}

void D::g(C c)

{c.k=0;//ok

c.j=0;//err

c.i=0;//ok

k=0;//ok

j=0;//ok

i=0;//ok

}

void C::h(C c)

{c.k=0;//ok

c.j=0;//ok

c.i=0;//ok

k=0;//ok

j=0;//ok

i=0;//ok

}

 

Констуктори та деструктори.