Рассмотрим следующий заголовочный файл:
// Foo.h
class Foo {
public:
template <typename T>
void read(T& value);
};
Я хочу явно создать шаблон функции члена Foo::read в исходном файле для всех типов, включенных в boost::mpl::vector:
// Foo.cc
#include <boost/mpl/vector.hpp>
#include <boost/mpl/begin_end.hpp>
#include "Foo.h"
template <typename T>
void Foo::read(T& value) { /* do something */ }
typedef boost::mpl::vector<int, long, float> types;
// template Foo::read<int >(int&);
// template Foo::read<long >(long&);
// template Foo::read<float>(float&);
// instantiate automatically ???
Возможно ли это? Спасибо заранее, Даниэль.
ИЗМЕНИТЬ
Я нашел некоторое решение - кажется, что назначение указателя на Foo::read<T> в конструкторе структуры, из которой объявлена переменная, вызывает создание экземпляра:
// intermezzo
template <typename T> struct Bar {
Bar<T>() {
void (Foo::*funPtr)(T&) = &Foo::read<T>;
}
};
static Bar<int > bar1;
static Bar<long > bar2;
static Bar<float> bar3;
Итак, процесс можно автоматизировать следующим образом:
// Foo.cc continued
template <typename B, typename E>
struct my_for_each {
my_for_each<B, E>() {
typedef typename B::type T; // vector member
typedef void (Foo::*FunPtr)(T&); // pointer to Foo member function
FunPtr funPtr = &Foo::read<T>; // cause instantiation?
}
my_for_each<typename boost::mpl::next<B>::type, E> next;
};
template<typename E>
struct my_for_each<E, E> {};
static my_for_each< boost::mpl::begin<types>::type,
boost::mpl::end<types>::type > first;
Но я не знаю, является ли это решение портативным и стандартным? (Работает с компиляторами Intel и GNU.)
Вы можете явно указать Foo для заданного параметра шаблона T с помощью template class Foo<T>;
Что касается пакетного создания, я не думаю, что это возможно. Возможно, с помощью вариационных шаблонов можно создать класс Instantiate, поэтому что-то вроде Instantiate<Foo, int, short, long, float, etc> будет создавать экземпляры соответствующих шаблонов, но кроме этого вам придется прибегать к ручному созданию экземпляров.
Я не уверен, что это решение вашей проблемы, но, возможно, вы можете сделать это с помощью специализированной специализации.
Новый заголовок:
// Foo.h
template < typename T >
struct RealRead;
class Foo {
public:
template <typename T>
void read(T& value);
};
template <typename T>
void Foo::read(T& value)
{
RealRead< T >::read( value );
}
Новый источник:
template < >
struct RealRead< int >
{
static void read( int & v )
{
// do read
}
};
template < >
struct RealRead< float >
{
static void read( float & v )
{
// do read
}
};
//etc
// explicitly instantiate templates
template struct RealRead< int >;
template struct RealRead< float >;
Явное инстанцирование имеет специальную грамматику и особый смысл для complier, поэтому не может быть сделано с мета-программированием.
ваше решение вызывает создание экземпляра, но не явное создание экземпляра.
Я не думаю, что это необходимо, и это невозможно.
Вы можете напрямую использовать (вызывать) функцию Foo: read (bar) для переменной строки любого типа, если тип четко определен в вашей реализации функции шаблона. Компилятор автоматически преобразует ваш аргумент в тип "T".
Например:
template <class T>
Foo::read(T & var)
{
std::cin >> var;
}
T корректно определен, когда T - потоковый тип, поддерживаемый cin.
Пример будет самодостаточным, если "Foo::" удален. Я имею в виду, что для "Foo::" вы должны были где-то определить класс Foo или пространство имен Foo, чтобы заставить его работать.
Однако обратите внимание, что шаблон всегда должен находиться внутри файла .h, а не файла .cpp(просто поиск в Интернете с ключевым словом "С++-шаблон не может быть реализован в файле cpp"
Если вы собираетесь использовать свой класс только в одном модуле (т.е. вы его не экспортируете), вы можете использовать boost/mpl/for_each. Функция шаблона, определенная таким образом (с использованием mpl/for_each), не будет экспортироваться (даже если вы объявляете __declspec (экспорт) перед именем класса или сигнатурой функции):
// Foo.cpp
#include <boost/mpl/vector.hpp>
#include <boost/mpl/for_each.hpp>
template<class T>
void read(T& value)
{
...
}
using types = boost::mpl::vector<long, int>;
//template instantiation
struct call_read {
template <class T>
void operator()(T)
{
T t; //You should make sure that T can be created this way
((Foo*)nullptr)->read<T>(t); //this line tells to compiler with templates it should instantiate
}
};
void instantiate()
{
boost::mpl::for_each<types>(call_read());
}
Если вам нужно экспортировать/импортировать структуру и методы шаблона, существует решение с использованием boost/preprocessor
// Foo.h
#ifdef <preprocessor definition specific to DLL>
# define API __declspec(dllexport)
#else
# define API __declspec(dllimport)
#endif
class API Foo {
public:
template<class T> void read(T& value);
};
// Foo.cpp
#include <boost/preprocessor/seq/for_each.hpp>
#include <boost/preprocessor/seq/enum.hpp>
#include <boost/mpl/vector.hpp>
template<class T>
void read(T& value)
{
...
}
//using this macro you can define both boost::mpl structure AND instantiate explicitly your template function
#define VARIANT_LIST (std::wstring)(long)(int)
using types = boost::mpl::vector<BOOST_PP_SEQ_ENUM(VARIANT_LIST)>;
//Here we should use our API macro
#define EXPLICIT_INSTANTIATION(r, d, __type__) \
template API void Foo::read<__type__>(__type__&);
BOOST_PP_SEQ_FOR_EACH(EXPLICIT_INSTANTIATION, _, VARIANT_LIST)
Если вам не нужна эта дополнительная функциональность, первое решение намного чище. Я думаю,
У меня было такое же требование недавно, и у меня были хорошие результаты с помощью простого экземпляра шаблона функции:
template <class... T>
void forceInstantiation(typedef boost::mpl::vector<T...>*) {
using ex = int[];
(void)ex{(void(&Foo::read<T>), 0)..., 0};
// C++17
// (void)((void(&Foo::read<T>), ...));
}
template void forceInstantiation(types*);