В первой части мы обсудили, как добиться переноса определения шаблона фунции из заголовочного файла в исходник, если набор типов, для которых должен быть инстанциирован шаблон известен заранее. В этой части мы посмотрим, как добиться этого красиво.
В первую очередь прийдётся сделать то, что я планировал сделать ближе к концу, но судя по комментариям из первой части, это нужно сделать срочно. А именно, больше никаких списков типов по Александреску. Теперь только шаблоны с переменным количеством параметров, или вариадики, в народе:
template <typename... Types> struct TypeList{}; // пустой класс для упаковки наборов типов
typedef TypeList<int, double, bool, char, const char*> MyTypeList; // конкретный набор типов для инстанциирования шаблона функции
Вернёмся к последнему результату из первой части и перепишем его на манер вариадиков:
template<typename T> struct SomethingDoer
{
static void doSomething() { }
};
template<typename Head, typename... Tail>
struct SomethingDoer<TypeList<Head, Tail...>>
{
typedef void (MyClass::*MemFuncType)(Head);
static void doSomething()
{
volatile MemFuncType x = &MyClass::f;
(void)(x);
SomethingDoer<TypeList<Tail...>>::doSomething();
}
};
template <typename TList>
struct Instantiator
{
Instantiator()
{
SomethingDoer<TList>::doSomething();
}
};
Instantiator<MyTypeList> a;
Теперь давайте подумаем, как усовершенствовать это решение. Совершенствование необходимо в двух направлениях: обобщение и избавление от хлама.
Со вторым заданием, вроде проще, разобраться. Весь класс Instantiator только и создан для того, чтобы слелать вызов: SomethingDoer<MyTypeList>::doSomething();. Ну, так это можно сделать и проще:
template<typename T> struct SomethingDoer
{
static int doSomething() // теперь doSomething возвращает значение, а это значит, что её результат можно присвоить переменной.
{
return 0;
}
};
template<typename Head, typename... Tail>
struct SomethingDoer<TypeList<Head, Tail...>>
{
typedef void (MyClass::*MemFuncType)(Head);
static int doSomething()
{
volatile MemFuncType x = &MyClass::f; (***)
(void)(x);
return SomethingDoer<TypeList<Tail...>>::doSomething();
}
};
int a = SomethingDoer<MyTypeList>::doSomething(); // тоже самое, что и раньше, только немного короче.
Ну, а теперь давайте обобщать. Самое больное место отмечено (***). Здесь происходит инстанциирования конкретного шаблона метода конкретного класса.
Весь остальной код ни с этим шаблоном, ни с классом ничего общего не имеет. Значит нужно вынести остаток кода за скобки, а в строчку с (***) вставить что-то более обобщённое. Т.е, если мы засунем шаблон MyClass::f в какую-нибудь оболочку, типа
template<typename T>
struct FuncWrapper_MyClass_f
{
typedef decltype(&MyClass::f<T>) type;
static constexpr type value = &MyClass::f<T>;
};
, то внутри функции doSomething нам уже ни класс MyClass, ни его шаблон метода f() не понадобятся.
Вот как теперь можно записать (класс SomethingDoer теперь переименован в Instantiator, а метод doSomething() — в instantiate()).
template<typename Head, typename... Tail> // пока всё, как и раньше
struct Instantiator<TypeList<Head, Tail...>> // пока всё, как и раньше
{
typedef Instantiator<TypeList<Tail...> > TailInstantiator; // тип для рекурсивного инстанциатора для хвоста списка типов
static std::pair<typename FuncWrapper_MyClass_f<Head>::type, decltype(TailInstantiator::instantiate())> instantiate()
{
auto headTypeInstantiate = FuncWrapper_MyClass_f<Head>::value; // здесь шаблон инстанциируится для головы списка,
return std::make_pair(headTypeInstantiate, TailInstantiator::instantiate()); // а здесь рекурсивно запускается инстанциирование для хвоста списка.
}
};
Не обращайте внимания на всякие навороты с возвратом пары — это нужно, чтобы компилятор не попытался отлынить от части своей работы. Теперь осталось только заменить упаковочный класс FuncWrapper_MyClass_f на что-то более общее. Всё, что нам нужно внутри метода instantiate() — это аттрибут FuncWrapper_MyClass_f::value и тип FuncWrapper_MyClass_f::type. Выглядеть это будет так:
template<template<typename>class FuncWrapperType, typename Type> // первый параметр шаблона - и есть тот новый обобщённый FuncWrapper_MyClass_f
struct Instantiator
{
static int instantiate(...)
{
return 0;
}
};
template<template<typename>class FuncWrapperType, typename Head, typename... Tail>
struct Instantiator<FuncWrapperType, TypeList<Head, Tail...> >
{
typedef Instantiator<FuncWrapperType, TypeList<Tail...> > TailInstantiator;
static typename std::pair<typename FuncWrapperType<Head>::type, decltype(TailInstantiator::instantiate())>
instantiate()
{
auto headTypeInstantiate = FuncWrapperType<Head>::value;
return std::make_pair(headTypeInstantiate, TailInstantiator::instantiate());
}
};
auto a = Instantiator<FuncWrapper_MyClass_f, MyTypeList>::instantiate(); // всё, как раньше, только теперь указываем FuncWrapper_MyClass_f снаружи instantiate(), а не внутри.
Данный шаг был самым важным из всех предыдущих. Нам удалось сделать механизм инстанциирования независимым от конкретных шаблонов, для которых этот механизм должен быть применён. Весь код struct Instantiator стал общим и теперь может быть вынесен из исходника myclass.cpp и быть использован для инстанциирования шаблонов других функций или методов класса. Всё что остаётся прописать в MyClass.cpp — это упаковочку FuncWrapper_MyClass_f. Но и это дело неблагородное, и если у Вас нету религиозных соображений на тему макросов препроцессора, то давайте для чёрной работёнки ими и воспользуемся.
define InstantiateMemFunc(className, funcName, types)
template<typename T>
struct FuncWrapper_##className_##funcName
{
typedef decltype(&className::funcName<T>) type;
static constexpr type value = &className::funcName<T>;
};
volatile auto i_##className_##funcName = detail::Instantiator<FuncWrapper_##className_##funcName, types>::instantiate();
Этот код тоже универсален и может быть помещён в центральном месте. В MyClass.cpp остаётся лишь написать:
namespace {
InstantiateMemFunc(MyClass, f, MyTypeList)
}
И всё. Также можно написать очень похожий макрос для свободных функций, а не методов класса, но не хочется место переводить.
Подведём итоги. В этой статье мы рассмотрели, как можно избавиться от определеия шаблонов в заголовочном файле при определённых условиях. Не ахти какая проблема, конечно, но всё-таки не аккуратненько. Заголовочный файл — это лицо программиста, а исходник — это его опа. На опе волосы могут быть, а на лице, кроме админов, раввинов и, разумеется, админ-раввинов, — нет. Мы, С++ программисты, должны следить за своим лицом, иначе оно превратится в…
Автор: JoraN
