Menyimpan definisi fungsi template C ++ dalam file .CPP

Saya memiliki beberapa kode templat yang saya ingin simpan dalam file CPP daripada inline di header. Saya tahu ini bisa dilakukan selama Anda tahu jenis templat mana yang akan digunakan. Sebagai contoh:

file .h

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

file .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&);

Perhatikan dua baris terakhir - fungsi templat foo :: do hanya digunakan dengan ints dan std :: strings, jadi definisi tersebut berarti aplikasi akan ditautkan.

Pertanyaan saya adalah - apakah ini hack jahat atau akankah ini bekerja dengan kompiler / penghubung lainnya? Saya hanya menggunakan kode ini dengan VS2008 saat ini tetapi akan ingin port ke lingkungan lain.

Masalah yang Anda uraikan dapat diselesaikan dengan menentukan templat di header, atau melalui pendekatan yang Anda jelaskan di atas.

Saya merekomendasikan membaca poin-poin berikut dari C ++ FAQ Lite :

• Mengapa saya tidak bisa memisahkan definisi kelas templat dari deklarasi dan memasukkannya ke dalam file .cpp?
• Bagaimana saya bisa menghindari kesalahan linker dengan fungsi template saya?
• Bagaimana cara ekspor kata kunci C ++ membantu dengan kesalahan linker template?

Mereka masuk ke banyak detail tentang ini (dan lainnya) masalah template.

Bagi yang lain di halaman ini bertanya-tanya apa sintaks yang benar (seperti yang saya lakukan) untuk spesialisasi template eksplisit (atau setidaknya dalam VS2008), berikut ini ...

Dalam file .h Anda ...

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

Dan dalam file .cpp Anda

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

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

Kode ini terbentuk dengan baik. Anda hanya perlu memperhatikan bahwa definisi template terlihat pada titik instantiation. Mengutip standar, § 14.7.2.4:

Definisi templat fungsi yang tidak diekspor, templat fungsi anggota yang tidak diekspor, atau fungsi anggota yang tidak diekspor atau anggota data statis templat kelas harus ada di setiap unit terjemahan di mana ia secara eksplisit dipakai.

Ini akan berfungsi dengan baik di mana pun templat didukung. Instansiasi template eksplisit adalah bagian dari standar C ++.

Contoh Anda benar tetapi tidak terlalu portabel. Ada juga sintaks yang sedikit lebih bersih yang dapat digunakan (seperti yang ditunjukkan oleh @ namespace-sid).

Misalkan kelas templated adalah bagian dari beberapa perpustakaan yang akan dibagikan. Haruskah versi lain dari kelas templated dikompilasi? Apakah pengelola perpustakaan seharusnya mengantisipasi semua kemungkinan penggunaan kelas yang templated?

Pendekatan alternatif adalah sedikit variasi pada apa yang Anda miliki: tambahkan file ketiga yang merupakan file templat implementasi / instantiation.

file foo.h

// Standard header file guards omitted

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

file foo.cpp

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

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

file foo-impl.cpp

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

Satu peringatan adalah bahwa Anda perlu memberitahu kompiler untuk mengkompilasi, foo-impl.cppbukan foo.cppsebagai kompilasi yang terakhir tidak melakukan apa-apa.

Tentu saja, Anda dapat memiliki beberapa implementasi di file ketiga atau memiliki beberapa file implementasi untuk setiap jenis yang ingin Anda gunakan.

Ini memungkinkan lebih banyak fleksibilitas saat berbagi kelas templated untuk penggunaan lain.

Setup ini juga mengurangi waktu kompilasi untuk kelas yang digunakan kembali karena Anda tidak mengkompilasi ulang file header yang sama di setiap unit terjemahan.

Ini jelas bukan peretasan yang tidak menyenangkan, tetapi perhatikan fakta bahwa Anda harus melakukannya (spesialisasi templat eksplisit) untuk setiap kelas / jenis yang ingin Anda gunakan dengan templat yang diberikan. Dalam hal BANYAK jenis meminta instantiasi template mungkin ada BANYAK baris dalam file .cpp Anda. Untuk memperbaiki masalah ini, Anda dapat memiliki TemplateClassInst.cpp di setiap proyek yang Anda gunakan sehingga Anda memiliki kontrol yang lebih besar jenis apa yang akan dipakai. Jelas solusi ini tidak akan sempurna (alias peluru perak) karena Anda mungkin akhirnya melanggar ODR :).

Ada, dalam standar terbaru, kata kunci (export ) yang akan membantu meringankan masalah ini, tetapi tidak diterapkan dalam kompiler yang saya ketahui, selain Comeau.

Lihat FAQ-lite tentang ini.

Itu adalah cara standar untuk mendefinisikan fungsi template. Saya pikir ada tiga metode yang saya baca untuk mendefinisikan template. Atau mungkin 4. Masing-masing dengan pro dan kontra.

1. Definisikan dalam definisi kelas. Saya tidak suka ini sama sekali karena saya pikir definisi kelas hanya untuk referensi dan harus mudah dibaca. Namun jauh lebih sulit untuk mendefinisikan template di kelas daripada di luar. Dan tidak semua deklarasi templat memiliki tingkat kerumitan yang sama. Metode ini juga menjadikan templat sebagai templat yang benar.

2. Tetapkan template di header yang sama, tetapi di luar kelas. Ini adalah cara yang paling saya sukai sebagian besar waktu. Itu membuat definisi kelas Anda rapi, template tetap menjadi template yang sebenarnya. Namun itu membutuhkan penamaan template lengkap yang bisa rumit. Juga, kode Anda tersedia untuk semua. Tetapi jika Anda membutuhkan kode Anda untuk sebaris ini adalah satu-satunya cara. Anda juga dapat melakukannya dengan membuat file .INL di akhir definisi kelas Anda.

3. Sertakan header.h dan implementasi.CPP ke main.CPP Anda. Saya pikir itulah caranya. Anda tidak perlu menyiapkan pre instantiations apa pun, itu akan berperilaku seperti template yang benar. Masalah yang saya miliki dengan itu adalah bahwa itu tidak wajar. Kami biasanya tidak memasukkan dan berharap untuk memasukkan file sumber. Saya kira karena Anda memasukkan file sumber, fungsi template dapat diuraikan.

4. Metode terakhir ini, yang merupakan cara diposting, mendefinisikan template dalam file sumber, seperti nomor 3; tetapi alih-alih memasukkan file sumber, kami membuat instantiate templat ke templat yang akan kami butuhkan. Saya tidak memiliki masalah dengan metode ini dan kadang-kadang berguna. Kami memiliki satu kode besar, tidak dapat manfaat dari inline jadi masukkan saja ke dalam file CPP. Dan jika kita tahu contoh umum dan kita bisa menentukannya. Ini menyelamatkan kita dari menulis pada dasarnya hal yang sama 5, 10 kali. Metode ini memiliki keuntungan menjaga kode tetap milik kami. Tapi saya tidak merekomendasikan menempatkan fungsi kecil, yang biasa digunakan dalam file CPP. Karena ini akan mengurangi kinerja perpustakaan Anda.

Catatan, saya tidak mengetahui konsekuensi dari file obj yang membengkak.

Ya, itulah cara standar untuk melakukan instantiasi eksplisit khusus . Seperti yang Anda nyatakan, Anda tidak dapat membuat contoh template ini dengan tipe lain.

Edit: dikoreksi berdasarkan komentar.

Mari kita ambil satu contoh, katakanlah untuk beberapa alasan Anda ingin memiliki kelas templat:

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

Jika Anda mengkompilasi kode ini dengan Visual Studio - itu bekerja di luar kotak. gcc akan menghasilkan kesalahan tautan (jika file header yang sama digunakan dari banyak file .cpp):

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

Dimungkinkan untuk memindahkan implementasi ke file .cpp, tetapi kemudian Anda harus mendeklarasikan kelas seperti ini -

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

Dan kemudian .cpp akan terlihat seperti ini:

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

Tanpa dua baris terakhir dalam file header - gcc akan berfungsi dengan baik, tetapi Visual studio akan menghasilkan kesalahan:

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

sintaks kelas template adalah opsional jika Anda ingin mengekspos fungsi melalui ekspor .dll, tetapi ini hanya berlaku untuk platform windows - jadi test_template.h bisa terlihat seperti ini:

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

dengan file .cpp dari contoh sebelumnya.

Namun ini memberikan lebih banyak sakit kepala ke tautan, jadi disarankan untuk menggunakan contoh sebelumnya jika Anda tidak mengekspor fungsi .dll.

Waktunya untuk pembaruan! Buat file inline (.inl, atau mungkin yang lain) dan cukup salin semua definisi Anda di dalamnya. Pastikan untuk menambahkan templat di atas setiap fungsi ( template <typename T, ...>). Sekarang alih-alih memasukkan file header di file inline Anda melakukan sebaliknya. Sertakan file inline setelah deklarasi kelas Anda ( #include "file.inl").

Saya tidak benar-benar tahu mengapa tidak ada yang menyebutkan ini. Saya tidak melihat kelemahan langsung.

Tidak ada yang salah dengan contoh yang Anda berikan. Tetapi saya harus mengatakan saya percaya itu tidak efisien untuk menyimpan definisi fungsi dalam file cpp. Saya hanya mengerti kebutuhan untuk memisahkan deklarasi dan definisi fungsi.

Ketika digunakan bersama dengan instantiation kelas eksplisit, Boost Concept Check Library (BCCL) dapat membantu Anda menghasilkan kode fungsi template dalam file cpp.

Tidak ada yang di atas bekerja untuk saya, jadi di sini adalah bagaimana Anda menyelesaikannya, kelas saya hanya memiliki 1 metode templated ..

.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);
}

ini menghindari kesalahan penghubung, dan tidak perlu memanggil Fungsi Sementara sama sekali