C ++テンプレート関数定義を.CPPファイルに保存する

ヘッダーのインラインではなく、CPPファイルに保存したいテンプレートコードがあります。使用されるテンプレートの種類がわかっている限り、これを実行できます。例えば：

.hファイル

class foo
{
public:
    template <typename T>
    void do(const T& t);
};

.cppファイル

template <typename T>
void foo::do(const T& t)
{
    // Do something with t
}

template void foo::do<int>(const int&);
template void foo::do<std::string>(const std::string&);

最後の2行に注意してください。foo:: doテンプレート関数は、intとstd :: stringsでのみ使用されるため、これらの定義はアプリがリンクすることを意味します。

私の質問は-これは厄介なハックですか、それとも他のコンパイラ/リンカーで動作しますか？現在、このコードはVS2008でのみ使用していますが、他の環境に移植したいと考えています。

あなたが説明する問題は、ヘッダーでテンプレートを定義することによって、または上で説明したアプローチによって解決できます。

C ++ FAQ Liteから次の点を読むことをお勧めします。

• テンプレートクラスの定義を宣言から分離して.cppファイル内に配置できないのはなぜですか？
• テンプレート関数でリンカーエラーを回避するにはどうすればよいですか？
• C ++キーワードエクスポートはテンプレートリンカーエラーをどのように助けますか？

彼らは、これら（およびその他）のテンプレートの問題について多くの詳細を説明しています。

このページの他の人は、明示的なテンプレートの特殊化（または少なくともVS2008の場合）の正しい構文は（Iと同じように）何なのかと疑問に思っている場合、次のように...

.hファイルで...

template<typename T>
class foo
{
public:
    void bar(const T &t);
};

そして、あなたの.cppファイル

template <class T>
void foo<T>::bar(const T &t)
{ }

// Explicit template instantiation
template class foo<int>;

このコードは整形式です。テンプレートの定義がインスタンス化の時点で表示されることに注意する必要があります。標準を引用すると、§14.7.2.4：

エクスポートされていない関数テンプレート、エクスポートされていないメンバー関数テンプレート、またはクラステンプレートのエクスポートされていないメンバー関数または静的データメンバーの定義は、明示的にインスタンス化されるすべての翻訳単位に存在する必要があります。

これは、テンプレートがサポートされているすべての場所で正常に動作するはずです。明示的なテンプレートのインスタンス化は、C ++標準の一部です。

あなたの例は正しいですが、あまり移植性がありません。（@ namespace-sidで指摘されているように）使用できる少しすっきりした構文もあります。

テンプレートクラスが、共有されるライブラリの一部であるとします。テンプレートクラスの他のバージョンをコンパイルする必要がありますか？ライブラリのメンテナは、クラスのテンプレート化されたすべての使用を予測することになっていますか？

別のアプローチは、あなたが持っているもののわずかなバリエーションです：テンプレート実装/インスタンス化ファイルである3番目のファイルを追加します。

foo.hファイル

// Standard header file guards omitted

template <typename T>
class foo
{
public:
    void bar(const T& t);
};

foo.cppファイル

// Always include your headers
#include "foo.h"

template <typename T>
void foo::bar(const T& t)
{
    // Do something with t
}

foo-impl.cppファイル

// Yes, we include the .cpp file
#include "foo.cpp"
template class foo<int>;

1つの警告は、あなたがコンパイルするコンパイラ指示する必要がありますということであるfoo-impl.cpp代わりにfoo.cpp、後者は何もしないコンパイルなどを。

もちろん、3番目のファイルに複数の実装を含めることも、使用するタイプごとに複数の実装ファイルを含めることもできます。

これにより、テンプレートクラスを他の用途に共有する際の柔軟性が大幅に向上します。

このセットアップでは、各翻訳単位で同じヘッダーファイルを再コンパイルしないため、再利用されたクラスのコンパイル時間も短縮されます。

これは間違いなく厄介なハックではありませんが、特定のテンプレートで使用するすべてのクラス/タイプに対してこれを行う必要がある（明示的なテンプレートの特殊化）ことに注意してください。テンプレートのインスタンス化を要求する多くのタイプの場合、.cppファイルに多数の行が含まれる可能性があります。この問題を解決するには、使用するすべてのプロジェクトにTemplateClassInst.cppを設定して、インスタンス化されるタイプをより細かく制御できるようにします。明らかに、ODRを壊してしまう可能性があるため、このソリューションは完璧ではありません（別名：銀の弾丸）。

最新の標準には、exportこの問題を緩和するのに役立つキーワード（）がありますが、私が知っているコモー以外のコンパイラには実装されていません。

これについてはFAQ-liteを参照してください。

これは、テンプレート関数を定義する標準的な方法です。テンプレートを定義するために私が読んだ方法は3つあると思います。またはおそらく4。それぞれ長所と短所。

1. クラス定義で定義します。クラス定義はあくまでも参照用であり、読みやすいはずなので、これはまったく好きではありません。ただし、クラスを外部で定義するよりも、テンプレートを定義する方が簡単です。また、すべてのテンプレート宣言が同じレベルの複雑さにあるわけではありません。このメソッドは、テンプレートを真のテンプレートにします。

2. 同じヘッダー内で、クラスの外でテンプレートを定義します。ほとんどの場合、これが私の好みの方法です。それはあなたのクラス定義をきちんと保ちます、テンプレートは本当のテンプレートのままです。ただし、テンプレートを完全に命名する必要があるため、注意が必要です。また、コードはすべての人が利用できます。ただし、コードをインラインにする必要がある場合は、これが唯一の方法です。これは、クラス定義の最後に.INLファイルを作成することでも実現できます。

3. header.hとimplementation.CPPをmain.CPPに含めます。それがそのやり方だと思います。事前インスタンス化を準備する必要はありません。本当のテンプレートのように動作します。私が持っている問題はそれが自然ではないということです。通常、ソースファイルはインクルードせず、インクルードする予定です。ソースファイルをインクルードしたので、テンプレート関数をインライン化できると思います。

4. 投稿された方法であるこの最後の方法は、3のように、ソースファイルでテンプレートを定義しています。ただし、ソースファイルを含める代わりに、必要なテンプレートにテンプレートを事前にインスタンス化します。私はこの方法で問題がなく、時々重宝します。大きなコードが1つあるので、インライン化してもメリットがないので、CPPファイルに入れてください。また、一般的なインスタンス化を知っていて、それらを事前定義できる場合。これにより、基本的に同じことを5、10回書く必要がなくなります。この方法には、コードを独占的に保つという利点があります。ただし、CPPファイルに定期的に使用される小さな関数を含めることはお勧めしません。これにより、ライブラリのパフォーマンスが低下します。

注、私は肥大化したobjファイルの結果を認識していません。

はい、それは特殊化の明示的なインスタンス化を行う標準的な方法です。あなたが述べたように、このテンプレートを他のタイプでインスタンス化することはできません。

編集：コメントに基づいて修正。

一例を挙げましょう。何らかの理由でテンプレートクラスが必要だとします。

//test_template.h:
#pragma once
#include <cstdio>

template <class T>
class DemoT
{
public:
    void test()
    {
        printf("ok\n");
    }
};

template <>
void DemoT<int>::test()
{
    printf("int test (int)\n");
}


template <>
void DemoT<bool>::test()
{
    printf("int test (bool)\n");
}

このコードをVisual Studioでコンパイルする場合-そのまま使用できます。gccはリンカーエラーを生成します（複数の.cppファイルから同じヘッダーファイルが使用されている場合）：

error : multiple definition of `DemoT<int>::test()'; your.o: .../test_template.h:16: first defined here

実装を.cppファイルに移動することは可能ですが、その場合は次のようにクラスを宣言する必要があります-

//test_template.h:
#pragma once
#include <cstdio>

template <class T>
class DemoT
{
public:
    void test()
    {
        printf("ok\n");
    }
};

template <>
void DemoT<int>::test();

template <>
void DemoT<bool>::test();

// Instantiate parametrized template classes, implementation resides on .cpp side.
template class DemoT<bool>;
template class DemoT<int>;

そして、.cppは次のようになります。

//test_template.cpp:
#include "test_template.h"

template <>
void DemoT<int>::test()
{
    printf("int test (int)\n");
}


template <>
void DemoT<bool>::test()
{
    printf("int test (bool)\n");
}

ヘッダーファイルに最後の2行がない場合、gccは正常に動作しますが、Visual Studioはエラーを生成します。

 error LNK2019: unresolved external symbol "public: void __cdecl DemoT<int>::test(void)" (?test@?$DemoT@H@@QEAAXXZ) referenced in function

.dllエクスポートを介して関数を公開する場合、テンプレートクラスの構文はオプションですが、これはWindowsプラットフォームにのみ適用できるため、test_template.hは次のようになります。

//test_template.h:
#pragma once
#include <cstdio>

template <class T>
class DemoT
{
public:
    void test()
    {
        printf("ok\n");
    }
};

#ifdef _WIN32
    #define DLL_EXPORT __declspec(dllexport) 
#else
    #define DLL_EXPORT
#endif

template <>
void DLL_EXPORT DemoT<int>::test();

template <>
void DLL_EXPORT DemoT<bool>::test();

前の例の.cppファイルを使用します。

ただし、これによりリンカーの頭痛が増えるため、.dll関数をエクスポートしない場合は前の例を使用することをお勧めします。

更新の時間です！インライン（.inl、またはおそらく他の）ファイルを作成し、その中のすべての定義をコピーします。必ず各関数の上にテンプレートを追加してください（template <typename T, ...>）。ここで、ヘッダーファイルをインラインファイルに含める代わりに、逆の処理を行います。クラスの宣言の後にインラインファイルを含めます（#include "file.inl"）。

なぜ誰もこれについて言及しなかったのか、本当にわかりません。私には差し迫った欠点はありません。

あなたが与えた例には何の問題もありません。しかし、関数定義をcppファイルに保存するのは効率的ではないと私は信じなければなりません。関数の宣言と定義を分離する必要性だけを理解しています。

Boost Concept Check Library（BCCL）を明示的なクラスのインスタンス化と一緒に使用すると、cppファイルでテンプレート関数コードを生成できます。

上記のどれも私にとってはうまくいかなかったので、ここでそれを解決する方法を示します。私のクラスにはテンプレート化されたメソッドが1つしかありません

.h

class Model
{
    template <class T>
    void build(T* b, uint32_t number);
};

.cpp

#include "Model.h"
template <class T>
void Model::build(T* b, uint32_t number)
{
    //implementation
}

void TemporaryFunction()
{
    Model m;
    m.build<B1>(new B1(),1);
    m.build<B2>(new B2(), 1);
    m.build<B3>(new B3(), 1);
}

これにより、リンカーエラーが回避され、TemporaryFunctionを呼び出す必要がまったくなくなります。