МЕТОДИ ОБ'ЄКТНО-ОРІЄНТОВАНОГО ПРОГРАМУВАННЯ - 2007 презентация

середа 15-16 год.
http://emerecu.ukma.kiev.ua/efolio

You are welcome!

Stockholm,
Kungliga Tekniska Högskolan

вимагає
Ієрархії класів
Дотримання дисципліни
стабільного інтерфейсу
нетермінальних класів
Накладних витрат непрямого виклику

{
public:
virtual void vf() {
cout<<"Base::f()"< void g() {
cout<<"Base::g()"<};

public Base {
public:
virtual void vf() {
cout<<" Derived ::f()"<};

& x){
x.f();
x.g(); }

Base b;
Derived d;

manipulator(b); //Base::f();Base::g()
manipulator(d); //Derived:: f();Base::g()

mov edx,dword ptr [ebp+8]
0040120A mov eax,dword ptr [edx]
0040120C mov esi,esp
0040120E mov ecx,dword ptr [ebp+8]
00401211 call dword ptr [eax]
00401213 cmp esi,esp
00401215 call __chkesp (00409620)
0040121A
x.g(); // виклик невіртуальної функції
00401700 mov ecx,dword ptr [ebp+8]
00401703 call @ILT+805(Base::g) (0040132a)
00401708

{
public:
void vf() {
dovf(); return;}
void g() {
cout<<"Base::g()"<private:
virtual void dovf() {
cout<<"Base::f()"<};

public NVIBase
{
private:
virtual void dovf() {
cout<<" Derived ::f()"<};

додаткових накладних витрат: один зайвий виклик невіртуальної інтерфейсної функції
x.vf();
00416E5E mov ecx,dword ptr [x]
00416E61 call NVIBase::vf (415EFBh)

NVINTBase {
public:
void vf() {
dovf(); return;}
void g() {
cout<<"Base::g()"< virtual ~NVINTBase()=0;
private:
virtual void dovf() {
cout<<"Base::f()"<};

class NVITBase: public NVINTBase
{};

class NVITDerived: public NVINTBase {
private:
virtual void dovf() {
cout<<" Derived ::f()"<};

delete nvip;
0043771D mov eax,dword ptr [nvip]
00437720 mov dword ptr [ebp-158h],eax
00437726 mov ecx,dword ptr [ebp-158h]
0043772C push ecx
0043772D call operator delete (41550Fh)
00437732 add esp,4

деструктора
delete pb;
00437780 mov eax,dword ptr [pb]
00437783 mov dword ptr [ebp-134h],eax
00437789 mov ecx,dword ptr [ebp-134h]
0043778F mov dword ptr [ebp-140h],ecx
00437795 cmp dword ptr [ebp-140h],0
0043779C je main+151h (4377C1h)
0043779E mov esi,esp
004377A0 push 1
004377A2 mov edx,dword ptr [ebp-140h]
004377A8 mov eax,dword ptr [edx]
004377AA mov ecx,dword ptr [ebp-140h]
004377B0 call dword ptr [eax]
004377B2 cmp esi,esp
004377B4 call @ILT+2795(__RTC_CheckEsp) (415AF0h)
004377B9 mov dword ptr [ebp-16Ch],eax
004377BF jmp main+15Bh (4377CBh)
004377C1 mov dword ptr [ebp-16Ch],0

динамічного розпізнавання типу об'єкту при значних затратах як на етапі програмування, так і виконання

{cout<<"Base::f()"< void g() {cout<<"Base::g()"<};

class Derived : public Base {
public:
void f() {cout<<" Derived::f()"<// пряме відсилання до базового класу
void g() {Base::g();}
};

}

Base b;
Derived d;

manipulator(b); //Base::f();Base::g()
manipulator(d); // Base::f();Base::g()

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

T>
void manipulator(T & x){
x.f();
x.g(); }

Base b;
Derived d;

manipulator(b); //Base::f();Base::g()
manipulator(d); //Derived:: f();Base::g()

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

f(char a='!', double x=1, bool t=true)
{
cout<<"ElderBerry::f()"< }
void g(char a='?')
{
cout<<"ElderBerry::g()"< }
void goToUncle(); // у Києві
};

{
public:
void f() {
cout<<"Murgatroyd::f()"< }
void g(ElderBerry & ga=ElderBerry(),
double a=3.14) {
cout<<" ElderBerry::g()"< ga.g();
}
// An exclamation of surprise
int heavensTo(const Murgatroyd &);
};

& x){
x.f();
x.g(); }

ElderBerry u;
Murgatroyd v;

manipulator(u); // ElderBerry::f(), ElderBerry:: g()
manipulator(v); // Murgatroyd ::f(), ElderBerry:: g()

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

успадкуванням (90% випадків)
Віртуальні функції найчастіше вживаються некоректно
Застосовувати динамічний поліморфізм варто лише тоді, коли статичного не вистачає
Узагальнене програмування найпотужніший механізм статичного поліморфізму, але...

як гарантувати працездатність за мінімальних вимог до типового параметру? Як уникнути збоїв на етапі виконання?

типів
Індексованість типів

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

значення
Того ж типу Т на новому місці

template
void construct( T*& p, const T& value )
{
p =new T(value);
return;
}

Base* p2 ) {
Base b;
Derived d;

construct( p1, 2.718 );
construct( p2, b );
construct( p1, 42 );
construct( p1, 42 );

construct( p2, d );
construct( p2, d );
}

p1, Base* p2 ) {
Base b;
Derived d;

construct( p1, 2.718 );
construct( p2, b );
// construct( p1, 42 ); 42 is int
construct( p1, 42 );

// construct( p2, d ); d is Derived
construct( p2, d );
}

на типовий параметр

значення типу Т2
на новому місці за указником типу Т1
Як уникнути недопустимих комбінацій типів

template
void construct( T1*& p, const T2& value )
{
p =new T2(value);
return;
}

Base, class Derived>
struct must_have_base
{
~must_have_base()
{
void (*p)(Derived*, Base*) = constraints;
}
private:
static void constraints(Derived* pd, Base* pb)
{
pb=pd;
}
};

недопустиму
комбінацію типів діагностується компілятором

template
void construct( T1*& p, const T2& value )
{
must_have_base check;
p =new T2(value);
return;
}

p1, Base* p2 ) {
Base b;
Derived d;

construct( p1, 2.718 );
construct( p2, b );
// construct( p1, 42 ); 42 is int
// construct( p1, 42 ); не підтип

construct( p2, d ); // ОК d is Derived
construct( p2, d );
}

class Convert>
struct must_be_converted
{
~must_be_converted()
{
void (*p)(Type &, const Convert &) =
constraints;
}
private:
static void constraints(Type & s, const Convert & t)
{
s=t; }
};

використати недопустиму
комбінацію типів діагностується компілятором

template
void construct( T1*& p, const T2& value )
{
must_be_converted check;
p =new T2(value);
return;
}

p1, Base* p2 ) {
Base b;
Derived d;

construct( p1, 2.718 );
construct( p2, b );
construct( p1, 42 ); // ОК 42 converted to double
construct( p1, 42 );

construct( p2, d ); // ОК d is Derived
construct( p2, d );
}

must_be_POD
{
~must_be_POD()
{
void (*p)() = constraints;
}
private:
static void constraints() {
union{
T T_is_not_POD_type;};
}
};

(*p)(const T &) = constraints;
}
private:
static void constraints
(const T& T_is_not_subscriptable) {
sizeof(T_is_not_subscriptable[0]);
}
};

T2>
struct must_have_same_size
{
~must_have_same_size() {
void (*p)() = constraints;
}
private:
static void constraints() {
const int T1_not_same_size_as_T2 =
sizeof(T1) == sizeof(T2);
int i[T1_not_same_size_as_T2];
}
};

контролюйте типи, але не вимагайте від них більше, ніж потрібно