Слайд 1Информатика. Спецглавы
Направление: Инфокоммуникационные технологии и системы связи
2012 год
Лекция 3
Слайд 2Наследование
Базовый класс
________
private:
protected:
public:
Произ-вольный класс
Класс-наследник
Слайд 3Создание класса-наследника в С++
// базовый класс
class A
{
...
} ;
//класс-наследник
class B :
public A
{
...
} ;
Слайд 4Пример базового класса
class Person
{
protected:
char Name[30];
public:
Person ();
void SetName (char* );
void Show
();
} ;
Слайд 5Класс-наследник
class Student : public Person
{
char dept[30];
public:
Student (char*, char* );
void SetDept
(char* );
void Show ();
} ;
Слайд 6Методы класса Person
Person::Person()
{
}
void Person::SetName (char* N)
{
strcpy (Name, N);
}
void Person::Show ()
{
std::cout
Слайд 7Собственные методы класса Student
Student::Student (char* N, char* D)
{
strcpy (Name, N);
strcpy
(Dept, D);
}
void Student::SetDept (char* D)
{
strcpy (Dept, D);
}
void Student::Show ()
{
std::cout
Name << “ “ << Dept << std::endl;
}
Слайд 8Текст программы
int main ()
{
Person A;
A.SetName (“Tom”);
Student B(“Ann”, “MTS”);
A.Show ();
B.Show ();
Person*
pperson = &B;
Student* pstudent = &B;
pperson->Show ();
pstudent->Show ();
B.SetName (“Kate”);
B.SetDept (“GF”);
pstudent->Show
();
return 0;
}
На экране:
My name is Tom
Ann MTS
My name is Ann
Ann MTS
Kate GF
Слайд 9Виртуальная функция
class Person
{
char Name[30];
public:
Person (char* );
void SetName (char* );
virtual void
Show ();
} ;
Слайд 10Текст программы
int main ()
{
Person A;
A.SetName (“Tom”);
Student B(“Ann”, “MTS”);
A.Show ();
B.Show ();
Person*
pperson = &B;
Student* pstudent = &B;
pperson->Show ();
pstudent->Show ();
B.SetName (“Kate”);
B.SetDept (“GF”);
pstudent->Show
();
return 0;
}
На экране:
My name is Tom
Ann MTS
Ann MTS
Ann MTS
Kate GF
Слайд 11Полиморфизм
Статический полиморфизм — поддерживается посредством перегрузки функций и операторов во
время компиляции
Динамический полиморфизм — поддерживается посредством виртуальных функций во время
выполнения программы
Слайд 12Конструкторы и наследование
class Person
{
protected:
char Name[30];
public:
Person (char*); //конструктор с параметром
void SetName
(char* );
void Show ();
} ;
Слайд 13Реализация конструкторов
Person::Person (char* N)
{
strcpy (Name, N);
}
Student::Student (char* N, char* D)
: Person (N)
{
strcpy (Dept, D);
}
Слайд 14Язык UML
UML: Unified Modeling Language
Стандарты: 1.0, 2.0
Назначение: графический язык для
визуализации, конструирования и документирования систем, в т.ч. программного обеспечения
Разработчики: Грейди
Буч, Джеймс Рамбо, Айвар Джекобсон
Элементы языка: диаграммы и их компоненты (предметы, отношения)
Слайд 15Диаграммы UML
Структурные диаграммы
Диаграмма компонентов
Диаграмма классов
Диаграмма объектов
Диаграмма развертывания
Диаграммы поведения
Диаграмма прецедентов
Диаграмма последовательности
Диаграмма
состояний
Слайд 16Диаграмма классов
Упрощенное обозначение
Полное обозначение
Обозначение класса на UML-диаграммах:
Слайд 17Взаимодействие классов
Виды взаимодействия:
Наследование
Агрегация (включение)
Использование (клиент-серверное взаимодействие)
Ассоциация
Слайд 18Наследование
Класс-наследник
class A
{
// . . .
} ;
class B : public
A
{
// . . .
} ;
Базовый класс
Слайд 19Агрегация
class A
{
// . . .
public:
void Message (
);
} ;
class B
{
// . . .
A a;
}
;
int main ( )
{
B b ;
// . . .
b . a . Message ( );
// . . .
}
Внешний класс
Внутренний класс
Слайд 20Использование
class A
{
// . . .
} ;
class B
{
// . . .
public:
void Fn ( A*) ;
} ;
int main (
)
{
A a;
B b ;
// . . .
b . Fn ( &a );
// . . .
}
Сервер
Клиент
Слайд 21Ассоциация
int main ( )
{
A a;
B b ;
// . . .
b.pa
= &a;
a.pb = &b;
// . . .
}
Пример связи один-к-одному
class B
{
// . . .
public:
A* pa;
} ;
class A
{
// . . .
public:
B* pb;
} ;
Мощность
связи:
Один-к-одному
Один-ко-много
Много-ко-много
1 1
Слайд 22Пример диаграммы классов
Факультет
Группа
1 N
1
1
N N
Лектор Студент Библиотека
Person Ст.билет
Слайд 23Друзья класса
class First
{
int x;
public:
void SetX (int);
friend class Second;
friend void Set_X
(First&, int);
} ;
void First::SetX (int xx)
{
x = xx;
}
Слайд 24Друзья : глобальная функция или класс
class Second
{
// . . .
public:
void
SetX (First&, int);
} ;
void Second::SetX (First& f,
int xx)
{
f.x =
xx;
}
void Set_X (First& f, int xx)
{
f.x = xx;
}
int main ()
{
First first;
first.SetX (10);
first.Show ();
Second second;
second.SetX (first, 20);
first.Show ();
Set_X (first, 30);
first.Show ();
}
На экране:
10
20
30
Слайд 25Указатель this
class A
{
public:
void Greet ();
void Prim ();
//. . .
} ;
void
A::Prim ()
{
Greet ();
this->Greet ();
(*this).Greet ();
//. . .
} ;
Слайд 26Перегрузка операторов
Встроенные перегружаемые операторы: = == != < >
>= + - * / ++(инкремент) –(декремент) (ввод) +=
-= и т.д.
Встроенные неперегружаемые операторы: . :: ?: (оператор условия)
Операторные функции:
<возвр_тип> operatorX(<тип_парам>);
Глобальная функция:
MyClass operator+(MyClass&,MyClass&);
Функция-член класса:
MyClass MyClass::operator+(MyClass&);
Слайд 27Глобальные операторные функции
bool operator==(MyClass, MyClass); // != < >
MyClass operator+(MyClass&,
AnyType); // - * /
istream& operator>> (istream&, MyClass&);
ostream& operator
(ostream&,const MyClass&);
Слайд 28Функции-члены класса
bool operator==(MyClass); // != < >
MyClass operator+(AnyType); // -
* /
MyClass& operator++(); // - - (++a)
MyClass operator++(int);
// - - (a++)
MyClass& operator=(MyClass&);
MyClass& operator+=(AnyType); // -=
Слайд 30Person.h
#pragma once
#include
class person
{
char Name[20];
int Year;
public:
person(void);
person(char* N, int Y);
bool operator==(person&);
//оператор отношения
person operator+(int);
//сложение
int operator-(person&); //Вычитание - результат в виде
//целого числа
person& operator++(); //Префиксный инкремент
person& operator=(person&); //Присваивание
//Перегрузка ввода через объект класса istream (cin)
friend std::istream& operator>>(std::istream&,person&);
//Перегрузка вывода через объект класса ostream (cout)
friend std::ostream& operator<<(std::ostream&,const person&);
};
Слайд 31main.cpp
#include "person.h"
int main(int argc, char* argv[])
{
person My1, My2("Nick",1989);
std::cin >> My1;
std::cout
<< My1;
std::cout << "My2: " << My2 < person My3;
My3=My1;
std::cout << "My3=My1: " << My3;
person My4=My3+6;
std::cout << "My4: " << My4;
int diff=My4-My2;
std::cout << "Diff=" << diff << std::endl;
std::cout << " Prefix: ++My2 " << ++My2;
std::cout << "My1==My3 " << (My1==My3) < return 0;
}
Слайд 32Person.cpp (1)
#include ".\person.h"
#include
person::person(void)
{
strcpy(Name, ''Noname'');
Year=0;
}
person::person(char* N,
int Y)
{
strcpy(Name, N);
Year=Y;
}
bool person::operator==(person& p)
{
bool cmp =!strcmp(Name,p.Name)&&Year==p.Year;
return cmp;
}
Слайд 33Person.cpp (2)
person person::operator+(int Y)
{
person Temp;
Temp.Year= Year+Y;
strcpy(Temp.Name,Name);
return Temp;
}
int person::operator-(person& p)
{
int Temp;
Temp=Year-p.Year;
return Temp;
}
Слайд 34Person.cpp (3)
person& person::operator++()
{
Year++;
return *this;
}
person& person::operator=(person& p)
{
if (this==&p)
return *this;
strcpy(Name, p.Name);
Year=p.Year;
return *this;
}
Слайд 35Person.cpp (4)
std::istream& operator>>(std::istream& is,person& p)
{
char buf[20]; int Y;
std::cout >buf; strcpy(p.Name,buf);
std::cout
<< "Year->";
is >> Y; p.Year = Y;
return is;
}
std::ostream& operator<<(std::ostream& os,const person& p)
{
os << "Name " << p.Name << " Year " << p.Year << std::endl;
return os;
}