C++ Academy · Pelajaran

Idiom CRTP

Pola template yang berulang secara unik

Idiom CRTP adalah pelajaran C++ Academy gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar C++ Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus C++ Academy mencakup 4 pelajaran total.

Apa Itu CRTP?

Pola Templat Berulang yang Menarik (CRTP) adalah idiom C++ yang membuat suatu kelas Derived mewarisi kelas dasar templat yang dibuat dengan Derived itu sendiri.

Shape: class Derived : public Base<Derived>
Kelas dasar mengetahui tipe turunannya saat kompilasi

template <typename T>
class Base {};

class Derived : public Base<Derived> {};

Mekanisme Inti

Di dalam kelas dasar, Anda dapat melakukan static_cast pada penunjuk this ke tipe turunan. Karena tipe turunan merupakan parameter templat, ini adalah konversi tipe sepenuhnya saat kompilasi tanpa biaya saat berjalan.

#include <iostream>

template <typename T>
class Base {
public:
    void interface() {
        static_cast<T*>(this)->implementation();
    }
};

class Derived : public Base<Derived> {
public:
    void implementation() { std::cout << "Derived impl\n"; }
};

int main() {
    Derived d;
    d.interface();
    return 0;
}

Mengapa "Berulang yang Menarik"?

Nama tersebut berasal dari paradoks yang tampak: kelas dasar merujuk ke kelas turunan, yang belum sepenuhnya didefinisikan ketika templat kelas dasar ditulis.

Ini berfungsi karena templat hanya dibuat saat digunakan
Pada saat pembuatan, Derived adalah tipe lengkap

Penggunaan Nyata Pertama

CRTP memungkinkan kelas dasar menyediakan fungsionalitas yang dapat digunakan kembali dan memanggil kembali kelas turunan. Di sini, kelas dasar menyediakan print() yang meneruskan panggilan ke name() milik kelas turunan.

#include <iostream>
#include <string>

template <typename T>
struct Named {
    void print() {
        std::cout << static_cast<T*>(this)->name() << "\n";
    }
};

struct Cat : Named<Cat> {
    std::string name() { return "Cat"; }
};

int main() {
    Cat c;
    c.print();
    return 0;
}

Tanpa Tabel Virtual

Berbeda dari polimorfisme saat berjalan, CRTP tidak memerlukan kata kunci virtual maupun penunjuk tabel virtual di setiap objek. Pengiriman ditentukan sepenuhnya saat kompilasi.

Objek lebih kecil, tanpa penunjuk tersembunyi
Pemanggilan dapat dibuat inline

Menghitung Instans

Salah satu penerapan klasik CRTP adalah penghitung objek. Setiap kelas turunan secara otomatis mendapatkan penghitung statisnya sendiri.

#include <iostream>

template <typename T>
struct Counter {
    static inline int count = 0;
    Counter() { ++count; }
    ~Counter() { --count; }
};

struct Widget : Counter<Widget> {};

int main() {
    Widget a, b;
    std::cout << Widget::count << "\n";
    return 0;
}

Setiap Derived Mendapatkan Keadaannya Sendiri

Karena Counter<Widget> dan Counter<Gadget> merupakan pembuatan templat yang berbeda, masing-masing memiliki count statis yang independen. Pemisahan ini tidak mungkin dilakukan dengan satu kelas dasar non-templat.

#include <iostream>

template <typename T>
struct Counter {
    static inline int count = 0;
    Counter() { ++count; }
};

struct A : Counter<A> {};
struct B : Counter<B> {};

int main() {
    A a1, a2;
    B b1;
    std::cout << A::count << " " << B::count << "\n";
    return 0;
}

static_cast Aman di Sini

Konversi ke tipe turunan di dalam kelas dasar aman hanya jika setiap objek bertipe Base<T> benar-benar merupakan T. CRTP menjamin hal ini berdasarkan konstruksinya, karena T adalah kelas yang mewarisi.

Jangan pernah membuat Base<Wrong> untuk kelas yang tidak berkaitan

Operator Perbandingan melalui CRTP

Anda dapat menghasilkan satu set lengkap operator perbandingan dari satu operator< dengan mewarisi pembantu perbandingan.

#include <iostream>

template <typename T>
struct Comparable {
    friend bool operator>(const T& a, const T& b) { return b < a; }
    friend bool operator==(const T& a, const T& b) { return !(a < b) && !(b < a); }
};

struct Num : Comparable<Num> {
    int v;
    Num(int x) : v(x) {}
    friend bool operator<(const Num& a, const Num& b) { return a.v < b.v; }
};

int main() {
    std::cout << (Num(3) > Num(2)) << "\n";
    return 0;
}

Pengaman Konstruktor Terlindungi

Untuk mencegah penyalahgunaan kelas dasar secara tidak sengaja, berikan konstruktor protected agar hanya kelas turunan yang dapat membuatnya.

#include <iostream>

template <typename T>
class Base {
protected:
    Base() = default;
public:
    void run() { static_cast<T*>(this)->step(); }
};

class Job : public Base<Job> {
public:
    void step() { std::cout << "step\n"; }
};

int main() {
    Job j;
    j.run();
    return 0;
}

CRTP dalam Pustaka Standar

CRTP muncul di berbagai pustaka C++ nyata.

std::enable_shared_from_this<T> menggunakannya
Banyak pustaka matematika templat ekspresi, seperti Eigen, bergantung padanya
Pembantu rentang dan pengiterasi menggunakan pola serupa

Mengenali pola X : Base<X> membantu Anda membaca kode tingkat lanjut.

Pemeriksaan Singkat

Uji pemahaman Anda tentang pola CRTP.

Rangkuman

Anda telah mempelajari idiom CRTP.

Derived : Base<Derived> memberikan tipe konkretnya kepada kelas dasar
static_cast<T*>(this) memungkinkan pengiriman saat kompilasi
Tanpa tabel virtual, objek lebih kecil, dan pemanggilan dapat dibuat inline
Digunakan untuk penghitung, komponen campuran perbandingan, dan pembantu pustaka

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Idiom CRTP” gratis?

Ya — teks lengkap “Idiom CRTP” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus C++ Academy, upgrade ke CoddyKit PRO. Kursus C++ Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Idiom CRTP”?

Pola template yang berulang secara unik Kamu berlatih C++ Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai C++ Academy?

Tidak diperlukan pengalaman sebelumnya. C++ Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.

Berapa lama pelajaran “Idiom CRTP” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran C++ Academy ini?

Ya. Setiap pelajaran C++ Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke C++ Academy