C ++ şablon işlev tanımlarını bir .CPP dosyasında depolama

Başlıkta satır içi yerine bir CPP dosyasında depolamak tercih ederim bazı şablon kodu var. Hangi şablon türlerinin kullanılacağını bildiğiniz sürece bunun yapılabileceğini biliyorum. Örneğin:

.h dosyası

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

.cpp dosyası

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

Son iki satırı not edin - foo :: do şablon işlevi yalnızca ints ve std :: dizeleri ile kullanılır, bu nedenle bu tanımlar uygulamanın bağlanacağı anlamına gelir.

Benim sorum - bu kötü bir kesmek mi yoksa bu diğer derleyiciler / bağlayıcılar ile çalışır mı? Şu anda sadece VS2008 ile bu kodu kullanıyorum ama diğer ortamlara bağlantı noktası isteyen olacak.

Açıkladığınız sorun, başlıkta şablon tanımlanarak veya yukarıda tarif ettiğiniz yaklaşımla çözülebilir.

C ++ FAQ Lite'tan aşağıdaki noktaları okumanızı tavsiye ederim :

• Neden şablon sınıfımın tanımını bildiriminden ayıramıyor ve .cpp dosyasının içine koyamıyorum?
• Şablon işlevlerimde bağlayıcı hatalarını nasıl önleyebilirim?
• C ++ anahtar kelime dışa aktarma, şablon bağlayıcı hatalarıyla nasıl yardımcı olur?

Bu (ve diğer) şablon sorunları hakkında birçok ayrıntıya girerler.

Bu sayfadaki açık şablon uzmanlığı (veya en azından VS2008'de) için doğru sözdiziminin (ben yaptığım gibi) ne olduğunu merak eden diğerleri için, bu ...

.H dosyanızda ...

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

Ve .cpp dosyanızda

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

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

Bu kod iyi biçimlendirilmiş. Yalnızca şablon tanımının örnekleme noktasında görünür olmasına dikkat etmeniz gerekir. Standardı teklif etmek için, § 14.7.2.4:

Dışa aktarılmayan bir işlev şablonunun, dışa aktarılmayan bir üye işlev şablonunun veya dışa aktarılmayan bir üye işlevinin veya bir sınıf şablonunun statik veri üyesinin tanımı, açıkça somutlaştırıldığı her çeviri biriminde bulunacaktır.

Bu, şablonların desteklendiği her yerde iyi çalışmalıdır. Açık şablon örneği C ++ standardının bir parçasıdır.

Örneğin doğru ama taşınabilir değil. Kullanılabilecek biraz daha temiz bir sözdizimi de vardır (@ namespace-sid tarafından belirtildiği gibi).

Şablonlu sınıfın paylaşılacak bazı kitaplığın parçası olduğunu varsayalım. Geçici sınıfın diğer sürümleri derlenmeli mi? Kütüphane sorumlusunun sınıfın olası tüm geçici kullanımlarını tahmin etmesi gerekiyor mu?

Alternatif bir yaklaşım, sahip olduğunuz şeyde küçük bir değişikliktir: şablon uygulama / örnekleme dosyası olan üçüncü bir dosya ekleyin.

foo.h dosyası

// Standard header file guards omitted

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

foo.cpp dosyası

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

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

foo-impl.cpp dosyası

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

Bir ihtar derlemek için derleyici söylemek gerekir ki foo-impl.cppyerine foo.cppikinci şey yapmaz derleme olarak.

Tabii ki, üçüncü dosyada birden fazla uygulamanız olabilir veya kullanmak istediğiniz her tür için birden çok uygulama dosyanız olabilir.

Bu, tempolu sınıfı diğer kullanımlar için paylaşırken çok daha fazla esneklik sağlar.

Bu kurulum, her çeviri biriminde aynı başlık dosyasını yeniden derlemediğiniz için yeniden kullanılan sınıflar için derleme sürelerini de azaltır.

Bu kesinlikle kötü bir hack değil, ancak verilen şablonla kullanmak istediğiniz her sınıf / tip için bunu yapmak zorunda kalacağınızın (açık şablon uzmanlığı) farkında olun. Şablon örneğini isteyen birçok türde ise .cpp dosyanızda çok sayıda satır olabilir. Bu sorunu gidermek için, kullandığınız her projede bir TemplateClassInst.cpp dosyası olabilir, böylece hangi türlerin somutlaştırılacağını daha iyi kontrol edebilirsiniz. Açıkçası bu çözüm mükemmel olmayacak (aka gümüş mermi), çünkü ODR'yi kırabilirsin :).

En son standartta, exportbu sorunu hafifletmeye yardımcı olacak bir anahtar kelime ( ) vardır, ancak Comeau dışında bildiğim hiçbir derleyicide uygulanmaz.

Bununla ilgili SSS lite'ye bakın .

Bu, şablon işlevlerini tanımlamanın standart bir yoludur. Şablonları tanımlamak için okuduğum üç yöntem olduğunu düşünüyorum. Ya da muhtemelen 4. Her biri artıları ve eksileri ile.

1. Sınıf tanımını tanımlar. Bunu hiç sevmiyorum çünkü sınıf tanımlarının kesinlikle referans olduğunu ve okunması kolay olduğunu düşünüyorum. Ancak, sınıftaki şablonları tanımlamak dışarıdan çok daha az zordur. Ve tüm şablon bildirimleri aynı karmaşıklık düzeyinde değildir. Bu yöntem ayrıca şablonu gerçek bir şablon haline getirir.

2. Şablonu aynı üstbilgide, ancak sınıfın dışında tanımlayın. Çoğu zaman bu benim tercih ettiğim yol. Sınıf tanımınızı düzenli tutar, şablon gerçek bir şablon olarak kalır. Bununla birlikte, zor olabilen tam şablon adlandırma gerektirir. Ayrıca, kodunuz herkes tarafından kullanılabilir. Ancak kodunuzun satır içi olması gerekiyorsa, bu tek yoldur. Bunu, sınıf tanımlarınızın sonunda bir .INL dosyası oluşturarak da gerçekleştirebilirsiniz.

3. Header.h ve application.CPP dosyasını main.CPP'nize ekleyin. Bence böyle yapılır. Herhangi bir ön somut örnek hazırlamanız gerekmeyecek, gerçek bir şablon gibi davranacaktır. Bununla ilgili sorunum, doğal olmaması. Normalde kaynak dosyaları eklemeyiz ve eklemeyi ummayız. Kaynak dosyayı eklediğiniz için, şablon işlevleri satır içine alınabilir.

4. Gönderilen yol olan bu son yöntem, tıpkı 3 numaralı gibi bir kaynak dosyadaki şablonları tanımlamaktır; ancak kaynak dosyayı eklemek yerine, şablonları ihtiyacımız olanlara önceden başlatırız. Bu yöntemle ilgili hiçbir sorunum yok ve bazen kullanışlı oluyor. Büyük bir kodumuz var, satır içi olmaktan yararlanamaz, bu yüzden sadece bir CPP dosyasına koyun. Ve ortak örneklemeleri biliyorsak ve bunları önceden tanımlayabilirsek. Bu da aynı şeyi 5, 10 kez yazmamızı sağlıyor. Bu yöntem, kodumuzu özel tutma avantajına sahiptir. Ancak CPP dosyalarına küçük, düzenli olarak kullanılan işlevler koymanızı önermiyorum. Bu, kütüphanenizin performansını azaltacağından.

Şişirilmiş obj dosyasının sonuçlarının farkında değilim.

Evet, uzmanlaşma açık örneklemenin standart yolu budur . Belirttiğiniz gibi, bu şablonu başka türlerle başlatamazsınız.

Düzenle: yoruma göre düzeltildi.

Bir örnek verelim, bir nedenden dolayı bir şablon sınıfına sahip olmak istediğinizi varsayalım:

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

Bu kodu Visual Studio ile derlerseniz - kutunun dışında çalışır. gcc, bağlayıcı hatası üretir (birden çok .cpp dosyasından aynı başlık dosyası kullanılırsa):

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

Uygulamayı .cpp dosyasına taşımak mümkündür, ancak daha sonra böyle bir sınıf bildirmeniz gerekir -

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

Ve sonra .cpp şöyle görünecektir:

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

Başlık dosyasında son iki satır olmadan - gcc düzgün çalışır, ancak Visual studio bir hata oluşturur:

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

.dll dışa aktarma yoluyla işlevi göstermek istiyorsanız şablon sınıfı sözdizimi isteğe bağlıdır, ancak bu yalnızca Windows platformu için geçerlidir - bu nedenle test_template.h şöyle görünebilir:

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

önceki örnekten .cpp dosyasıyla.

Ancak bu, bağlayıcıya daha fazla baş ağrısı verir, bu nedenle .dll işlevini dışa aktarmazsanız önceki örneği kullanmanız önerilir.

Güncelleme zamanı! Bir satır içi (.inl veya muhtemelen başka bir) dosya oluşturun ve tüm tanımlarınızı bu dosyaya kopyalayın. Şablonu her işlevin ( template <typename T, ...>) üstüne eklediğinizden emin olun . Şimdi başlık dosyasını satır içi dosyaya eklemek yerine bunun tam tersini yaparsınız. Sınıfınızın ( ) bildiriminden sonra satır içi dosyayı ekleyin #include "file.inl".

Kimsenin bundan neden bahsetmediğini gerçekten bilmiyorum. Anında herhangi bir dezavantaj görmüyorum.

Verdiğiniz örnekte yanlış bir şey yok. Ancak işlev tanımlarını bir cpp dosyasında saklamanın etkili olmadığına inandığımı söylemeliyim. Yalnızca işlevin bildirimini ve tanımını ayırma ihtiyacını anlıyorum.

Açık sınıf örnekleme ile birlikte kullanıldığında, Boost Concept Check Library (BCCL), cpp dosyalarında şablon işlev kodu oluşturmanıza yardımcı olabilir.

Yukarıdakilerin hiçbiri benim için çalışmadı, bu yüzden nasıl çözdüm, sınıfımda sadece 1 yöntem şablonu var ..

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

Bu, bağlayıcı hatalarını önler ve TemporaryFunction'u çağırmanıza gerek yoktur