Void main( )

Class que

Class A

{ int x, y;

public:

A (int xx=0, int yy =0){ x=xx; y = yy; }

A func ();

…

}

A A:: func() { if (x%2) x++; // функция x преобразующая в четное

return * this;

}

void main ()

{ A a1 (17, 55)

A a2 = a1. func ();

}

/* Можно объявить так

A* A:: func ()

{ …

return this} */

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

Пример: Очередь

#include <iostream.h>

#include<stdio.h>

{ static que*first; // указатель(адрес)первого элемента очереди

que*next; // указатель на следующий элемент очереди

char bukva; //содержимое элемента очереди

public: // общедоступные функции

que(char c) { bukva = c }; // конструктор

void add (void); // функция добавления элемента в очередь

static void print (void); // вывод содержимого очереди

}

// определения функций:

void que::add(void)

{ que* list= first; // вспомогательный указатель устанавливается на

// начало очереди

que * uk; // вспомогательный указатель для продвижения по

//очереди

while(list!=NULL) { uk = list; list=list->next } //продвижение по очереди

if(uk!=NULL) {uk->next=this; }// присоединение в конец очереди

else first = this; // очередь пустая

this->next=NULL; }

void que::print (void)

{ que *list = first; // устанавливаем на начало очереди

if (list = = NULL) {cout << “ список пуст”; return; }

else cout<<”содержимое списка:”

while(list!=NULL)

{ cout<< list->bukva; list= list->next; }// выводим и продвигаемся по

// очереди

}

que * que:: first = NULL; //инициализация статического компонента

{ // формируем объекты класса

que A(‘a’); que B(’b’); queC(‘c’); queD(‘d’);

que::print(); // выводим фразу, что список пуст

A.add(); B.add(); C.add(); D.add();// включаем в список

// элементы

que::print(); } // выводим список

Наследование

Наследование – одна из наиболее фундаментальных концепций ООП.

Суть метода:

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

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

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

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

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

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

Наследование классов

При наследовании классов важную роль играет статус доступа компонента.

В иерархии классов (при наследовании) относительно доступности компонент принято следующее соглашение:

1) Собственные (private) методы и данные доступны только внутри класса, где они определены.

2) Защищенные (protected) компоненты доступны внутри класса, где они определены, и также доступны во все производных классах.

3) Общедоступные (public) компоненты класса – глобальны, т.е. доступны из любой точки программы.

На доступность компонент влияет также выбор ключевого слова (class, struct, union), с помощью которого объявлен класс.

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

Классы union не могут использоваться при наследовании!

Определение производных классов:

сlass T: X, Y, Z {…};

Класс T – потомок базовых классов X, Y, Z, из которых он наследует компоненты и методы.

Наследуются методы и данные со статусом доступа public и protected!

При этом,

- еслипроизводныйкласс имеет спецификатор class, то компоненты родителя получают по умолчанию в классе потомке статус - private.

- если это struct – унаследованные компоненты имеют статус public.

class A { protected: int x;

public: float y;…};

class B: A {... }; // x, y наследуются как private

struct C: A {...}; // x, y наследуются как public

Изменить статус доступа, получаемый по умолчанию можно опять с помощью спецификаторов public, protected и private.

class D: protected A {... }; // x, y наследуются как protected

class E: public A {... }; //x наследуются как protected, а y как public

class M: private A {... }; // x, y наследуются как private

struct N:: protected A {...}; // x, y наследуются как protected

struct P: public A {... }; // x наследуются как protected, а y как public

struct N:: private A {...}; // x, y наследуются как private

Пример:

…

class A { //базовый класс

int x // закрытое данное класса А

public:

A(int xx =0) { x=xx; cout<< “ A! ”;} // конструктор класса А

int GetX () {return x;} // функция-член класса А

~A () {cout<<endl<<”DA ”; } // деструктор класса А

};

class B: public A { // производный от А класс B

int y; // закрытое данное класса B

public:

B (int yy=0) { y = yy; cout << “ B! ”; } // конструктор класса B

int GetY { return y;} // функция-член класса B

~B () { cout<< “ DB “; } // деструктор класса B

};