0Pricing
C++ Academy · Pelajaran

Polimorfisme Statis

Hindari overhead pemanggilan virtual

Polimorfisme Statis adalah pelajaran C++ Academy gratis di CoddyKit. Ini adalah pelajaran 2 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.

Dua Jenis Polimorfisme

C++ mendukung dua jenis polimorfisme.

  • Dinamis: fungsi virtual diselesaikan saat berjalan melalui tabel virtual
  • Statis: templat/CRTP diselesaikan saat kompilasi

Polimorfisme statis mengorbankan keluwesan demi kecepatan.

Biaya virtual

Pemanggilan virtual memerlukan lompatan tidak langsung melalui tabel virtual. Kompilator biasanya tidak dapat membuatnya inline, sehingga banyak optimasi terhalang.

#include <iostream>

struct Shape {
    virtual double area() const = 0;
    virtual ~Shape() = default;
};

struct Square : Shape {
    double s;
    Square(double x) : s(x) {}
    double area() const override { return s * s; }
};

int main() {
    Shape* p = new Square(3);
    std::cout << p->area() << "\n";
    delete p;
    return 0;
}

Pengiriman Statis dengan CRTP

Dengan CRTP, kelas dasar memanggil metode turunan secara langsung melalui konversi tipe saat kompilasi, sehingga kompilator dapat membuat semuanya inline.

#include <iostream>

template <typename T>
struct Shape {
    double area() const { return static_cast<const T*>(this)->area(); }
};

struct Square : Shape<Square> {
    double s;
    Square(double x) : s(x) {}
    double area() const { return s * s; }
};

int main() {
    Square sq(3);
    std::cout << sq.area() << "\n";
    return 0;
}

Penamaan Penerus

Ketika kelas dasar dan kelas turunan sama-sama mendefinisikan area, berikan nama yang berbeda kepada penerus kelas dasar, seperti compute, agar penerus tersebut secara jelas memanggil implementation milik kelas turunan.

#include <iostream>

template <typename T>
struct Shape {
    double compute() const { return static_cast<const T*>(this)->area(); }
};

struct Circle : Shape<Circle> {
    double r;
    Circle(double x) : r(x) {}
    double area() const { return 3.14159 * r * r; }
};

int main() {
    Circle c(2);
    std::cout << c.compute() << "\n";
    return 0;
}

Templat sebagai Polimorfisme Statis

Templat fungsi biasa juga merupakan polimorfisme statis: kode yang sama berfungsi untuk tipe apa pun yang menyediakan antarmuka yang diperlukan, atau pengetikan bebek saat kompilasi.

#include <iostream>

struct Dog { void speak() const { std::cout << "Woof\n"; } };
struct Cat { void speak() const { std::cout << "Meow\n"; } };

template <typename Animal>
void make_speak(const Animal& a) { a.speak(); }

int main() {
    make_speak(Dog{});
    make_speak(Cat{});
    return 0;
}

Saat Tipe Diketahui

Polimorfisme statis hanya berlaku ketika tipe konkret diketahui saat kompilasi. Jika Anda harus menyimpan objek heterogen dalam satu wadah dan memilih perilaku saat waktu proses, Anda tetap memerlukan fungsi virtual.

Tanpa Wadah Heterogen

Anda tidak dapat menempatkan Shape<Square> dan Shape<Circle> dalam std::vector yang sama sebagai satu kelas dasar bersama, karena keduanya merupakan tipe yang tidak saling terkait. Inilah keterbatasan utama polimorfisme statis.

Manfaat Kinerja

Dengan menyisipkan pemanggilan yang didispatch, kompilator dapat melipat konstanta dan menghilangkan overhead pemanggilan fungsi sepenuhnya. Dalam perulangan ketat pada satu tipe yang diketahui, polimorfisme statis dapat jauh lebih cepat.

#include <iostream>

template <typename T>
struct Op {
    int apply(int x) const { return static_cast<const T*>(this)->apply(x); }
};

struct Doubler : Op<Doubler> {
    int apply(int x) const { return x * 2; }
};

int main() {
    Doubler d;
    int sum = 0;
    for (int i = 0; i < 5; ++i) sum += d.apply(i);
    std::cout << sum << "\n";
    return 0;
}

Menggabungkan Keduanya

Anda dapat menggunakan CRTP untuk jalur kritis dan pembungkus virtual yang tipis ketika penghapusan tipe diperlukan. Dengan demikian, Anda memperoleh kecepatan di tempat yang penting dan fleksibilitas di tempat yang diperlukan.

Pemeriksaan Antarmuka Statis

Jika kelas turunan lupa mengimplementasikan metode yang diperlukan, kesalahan muncul saat kompilasi ketika penerus kelas dasar dibuat instansiasinya, bukan saat waktu proses.

#include <iostream>

template <typename T>
struct Greeter {
    void greet() const { static_cast<const T*>(this)->hello(); }
};

struct English : Greeter<English> {
    void hello() const { std::cout << "Hello\n"; }
};

int main() {
    English{}.greet();
    return 0;
}

Memilih Alat Right

Gunakan polimorfisme statis ketika:

  • Tipe diketahui saat kompilasi
  • Kinerja sangat penting
  • Anda tidak memerlukan tipe dasar bersama saat waktu proses

Jika tidak, pilih fungsi virtual untuk kejelasan dan fleksibilitas.

Uji Cepat

Pilih kompromi utama dari polimorfisme statis.

Ringkasan

Anda telah membandingkan polimorfisme statis dan dinamis.

  • Virtual = pemanggilan saat waktu proses, tabel virtual, wadah heterogen
  • CRTP/templat = pemanggilan saat kompilasi, dapat disisipkan, lebih cepat
  • Statis memerlukan tipe yang diketahui saat kompilasi
  • Pilih berdasarkan kebutuhan fleksibilitas dibanding kinerja

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Polimorfisme Statis” gratis?

Ya — teks lengkap “Polimorfisme Statis” 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 “Polimorfisme Statis”?

Hindari overhead pemanggilan virtual 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 2 dari 4.

Berapa lama pelajaran “Polimorfisme Statis” 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

  1. Idiom CRTP
  2. Polimorfisme Statis
  3. Mixin dengan CRTP
  4. Kapan Menggunakan CRTP
← Kembali ke C++ Academy