Некоторые паттерны реализации полиморфного поведения...

2

Некоторые паттерны

реализации полиморфного

поведения в C++

Дмитрий Леванов

Ведущий разработчик Крипта

3

Крипта

4

Разработка Крипты

Много логов в разных форматах

Сложные цепочки обработки

Высокие требования к производительности

Много одинаковой похожей логики

Хочется делать всё однообразно

5

Полиморфизм

6

Полиморфизм

Способ поставить в соответствие некой

грамматической конструкции контекстно-

зависимую семантику

или, по-русски:

Текст программы [почти] один и тот же, а

смысл разный

7

Шаблоны проектирования

Abstract server/client

Adapter

Decorator

Proxy

Template method

Command

Strategy

…

8

Виртуальный полиморфизм

struct Base {

virtual void do() { std::cout << “base”; }

};

struct Derived : public Base {

virtual void do() override {

std::cout << “derived”;

}

};

std::unique_ptr<Base> b(new Derived);

b->do(); // derived

Явные интерфейсы

Типобезопасно

Работают фичи, зависящие от _vptr

9

Виртуальный полиморфизм: минусы

Медленный вызов методов

Расход памяти на объекты

Требует наличия иерархии классов Приходится иметь дело с T* или T&

Грабли с виртуальными методами

Инвариантность параметров

10







Во многих случаях это не критично

11







Во многих случаях это не критично

Но иногда может стать проблемой

12

Простой пример

13

Простой пример

struct Handler {

virtual void handle(int) = 0;

virtual ~Handler() {}

};

void for_each(const std::vector<int>& v, const Handler& h) {

for (int i : v) {

h.handle(i);

}

}

//...

std::vector<int> vect = {1,2,3};

MyHandler handler;

for_each(vect, handler);

14

То же самое, но лучше

template<typename Handler>


for (int i : v) {

h.handle(i);

}

}

//...


MyHandler handler;


15



void for_each(const std::vector<int>& v, Handler& h) {

for (int i : v) {

h.handle(i);

}

}

struct Sum {

int sum = 0;

void handle(int i) { sum += i; }

};

std::vector<int> vect(1000000000);

Sum handler;


16




for (int i : v) {

h.handle(i);

}

}

struct Sum {

int sum = 0;

void handle(int i) { sum += i; }

};


Sum handler;


Бесплатное ускорение x9.2 (-5 тактов на вызов)

17




for (int i : v) {

h.handle(i);

}

}

struct PositivesSum {

int sum = 0;

void handle(int i) { if (i > 0) sum += i; }

};


PositivesSum handler;


Бесплатное ускорение x2.8

18

Продолжаем улучшать



for (int i : v) {

h(i);

}

}

//...


MyHandler handler;


19

Совсем хорошо



for (int i : v) {

h(i);

}

}

//...


for_each(vect, [](int i){std::cout << i; });

20

Или так


void for_each(const std::vector<int>& v) {

for (int i : v) {

Handler::handle(i);

}

}

//...


for_each<MyHandler>(vect);

21

Статический полиморфизм: плюсы

Нет накладных расходов на вызов методов

Не надо наследоваться

Не надо иметь дело с указателями

Контрвариантность параметров

Можно использовать лямбды

22

Статический полиморфизм: минусы

Нельзя положить в коллекцию

Сложно проверять правильность кода

Медленно компилируется

Может распухнуть бинарник

Нельзя явно задать интерфейсы

Мало помощи от IDE

23

Синтаксис иногда довольно

странный…

this->do();

24


странный…

this->do();

typename T::iter f(typename T::iter i);

25


странный…

this->do();

typename T::iter f(typename T::iter i);

this->template do<T>(); // WTF???

26

Curiously Recurring

Template Pattern

27

Template method

28

Template method

struct Game {

void play() {

while(!end()) {

makeTurn();

switchActivePlayer();

}

}

virtual bool end() = 0;

virtual void makeTurn() = 0;

virtual void switchActivePlayer() = 0;

virtual ~Game() {}

};

29

«Виртуальный» вызов без virtuala.k.a. Curiously Recurring Template Pattern

30


template<typename Derived>

class Game {

void end() {

static_cast<Derived*>(this)->end();

}

};

31



class Game {

void end() {


}

};

class Chess : public Game<Chess> {

void end() {/*Check if king surrounded*/}

};

32



class Game {

void end() {


}

};

class Chess : public Game<Chess> {

void end() {/*Check if king surrounded*/}

};

std::unique_ptr<Game<Chess>> game(new Chess);

game->play(); // calls Chess::end() inside

33

CRTP

«Виртуальный» метод может быть

статическим

Может работать в ~7 раз быстрее виртуальной версии*

http://bit.ly/crtp_vs_virtual

34

Tag dispatching

35

Tag dispatching

template <class InputIter, class Dist>

void advance(InputIter& it, Dist n);


void advance(InputIter& i, Dist n) {

while (n--) ++i;

}

template <class RndAcsIter, class Dist>

void advance(RndAcsIter& i, Dist n) {

i += n;

}

36

Tag dispatching


void advance(InputIter& it, Dist n);


void advance(InputIter& i, Dist n, input_iter_tag) {

while (n--) ++i;

}


void advance(RndAcsIter& i, Dist n, rnd_acs_iter_tag) {

i += n;

}

37

Tag dispatching


void advance(InputIter& it, Dist n) {

typename iter_traits<InputIter>::iter_category cat;

advance(i, n, cat);

}


void advance(InputIter& i, Dist n, input_iter_tag) {

while (n--) ++i;

}


void advance(RndAcsIter& i, Dist n, rnd_acs_iter_tag) {

i += n;

}

38

External polymorphism

39

Задача

Пишем инструмент для отладки

Есть множество объектов, не связанных

какой-либо иерархией

Хотим сложить их в одну коллекцию,

проитерироваться по ней, и распечатать

содержимое объектов

int x = 10;

Foo bar;

MagicCollection objects;

objects.add(x);

objects.add(bar);

for (const auto& obj : objects) {

obj.dump();

}

40


struct Dumpable {

virtual void dump() const = 0;

};

41


struct Dumpable {


};

template<typename T>

class ConcreteDumpable<T> : public Dumpable {

const T& value;

public:

ConcreteDumpable(const T& value) : value(value) {}

virtual void dump() const override {

::dump(value);

}

};

42


struct Dumpable {


};


class ConcreteDumpable<T> : public Dumpable {

const T& value;

public:

ConcreteDumpable(const T& value) : value(value) {}

virtual void dump() const override {

::dump(value);

}

};

void dump(const Foo& foo) {

foo.printToConsole();

}

43

External polymorphismclass Dumper {

using DumpablePtr = std::unique_ptr<Dumpable>;

std::vector<DumpablePtr> dumpables;

public:


void add(const T& obj) {

dumpables.push_back(

DumpablePtr(new ConcreteDumpable<T>(obj)));

}

void dumpAll() const {

for (const auto& d : dumpables) { d->dump(); }

}

};

44

External polymorphismclass Dumper {

using DumpablePtr = std::unique_ptr<Dumpable>;

std::vector<DumpablePtr> dumpables;

public:


void add(const T& obj) {

dumpables.push_back(

DumpablePtr(new ConcreteDumpable<T>(obj)));

}

void dumpAll() const {

for (const auto& d : dumpables) { d->dump(); }

}

} dumper;

dumper.add(10);

dumper.add(Foo());

dumper.dumpAll();

45


Симбиоз виртуального и статического

полиморфизма Для поддержки нового типа T надо добавить

только ::dump(T)

Можно строить параллельные иерархии

46

Новые возможности C++

47

Новые возможности C++11: лямбды

int x = 10;

std::vector<int> v = { 1, 2, 3 };

for_each(v.begin(), v.end(), [x](int i){cout << i+x;});

48


int x = 10;

std::vector<int> v = { 1, 2, 3 };

for_each(v.begin(), v.end(), [x](int i){cout << i+x;});

class Lambda {

int x;

public:

Lambda(int x) : x(x) {}

void operator( )(int i) const {std::cout << i+x;}

};

for_each(v.begin(), v.end(), Lambda());

49


int x = 10;

std::vector<int> v = { 1, 2, 3 };

for_each(v.begin(), v.end(), [x](auto i){cout << i+x;});

50


int x = 10;

std::vector<int> v = { 1, 2, 3 };

for_each(v.begin(), v.end(), [x](auto i){cout << i+x;});

class Lambda {

int x;

public:

Lambda(int x) : x(x) {}


void operator()(T i) const {std::cout << i+x;}

};

51

Новые возможности C++11:

std::function

void print(int i) { std::cout << i; }

struct Print {

void operator()(int i) { std::cout << i+x; }

void print(int i) { std::cout << i+x; }

}

Print p;

std::function<void(int)> p1 = print;

std::function<void(int)> p2 = Print();

std::function<void(int)> p3 = std::bind(Print::print, p, _1);

std::function<void(int)> p4 = std::bind(Print::print, &p, _1);

std::function<void(const Print&, int)> p5 = &Print::print;

std::function<void(int)> p6 =

[](int i) { std::cout << i; };

52

Новые возможности C++11:

лямбды и std::function

auto lambda1 = []() {};

auto lambda2 = []() {};

lambda1(); // fast

std::function<void()> f = []() {};

f(); // slow


void for_each(const std::vector<int>& v,

const Handler& h);

void for_each(const std::vector<int>& v,

std::function<void(int)> f);

53

Новые возможности C++11: std::function

Позволяют сохранить исполняемые объекты

(включая лямбды), в том числе в коллекцию

Может быть медленной (~10 раз медленнее

шаблонной функции)

Обеспечивает явную спецификацию

интерфейса

54

Пример из жизни

55

Исходные условия

id=1234 \t time=2014.26.09 19:00

struct RecordBase {

void Load(const std::string& str);

std::string GetValue(const std::string& key) const;

void SetValue(const std::string& key,

const std::string& value);

};

Хотим быстро создавать абстракции, позволяющие

типизированно работать с записями

56

Версия 1.0struct EventRecord : RecordBase {

int GetId() const {

const auto& str = GetValue("id");

// Parse id from str

return id;

}

void SetId(int id) {

// Serialize id to str

SetValue("id", str);

}

time_t GetTs() const {

const auto& str = GetValue("time");

// Parse ts from str

return ts;

}

void SetTs(time_t ts) {

// Serialize ts to str

SetValue("date", str);

}

};

57

Версия 1.1

struct EventRecord : RecordBase {

int GetId() const {

return ::FromString(GetValue("id"));

}


SetValue("id", ::ToString(id));

}

int GetTs() const {

return ::FromString(GetValue("time"));

}


SetValue("time", ::ToString(ts));

}

};

58

Уходим из ::

struct Serializer {


static T FromString(const std::string& str) {

return ::FromString<T>(str);

}


static string ToString(const T& value) {

return ::ToString(value);

}

};

59

Инкапсулируем логику RecordBase

struct RecordBase {

std::string GetValue(const std::string& key) const;

void SetValue(const std::string& key,

const std::string& value);

template<typename T, typename Szr = Serializer>

T Get(const string& key) const {

return Szr::FromString<T>(GetValue(key));

}

template<typename Szr = Serializer, typename T>

void Set(const std::string& key, const T& value) {

SetValue(key, Szr::ToString(ts));

}

};

60

Упрощаем EventRecord


int GetId() const {

return Get<int>("id");

}


Set<>("id", id);

}

int GetTs() const {

return Get<time_t, DateSerializer>("time");

}


Set<DateSerializer>("time", ts);

}

};

61

Еще больше инкапсуляции

template<typename T, typename Szr = Serializer>

class Property {

RecordBase* record;

std::string key;

public:

Property(RecordBase* record, const std::string& key)

: record(record), key(key) {}

T Get() const {

return Szr::FromString(record->GetValue(key));

}

void Set(const T& value) {

record->SetValue(key, Szr::ToString(value));

}

};

62

Итоговая версия


Property<int> Id;

Property<time_t, DateSerializer> Ts;

EventRecord() : Id(this, "id"), Ts(this, "time") {}

};

EventRecord record;

record.Id.Set(123);

time_t ts = record.Ts.Get();

63

Заключение

64

Статический полиморфизм

Большая гибкость

Ограниченность в этапе компиляции

Поощряется свежими стандартами

Сложно писать библиотечный код

Просто писать клиентский код

65

Спасибо за внимание!

Дмитрий Леванов

Ведущий разработчик Крипта

[email protected]

66

Источники

1. http://www.inteks.ru/OOAD/P-Cources.OOAD.part1.pdf

2. http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern

3. http://www.cs.wustl.edu/~schmidt/PDF/External-Polymorphism.pdf

4. http://www.generic-programming.org/languages/cpp/techniques.php

5. http://eli.thegreenplace.net/2013/12/05/the-cost-of-dynamic-virtual-

calls-vs-static-crtp-dispatch-in-c/

http://www.inteks.ru/OOAD/P-Cources.OOAD.part1.pdf

http://www.cs.wustl.edu/~schmidt/PDF/External-Polymorphism.pdf

http://www.cs.wustl.edu/~schmidt/PDF/External-Polymorphism.pdf

http://www.generic-programming.org/languages/cpp/techniques.php

http://eli.thegreenplace.net/2013/12/05/the-cost-of-dynamic-virtual-calls-vs-static-crtp-dispatch-in-c/

Некоторые паттерны реализации полиморфного поведения...

Internet

Transcript of Некоторые паттерны реализации полиморфного поведения...