на тему рефераты Информационно-образоательный портал
Рефераты, курсовые, дипломы, научные работы,
на тему рефераты
на тему рефераты
МЕНЮ|
на тему рефераты
поиск
Розробка власного класу STRING
/i>{

employee e ("J. Brown",1234);

manager m ("J. Smith",2,1234);

employee:: print_list ();

}

надрукує

J. Smith 1234

level 2

J. Brown 1234

Зверніть увагу, що функція друку буде працювати навіть у тому випадку, якщо функція employee_list () була написана й трансльована ще до того, як був задуманий конкретний похідний клас manager! Очевидно, що для правильної роботи віртуальної функції потрібно в кожному об'єкті класу employee зберігати деяку службову інформацію про тип. Як правило, реалізація як така інформація використовується просто вказівник. Цей вказівник зберігається тільки для об'єктів класу з віртуальними функціями, але не для об'єктів всіх класів, і навіть для не для всіх об'єктів похідних класів. Додаткова пам'ять виділяється тільки для класів, у яких описані віртуальні функції. Помітимо, що при використанні поля типу, для нього однаково потрібна додаткова пам'ять.

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

1.14.7 Абстрактні класи

Багато класів подібні із класом employee тим, що в них можна дати розумне визначення віртуальним функціям
. Однак, є й інші класи. Деякі, наприклад, клас shape, представляють абстрактне поняття (фігура), для якого не можна створити об'єкти. Клас shape набуває сенсу тільки як базовий клас у деякому похідному класі. Причиною є те, що неможливо дати осмислене визначення віртуальних функцій класу shape:

class shape {

// ...

public:

virtual void rotate (int) { error ("shape:: rotate"); }

virtual void draw () { error ("shape:: draw"): }

// не можна не обертати, не малювати абстрактну фігуру

// ...

};

Створення об'єкта типу shape (абстрактної фігури) законна, хоча зовсім безглузда операція:

shape s; // нісенітниця: ''фігура взагалі''

Вона безглузда тому, що будь-яка операція з об'єктом s приведе до помилки.

Краще віртуальні функції класу shape описати як чисто віртуальні. Зробити віртуальну функцію чисто віртуальної можна, додавши ініціалізатор = 0:

class shape {

// ...

public:

virtual void rotate (int) = 0; // чисто віртуальна функція

virtual void draw () = 0; // чисто віртуальна функція

};

Клас, у якому є віртуальні функції, називається абстрактним. Об'єкти такого класу створити не можна:

shape s; // помилка: змінна абстрактного класу shape

Абстрактний клас можна використати тільки в якості базового для іншого класу:

class circle: public shape {

int radius;

public:

void rotate (int) { } // нормально:

// перевизначення shape:: rotate

void draw (); // нормально:

// перевизначення shape:: draw

circle (point p, int r);

};

Якщо чиста віртуальна функція не визначається в похідному класі, то вона й залишається такою, а значить похідний клас теж є абстрактним. При такому підході можна реалізовувати класи поетапно:

class X {

public:

virtual void f () = 0;

virtual void g () = 0;

};

X b; // помилка: опис об'єкта абстрактного класу X

class Y: public X {

void f (); // перевизначення X:: f

};

Y b; // помилка: опис об'єкта абстрактного класу Y

class Z: public Y {

void g (); // перевизначення X:: g

};

Z c; // нормально

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

class character_device {

public:

virtual int open () = 0;

virtual int close (const char*) = 0;

virtual int read (const char*, int) =0;

virtual int write (const char*, int) = 0;

virtual int ioctl (int. .) = 0;

// ...

};

Дійсні драйвери будуть визначатися як похідні від класу character_device.

1.14.8 Множинне входження базового класу

Можливість мати більше одного базового класу спричиняє можливість кількаразового входження класу як базового
. Припустимо, класи task і displayed є похідними класу link, тоді в satellite (зроблений на їх основі) він буде входити двічі:

class task: public link {

// link використається для зв'язування всіх

// завдань у список (список диспетчера)

// ...

};

class displayed: public link {

// link використається для зв'язування всіх

// зображуваних об'єктів (список зображень)

// ...

};

Але проблем не виникає. Два різних об'єкти link використаються для різних списків, і ці списки не конфліктують один з одним. Звичайно, без ризику неоднозначності не можна звертатися до членів класу link, але як це зробити коректно, показано в наступному розділі. Графічно об'єкт satellite можна представити так:

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

1.14.9 Вирішення неоднозначності

Природно, у двох базових класів можуть бути функції-члени з однаковими іменами
:

class task {

// ...

virtual debug_info* get_debug ();

};

class displayed {

// ...

virtual debug_info* get_debug ();

};

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

void f (satellite* sp)

{

debug_info* dip = sp->get_debug (); // помилка: неоднозначність

dip = sp->task:: get_debug (); // нормально

dip = sp->displayed:: get_debug (); // нормально

}

Однак, явний дозвіл неоднозначності клопітно, тому для її усунення найкраще визначити нову функцію в похідному класі:

class satellite: public task, public derived {

// ...

debug_info* get_debug ()

{

debug_info* dip1 = task: get_debug ();

debug_info* dip2 = displayed:: get_debug ();

return dip1->merge (dip2);

}

};

Тим самим локалізується інформація з базових для satellite класів. Оскільки satellite:: get_debug () є перевизначенням функцій get_debug () з обох базових класів, гарантується, що саме вона буде викликатися при всякім звертанні до get_debug () для об'єкта типу satellite.

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

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

void manager:: print ()

{

employee:: print ();

// ...

}

передбачається, що employee - прямій базовий клас для manager. Результат цієї функції не зміниться, якщо employee виявиться непрямим базовим класом для manager, а в прямому базовому класі функції print () немає. Однак, хтось міг би в такий спосіб перешикувати класи:

class employee {

// ...

virtual void print ();

};

class foreman: public employee {

// ...

void print ();

};

class manager: public foreman {

// ...

void print ();

};

Тепер функція foreman:: print () не буде викликатися, хоча майже напевно передбачався виклик саме цієї функції. За допомогою невеликої хитрості можна перебороти ці труднощі:

class foreman: public employee {

typedef employee inherited;

// ...

void print ();

};

class manager: public foreman {

typedef foreman inherited;

// ...

void print ();

};

void manager:: print ()

{

inherited:: print ();

// ...

}

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

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

У попередніх розділах множинне спадкування розглядалося як істотного фактора, що дозволяє за рахунок злиття класів безболісно інтегрувати незалежно, що створювалися програми
. Це саме основне застосування множинного спадкування, і, на щастя (але не випадково), це найпростіший і надійний спосіб його застосування.

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

Віртуальний базовий клас можна використати для подання "головного" класу, що може конкретизуватися різними способами:

class window {

// головна інформація

virtual void draw ();

};

Для простоти розглянемо тільки один вид загальної інформації із класу window - функцію draw (). Можна визначати різні більше розвинені класи, що представляють вікна (window). У кожному визначається своя (більше розвинена) функція малювання (draw):

class window_w_border: public virtual window {

// клас "вікно з рамкою"

// визначення, пов'язані з рамкою

void draw ();

};

class window_w_menu: public virtual window {

// клас "вікно з меню"

// визначення, пов'язані з меню

void draw ();

};

Тепер хотілося б визначити вікно з рамкою й меню:

class Clock: public virtual window,

public window_w_border,

public window_w_menu {

// клас "вікно з рамкою й меню"

void draw ();

};

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

Страницы: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15



© 2003-2013
Рефераты бесплатно, курсовые, рефераты биология, большая бибилиотека рефератов, дипломы, научные работы, рефераты право, рефераты, рефераты скачать, рефераты литература, курсовые работы, реферат, доклады, рефераты медицина, рефераты на тему, сочинения, реферат бесплатно, рефераты авиация, рефераты психология, рефераты математика, рефераты кулинария, рефераты логистика, рефераты анатомия, рефераты маркетинг, рефераты релиния, рефераты социология, рефераты менеджемент.