การจัดเก็บนิยามฟังก์ชันเท็มเพลต 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&);

หมายเหตุสองบรรทัดสุดท้าย - ฟังก์ชั่นเทมเพลต foo :: do ใช้กับสตริง ints และ std :: เท่านั้นดังนั้นคำจำกัดความเหล่านั้นจึงหมายความว่าแอปจะลิงก์

คำถามของฉันคือ - แฮ็คนี้น่ารังเกียจหรือจะใช้กับคอมไพเลอร์ / ลิงเกอร์คนอื่นได้หรือไม่? ฉันใช้รหัสนี้กับ VS2008 เท่านั้นในขณะนี้ แต่จะต้องการพอร์ตไปยังสภาพแวดล้อมอื่น ๆ

ปัญหาที่คุณอธิบายสามารถแก้ไขได้โดยการกำหนดแม่แบบในส่วนหัวหรือผ่านวิธีการที่คุณอธิบายข้างต้น

ฉันแนะนำให้อ่านประเด็นต่อไปนี้จากC ++ FAQ Lite :

• ทำไมฉันไม่สามารถแยกนิยามของคลาสเทมเพลตของฉันออกจากการประกาศและวางไว้ในไฟล์. cpp
• ฉันจะหลีกเลี่ยงข้อผิดพลาด linker ด้วยฟังก์ชั่นแม่แบบของฉันได้อย่างไร
• การส่งออกคำหลัก C ++ ช่วยด้วยแม่แบบข้อผิดพลาด linker ได้อย่างไร

พวกเขามีรายละเอียดมากมายเกี่ยวกับปัญหาเทมเพลตเหล่านี้ (และอื่น ๆ )

สำหรับคนอื่น ๆ ในหน้านี้สงสัยว่าไวยากรณ์ที่ถูกต้องคืออะไร (เช่นเดียวกับฉัน) สำหรับความเชี่ยวชาญเทมเพลตอย่างชัดเจน (หรืออย่างน้อยใน VS2008) มันมีดังต่อไปนี้ ...

ในไฟล์. 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)

สมมติว่าคลาส templated เป็นส่วนหนึ่งของไลบรารีบางอย่างที่จะแชร์ คลาสอื่นที่มีเทมเพลตควรรวบรวมหรือไม่ ผู้ดูแลห้องสมุดควรคาดหวังการใช้งานเทมเพลตที่เป็นไปได้ทั้งหมดหรือไม่?

วิธีอื่นคือความผันแปรเล็กน้อยในสิ่งที่คุณมี: เพิ่มไฟล์ที่สามซึ่งเป็นไฟล์การนำไปใช้งาน / การสร้างอินสแตนซ์

ไฟล์ 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>;

ข้อแม้หนึ่งคือคุณต้องบอกให้คอมไพเลอร์คอมไพล์foo-impl.cppแทนการคอมไพล์foo.cppหลังไม่ได้ทำอะไรเลย

แน่นอนว่าคุณสามารถมีการนำไปใช้งานหลายไฟล์ในไฟล์ที่สามหรือมีไฟล์การนำไปใช้หลายไฟล์สำหรับแต่ละประเภทที่คุณต้องการใช้

สิ่งนี้ช่วยให้มีความยืดหยุ่นมากขึ้นเมื่อแบ่งปันคลาส templated สำหรับการใช้งานอื่น

การตั้งค่านี้ยังช่วยลดเวลาในการคอมไพล์สำหรับคลาสที่นำกลับมาใช้ใหม่เนื่องจากคุณไม่ได้ทำการคอมไพล์ไฟล์ส่วนหัวซ้ำกันในแต่ละหน่วยการแปล

นี่ไม่ใช่แฮ็คที่น่ารังเกียจอย่างแน่นอน แต่ระวังให้ดีว่าคุณจะต้องทำมัน (ความเชี่ยวชาญด้านเทมเพลตอย่างชัดเจน) สำหรับทุกคลาส / ประเภทที่คุณต้องการใช้กับเทมเพลตที่กำหนด ในกรณีที่มีหลายประเภทที่ขอให้สร้างอินสแตนซ์ของเท็มเพลตอาจมีบรรทัดจำนวนมากในไฟล์. cpp ของคุณ เพื่อแก้ไขปัญหานี้คุณสามารถมี TemplateClassInst.cpp ในทุกโครงการที่คุณใช้เพื่อให้คุณสามารถควบคุมประเภทที่จะอินสแตนซ์ได้ดียิ่งขึ้น เห็นได้ชัดว่าวิธีนี้จะไม่สมบูรณ์แบบ (กระสุนเงินหรือที่รู้จักกันดี) เนื่องจากคุณอาจต้องทำลาย ODR :)

มีอยู่ในมาตรฐานล่าสุดคือคำหลัก ( export) ที่จะช่วยบรรเทาปัญหานี้ แต่ก็ไม่ได้นำไปใช้กับคอมไพเลอร์ที่ฉันรับรู้นอกเหนือจาก Comeau

ดูคำถามที่พบบ่อยเกี่ยวกับเรื่องนี้

นั่นเป็นวิธีมาตรฐานในการกำหนดฟังก์ชั่นเทมเพลต ฉันคิดว่ามีสามวิธีที่ฉันอ่านเพื่อกำหนดแม่แบบ หรืออาจเป็น 4. แต่ละคนมีข้อดีข้อเสีย

1. กำหนดในคำจำกัดความของชั้นเรียน ฉันไม่ชอบสิ่งนี้เลยเพราะฉันคิดว่าคำจำกัดความของชั้นเรียนมีไว้เพื่ออ้างอิงอย่างเคร่งครัดและควรอ่านง่าย อย่างไรก็ตามมันมีความยุ่งยากน้อยกว่ามากในการกำหนดแม่แบบในชั้นเรียนนอก และไม่ใช่การประกาศเทมเพลตทั้งหมดที่อยู่ในระดับความซับซ้อนเดียวกัน วิธีนี้ยังทำให้แม่แบบเป็นแม่แบบที่แท้จริง

2. กำหนดเทมเพลตในส่วนหัวเดียวกัน แต่นอกคลาส นี่เป็นวิธีที่ฉันชอบมากที่สุด มันทำให้คลาสของคุณเป็นระเบียบเรียบร้อยเทมเพลตยังคงเป็นเทมเพลตจริง อย่างไรก็ตามต้องมีการตั้งชื่อแม่แบบเต็มรูปแบบซึ่งอาจยุ่งยาก นอกจากนี้โค้ดของคุณก็มีให้สำหรับทุกคน แต่ถ้าคุณต้องการให้โค้ดของคุณเป็นแบบอินไลน์นี่เป็นวิธีเดียวเท่านั้น คุณยังสามารถทำสิ่งนี้ได้โดยสร้างไฟล์. INL ท้ายคำจำกัดความของคลาส

3. รวมส่วนหัว. h และการนำไปปฏิบัติ CPP ใน main.CPP ของคุณ ฉันคิดว่านั่นเป็นวิธีที่ทำได้ คุณไม่ต้องเตรียมอินสแตนซ์ล่วงหน้าใด ๆ มันจะทำตัวเหมือนเทมเพลตจริง ปัญหาที่ฉันมีกับมันคือมันไม่เป็นธรรมชาติ ปกติแล้วเราจะไม่รวมและคาดว่าจะรวมไฟล์ต้นฉบับ ฉันเดาว่าเนื่องจากคุณรวมไฟล์ต้นฉบับไว้แล้วฟังก์ชันเทมเพลตก็สามารถแทรกเข้ามาได้

4. วิธีสุดท้ายนี้ซึ่งเป็นวิธีการโพสต์กำหนดแม่แบบในไฟล์ต้นฉบับเช่นเดียวกับหมายเลข 3 แต่แทนที่จะรวมไฟล์ต้นฉบับไว้เราจะสร้างอินเทอร์เฟซให้กับเทมเพลตที่เราต้องการ ฉันไม่มีปัญหากับวิธีนี้และบางครั้งมันก็มีประโยชน์ เรามีหนึ่งรหัสขนาดใหญ่มันไม่สามารถได้รับประโยชน์จากการถูก inline ดังนั้นเพียงแค่ใส่มันในไฟล์ CPP และถ้าเรารู้อินสแตนซ์ทั่วไปและเราสามารถกำหนดไว้ล่วงหน้าได้ สิ่งนี้ช่วยเราจากการเขียนโดยพื้นฐานสิ่งเดียวกัน 5, 10 ครั้ง วิธีนี้มีประโยชน์ในการรักษารหัสของเราไว้ แต่ฉันไม่แนะนำให้ใส่ฟังก์ชั่นเล็ก ๆ ที่ใช้เป็นประจำในไฟล์ CPP เช่นนี้จะลดประสิทธิภาพของห้องสมุดของคุณ

หมายเหตุฉันไม่ได้ตระหนักถึงผลที่ตามมาของไฟล์ obj ป่อง

ใช่นั่นเป็นวิธีมาตรฐานในการทำspecializiation instantiation ชัดเจน ตามที่คุณระบุคุณไม่สามารถยกตัวอย่างเทมเพลตนี้ด้วยประเภทอื่น ๆ

แก้ไข: แก้ไขตามความคิดเห็น

ลองมาตัวอย่างหนึ่งสมมติว่าด้วยเหตุผลบางอย่างที่คุณต้องการมีคลาสเทมเพลต:

//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 จะสร้างข้อผิดพลาด linker (หากไฟล์ส่วนหัวเดียวกันถูกใช้จากไฟล์. 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");
}

หากไม่มีสองบรรทัดสุดท้ายในไฟล์ส่วนหัว - 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 จากตัวอย่างก่อนหน้า

อย่างไรก็ตามสิ่งนี้จะทำให้ปวดหัวกับ linker ได้มากกว่าดังนั้นจึงแนะนำให้ใช้ตัวอย่างก่อนหน้าถ้าคุณไม่ส่งออกฟังก์ชัน. dll

ได้เวลาอัพเดทแล้ว! สร้างไฟล์อินไลน์ (.inl หรือไฟล์อื่น ๆ ) และคัดลอกคำจำกัดความของคุณทั้งหมดในนั้น อย่าลืมเพิ่มเทมเพลตด้านบนแต่ละฟังก์ชัน ( template <typename T, ...>) ตอนนี้แทนที่จะรวมไฟล์ส่วนหัวในไฟล์อินไลน์ที่คุณทำตรงกันข้าม รวมไฟล์อินไลน์หลังจากการประกาศคลาสของคุณ ( #include "file.inl")

ฉันไม่รู้จริง ๆ ว่าทำไมไม่มีใครพูดถึงเรื่องนี้ ฉันไม่เห็นข้อเสียทันที

ไม่มีอะไรผิดปกติกับตัวอย่างที่คุณให้ แต่ฉันต้องบอกว่าฉันเชื่อว่ามันไม่มีประสิทธิภาพในการจัดเก็บคำจำกัดความของฟังก์ชั่นในไฟล์ cpp ฉันเข้าใจเฉพาะความต้องการแยกการประกาศและคำจำกัดความของฟังก์ชัน

เมื่อใช้ร่วมกับการสร้างคลาสอินสแตนซ์ชัดแจ้ง Boost Concept Check Library (BCCL) สามารถช่วยคุณสร้างโค้ดฟังก์ชันเทมเพลตในไฟล์ cpp

ไม่มีข้อใดถูกใช้งานได้สำหรับฉันดังนั้นนี่คือวิธีที่ y แก้ไขชั้นเรียนของฉันมีวิธีการ 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);
}

เป็นการหลีกเลี่ยงข้อผิดพลาดของ linker และไม่จำเป็นต้องเรียกใช้ TemporaryFunction เลย