Generalized FUNCTORS презентация

Фін-3

перепрошую за всі лажі та недопрацювання.

☺

be applied for the benefit of simplicity. )

це будь-який виклик процедури, що дозволений в С++ та інкапсульований в об'єкт першого класу, який гарантує типову безпеку

generalized functor is any processing invocation that C++ allows, encapsulated as a typesafe first-class object

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

Richard Helm, Ralph Johnson, and John Vlissides . 1995. Design Patterns: Elements of Reusable Object-Oriented Software.

виклик не тільки не знає як виконується робота, а й не має уявлення для якого виду роботи призначений клас Command

0, 200, 100);

Command resizeCmd(
window, // Object
&Window::Resize, // Member function
0, 0, 200, 100); // Arguments
// Later on...
resizeCmd.Execute(); // Resize the window

окремо від самих програм (skinnable)

Оболонки не мають архітектури, вони лише надають місця для об'єктів класу Command

void Bar();

int main()
{
void (*pF)() = &Foo;
Foo(); // Call Foo directly
Bar(); // Call Bar directly
(*pF)(); // Call Foo via pF
void (*pF2)() = pF; // Create a copy of pF
pF = &Bar; // Change pF to point to Bar
(*pF)(); // Now call Bar via pF
(*pF2)(); // Call Foo via pF2
}

на функції
Відсилки на функції (константні вказівники)
Функтори (об'єкти, в яких визначений operator() )
Результати застосування операторів .* та ->* до указників на функції-члени.

реалізацію, але це сховано всередині нього.

Реалізація базового класу - FunctorImpl

проблема

class Functor {
public: void operator()();
// other member functions
private:
// implementation goes here
};

ResultType>
class Functor {
public:
ResultType operator()();
// other member functions
private:
// implementation
};

маємо морального права накладати обмеження на кількість аргументів operator()’а та на їх тип.

Крім того змінних шаблонів в С++ немає.

А еліпси (ellipsis) типу printf – це не красиво, та ще й небезпечно.

Що робити?

with no arguments template

class Functor { ... };

// Functor with one argument template

class Functor { ... };

TList>
class Functor { ... };


Functor myFunctor;

template
class FunctorImpl {
public: virtual R operator()() = 0;
virtual FunctorImpl* Clone() const = 0;
virtual ~FunctorImpl() {}
};

template
class FunctorImpl{
public: virtual R operator()(P1) = 0;
virtual FunctorImpl* Clone() const = 0;
virtual ~FunctorImpl() {}
};

class TList>
class Functor {
public:
Functor();
Functor(const Functor&);
Functor& operator=(const Functor&);
explicit Functor(std::auto_ptr spImpl);
...
private:
FunctorImpl Impl;
std::auto_ptr spImpl_;
};

TList>
class Functor {
typedef TList ParmList;
typedef typename TypeAtNonStrict::Result Parm1;
typedef typename TypeAtNonStrict::Result Parm2;
... as above ...
};

Доступаємось до типу, знаючи його номер (дивно, але працює ☺ )

TList>
class Functor {
... as above ...
public:
R operator()()
{ return (*spImpl_)(); }
R operator()(Parm1 p1)
{ return (*spImpl_)(p1); }
R operator()(Parm1 p1, Parm2 p2)
{ return (*spImpl_)(p1, p2); }
};

myFunctor;

double result = myFunctor(4, 5.6);

// Wrong invocation.
double result = myFunctor();

class TList>
class Functor {
... as above ...
public:
template
Functor(const Fun& fun);
};

Таким чином ми доступатимемось до інших функторів

конструктора

template
class FunctorHandler : public FunctorImpl
<
typename ParentFunctor::ResultType,
typename ParentFunctor::ParmList
>
{
public:
typedef typename ParentFunctor::ResultType ResultType;
…

: fun_(fun) {}
FunctorHandler* Clone() const {
return new FunctorHandler(*this); }
ResultType operator()() { return fun_(); }
ResultType operator()(typename ParentFunctor::Parm1 p1) {
return fun_(p1); }
ResultType operator()(typename ParentFunctor::Parm1 p1, typename ParentFunctor::Parm2 p2){
return fun_(p1, p2); }
private:
Fun fun_;
};

R, class TList>
template
Functor::Functor(const Fun& fun) :
spImpl_(new FunctorHandler(fun));
{ }

Ще один трюк – шаблонне визначення члена поза межами класу
("out-of-class member template definition." )

struct TestFunctor {
void operator()(int i, double d) {
cout <<"TestFunctor::operator()(" << i << ", " << d << ") called.\n"; }
};

int main() {
TestFunctor f;
Functor cmd(f);
cmd(4, 4.5);
}

красиво

Працюємо з функторами

Працюємо з функціями

Автоматично зводимо типи аргументів та результатів (все й справді чесно) (приклад: char* -> string)

нюанси (але вони дещо виходять за межі нашого обговорення, та й для чого ускладнювати?)

Реалізується тим же шляхом що й FunctorHandler

виклику ми не тільки вкажемо на виконавця, але й задамо атрибути виконання, тобто певне описання середовища, в якому відбувається робота ).

Ланцюжок – (MacroCommand, з Gamma et al*, 1995) - дозволяє створювати пакет виконання команд. Всі команди на момент “запаковування” повинні бути зв'язаними. Проте пізніше однією командою можна запустити цілу програму, створену на етапі виконання.

* Gamma, Erich, Richard Helm, Ralph Johnson, and John Vlissides . 1995. Design Patterns: Elements of Reusable Object-Oriented Software. Reading, MA: Addison-Wesley.

використовувалась версія 0.1.7

вдячний, якщо питання Ви не задаватимете. ☺