Локи в C++: библиотека для проектирования и метапрограммирования

Привет, Хабр!

Сегодня мы рассмотрим библиотеку Loki, которая названа в честь одного из самых интересных и хитроумных богов скандинавской мифологии. Как и его мифологический тёзка, Loki в C++ отличается гибкостью и изяществом, имея мощные инструменты для метапрограммирования и реализации паттернов проектирования.

Принципы Loki

1. Малое прекрасно:

   • Принцип заключается в минимизации внутренних зависимостей между компонентами библиотеки. Каждый компонент может быть использован независимо!

   • Например, существуют такие компоненты, как SmartPointer или TypeList, они могут быть использованы отдельно друг от друга.

2. Мультипликативное превосходство:

   • Loki фокусируется на достижении сложных, спец. дизайнов через комбинацию простых и абстрактных компонентов.

3. Минимальные зависимости:

   • Loki делает минимальные предположения о своем окружении и предоставляет гибкие точки расширения, чтобы можно было адаптировать библиотеку под нужды без необходимости вносить изменения в саму либу.

Основные компоненты Loki

Типы данных

TypeList — это метапрограммная структура данных, которая представляет собой список типов. Используют для манипуляций с типами на этапе компиляции.

Можно выполнять различные операции с TypeList: доступ к первому элементу, добавление и удаление элементов.

Например, доступ к первому элементу осуществляется с помощью front :

template <typename List> struct Front;  template <typename Head, typename... Tail> struct Front<TypeList<Head, Tail...>> {     using Type = Head; };  using FirstType = Front<MyTypes>::Type;  // int

Добавление элемента в начало списка с помощью PushFront:

template <typename List, typename NewType> struct PushFront;  template <typename... Types, typename NewType> struct PushFront<TypeList<Types...>, NewType> {     using Type = TypeList<NewType, Types...>; };  using NewList = PushFront<MyTypes, char>::Type;  // TypeList<char, int, double, std::string>

template <typename List, typename NewType> struct PushFront;  template <typename... Types, typename NewType> struct PushFront<TypeList<Types...>, NewType> {     using Type = TypeList<NewType, Types...>; };  using NewList = PushFront<MyTypes, char>::Type;  // TypeList<char, int, double, std::string>

Еще существует NullType, который используется для обозначения конца списка типов или отсутствия типа.

struct NullType {};  using EmptyList = TypeList<>;

Умные указатели

Умные указатели в Loki представляют из себя шаблоны для управления ресурсами и автоматического освобождения памяти:

#include <loki/SmartPtr.h>  using namespace Loki;  typedef SmartPtr<int> IntPtr;  void example() {     IntPtr p(new int(10));     // автоматическое освобождение памяти при выходе из области видимости p }

Мультиметоды

Мультиметоды позволяют реализовать множественную диспетчеризацию в C++. Так можно вызывать различные функции в зависимости от типов аргументов во время выполнения:

#include <loki/MultiMethods.h>  using namespace Loki;  struct Base {     virtual ~Base() {} };  struct Derived1 : Base {}; struct Derived2 : Base {};  void function(Derived1&) { /* ... */ } void function(Derived2&) { /* ... */ }  int main() {     Derived1 d1;     Derived2 d2;     Base* b1 = &d1;     Base* b2 = &d2;      // вызов функции в зависимости от типа аргумента     Invoke(function, *b1);     Invoke(function, *b2); }

Функторы

Функторы предоставляют объект-ориентированный способ работы с функциями:

#include <loki/Functor.h>  using namespace Loki;  void print(int x) {     std::cout << x << std::endl; }  int main() {     Functor<void, LOKI_TYPELIST_1(int)> f(print);     f(10);  // Выведет 10 }

Паттерны проектирования: одиночка, фабрика, посетитель

Есть реализация паттерна одиночка с возможностью управления временем жизни объекта:

#include <loki/Singleton.h>  using namespace Loki;  class MySingleton { public:     void DoSomething() { /* ... */ } };  int main() {     MySingleton& instance = Singleton<MySingleton>::Instance();     instance.DoSomething(); }

Фабрика позволяет создавать объекты различных классов, не зная их точных типов:

#include <loki/Factory.h>  using namespace Loki;  class Base { public:     virtual ~Base() {}     virtual void DoSomething() = 0; };  class Derived : public Base { public:     void DoSomething() override { std::cout << "Derived" << std::endl; } };  int main() {     typedef Factory<AbstractFactoryUnit, Base, int> MyFactory;     MyFactory factory;     factory.Register<Derived>(1);     std::unique_ptr<Base> obj(factory.CreateObject(1));     obj->DoSomething();  // Выведет "Derived" }

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

#include <loki/Visitor.h>  using namespace Loki;  class Element { public:     virtual void Accept(Visitor<void, Element>& visitor) = 0; };  class ConcreteElement : public Element { public:     void Accept(Visitor<void, Element>& visitor) override {         visitor.Visit(*this);     } };  class ConcreteVisitor : public Visitor<void, Element> { public:     void Visit(ConcreteElement& element) {         std::cout << "Visited ConcreteElement" << std::endl;     } };  int main() {     ConcreteElement elem;     ConcreteVisitor visitor;     elem.Accept(visitor);  // выведет "Visited ConcreteElement" } 

Политика-ориентированный дизайн

Политика-ориентированный дизайн позволяет создавать классы, которые могут быть настроены с помощью шаблонных параметров. Достигается за счет разбиения поведения класса на несколько политик, каждая из которых реализует определенную функциональность:

template <typename T, typename ThreadingModel> class Singleton { public:     static T& Instance() {         static T instance;         return instance;     } private:     Singleton() {}     ~Singleton() {} };  class SingleThreaded { public:     typedef int Lock; };  class MultiThreaded { public:     class Lock {     public:         Lock() { /* lock mechanism */ }         ~Lock() { /* unlock mechanism */ }     }; };  typedef Singleton<MyClass, SingleThreaded> MySingleton;

Примеры использования

TypeList для динамического создания объектов:

#include <iostream> #include <loki/Typelist.h> #include <loki/Factory.h>  using namespace Loki;  // определяем несколько классов class A { public: void Display() { std::cout << "Class A\n"; } }; class B { public: void Display() { std::cout << "Class B\n"; } }; class C { public: void Display() { std::cout << "Class C\n"; } };  // создаем TypeList из классов typedef TYPELIST_3(A, B, C) MyTypeList;  // фабрика для создания объектов из TypeList typedef Factory<AbstractFactoryUnit, MyTypeList> MyFactory;  int main() {     MyFactory factory;     factory.Register<A>(1);     factory.Register<B>(2);     factory.Register<C>(3);      std::unique_ptr<A> a(factory.CreateObject(1));     std::unique_ptr<B> b(factory.CreateObject(2));     std::unique_ptr<C> c(factory.CreateObject(3));      a->Display();     b->Display();     c->Display();      return 0; }

Так можно динамически создавать объекты различных типов, используя TypeList и фабрику.

Управление памятью с помощью SmartPtr:

#include <iostream> #include <loki/SmartPtr.h>  using namespace Loki;  class Resource { public:     Resource() { std::cout << "Resource Acquired\n"; }     ~Resource() { std::cout << "Resource Released\n"; } };  void useResource() {     SmartPtr<Resource> res(new Resource());     // ресурс автоматом освободится в конце блока }  int main() {     useResource();     return 0; }

Реализация многометодного диспетчера:

#include <iostream> #include <loki/MultiMethods.h>  using namespace Loki;  class Animal { public:     virtual ~Animal() {}     LOKI_DEFINE_VISITABLE() };  class Dog : public Animal { public:     void Bark() { std::cout << "Woof!\n"; }     LOKI_DEFINE_VISITABLE() };  class Cat : public Animal { public:     void Meow() { std::cout << "Meow!\n"; }     LOKI_DEFINE_VISITABLE() };  void Speak(Animal&) { std::cout << "Unknown animal sound\n"; } void Speak(Dog& d) { d.Bark(); } void Speak(Cat& c) { c.Meow(); }  int main() {     Dog dog;     Cat cat;     Animal* animals[] = { &dog, &cat };      for (Animal* animal : animals) {         Invoke(Speak, *animal);     }      return 0; }

Functor для обратных вызовов

#include <iostream> #include <loki/Functor.h>  using namespace Loki;  void PrintNumber(int number) {     std::cout << "Number: " << number << std::endl; }  int main() {     Functor<void, LOKI_TYPELIST_1(int)> func(PrintNumber);     func(42);     return 0; }

---

Подробнее с библиотекой можно ознакомиться здесь.

В завершение хочу рассказать об открытых уроках для разработчиков на C++, которые совсем скоро пройдут в Otus:

• 11 июня: Условные переменные в С++. Узнаете, что такое std::condition_variable, какие задачи он решает и типовые ошибки при его использовании. Узнаете, что такое spurious wakeup и напишите несколько concurrency-примитивов на основе condition_variable. Записаться бесплатно можно по ссылке.

• 24 июня: Как разработчику на С++ организовать кроссплатформенную разработку? На этом уроке узнаете, как решить проблему поиска зависимостей, напишите conan-файл и сможете организовать свой сервер пакетов в своей экосистеме CI/CD. Запись по ссылке.