Размещено на http://www.allbest.ru/

МІНІСТЕРСТВО ОСВІТИ І НАУКИ, МОЛОДІ ТА СПОРТУ УКРАЇНИ

МІЖНАРОДНИЙ НАУКОВО-ТЕХНІЧНИЙ УНІВЕРСИТЕТ ІМЕНІ АКАДЕМІКА ЮРІЯ БУГАЯ

Курсова робота

з дисципліни Об'єктно - орієнтоване програмування»

Виконав:

Студент Групи ЗКД-31

Кирилюк Богдан Олександрович

Перевірила викл.

Коротун Тетяна Михайлівнаа

КИЇВ - 2015

Введення

Об'ємктно-орієнтомване програмувамння (ООП) -- одна з парадигм програмування, яка розглядає програму як множину «об'єктів», що взаємодіють між собою. Основу ООП складають три основні концепції: інкапсуляція, успадкування та поліморфізм. Одною з переваг ООП є краща модульність програмного забезпечення (тисячу функцій процедурної мови, в ООП можна замінити кількома десятками класів із своїми методами). Попри те, що ця парадигма з'явилась в 1960-тих роках, вона не мала широкого застосування до 1990-тих, коли розвиток комп'ютерів та комп'ютерних мереж дозволив писати надзвичайно об'ємне і складне програмне забезпечення, що змусило переглянути підходи до написання програм. Сьогодні багато мов програмування або підтримують ООП (Lua) або ж є цілком об'єктно-орієнтованими (зокрема, Java, C#, C++, Python, PHP, Ruby та Objective-C, ActionScript 3, Swift, Vala).

Об'єктно-орієнтоване програмування сягає своїм корінням до створення мови програмування Симула в 1960-тих роках, одночасно з посиленням дискусій про кризу програмного забезпечення. Разом із тим, як ускладнювалось апаратне та програмне забезпечення, було дуже важко зберегти якість програм. Об'єктно-орієнтоване програмування частково розв'язує цю проблему шляхом наголошення на модульності програми[1].

На відміну від традиційних поглядів, коли програму розглядали як набір підпрограм, або як перелік інструкцій комп'ютеру, ООП програми можна вважати сукупністю об'єктів. Відповідно до парадигми об'єктно-орієнтованого програмування, кожний об'єкт здатний отримувати повідомлення, обробляти дані, та надсилати повідомлення іншим об'єктам. Кожен об'єкт -- своєрідний незалежний автомат з окремим призначенням та відповідальністю[2].

1. Визначення ОПП

Об'єктно-орієнтоване програмування - це метод програмування, заснований на поданні програми у вигляді сукупності взаємодіючих об'єктів, кожен з яких є екземпляром певного класу, а класи є членами певної ієрархії наслідування.[3]. Програмісти спочатку пишуть клас, а на його основі при виконанні програми створюються конкретні об'єкти (екземпляри класів). На основі класів можна створювати нові, які розширюють базовий клас і таким чином створюється ієрархія класів.

На думку Алана Кея, розробника мови Smalltalk, якого вважають одним з «батьків-засновників» ООП, об'єктно-орієнтований підхід полягає в наступному наборі основних принципів:

· Все є об'єктами.

· Всі дії та розрахунки виконуються шляхом взаємодії (обміну даними) між об'єктами, при якій один об'єкт потребує, щоб інший об'єкт виконав деяку дію. Об'єкти взаємодіють, надсилаючи і отримуючи повідомлення. Повідомлення -- це запит на виконання дії, доповнений набором аргументів, які можуть знадобитися при виконанні дії.

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

· Кожен об'єкт є представником (екземпляром, примірником) класу, який виражає загальні властивості об'єктів.

· У класі задається поведінка (функціональність) об'єкта. Таким чином усі об'єкти, які є екземплярами одного класу, можуть виконувати одні й ті ж самі дії.

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

Таким чином, програма являє собою набір об'єктів, що мають стан та поведінку. Об'єкти взаємодіють використовуючи повідомлення. Будується ієрархія об'єктів: програма в цілому -- це об'єкт, для виконання своїх функцій вона звертається до об'єктів що містяться у ньому, які у свою чергу виконують запит шляхом звернення до інших об'єктів програми. Звісно, щоб уникнути безкінечної рекурсії у зверненнях, на якомусь етапі об'єкт трансформує запит у повідомлення до стандартних системних об'єктів, що даються мовою та середовищем програмування. Стійкість та керованість системи забезпечуються за рахунок чіткого розподілення відповідальності об'єктів (за кожну дію відповідає певний об'єкт), однозначного означення інтерфейсів міжоб'єктної взаємодії та повної ізольованості внутрішньої структури об'єкта від зовнішнього середовища (інкапсуляції).

2. Клас - це модуль, архітектурна одиниця побудови програмної системи. Модульність побудови - основна властивість програмних систем. У ООП програмна система, що будується за модульним принципом, складається з класів, що є основним видом модуля. У мові C# дозволяється оголосити клас, який не розглядається як тип даних, і в якого зберігається єдина роль - роль модуля. В цьому класі можуть бути задані константи, лише статичні поля і лише статичні методи. У нього немає конструкторів в звичайному сенсі цього слова, що дозволяють створювати об'єкти - екземпляри класу.

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

Формально клас описується таким чином:

Синтаксис опису класу:

тип доступу class им'я_класу {

тип_доступу тип им'я змінної1;

тип_доступу тип им'я змінної2;

тип_доступу тип_результату

им'я _методу1(список_параметрів) {тіло_методу}

}

де тип_доступу визначає область видимості класу. Для класів визначено

такі модифікатори доступу:

public - клас доступний для інших компонент;

internal - клас видимий в середині цього компонента (збірки).

Для членів класу (даних і методів) визначені такі модифікатори доступу:

рublic - члени класу доступні за межами даного класу;

internal - члени класу доступні в межах однієї збірки;

рrotected - члени класу доступні усередині даного класу;

private - члени класу доступні тільки для інших членів даного класу.

За замовчанням застосовується модифікатор internal.

2. Використання покажчика this

Кожен об'єкт містить свій екземпляр полів класу. Методи знаходяться в пам'яті в одному екземплярі і використовуються всіма об'єктами спільно, тому необхідно забезпечити роботу методів нестатичних екземплярів з полями саме того об'єкту, для якого вони були викликані. Для цього в будь-який нестатичний метод автоматично передається прихований параметр this, в якому зберігається посилання на поточний екземпляр об'єкта, що викликав функцію.

Це посилання є прихованим показчиком на кожний нестатичний метод класу. Будь-який метод може використовувати ключове слово this для доступу до інших нестатичних методів і змінних цього об'єкта.

У явному вигляді параметр this застосовується для того, щоб повернути з методу посилання на об'єкт, а також для ідентифікації поля в разі, якщо його ім'я збігається з іменем параметра методу, наприклад:

Приклад 2.4.

class Demo

{

double y;

public Demo T() // метод повертає посилання на екземпляр

{

return this;

}

public void Sety( double y )

{

this.y = y; // полю y призначається значення параметра y

}

4. Композиція класів. Статичні елементи класу.

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

У UML композиції буде показано як асоціації з зафарбованим ромбом з боку цілого.

Конструктор

Існує спеціальна категорія функцій-членів, які відповідають за такі дії з об'єктами, як ініціалізація, присвоювання, управління пам'яттю, перетворення типів і знищення. Такі функції називаються конструкторами. Вони викликаються компілятором неявно кожного разу, коли об'єкт класу визначається або створюється оператором new. В оголошенні конструктора його ім'я збігається з ім'ям класу. Ось, наприклад, оголошення конструктора класу Screen, в якому задані значення за замовчуванням для параметрів hi, wid і bkground:

class Screen

{

public:

Screen (int hi = 8, int wid = 40, char bkground = '#');

/ / Оголошення інших функцій-членів не змінюються

};

Визначення конструктора класу Screen виглядає так:

Screen :: Screen (int hi, int wid, char bk):

_height (hi), / / ??ініціалізувати _height значенням hi

_width (wid), / / ??ініціалізувати _width значенням wid

_cursor (0), / / ??ініціалізувати _cursor нулем

_screen (hi * wid, bk) / / розмір екрана дорівнює hi * wid

/ / Всі позиції инициализируются

/ / Символом '#'

{/ / Вся робота виконана в списку ініціалізації членів

}

Кожен оголошений об'єкт класу Screen автоматично ініціалізується конструктором:

Screen s1; / / Screen (8,40, '#')

Screen * ps = new Screen (20); / / Screen (20,40, '#')

int main () {

Screen s (24,80, '*'); / / Screen (24,80, '*')

/ / ...

}

Десруктор

Одна з цілей, що стоять перед конструктором, - забезпечити автоматичне виділення ресурсу. Ми вже бачили в прикладі з класом Screen конструктор, де за допомогою оператора new виділяється пам'ять для членів класу. Можна також уявити ситуацію, коли потрібно отримати монопольний доступ до поділюваного пам'яті або до критичної секції потоку. Для цього необхідна симетрична операція, що забезпечує автоматичне звільнення пам'яті або повернення ресурсу по завершенні часу життя об'єкта, - деструктор. Деструкція - це спеціальна визначувана користувачем функція-член, яка автоматично викликається, коли об'єкт виходить з області видимості або коли до покажчика на об'єкт застосовується операція delete. Ім'я цієї функції утворене з імені класу з попереднім символом "тильда" (~). Деструкція не повертає значення і не приймає ніяких параметрів, а отже, не може бути перевантажений. Хоча дозволяється визначати кілька таких функцій-членів, лише одна з них буде застосовуватися до всіх об'єктів класу. Ось, наприклад, деструктор для нашого класу Screen:

class Screen

{

public:

~ Screen ();

/ / Оголошення інших функцій-членів не змінюються

};

Визначення деструктора класу Screen виглядає так:

Screen :: ~ Screen ():

{

/ / Звільнення виділеної пам'яті

}

3. Дружні функції і дружні класи

Використання дружніх функцій

#include <stdio.h>

class TComplex

{

friend TComplex sum(TComplex, TComplex);

double Re;

double Im;

public:

static int counter;

TComplex(double x, double y):Re(x),Im(y)

{ counter++;printf("Ctor %d\n",counter);}

TComplex(TComplex& z)

{ Re = z.Re; Im = z.Im; counter++; printf("Copy %d\n",counter);}

~TComplex(){printf("Dtor %d\n",counter);counter--;}

void print() {printf("Z = %lf + i*%lf\n",Re,Im);}

};

TComplex sum(TComplex,TComplex);

int TComplex::counter = 0;

int main()

{

printf("Start main\n");

TComplex z(1,1), w(2,2), u(0,0);

u = sum(z,w);

printf("End sum\n");

u.print();

printf("End main\n");

return 0;

}

TComplex sum(TComplex u, TComplex v)

{

printf("Start \n");

TComplex w(0,0);

w.Re= u.Re + v.Re;

w.Im=u.Im + v.Im;

return w;

}

Дружня функція має всі права члена класу. Отже, їй доступні всі поля -- як відкриті, так і закриті. Для того

щоб оголосити функцію дружньої, ключове слово friend слід помістити в оголошення класу. (Клас сам

оголошує своїх друзів!)

Розділимо клас TComplex на два: TNumber і TFunction. У першому класі залишимо змінні-члени, а до

другого віднесемо усі функції.

Використання дружніх функцій-членів

#include <stdio.h>

class TNumber;

class TFunction

{

public:

void print(TNumber z);

};

class TNumber

{

double Re;

double Im;

public:

static int counter;

TNumber(double x, double y):Re(x),Im(y)

{ counter++;printf("Ctor %d\n",counter);}

TNumber(TNumber& z)

{ Re = z.Re; Im = z.Im; counter++; printf("Copy %d\n",counter);}

~TNumber(){printf("Dtor %d\n",counter);counter--;}

friend void TFunction::print(TNumber);

};

int TNumber::counter = 0;

int main()

{

printf("Start main\n");

TNumber z(1,1);

TFunction a;

a.print(z);

printf("End main\n");

return 0;

}

void TFunction::print(TNumber z)

{

printf("z = %lf + i*%lf\n", z.Re, z.Im);

}

У результаті одержуємо наступні повідомлення.

Start main

Ctor 1

Copy 2

z = 1.000000 + i*1.000000

Dtor 2

End main

Dtor 1

Зверніть увагу на те, що функція print(), що належить класу TFunction, одержує параметр типу

TNumber. Отже, цей тип повинний бути визначений раніше. Однак клас TNumber оголошує дружню функцію print(), що належить класу TFunction. Для розв'язання цієї проблеми в мові С++ передбачений механізм неповного оголошення класу.

Працюючи з дружніми функціями, потрібно враховувати наступні обмеження.

1. Вони не успадковуються.

2. Вони не можуть мати специфікатори static і extern.

3. У класі, функція-член якого є дружньою до не цілком оголошеного класу, слід розміщати тільки прототип. Реалізація функції повинна знаходитися після повного оголошення класу.

Коли усі функції деякого класу є дружніми стосовно іншого класу, можна оголосити весь клас дружнім.

Наприклад, попередню програму можна переробити в такий спосіб.

Використання дружніх класів

#include <stdio.h>

class TNumber; // Неповне оголошення

TFunction

{

public:

void print(TNumber z); // Апеляція до не цілком оголошеного класу

};

class TNumber

{

double Re;

double Im;

public:

static int counter;

TNumber(double x, double y):Re(x),Im(y)

{ counter++;printf("Ctor %d\n",counter);}

TNumber(TNumber& z)

{ Re = z.Re; Im = z.Im; counter++; printf("Copy %d\n",counter);}

~TNumber(){printf("Dtor %d\n",counter);counter--;}

friend class TFunction; // Оголошення дружнього класу

};

int TNumber::counter = 0;

int main()

{

printf("Start main\n");

TNumber z(1,1);

TFunction a;

a.print(z);

printf("End main\n");

return 0;

}

void TFunction::print(TNumber z)

{

printf("z = %lf + i*%lf\n", z.Re, z.Im);

}

Варто мати на увазі, що члени класу TFunction просто мають доступ до членів класу TNumber, але члени

класу TNumber від цього не стають членами класу TFunction.

Іноді два класи настільки тісно зв'язані, що їм необхідний повний доступ до всіх членів. У цьому випадку їх

оголошують взаємно дружніми.

Використання взаємно дружних класів

#include <stdio.h>

class TNumber;

class TFunction

{

void print(TNumber z);

friend class TNumber;

};

class TNumber

{

double Re;

double Im;

public:

static int counter;

TNumber(double x, double y):Re(x),Im(y)

{ counter++;printf("Ctor %d\n",counter);}

TNumber(TNumber& z)

{ Re = z.Re; Im = z.Im; counter++; printf("Copy %d\n",counter);}

~TNumber(){printf("Dtor %d\n",counter);counter--;}

void sum(TNumber y, TFunction z)

{Re = Re + y.Re; Im = Im + y.Im; z.print(*this);}

friend class TFunction;

};

int TNumber::counter = 0;

int main()

{

printf("Start main\n");

TNumber z(1,1),x(1,1);

TFunction a;

z.sum(z,a);

printf("End main\n");

return 0;

}

void TFunction::print(TNumber z)

{

printf("z = %lf + i*%lf\n", z.Re, z.Im);

}

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

Start main

Ctor 1

Ctor 2

Copy 3

Copy 4

z = 2.000000 + i*2.000000

Dtor 4

Dtor 3

End main

Dtor 2

Dtor 1

Як бачимо, функція sum(), що є членом класу TNumber, одержує вільний доступ до функції print(), оголошеної в закритому розділі класу TFunction. Якби класи TNumber і TFunction не були взаємно дружніми, це було б неможливо.

4. Перевантаження операцій

Оператор посилання на член об'єкта є унарним. Операторна функція, що перевантажуєйого, виглядає в

такий спосіб.

об'єкт -> елемент

Цей запис еквівалентний наступному вираженню.

об'єкт.operator->(елемент);

Функція operator- >() повинна бути нестатичним членом класу. Як параметр вона одержує об'єкт чи класу посилання на нього, повертаючи вказівник this на об'єкт, де виконується виклик, або посилання на об'єкт будь-якого іншого класу, у якому визначений оператор ->. її зручно використовувати в контейнерних класах, що містять усередині себе вказівник на інший клас. Основний зміст перевантаження оператора -> полягає в додатковій функціональності, що розширює можливості звичайних вказівників.

Наприклад, у приведеній нижче програмі функція operator- >() веде підрахунок посилань на коженоб'єкт класу.

Перевантаження оператора ->

#include <stdio.h>

class TClass

{

int n;

int counter;

public:

TClass(int x):n(x),counter(0) { }

TClass* operator->();

int get(void) { return n;}

int ref(void) { return counter; }

};

TClass* TClass::operator ->()

{

counter++;

return this;

}

int main()

{

TClass a(1), b(2);

printf("n = %d \n",a->get());

printf("n = %d \n",b->get());

printf("n = %d \n",a->get());

printf("counter = %d \n",a->ref());

printf("counter = %d \n",b->ref());

return 0;

}

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

n = 1

n = 2

n = 1

counter = 3

counter = 2

Зверніть увагу на те, що функція operator- >() у даному прикладі повертає значення типу TClass*.

Розглянемо тепер програму, у якій створюється контейнер, що містить масив вказівників на об'єкти класу

TClass.

#include <stdio.h>

class TClass

{

int n;

int counter;

public:

TClass(int x):n(x),counter(0) { }

TClass* operator->();

int get(void) { return n;}

int ref(void) { return counter; }

};

TClass* TClass::operator ->()

{

counter++;

return this;

}

class TContainer

{

public:

int m;

TClass* p[];

TContainer(int k, TClass* q[])

{

m = k;

for(int i=0; i<m; i++)p[i]=q[i];

}

TContainer* operator->();

};

TContainer* TContainer::operator ->()

{

return this;

};

int main()

{

int m = 2;

TClass a(1), b(2);

TClass* p[]={&a, &b};

TContainer c(m,p);

for(int i=0; i<m; i++) printf("%ld \n",c->p[i]->get());

return 0;

}

Оскільки й у класі TContainer, і в класі TClass міститься перевантажена версія оператора ->, ми можемо скористатися ланцюжком операторів c- >p[i]- >get(), що забезпечує перегляд умісту контейнера.

5. Спадкування і його роль в ООП

Спадкування є основною концепцією об'єктно-орієнтовного програмування (ООП). З його допомогою створюється ієрархія класів. Спадкування використовується для розширення функціональних можливостей класу. У мові C# клас, від якого успадковується , називається базовим, а клас, який успадковує, - похідним. Отже, похідний клас є спеціалізованим варіантом базового класу. Він успадковує усі змінні, методи, властивості і індексатори, визначувані в базовому класі, додаючи до них свої власні елементи. Базовий клас не має доступу до членів свого похідного класу. На відміну від C++, у C# заборонено множинне спадкування, тобто клас може успадковувати властивості і методи тільки від одного базового класу (предка). Множинне спадкування можна реалізувати за допомогою інтерфейсів. Таким чином, в C# є два типи спадкування: спадкування реалізації і спадкування інтерфейсів.

6. Відкрите, захищене і закрите спадкування

Використання відкритого успадкування

#include <stdio.h>

class TInner

{

public:

int i;

TInner(int n):i(n){ printf("Ctor TInner\n");}

TInner(TInner& x){ *this = x; printf("Copy ctor TInner\n");}

~TInner(){printf("Dtor TInner\n");}

};

class TBase

{

public:

double a;

TInner b;

TBase():b(10),a(5.0){printf("Ctor TBase\n");}

~TBase(){printf("Dtor TBase\n");}

TBase(TBase& x):b(10){ *this = x; printf("Copy ctor TBase\n");}

void printBase() {printf("TBase::TInner::i = %d a = %lf\n",b.i, a);}

};

class TDerived: public TBase

{

public:

char c;

TDerived():c('Z'){printf("Ctor TDerived\n");}

TDerived(TDerived& x){ *this = x; printf("Copy ctor TDerived\n");}

~TDerived(){printf("Dtor TDerived\n");}

void printDerived() {printf("TDerived::TInner::i = %d c = %c\n",b.i,c);}

};

class TDerived2: public TDerived

{

public:

float f;

TDerived2():f(10.0){printf("Ctor TDerived2\n");}

~TDerived2(){printf("Dtor TDerived2\n");}

void printDerived2() {printf("TDerived2::TInner::i = %d f = %lf\n",b.i,f);}

};

int main()

{

TBase first;

TDerived second;

TDerived2 third;

first.printBase();

second.printDerived();

third.printDerived2();

printf("Sizeof(TBase) = %d\n", sizeof(TInner));

printf("Sizeof(TBase) = %d\n", sizeof(TBase));

printf("Sizeof(TDerived) = %d\n", sizeof(TDerived));

printf("Sizeof(Tderived2) = %d\n", sizeof(TDerived2));

return 0;

}

У цій програмі описано чотири класи: TInner, TBase, TDerived, TDerived2. Клас TBase є

контейнерним; він містить об'єкт класу TInner. Крім того, клас TBase є базовим стосовно класу TDerived.

У свою чергу, клас TDerived є базовим стосовно класу TDerived2.

У функції main() створюється три об'єкти -- first, second і third -- класів TBase, TDerived і

TDerived2 відповідно. Потім викликаються функції, що виводять на екран вміст цих об'єктів. орієнтований програмування препроцесор оператор

Закрите успадкування

Припустимо, що ми застосували закрите успадкування. У цьому випадку усі відкриті і захищені поля

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

Применим закрите успадкування при висновку класу TDerived.

class TDerived: private TBase // Закрите успадкування

{

public:

char c;

TDerived():c('Z'){printf("Ctor TDerived\n");}

TDerived(TDerived& x):b(10){ *this = x; printf("Copy ctor TDerived\n");}

~TDerived(){printf("Dtor TDerived\n");}

void printDerived() {printf("TDerived::TInner::i = %d c = %c\n",b.i,c);}

};

На його відношення до полів класу TBase це ніяк не впливає. Однак тепер визначення класу TfDerived2

стало неправильним. Його функція-член printDerived2() не має доступу до поля b, що стало закритим.

Існує два способи вирішення цієї проблеми. Перший -- переписати класи TDerived і TDerived2,

відкривши шлях до поля b. Другий -- відкрити поле b насильно, використовувавши уточнення.

class TDerived: private TBase

{

public:

char c;

TBase::b; // Уточнення

TDerived():c('Z'){printf("Ctor TDerived\n");}

TDerived(TDerived& x){*this = x; printf("Copy ctor TDerived");}

~TDerived(){printf("Dtor TDerived\n");}

void printDerived() {printf("TDerived::TInner::i = %d c = %c\n",b.i,c);}

};

Виділений рядок називається уточненням поля b. Незважаючи на те що відповідно до правил закритого успадкування цей член вважається закритим, він повторно з'являється у відкритому розділі класу TDerived і стає відкритим.

Захищене успадкування

Ми уже не раз згадували специфікатор доступу protected, але лише тепер прийшла пора розкрити його зміст.

Це пояснюється тим, що його відмінність від специфікатора private виявляється тільки при успадкуванні класів. В всем іншому специфікатори protected і private еквівалентні. При захищеному успадкуванні відкриті члени базового класу стають захищеними членами похідного класу. Вони видні лише функціям базового і похідного класів і є невидимими з інших точок програми. Таким чином, програма як і раніше має доступ до відкритих членів базового класу через його об'єкти, але втрачає доступ до цих полів, якщо доступ здійснюється через об'єкти похідного класу.

Уявимо собі, що клас TDerived оголошений захищеним.

class TDerived: protected TBase

{

public:

char c;

TDerived():c('Z'){printf("Ctor TDerived\n");}

TDerived(TDerived& x){*this = x; printf("Copy ctor TDerived");}

~TDerived(){printf("Dtor TDerived\n");}

void printDerived() {printf("TDerived::TInner::i = %d c = %c\n",b.i,c);}

};

Функція printDerived() як і раніше має доступ до поля b.i, однак прямого доступу до цього

відкритого поля класу TBase через об'єкти класів TDerived і TDerived2 тепер немає.

int main()

{

TBase first;

TDerived second;

TDerived2 third;

printf("TBase::TInner::b = %d \n",first.b.i);

printf("TDerived::TInner::b = %d \n",second.b.i); // Помилка! Нет доступу!

printf("TDerived2::TInner::b = %d \n",third.b.i); // Помилка! Нет доступу!

return 0;

7. Множинне спадкування

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

Мови програмування з підтримкою множинного спадкування: Eiffel, C++, Dylan, Python, Perl, Curl, Common Lisp (завдяки CLOS), OCaml, Tcl (завдяки Incremental Tcl)[1] та Object REXX (завдяки використанню класів домішок).

8. Абстрактні класи та функції

В об'єктно-орієнтованому програмуванні абстрактний клас - це базовий клас, від якого не можна створити екземпляру. На практиці абстрактні класи реалізують один з принципів ООП - поліморфізм. В абстрактному класі можна описати (або не визначити) абстрактні методи та властивості. Абстрактний метод не реалізовується в класі в якому описується, але має бути реалізований в неабстрактному нащадку. Абстрактні класи вважаються найбільшими узагальненими абстракціями, тобто відношення об'єму описів до об'єму реалізації найбільше. В деяких мовах заборонено створювати екземпляри абстрактних класів, в інших дозволяється (наприклад, Delphi), але звернення даного екземпляра, до абстрактного методу викличе помилку. В багатьох мовах дозволяється оголошувати будь-який клас абстрактним навіть, якщо в ньому нема абстрактних методів (наприклад, Java), для того щоб заборонити створення екземплярів. Абстрактний клас можна розглядати, як інтерфейс для сімейства класів, які ним породжені, але на противагу класичному інтерфейсу, абстрактний клас може містити реалізацію методів та властивості. Абстрактні методи переважно є і віртуальними, через це поняття «абстрактний» та «віртуальний» інколи плутають

Абстрактні класи відіграють важливу роль для статичної типізації в об'єктно-орієнтованих мовах. Багато динамічно типізованих мов не мають схожих механізмів (хоча використання латентної типізації відкидає потребу в абстрактних класах); а ще трейти, реалізацію яких можна знайти в сучасних динамічно типізованих мовах. Деякі програмісти стверджують, що класи повинні бути фінальними (без похідних), або абстрактним.

Абстрактні класи корисні тим, що за їхньою допомогою можна визначити протокол; набір операцій, які мають бути у всіх об'єктах, які реалізують протокол.

9. Поліморфізмі віртуальні функції

Однією з трьох основних особливостей ООП є поліморфізм. Стосовно мови програмування C++, під терміном поліморфізм розуміють механізм реалізації функції, у якому різні результати можна отримати за допомогою одного її імені. З цієї причини поліморфізм іноді характеризується фразою "один інтерфейс, багато методів". Це означає, що до всіх функцій-членів класу можна отримати доступ одним і тим самим способом, незважаючи на можливу відмінність у конкретних діях, пов'язаних з кожною окремою операцією. У мові програмування C++ поліморфізм підтримується як у процесі виконання програми, так у період її компілювання. Перевантаження операторів і функцій - це приклади поліморфізму, що належить до моменту компілювання. Але, попри потужність механізму перевантаження операторів і функцій, він не у змозі вирішити всі завдання, які виникають в реальних додатках, розроблених з використанням ООП. Тому у мові C++ також реалізовано поліморфізм періоду виконання, який базується на використанні похідних класів і віртуальних функцій, що і становить основні теми цього розділу. Почнемо розгляд матеріалу з короткого опису вказників на похідні типи, оскільки саме вони забезпечують підтримку динамічного поліморфізму.

Віртуальна функція - це така функція, яка оголошується в базовому класі з використанням ключового слова virtual і перевизначається в одному або декількох похідних класах. Таким чином, кожен похідний клас може мати власну версію віртуальної функції.

10. Динамічні структури даних

Динамічні структури за визначенням характеризуються відсутністю фізичної суміжності елементів структури в пам'яті непостійністю і непередбачуваністю розміру (числа елементів) структури в процесі її обробки [1-2]. У цьому розділі розглянуті особливості динамічних структур, визначувані їх першою характерною властивістю. Особливості, пов'язані з другою властивістю розглядаються в останньому розділі даного розділу.

Оскільки елементи динамічної структури розташовуються по непередбачуваних адресах пам'яті, адреса елементу такої структури не може бути обчислений з адреси початкового або попереднього елементу. Для встановлення зв'язку між елементами динамічної структури використовуються покажчики, через які встановлюються явні зв'язки між елементами. Таке представлення даних в пам'яті називається зв'язним. Елемент динамічної структури складається з двох полів:

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

· поле зв'язок, в якому містяться один або декілька покажчиків, що пов'язує даний елемент з іншими елементами структури;

Коли зв'язне представлення даних використовується для вирішення прикладного завдання, для кінцевого користувача "видимим" робиться тільки вміст інформаційного поля, а поле зв'язок використовується тільки програмістом-розробником.

Достоїнства зв'язного представлення даних - в можливості забезпечення значної мінливості структур;

· розмір структури обмежується тільки доступним об'ємом машинної пам'яті;

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

Разом з тим зв'язне уявлення не позбавлене і недоліків, основні з яких:

робота з покажчиками вимагає, як правило, вищої кваліфікації від програміста;

· на поля зв'язок витрачається додаткова пам'ять;

· доступ до елементів зв'язної структури може бути менш ефективним за часом.

Останній недолік є найбільш серйозним і саме їм обмежується застосовність зв'язного представлення даних. Якщо в суміжному представленні даних для обчислення адреси будь-якого елементу нам у всіх випадках достатньо було номери елементу і інформації, що міститься в дескрипторі структури, то для зв'язного уявлення адреса елементу не може бути обчислений з початкових даних. Дескриптор зв'язної структури містить один або декілька покажчиків, що дозволяють увійти до структури, далі пошук необхідного елементу виконується проходженням по ланцюжку покажчиків від елементу до елементу. Тому зв'язне уявлення практично ніколи не застосовується в завданнях, де логічна структура даних має вид вектора або масиву - з доступом по номеру елементу, але часто застосовується в завданнях, де логічна структура вимагає іншої початкової інформації доступу (таблиці, списки, дерева і так далі).

11. Пре процесор і основні пре процесорні оператори

Препроцесор С / С ++ (англ. Pre processor, предобработчік) - програма, яка готує код програми на мові C / C ++ до компіляції.

Препроцесором виконуються наступні дії:

заміна відповідних диграфів і тріграфов на еквівалентні символи «#» і «\»;

видалення екранованих символів переведення рядка;

заміна малих і блокових коментарів порожніми рядками (з вилученням оточуючих пропусків і символів табуляції);

вставка (включення) вмісту довільного файлу (#include);

макропідстановки (#define);

умовна компіляція (#if, #ifdef, #elif, #else, #endif);

виведення повідомлень (#warning, #error).

Умовна компіляція дозволяє вибрати код для компіляції в залежності від:

моделі процесора (платформи);

розрядності адрес;

розмірності типів;

наявності / відсутності підтримки розширень мови;

наявності / відсутності бібліотек і / або функцій;

особливостей поведінки конкретних функцій;

й іншого.

Етапи роботи препроцесора:

лексичний аналіз коду C / C ++ (синтаксичнийаналіз не виконується);

обробка директив;

виконання підстановок:

диграфів і тріграфов;

коментарів;

директив;

лексем, заданих директивами.

12. Шаблони функцій

Шаблони (англ. template) -- засіб мови C++, який призначений для кодування узагальнених алгоритмів, без прив'язки до деяких параметрів: типу даних, розміру буфера та стандартного значення. В C++ можливе створення шаблону функції і шаблону класу. Хоча шаблони надають коротку форму запису ділянки коду, насправді їх використання не скорочує виконаний код, тому що для кожного набору параметрів компілятор створює окремий екземпляр функції або класу.

При створенні функцій іноді виникають ситуації, коли дві функції виконують однакову послідовність дій, але працюють з різними типами даних (наприклад, одна використовує параметри типу int, а інша типу float або double). За допомогою механізму перевантаження функцій можна використовувати одне й те ж ім'я для функцій, що виконують різні дії і мають різні типи параметрів. Однак, якщо функції повертають значення різних типів, слід використовувати для них унікальні імена. Шаблонна функція дає можливість оперувати параметрами різних типів і повертати значення різних типів, що значно полегшує роботу і зменшує кількість змінних у коді. Іншими словами шаблонна функція являє собою набір функцій.

13. Шаблони класів

class A

{

/ * ... * /

public:

template <class T> T & ConvertTo ();

template <class T> void ConvertFrom (const T & data);

};

template <class T>

void f (T Container)

{

int i1 = Container.template ConvertTo <int> () + 1;

Container.ConvertFrom (i1); // кваліфікатор не потрібен

}

14. Обробка виняткових ситуацій

#include <iostream>

using namespace std;

int main()

{

int n = 10, m = 0;

printf("Початок\n");

try

{

printf("У блоці try\n");

if(m==0) throw "Divide by zero"; else n=n/m;

printf("Подальша частина блоку не виконується!");

}

catch (const char* s)

{

printf("%s\n",s);

}

printf("Кінець\n");

return 0;

}

15. Огляд стандартної бібліотеки С++

Стандартна бібліотека Сі++ включає стандартну бібліотеку Сі з невеликими змінами, які роблять її відповіднішою для мови Сі++. Інша велика частина бібліотеки Сі++ заснована на Стандартній Бібліотеці Шаблонів (STL). Вона надає такі важливі інструменти, як контейнери (наприклад, вектори і списки) і ітератори (узагальнені вказівники), що надають доступ до цих контейнерів як до масивів. Крім того, STL дозволяє схожим чином працювати і з іншими типами контейнерів, наприклад, асоціативними списками, стеками, чергами.

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

Так само, як і в Сі, можливості бібліотек активізуються використанням директиви #include для включення стандартних файлів. Всього в стандарті Сі++ визначено 50 таких файлів.

STL до включення в стандарт Сі++ була сторонньою розробкою, на початку -- фірми HP, а потім SGI. Стандарт мови не називає її «STL», оскільки ця бібліотека стала невід'ємною частиною мови, проте багато людей досі використовують цю назву, щоб відрізняти її від решти частини стандартної бібліотеки (потоки введення/виведення (Iostream), підрозділ Сі тощо). Проект під назвою STLport, заснований на SGI STL, здійснює постійне оновлення STL, IOstream і рядкових класів. Деякі інші проекти також займаються розробкою приватних застосувань стандартної бібліотеки для різних конструкторських завдань. Кожен виробник компіляторів Сі++ обов'язково поставляє якусь реалізацію цієї бібліотеки, оскільки вона є дуже важливою частиною стандарту і широко використовується.

Причиною успіху STL, зокрема її вхід до стандартної бібліотеки С++, була націленість на широке коло завдань і узагальнена структура. В цьому сенсі, близькою за духом STL на сьогодні є бібліотека Boost. Boost теж є бібліотекою загального застосування і теж впливає на формування стандартної бібліотеки С++.

16. Загальна характеристика контейнерних класів

Контейнерами називаються об'єкти, що містять інші об'єкти. Контейнери управляють розміщенням

об'єктів в оперативній пам'яті, використовуючи конструктори, видаляють об'єкти з пам'яті за допомогою

деструкторів, а також додають і видаляють об'єкти за допомогою операцій вставки й видалення.

У стандартній бібліотеці описано 10 шаблонних класів контейнерів.

Назва Заголовок Опис

vector <vector> Вектор

list <list> Двозв'язний список

deque <deque> Двостороння черга

set <set> Множина

multiset <set> Мультимножина

map <map> Асоціативний масив, що містить унікальні ключі й

значення

multimap <multimap> Асоціативний масив, що допускає дублювання

ключів і значень

stack <stack> Стек

queue <queue> Черга

priority_queue <queue> Черга із пріоритетом

bitset <bitset> Бітовий набір

Загальна структура контейнерів

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

1. Контейнер може містити об'єкти будь-якого типу, крім посилань.

2. Конструктор копіювання об'єкта, що втримується в контейнері, повинен виконувати операцію вставки.

3. Виділення й звільнення пам'яті, зайнятої об'єктом, що зберігається в контейнері, повинне здійснюватися

автоматично.

4. Контейнер повинен допускати автоматичну зміну розмірів.

5. Деструктор контейнера повинен викликати деструктори об'єктів, що зберігаються в ньому. Якщо

конструктор містить вказівники, звільнення пам'яті здійснюється окремою операцією.

Контейнери в бібліотеці STL можна розділити на дві категорії -- послідовності й асоціативні контейнери.

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

оператор typedef, що уніфікує імена.

типів, загальні для всіх контейнерів

Ім'я Опис

size_type Цілочисельний тип

reference Посилання на елемент

const_reference Константне посилання на елемент

difference_type Цілочисельний тип відстані між двома ітераторами

iterator Ітератор

const_iterator Константний ітератор

reverse_iterator Зворотний ітератор

const_reverse_iterator Константний зворотний ітератор

value_type Тип значення, що зберігається в контейнері

allocator_type Тип розподільника

key_type Тип ключа

key_compare Тип функції, що порівнює два ключі

value_compare Тип функції, що порівнює два значення

Послідовні контейнери.

Послідовності Послідовність -- це різновид контейнерів, що містять скінчену множину однотипних об'єктів, упорядкованих у лінійному порядку. У бібліотеці STL передбачено три види послідовних контейнерів: вектор (клас vector), список (клас list) і двостороння черга (клас deque). Крім того, вони є базовими класами для створення більше складних контейнерів -- стека (клас stack), черги (клас queue) і черги із пріоритетом (клас priority_queue). Для кожної з послідовностей передбачений свій набір операцій, але існують операції, загальні для всіх послідовностей.

17. Асоціативні контейнери

Асоціативні контейнери -- це структури даних, що забезпечують швидкий пошук даних по ключі. У стандартній бібліотеці шаблонів передбачено чотири різновиди асоціативних контейнерів: set (множина), multiset (мультимножина), map (асоціативний масив) і multimap (асоціативний мультимассив). Терміни “мультимножина” й “мультимассив” означають, що ці контейнери допускають дублікати елементів, на відміну від множини й масиву, у яких елементи повинні бути унікальними. Асоціативні контейнери залежать від двох параметрів -- Key (ключ) і Compare (відношення повного впорядкування по ключі Key). Класи set й multiset являють собою “вырожденные” асоціативні контейнери, у яких значення не важливі -- всі операції здійснюються через ключі. Контейнер класу set повинен складатися з унікальних ключів, а об'єкт класу multiset допускає дублікати. У класах map й multimap зберігаються пари, що складаються з об'єктів довільного типу T, пов'язаних з об'єктами класу Key. Ітератор асоціативного контейнера є двунаправленным. Операція вставки не впливає на коректність ітераторов і посилань на елементи контейнера, а операція видалення анулює лише ітератори й посилання, установлені на вилучені елементи. Крім того, ітератори асоціативних контейнерів переміщаються по контейнері в порядку зростання ключів. Операції, загальні для всіх асоціативних контейнерів

Адаптери стандартних контейнерів

Шаблонові класи vector, list й deque описують всі основні операції над послідовностями. Хоча вони містять досить велику кількість однакових операцій, по своїй структурі й принципам функціонування жоден із

цих класів не можна замінити іншим. Завдяки тому, що в класах vector, list й deque реалізовані базові операції, їх можна використати як основу для створення більше складних структур -- стеков і черг. Отже, для

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

18. Алгоритми і функції стандартної бібліотеки

Стандартна бібліотека шаблонів (англ. Standard Template Library; STL) -- бібліотека для C++, що містить набір узгоджених узагальнених алгоритмів, контейнерів, засобів доступу до їхнього вмісту і різних допоміжних функцій.

Стандартна бібліотека шаблонів до включення в стандарт C++ була сторонньою розробкою, на початку -- фірми HP, а потім SGI. Стандарт мови не називає її «STL», оскільки ця бібліотека стала невід'ємною частиною мови, проте багато людей досі використовують цю назву, щоб відрізняти її від решти частини стандартної бібліотеки (потоки вводу/виводу (iostream), підрозділ Сі тощо).

Проект під назвою STLPort, заснований на SGI STL, здійснює постійне оновлення STL, IOstream і рядкових класів. Деякі інші проекти також займаються розробкою приватних застосувань стандартної бібліотеки для різних конструкторських завдань. Кожен виробник компіляторів C++ обов'язково поставляє яку-небудь реалізацію цієї бібліотеки, оскільки вона є дуже важливою частиною стандарту і широко використовується.

У бібліотеці виділяють чотири основних компонентів:

1. Контейнер (container) - зберігання набору об'єктів в пам'яті.

2. Ітератор (iterator) - забезпечення засобів послідовного доступу до вмісту контейнера.

3. Алгоритм (algorithm) - визначення обчислювальної процедури.

4. Функціональний об'єкт (functor) - заховання функції в об'єкті для використання іншими компонентами.

Розділення дозволяє зменшити кількість компонентів. Наприклад, замість написання окремої функції пошуку елементу для кожного типу контейнера забезпечується єдина версія, яка працює з кожним з них, поки дотримуються основні вимоги.

19. Достоїнства і недоліки об'єктно - орієнтованого стилю програмування

Переваги мови C++

Швидкодія. Швидкість роботи програм на С++ практично не поступається програмам на С, хоча програмісти отримали в свої руки нові можливості і нові засоби.

Масштабованість. На мові C++ розробляють програми для самих різних платформ і систем.

Можливість роботи на низькому рівні з пам'яттю, адресами, портами. (Що, при необережному використанні, може легко перетворитися на недолік.)

Можливість створення узагальнених алгоритмів для різних типів даних, їх спеціалізація, і обчислення на етапі компіляції, з використанням шаблонів.

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

Недоліки мови C++

Наявність безлічі можливостей, що порушують принципи типобезпеки приводить до того, що в С++ програми може легко закрастися важковловима помилка. Замість контролю з боку компілятора розробники вимушені дотримуватися вельми нетривіальних правил кодування. По суті ці правила обмежують С++ рамками якогось безпечнішої підмови. Більшість проблем типобезпеки С++ успадкована від С, але важливу роль в цьому питанні грає і відмова автора мови від ідеї використовувати автоматичне управління пам'яттю (наприклад, збірку сміття). Так візитною карткою С++ стали вразливості типу «переповнювання буфера».

Погана підтримка модульності. Підключення інтерфейсу зовнішнього модуля через препроцесорну вставку заголовного файлу (#include) серйозно уповільнює компіляцію, при підключенні великої кількості модулів. Для усунення цього недоліку, багато компіляторів реалізують механізм прекомпіляциі заголовних файлів (англ. Precompiled Headers).

Недостача інформації про типи даних під час компіляції (CTTI).

Мова C++ є складною для вивчення і для компіляції.

Деякі перетворення типів неінтуїтивні. Зокрема, операція над беззнаковим і знаковим числами видає беззнаковий результат.

Препроцесор С++ (успадкований від C) дуже примітивний. Це приводить з одного боку до того, що з його допомогою не можна (або важко) здійснювати деякі завдання метапрограмування, а з іншою, в наслідку своєї примітивності, він часто приводить до помилок і вимагає багато дій з обходу потенційних проблем. Деякі мови програмування (наприклад, Scheme і Nemerle) мають набагато могутніші і безпечніші системи метапрограмування (також звані макросами, але макроси С/С++ вони мало нагадують).

З кінця 1990-х в співтоваристві С++ набуло поширення так зване метапрограмування на базі шаблонів. По суті, воно використовує особливості шаблонів C++ в цілях реалізації на їхній базі інтерпретатора примітивної функціональної мови програмування, що виконується під час компіляції.

Сама по собі ця можливість вельми приваблива, але, внаслідкок вище згаданого, такий код вельми важко сприймати і відладжувати. Мови Lisp/Scheme, Nemerle і деякі інші мають могутніші і водночас простіші для сприйняття підсистеми метапрограмування. Крім того, в мові D реалізована порівнянна по потужності, але значно простіша в застосуванні підсистема шаблонного метапрограмування.

Хоча декларується, що С++ мультипарадигмена мова, реально в мові відсутня підтримка функціонального програмування. Частково, даний пропуск усувається різними бібліотеками (Loki, Boost) що використовують засоби метапрограмування для розширення мови функціональними конструкціями (наприклад, підтримкою лямбд/анонімних методів), але якість подібних рішень значно поступається якості вбудованих у функціональні мови рішень. Такі можливості функціональних мов, як зіставлення зі зразком взагалі украй складно емулювати засобами метапрограмування.

...