20

次のヘッダー ファイルを検討してください。

// 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 コンパイラで動作します。)

4

6 に答える 6

1

少し前に同じ要件があり、単純な関数テンプレートのインスタンス化で良い結果が得られました。

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*);
于 2016-12-31T14:40:05.953 に答える
0

これがあなたの問題の解決策であるかどうかはわかりませんが、テンプレートの特殊化でできるかもしれません。

新しいヘッダー：

// 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 >;
于 2011-04-19T11:37:02.437 に答える
0

指定された T テンプレート パラメーターの Foo を明示的にインスタンス化するには、次のようにします。template class Foo<T>;

バッチインスタンス化に関しては、私はそれが可能だとは思わない. おそらく、可変個引数テンプレートを使用すると、適切なテンプレートをインスタンス化するようなもので Instantiate クラスを作成できますInstantiate<Foo, int, short, long, float, etc>が、それ以外は手動でインスタンス化する必要があります。

于 2011-07-01T15:38:52.860 に答える
0

明示的なインスタンス化には、コンパイラにとって特別な文法と特別な意味があるため、メタプログラミングでは実行できません。

あなたのソリューションはインスタンス化を引き起こしますが、明示的なインスタンス化は引き起こしません。

于 2014-05-23T16:16:16.087 に答える
0

私はそれが必要だとは思いませんし、可能でもありません。

テンプレート関数の実装で型が適切に定義されている限り、任意の型の変数 bar に対して関数 Foo:read(bar) を直接使用 (呼び出す) ことができます。コンパイラは、引数を自動的に "T" 型に変換します。

例えば：

template <class T>
Foo::read(T & var)
{
    std::cin >> var;
}

T が cin によってサポートされるストリーミング型である場合、T は明確に定義されています。

「Foo::」が削除された場合、例は自己完結型になります。つまり、「Foo::」の場合、それを機能させるには、クラス Foo または名前空間 Foo をどこかに定義する必要があります。

ただし、テンプレートは常に .cpp ファイルではなく .h ファイル内に配置する必要があることに注意してください (「c++ テンプレートは cpp ファイルに実装できません」というキーワードで Web を検索してください)。

于 2014-09-04T10:54:13.953 に答える
0

クラスを単一のモジュールでのみ使用する場合 (つまり、エクスポートしない場合) は、boost/mpl/for_each を使用できます。この方法で (mpl/for_each を使用して) 定義されたテンプレート関数はエクスポートされません (クラス名または関数シグネチャの前に __declspec(export) を宣言しても):

// 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());
}

エクスポート/インポートが必要な場合は、構造化とテンプレートのメソッドがあり、ブースト/プリプロセッサを使用したソリューションがあります

// 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)

この追加機能が必要ない場合は、最初のソリューションの方がはるかにクリーンだと思います

于 2016-03-09T15:18:16.457 に答える