Недостатки типичной реализации
В статье намеренно не приведен пример типичной реализации паттерна посетителя в C++.
Если вы не знакомы с этим шаблоном, то вот тут можно с ним ознакомиться.
А если в двух словах, то этот шаблон очень полезен если вам нужно обойти коллекцию из указателей на абстрактный базовый класс, применив к ним какую то операцию в зависимости от типа, который скрывается за абстракцией.
Поэтому перейдем сразу к недостаткам, которые хотели бы устранить.
-
При добавлении класса в иерархию (или удалении), приходится изменить много мест в коде. (Каждый раз лезть и добавлять чисто виртуальную функцию-член в абстрактный класс, и почти во все реализации.)
-
При добавлении нового посетителя, приходится наследоваться от абстрактного класса, даже если мы всего то хотим вызвать просто шаблон функции. При этом мы не можем сделать шаблон виртуальной функции-члена visit у посетителя (причина этого проста, шаблонов виртуальных функций-членов просто нет). Каждую реализацию функции-члена visit приходится делать отдельно.
-
Класс посетителя привязан к предметной области.
Что хотим получить?
-
Имея на руках указатель на абстрактный базовый класс, хотим сразу получать реальный тип объекта и отправлять его самого или его тип в какой-нибудь шаблон функции, не используя при этом никаких конструкций из dynamic_cast или static_cast и не создавая множество одинаковых переопределений виртуальных функций.
-
Простым способом добавлять или удалять классы, которые посетитель может обойти.
-
Не привязанный к предметной области посетитель.
Реализация
Начинаем с создания абстрактного посетителя.
Source:
template< class T > struct AbstractVisitor { virtual ~AbstractVisitor() = default; virtual void visit( T& ) = 0; };(Пояснение: здесь виртуальная функция-член visit не является шаблоном, количество виртуальных функций при инстанцировании класса AbstractVisitor точно известно т.к. T является параметром шаблона класса, а не функции )
Инстанс конкретного посетителя сможет обойти только один тип объекта. Нам же необходимо чтобы посетитель мог обходить несколько различных типов объектов.
Для этого создадим простой список типов TypeList и класс агрегатор AbstractVisitors. Список у AbstractVisitors будет содержать все типы объектов, которые посетитель может обойти.
Source:
template< class ... T > struct TypeList { }; template< class T > struct AbstractVisitor { virtual ~AbstractVisitor() = default; virtual void visit( T& ) = 0; }; template< class ...T > struct AbstractVisitors; template< class ... T > struct AbstractVisitors< TypeList< T... > > : AbstractVisitor< T >... { };Т.к. мы не хотим каждый раз наследоваться от абстрактного посетителя, наследуемся от него один раз и будем принимать функтор (если быть точным, то принимать будем обобщённую лямбду). Для этого создадим класс Dispatcher.
Source:
template< class Functor, class ... T > struct Dispatcher; template< class Functor, class ... T > struct Dispatcher< Functor, TypeList< T... > > : AbstractVisitors< TypeList< T... > > { Dispatcher( Functor functor ) : functor( functor ) {} Functor functor; };Теперь необходимо для всех типов из листа переопределить виртуальную функцию-член visit.
Для этого создадим класс Resolver, который этим и будет заниматься. А сам класс Dispatcher унаследуем от всех возможных типов Resolver-ов.
Дополнительно необходимо вызывать функтор в переопределенной функции, воспользуемся (CRTP) и передадим тип Dispatcher как аргумент шаблона во все Resolver.
(Подробнее о том что такое CRTP можно почитать тут).
Source:
template< class Dispatcher, class T > struct Resolver : AbstractVisitor< T > { void visit( T& obj ) override { static_cast< Dispatcher* >( this )->functor( obj ); }; }; template< class Functor, class ... T > struct Dispatcher< Functor, TypeList< T... > > : AbstractVisitors< TypeList< T... > >, Resolver< Dispatcher< Functor, TypeList< T... > >, T >... { Dispatcher( Functor functor ) : functor( functor ) {} Functor functor; };Вроде все в порядке.
Попробуем создать объект класс Dispatcher. Компилятор начинает ругаться на то, что объект класса Dispatcher абстрактный, как же так?
Причина этого в том, что мы переопределили виртуальные функции для Resolver, но для Dispatcher мы ведь ничего не переопределяли.
Чтобы этого избежать, необходимо сделать наследование от AbstractVisitor< T >виртуальным.(Подробнее о размещении объектов в памяти и виртуальном наследовании можно почитать тут.)
Source:
template< class ... T > struct AbstractVisitors< TypeList< T... > > : virtual AbstractVisitor< T >... { }; template< class Dispatcher, class T > struct Resolver : virtual AbstractVisitor< T > { void visit( T& obj ) override { static_cast< Dispatcher* >( this )->functor( obj ); }; };Создадим абстрактный базовый класс (AbstractObject) и какие-нибудь классы (Object1, Object2), которые хотели обойти.
Так же создадим функцию test и шаблон функции test, которые будут получать непосредственно ссылку на объект определенного типа.
Пример использования:
Source:
struct Object1; struct Object2; using ObjectList = TypeList< Object1, Object2 >; struct AbstractObject { virtual void accept( AbstractVisitors< ObjectList >& visitor ) = 0; }; struct Object1 : AbstractObject { void accept( AbstractVisitors< ObjectList >& visitor ) override { static_cast< AbstractVisitor< Object1 >& >( visitor ).visit( *this ); }; }; struct Object2 : AbstractObject { void accept( AbstractVisitors< ObjectList >& visitor ) override { static_cast< AbstractVisitor< Object2 >& >( visitor ).visit( *this ); }; }; void test( Object1& obj ) { std::cout << "1" << std::endl; } template< class T > void test( T& obj ) { std::cout << "2" << std::endl; } int main() { Object1 t1,t2,t3,t4; Object2 e1,e2,e3; std::vector< AbstractObject* > vector = { &t1, &e1, &t2, &t3, &e2, &e3, &t4 }; auto l = []( auto& obj ){ test(obj); }; Dispatcher<decltype(l), ObjectList> dispatcher; for( auto* obj : vector ) { obj->accept( dispatcher ); } }(Пояснение: мы не можем просто написать visitor.visit( *this ), это приведет к неоднозначности, если классов в иерархии будет больше двух.)
Строчки на которых создается обобщенная лямбда и объект класса Dispatchable какие-то то страшные и не удобные, спрятать бы все это от глаз.
Так же, хотелось бы спрятать функцию-член accept у AbstractObject, Object1 и Object2, т.к. тело функции для всех типов объектов будет одинаковое, различаться будет только тип объекта.
Для этого создадим абстрактный класс Dispatchable. Cделаем у него чисто виртуальную функцию-член accept и шаблон функции-члена который будет принимать функтор. В нем собственно и будем создавать наш Dispatcher.
Помимо этого создадим макрос DISPATCHED, он понадобится чтобы спрятать переопределение функции-члена accept у Object1 и Object2.
Source:
template< class TypeList > struct Dispatchable { virtual ~Dispatchable() = default; virtual void accept( AbstractVisitors< TypeList >& ) = 0; template< class Functor > void dispatch( Functor functor ) { static Dispatcher< decltype(functor), TypeList > dispatcher( functor ); accept( dispatcher ); }; }; #define DISPATCHED( TYPE, TYPE_LIST ) \ void accept( AbstractVisitors< TYPE_LIST >& visitor ) override \ { \ static_cast< AbstractVisitor< TYPE >& >( visitor ).visit( *this ); \ }Затем наследуем AbstractObject от класса Dispatchable. А в классы Object1 и Object2 добавляем макрос DISPATCHED.
Source:
struct Object1; struct Object2; using ObjectList = TypeList< Object1, Object2 >; struct AbstractObject : Dispatchable< ObjectList > { }; struct Object1 : AbstractObject { DISPATCHED( Object1, ObjectList ) }; struct Object2 : AbstractObject { DISPATCHED( Object2, ObjectList ) }; Отлично, мы спрятали все функции-члены accept и вынесли общий код. Вот теперь все готово.
Пример использования:
Source:
void test( Object1& obj ) { std::cout << "1" << std::endl; } template< class T > void test( T& obj ) { std::cout << "2" << std::endl; } int main() { Object1 t1,t2,t3,t4; Object2 e1,e2,e3; std::vector< AbstractObject* > vector = { &t1, &e1, &t2, &t3, &e2, &e3, &t4 }; for( auto* obj : vector ) { obj->dispatch( []( auto& obj ) { test(obj); } ); } }Output:
1
2
1
1
2
2
1
Заключение
-
Чтобы добавить или удалить класс, который будет обрабатываться посетителем, достаточно просто изменить список типов.
-
Посетитель не привязан к предметной области, т.к. является шаблоном класса.
-
Можем в полной мере пользоваться шаблонами функций.
Какие недостатки?
-
Дополнительная косвенность, т.к. Dispatcher содержит функтор.
Ссылка на код в compiler explorer.
Full source:
#include <type_traits> #include <iostream> #include <vector> template< class ... T > struct TypeList { }; template< class T > struct AbstractVisitor { virtual ~AbstractVisitor() = default; virtual void visit( T& ) = 0; }; template< class ...T > struct AbstractVisitors; template< class ... T > struct AbstractVisitors< TypeList< T... > > : virtual AbstractVisitor< T >... { }; template< class Dispatcher, class T > struct Resolver : virtual AbstractVisitor< T > { void visit( T& obj ) override { static_cast< Dispatcher* >( this )->functor( obj ); }; }; template< class Functor, class ... T > struct Dispatcher; template< class Functor, class ... T > struct Dispatcher< Functor, TypeList< T... > > : AbstractVisitors< TypeList< T... > >, Resolver< Dispatcher< Functor, TypeList< T... > >, T >... { Dispatcher( Functor functor ) : functor( functor ) {} Functor functor; }; template< class TypeList > struct Dispatchable { virtual ~Dispatchable() = default; virtual void accept( AbstractVisitors< TypeList >& ) = 0; template< class Functor > void dispatch( Functor functor ) { static Dispatcher< decltype(functor), TypeList > dispatcher( functor ); accept( dispatcher ); }; }; #define DISPATCHED( TYPE, TYPE_LIST ) \ void accept( AbstractVisitors< TYPE_LIST >& visitor ) override \ { \ static_cast< AbstractVisitor< TYPE >& >( visitor ).visit( *this ); \ } struct Object1; struct Object2; using ObjectList = TypeList< Object1, Object2 >; struct AbstractObject : Dispatchable< ObjectList > { }; struct Object1 : AbstractObject { DISPATCHED( Object1, ObjectList ) }; struct Object2 : AbstractObject { DISPATCHED( Object2, ObjectList ) }; void test( Object1& obj ) { std::cout << "1" << std::endl; } template< class T > void test( T& obj ) { std::cout << "2" << std::endl; } int main() { Object1 t1,t2,t3,t4; Object2 e1,e2,e3; std::vector< AbstractObject* > vector = { &t1, &e1, &t2, &t3, &e2, &e3, &t4 }; for( auto* obj : vector ) { obj->dispatch( []( auto& obj ) { test(obj); } ); } }ссылка на оригинал статьи https://habr.com/ru/post/532412/
Добавить комментарий