В стандартной библиотеке языка программирования C++ существует много классов, наделенных если не абсолютно одинаковыми свойствами, то очень похожими.
Так, стандарт вводит отдельное требование BitmaskType, описывающее свойства, какими должны обладать битовые маски в стандартной библиотеке: для них должен быть определены операции «и», «или», «не», а значение 0 должно представлять пустую маску.
В стандартной библиотеке классов, от которых требуется соблюдение этого требования, очень много: std::chars_format, std::launch, std::filesystem::perms, std::filesystem::perm_options, std::filesystem::copy_options, std::filesystem::directory_options... Единственное, чем они отличаются — это набором возможных значений. Реализации же битовых операций над ними похожи как две капли воды.
Сравните сами реализации битовых операций для perms, directory_options и perm_options (примеры взяты из libc++ — одной из самой популярных реализаций стандартной библиотеки): comparison table. Они идентичны один в один за исключением того, что используют различные типы в качестве основы (underlying type у enum class). Их реализация — чистый копипаст. Кроме того не могу не обратить ваше внимание на недочет, закравшийся в реализацию битовых операций для perm_options в результате такого копипаста: в качестве underlying type для perm_options определен unsigned char, а приводим мы аргументы операторов (в static_cast) к unsigned (unsigned int). Это не является ошибкой, но тем не менее способно ввести в заблуждение программиста, работающего с данным кодом.
Примечательно то, что на данный момент в плюсах нет способа устранить этот копипаст. Ни наследование, ни какой-либо другой метод в данном случае не помощник.
Решение данной проблемы, предложенное (P0707R3) Гербом Саттером, председателем совета по стандартизации C++ — метаклассы, сущность, позволяющая управлять процессом компиляции для конкретного пользовательского типа.
Рассмотрим их возможности на следующем примере:
// Определение метакласса
constexpr void interface(meta::type target, const meta::type source) {
compiler.require(source.variables().empty(), "interfaces may not contain data");
for (auto f: source.functions()) {
compiler.require(!f.is_copy() && !f.is_move(), "interfaces may not copy or move; consider a virtual clone() instead");
if (!f.has_access()) f.make_public();
compiler.require(f.is_public(), "interface functions must be public");
f.make_pure_virtual();
->(target) f;
}
->(target) { virtual ~(source.name()$)() noexcept { } }
}
// Использование метакласса
interface Shape {
int area() const;
void scale_by(double factor);
};Метакласс определяется с помощью функции, выполняющейся на этапе компиляции и принимающей два аргумента: target — тип, представляющий результат преобразования исходного класса, и source — исходный пользовательский класс:
constexpr void interface(meta::type target, const meta::type source) {В нем доступны следующие возможности:
1. Генерация ошибок и предупреждений компиляции. Например, следующий код выдаст пользователю ошибку компиляции с сообщением «interfaces may not contain data», если в исходном классе определены какие-либо поля:
compiler.require(source.variables().empty(), "interfaces may not contain data");2. Получение информации об исходном классе через методы аргумента source. Тип meta::type инкапсулирует всю информацию о классе: информацию о его полях, методах, базовых классах, модификаторах, примененных к нему, и так далее.
3. Модификация (инъекция нового исходного кода) результирующего класса target при помощи специального синтаксиса. Например, следующий код добавит в него виртуальный деструктор (знак $ необходим для того, чтобы результат вызова source.name() подставился в инъектируемый исходный код):
->(target) { virtual ~(source.name()$)() noexcept { } }А следующий — поле valueтипа int:
->(target) { int value; }Теперь мы можем осмыслить полностью, что делает вышеприведенный код.
Он определяет метакласс с именем interface:
constexpr void interface(meta::type target, const meta::type source) {Который выдает ошибку компиляции, если в исходный класс содержит какие-нибудь поля:
compiler.require(source.variables().empty(), "interfaces may not contain data");Итерируется по всем его методам (получаемым по значению, так что мы можем их модифицировать), выдавая ошибку, если они являются copy/move конструкторами или операторами присваивания:
for (auto f: source.functions()) {
compiler.require(!f.is_copy() && !f.is_move(), "interfaces may not copy or move; consider a virtual clone() instead"); Присваивая им, если разработчик явно не указал их модификатор доступа, public модификатор:
if (!f.has_access()) f.make_public();И выдавая ошибку, если разработчик определил метод не как public, а как private или protected:
compiler.require(f.is_public(), "interface functions must be public");Делая их чисто виртуальными:
f.make_pure_virtual();Добавляя их в результирующий класс target (который в начале функции является абсолютно пустым):
->(target) f;И, наконец, проитерировавшись по всем классам, добавляет в target виртуальный деструктор с пустым телом:
->(target) { virtual ~(source.name()$)() noexcept { } }Теперь мы можем применять метакласс следующим образом:
interface Shape {
int area() const;
void scale_by(double factor);
};Компилятор, разобрав на этапе компиляции это определение, ввиду того, что мы применили к нему метакласс, передаст наш класс Shape в качестве аргумента source в функцию, реализующую метакласс interface, а в качестве target передаст тип, представляющий пустой класс (единственно обладающий тем же именем, что и исходный).
Когда функция исполнится, он заменит наш исходный класс классом, который был передан в функцию interface как target. Таким образом, метакласс попросту преобразует на этапе компиляции вышеприведенный класс в следующий (вышеприведенный и нижеприведенный код семантически эквивалентны):
class Shape {
public:
virtual int area() const = 0;
virtual void scale_by(double factor) = 0;
virtual ~Shape() { }
};Теперь нам становится ясно решение исходной проблемы: нужно написать метакласс битовой маски, избавляющий пользователя от необходимости копипастить реализации битовых операций благодаря тому, что он определяет их сам.
Его использование может выглядеть следующим образом:
// В коде библиотеки
bitmask perm_options: unsigned char {
auto replace, add, remove, nofollow;
}
// В пользовательском же коде он используется так же
// как использовался оригинальный perm_options с кучей бойлерплейта
// метакласс реализовал весь необходимый функционал за нас
perm_options options = (perm_options::add | perm_options::remove) & (~perm_options::replace);На этой радостной ноте (мы нашли способ дедублицировать код реализации различных классов-битовых масок: сравните код, который у нас был, и полностью эквивалентный ему код, благодаря метаклассам лишенный всякого бойлерплейта) мы закончим наше скромное введение. Реализация же вышеописанного метакласса оставляется в качестве упражнения внимательному читателю.
