C++ Academy · บทเรียน

เมื่อใดควรใช้ CRTP

ข้อแลกเปลี่ยนและข้อควรระวัง

เมื่อใดควรใช้ CRTP เป็นบทเรียน C++ Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน C++ Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส C++ Academy มีบทเรียนทั้งหมด 4 บทเรียน

เครื่องมือทรงพลังแต่ต้องใช้อย่างระมัดระวัง

CRTP มีพลังมาก แต่ทำให้โค้ดซับซ้อนขึ้น บทเรียนนี้ครอบคลุมกรณีที่การใช้ CRTP คุ้มค่าและข้อควรระวังที่ควรหลีกเลี่ยง

เหมาะสำหรับ: เส้นทางการทำงานที่ต้องการความเร็ว

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

เหมาะสำหรับ: พฤติกรรมที่นำกลับมาใช้ใหม่

CRTP เหมาะอย่างยิ่งสำหรับการเพิ่มพฤติกรรมที่นำกลับมาใช้ใหม่ได้ เช่น ตัวนับ การเปรียบเทียบ และการทำอนุกรม ซึ่งต้องเรียกย้อนกลับไปยังประเภทจริง

#include <iostream>
#include <string>

template <typename T>
struct Serializable {
    void save() const { std::cout << static_cast<const T*>(this)->serialize() << "\n"; }
};

struct Config : Serializable<Config> {
    std::string serialize() const { return "config-data"; }
};

int main() {
    Config{}.save();
    return 0;
}

ข้อควรระวัง: ไม่มีประเภทร่วมขณะทำงาน

หากผู้เรียกต้องการประเภทเดียวขณะทำงานเพื่อเก็บรูปร่างหลายแบบไว้ด้วยกัน CRTP จะไม่ช่วยแก้ปัญหา เนื่องจากการสร้างอินสแตนซ์แต่ละครั้งเป็นคนละประเภทกัน

ต้องการโครงสร้างเก็บข้อมูลแบบพหุสัณฐานหรือไม่ ควรใช้ฟังก์ชันเสมือน

ข้อควรระวัง: ข้อผิดพลาดที่อ่านเข้าใจยาก

ข้อความข้อผิดพลาดของ CRTP อาจยาวและทำความเข้าใจได้ยาก เพราะมักแสดงลึกลงไปภายในการสร้างอินสแตนซ์ของแม่แบบ การระบุประเภทสืบทอดผิดใน Base<Wrong> อาจยังคอมไพล์ผ่าน จนกว่าจะมีการเรียกใช้ฟังก์ชันสมาชิกที่ไม่มีอยู่

ข้อควรระวัง: ประเภทสืบทอดไม่ถูกต้อง

การส่งประเภทที่ไม่ถูกต้องให้ฐานจะทำลายข้อตกลงของ static_cast และก่อให้เกิดพฤติกรรมไม่กำหนด ควรเขียน Derived : Base<Derived> โดยใช้ชื่อที่ตรงกันเสมอ

#include <iostream>

template <typename T>
struct Base {
    void go() { static_cast<T*>(this)->step(); }
};

struct Right : Base<Right> {
    void step() { std::cout << "ok\n"; }
};

int main() {
    Right{}.go();
    return 0;
}

ทางเลือก: std::variant

เมื่อคุณมีชุดประเภทที่กำหนดตายตัวและต้องการความหมายแบบค่า การใช้ std::variant ร่วมกับ std::visit จะให้การเลือกเรียกขณะคอมไพล์โดยไม่ต้องสืบทอด และมักเข้าใจได้ง่ายกว่า CRTP

#include <iostream>
#include <variant>

struct Add { int operator()(int a, int b) { return a + b; } };
struct Mul { int operator()(int a, int b) { return a * b; } };

int main() {
    std::variant<Add, Mul> op = Mul{};
    int r = std::visit([](auto f) { return f(3, 4); }, op);
    std::cout << r << "\n";
    return 0;
}

ทางเลือก: Concepts (C++20)

สำหรับการตรวจสอบส่วนติดต่อขณะคอมไพล์เพียงอย่างเดียว concepts ของ C++20 มักใช้แทน CRTP ได้ โดยจำกัดแม่แบบและให้ข้อความข้อผิดพลาดที่เข้าใจง่ายกว่าโดยไม่ต้องสืบทอด

ข้อแลกเปลี่ยนด้านความอ่านง่าย

CRTP เพิ่มกลไกแม่แบบที่ผู้เริ่มต้นอาจอ่านได้ยาก ควรใช้เมื่อประโยชน์ด้านประสิทธิภาพหรือการนำกลับมาใช้ใหม่มีมากกว่าความซับซ้อนที่เพิ่มขึ้นอย่างชัดเจน

ข้อควรพิจารณาด้านการบำรุงรักษา

CRTP ทำให้ฐานและประเภทสืบทอดเชื่อมโยงกันอย่างแน่นหนา การปรับโครงสร้างส่วนติดต่อของคลาสเจ้าของอาจส่งผลต่อมิกซ์อินทุกตัว ควรบันทึกฟังก์ชันสมาชิกที่คลาสเจ้าของต้องมีไว้อย่างชัดเจน

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

รายการตรวจสอบเพื่อการตัดสินใจ

ควรเลือกใช้ CRTP เมื่อ:

ต้องการการเลือกเรียกแบบคงที่เพื่อความเร็ว
ต้องการเพิ่มพฤติกรรมที่เรียกเข้าไปยังประเภทจริง
ไม่จำเป็นต้องมีฐานร่วมขณะทำงาน
ความซับซ้อนนั้นคุ้มค่า

มิฉะนั้น ควรพิจารณาฟังก์ชันเสมือน ชนิดแปรผัน หรือแนวคิด

ตรวจสอบความเข้าใจ

เลือกทางเลือกที่ดีที่สุดเมื่อคุณต้องการประเภทร่วมขณะทำงาน

สรุปทบทวน

คุณได้เรียนรู้ว่า CRTP เหมาะกับกรณีใด

เหมาะอย่างยิ่งสำหรับเส้นทางการทำงานที่ต้องการความเร็วและพฤติกรรมเรียกกลับที่นำกลับมาใช้ใหม่
ไม่เหมาะเมื่อจำเป็นต้องมีประเภทร่วมขณะทำงาน
ควรระวังข้อผิดพลาดที่อ่านเข้าใจยากและการใช้ประเภทผิด
ทางเลือกอื่น: ฟังก์ชันเสมือน, std::variant และแนวคิดของ C++20

คำถามที่พบบ่อย

บทเรียน “เมื่อใดควรใช้ CRTP” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “เมื่อใดควรใช้ CRTP” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส C++ Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส C++ Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “เมื่อใดควรใช้ CRTP”

ข้อแลกเปลี่ยนและข้อควรระวัง คุณปฏิบัติ C++ Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน C++ Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน C++ Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน

บทเรียน “เมื่อใดควรใช้ CRTP” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน C++ Academy นี้ได้ไหม

ได้ บทเรียน C++ Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ C++ Academy