🗊Презентация Объекто-ориентированное программирование

Введение

Парадигмы программирования Структу́рное программи́рование Функциона́льное программи́рование Логи́ческое программи́рование Автома́тное программи́рование Объе́ктно-ориенти́рованное программи́рование Событи́йно-ориенти́рованное программи́рование Агентно-ориентированное программи́рование

Объекто-ориентированное программирование Объекто-ориентированное программирование Использует в качестве основных логических конструктивных элементов объекты, а не алгоритмы Каждый объект является экземпляром (instance) определенного класса (class); Классы образуют иерархии

Элементы объектной модели • Абстракция • Инкапсуляция • Модульность • Иерархия • Контроль типов • Параллелизм • Персистентность

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

Класс - это множество объектов, имеющих общую структуру и общее поведение.

Ограничения доступа

Основные свойства и правила использования конструкторов: Основные свойства и правила использования конструкторов: конструктор имеет то же имя, что и класс, в котором он объявляется; конструктор не возвращает значения (даже типа void); конструктор не наследуется в производных классах. конструктор может иметь параметры, заданные по умолчанию; конструктор - это функция, но его нельзя объявить с ключевым словом virtиal; невозможно получить в программе адрес конструктора; если конструктор не задан в программе, то он будет aвтоматически сгенерирован; конструктор вызывается автоматически только при описании объекта; объект, содержащий конструктор, нельзя включить в виде компонента в объединение; конструктор класса Х не может иметь параметр типа Х, может иметь параметр ссылку на объект типа Х, в этом случае он называется конструктором для копирования (сору constrиctor) класса Х.

Основные свойства и правила использования деструкторов: Основные свойства и правила использования деструкторов: деструктор имеет то же самое имя, что и класс, в котором он объявляется, с префиксом ~ (тильдой); деструктор не возвращает значения ; деструктор не наследуется в производных классах; производный класс может вызвать деструкторы для его базовых классов; деструктор не имеет параметров; класс может иметь только один деструктор; деструктор - это функция, и он может быть виртуальным; невозможно получить в программе адрес деструктор); если деструктор не задан в программе, то он будет автоматически сгенерирован компилятором; деструктор можно вызвать так же, как обычную функцию, например: date *my_day; my_day->date::~date(). деструктор вызывается автоматически при разрушении объекта.

Области видимости для классов int x = 2; class Example { void f () {x = 0;} short x }; void f () {::x = 0;}

Спецификатор памяти static class Example { public: static int x ; } p1, p2; int Example::x=67;

Спецификатор const class Stack { char s[MaxSize]; int top; public: Stack () {top = 0;} void Look_Top() const {cout << s[top];} void push() {top++;} }; const Stack s1; Stack s2; s2.Look_Top(); s1.push(); s1.Look_Top();

Указатель this date today, my_day; today.out(); my_day.out(); cout << day << " " << month; Date *const this; cout << this­>day << " " << this­>month;

Организация списка Организация списка

void spisok::Look() void spisok::Look() { cout << value << "\n" << str << "\n"; } spisok * spisok::Get_Next() { return next; } main() { spisok * p; p = new spisok(1,"stroka1"); p = new spisok(2,"stroka2"); p = new spisok(3,"stroka3"); p=spisok::first; while (p!=0) { p->Look(); p=p->Get_Next(); } }

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

Дружественные функции class rectangle {int color, x, y; }; class circle {int color, x, y, radius; pubIic: friend bool equal-color(circle с, rectangle r); }; bool equal-color (circle с, rectangle r) { if(c.color == r.color) return true; else return false; }

Член-функция одного класса может быть объявлена со спецификатором friend для другого класса. Член-функция одного класса может быть объявлена со спецификатором friend для другого класса. class Х { int function_of_X(…); }; class У { friend int Х:: function_of_X(…); }; class Z { friend class У; };

class my_class2; class my_class2; class my_ class 1 { int а; friend void fun(my_class1&,my_class2&); pubIic: my_class1(int А) : а(А) {}; }; class my_class2 { int а; friend void fun(my_class1&,my_class2&); pubIic: my_class2(int А) : а(А) {}; }; void fun(my_class1& M1,my_class2& М2) { if (М1.а == М2.а) cout « "equal\n"; else cout « "not equal\n"; void main(void) { my_class1 mс1(100); my_class2 mc2( 100); fun(mc1,mc2);}

class Х; class Х; class У { int а; void Y(int c): a(c){}; pubIic: void display(X* рХ); }; class Х { int а; void X(int C): a(C){}; pubIic: friend void Y::display(X*); }; void Y::display(X* рХ) { cout« pX->a « '\t' « а «endl; } void main(void) { Х my_X(100); У my_У(200); my_Y.display(&my_X); / / Результат: 100 200 }

Основные свойства и правила использования спецификатора friend: friend функции не являются компонентами класса, но получают доступ ко всем его компонентам; если friend функции одного класса не являются компонентами другого класса, то они вызываются так же, как и обычные rлобальные функции (без операторов . и ->); если friend функции одного класса не являются компонентами другого класса, то они не имеют указателя this; friend функции не наследуются в производных классах; отношение friend не является транзитивным.

Объявление и разрушение глобальных объектов: Объявление и разрушение глобальных объектов: class А { int i; pubIic: A(int I) : i(I) { cout « "class А" « i « " constructor\n";} ~A() { cout « "class А" « i « "destructor\n"; } }; А а1(1),а2(2); void main(void) { getch(); } Результаты выполнения этой программы: class А 1 constructor class А2 constructor < здесь можно нажать любую клавишу> class А2 destructor class А 1 destructor

Объявление и разрушение локальных объектов. Объявление и разрушение локальных объектов. class А { int i; pubIic: A(int I) : i(I) { cout « "class А" « i « " constructor\n"; } ~A() { cout « "class А" « i « "destructor\n"; } }; void fuпction(void) { cout« "begin\n"; А а1(1),а2(2); cout «"end\n"; } void main(void) { cout« "before\n"; function(); cout « "after\n"; } } Результаты: before begin class А 1 constructor class А2 constructor end class А2 destructor class А 1 destructor after

Создание объектов в динамически выделяемой памяти Создание объектов в динамически выделяемой памяти class А { int i; pubIic: A(int I) : i(I) { cout « "class А" « i « " constructor\n"; } ~A () { cout « "class А" « i « "destructor\n"; } }; void main(void) { А *р1 == new А(1); А *р2 == new А(2); delete р1; delete р2; } Результаты : class А 1 constructor class А2 constructor class А 1 destructor class А2 destructor

Объявление объектов в виде компонентов в друrих классах. Объявление объектов в виде компонентов в друrих классах. class а {int j; pubIic a(int J} : j(J} { cout « "class а" « j « " constructor\n"; } ~a() { cout « "class а" « j « "destructor\n"; } }; class b {int i; а а1; pubIic: b(int I,int J} : а1 (J},i(I) { cout « "class b" « i « "constructor\n"; } ~b() { cout « "class b" « i « "destructor\n"; } }; void main(void) { b b1(1, 1}; b b2(2,1);} } Результаты: class а1 constructor class b1 constructor class а1 constructor class b2 constructor class b2 destructor class а1 destructor class b1 destructor class а1 destructor

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

class employee class employee { char * name; // имя int income; // доход employee * next; // следующий служащий public: employee (char * n, int i); // конструктор void print() const; // вывод на экран }; employee::employee(char * n, int i) : name(n), income(i) { next = 0;} void employee::print() const { cout << name << "\n";}

class manager : public employee class manager : public employee { int level; // уровень employee * group; // подчиненные public: manager(char *, int, int, employee *); void print() const; }; void manager::print() const { employee::print(); cout << "руководит : "; group->print();} manager::manager(char* n, int i,int l, employee * g): employee(n,i), level(l), group(g)

void main() void main() { employee person (“Иванов”,20); manager one_more(“Петров”,40,1,&person); person.print(); one_more.print(); }

Основные правила использования базовых и производных классов: Пусть функция F принадлежит базовому классу Б. Тогда в производном классе П можно: 1) полностью заменить функцию F (старая Б::F и новая П::F); 2) доопределить (частично изменить) функцию F; 3) использовать функцию Б::F без изменения. - Если объявить указатель рБ на базовый класс, то ему можно присвоить значение указателя на объект производного класса; - указателю рП на производный класс нельзя присвоить значение указателя на объект базовоrо класса; - регулирование доступа к компонентам базового и производного классов осуществляется с помощью атрибутов private, public и protected; - производный класс может быть в свою очередь базовым. Множество классов, связанных отношением наследования базовый - производный, называется иерархией классов.

Наследование атрибутов компонентов базового класса:

class base class base {protected: int x; public: char * str; void f(int, char*); }; class generate : private base { protected: int base::x; public: char * base::str; base::f; …}

Множественное наследование class base1 {public: int field; char * str; };  class base2 {public: int field; int data; }; class generate :public base1, public base2 {…}; Generate ex; ex.field = 4; ex.base1::filed = 4;

class base class base {public: int field; char * str; }; class gen1 : public base {public: float s; }; class gen2 : public base {public: char * name; }; class global : public gen1, public gen2 {…} ex;

Использование виртуального класса class gen1 : virtual public base{...}; class gen2 : virtual public base{...}; class global : public gen1, public gen2 {…} ex; Формально конструктор класса global будет иметь вид: global::global() : base(), gen1(), gen2() {...}

Полиморфизм class Base { public: int f(const int &d) ; int CallFunction(const int &d) { return f(d)+1; } }; class Derived: public Base { public: int f(const int &d) { return d*d; } }; int main() { Base a; cout << a.CallFunction(5)<< endl; Derived b; cout << b.CallFunction(5)<< endl; return(); }

class Clock class Clock { public: void print() const { cout << "Clock!" << endl; } }; class Alarm: public Clock { public: void print() const { cout << "Alarm!" << endl; } }; void settime(Clock &d) { d.print(); } Clock W; settime(W); Alarm U; settime(U); Clock *c1 = &W; c1->print(); c1 = &U; c1->print(); } ((Alarm *)c1)->print();

Правила описания и использования виртуальных функций: Правила описания и использования виртуальных функций: Виртуальная функция может быть только методом класса. Любую перегружаемую операцию-метод класса можно сделать виртуальной. Виртуальная функция, как и сама виртуальность, наследуется. Виртуальная функция может быть константной. Если в базовом классе впервые объявлена виртуальная, то функция должна быть либо чистой (virtual int f(void) = 0;), либо для нее должно быть задано определение. Если в базовом классе определена виртуальная функция, то метод производного класса с такими же именем и прототипом автоматически является виртуальным. Конструкторы не могут быть виртуальными. Статические методы не могут быть виртуальными. Деструкторы могут (чаще — должны) быть. Если некоторая функция вызывается с использованием ее полного имени, то виртуальный механизм игнорируется.

Вызов виртуальной функции может не являться виртуальным в некоторых случаях: Вызов виртуальной функции может не являться виртуальным в некоторых случаях: Вызывается не через указатель или ссылку: global object; object.f(); Вызывается через указатель или ссылку, но с уточнением имени класса: base * p; global object; p = &object; p->f(); // виртуальный вызов p->global::f(); // не виртуальный вызов вызывается в конструкторе или деструкторе базового класса.