0Pricing
C++ Academy · Pelajaran

std::function: Callable dengan Penghapusan Tipe

Sembunyikan tipe di balik std::function dan pahami optimasi buffer kecil

std::function: Callable dengan Penghapusan Tipe adalah pelajaran C++ Academy gratis di CoddyKit. Ini adalah pelajaran 4 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.

Masalahnya: Satu Tipe untuk Banyak Objek yang Dapat Dipanggil

Setiap lambda memiliki tipe unik. Setiap pointer fungsi juga memiliki tipe yang berbeda. Kita memerlukan satu tipe yang dapat menyimpan semuanya — std::function.

Parameter Templat

std::function<Signature> menerima tipe pengembalian dan tipe parameter. Ia menerima apa pun yang dapat dipanggil dengan tanda tangan tersebut.

#include <functional>
std::function<int(int, int)> op;
op = [](int a, int b) { return a + b; };
std::cout << op(3, 4);   // 7

Menyimpan Objek yang Dapat Dipanggil dengan Tipe Berbeda

Variabel std::function yang sama dapat menyimpan lambda, pointer fungsi, atau funktor — selama tanda tangannya cocok.

std::function<int(int)> f;
f = [](int x) { return x * 2; };       // lambda
f = ::abs;                              // function pointer
f = std::negate<int>{};                  // functor

Penghapusan Tipe

Secara internal, std::function menggunakan penghapusan tipe — ia menyimpan objek apa pun yang dapat dipanggil dan menyembunyikan tipe sebenarnya di balik antarmuka yang seragam. Implementasinya sering menggunakan alokasi heap kecil.

Biaya Kinerja

Pemanggilan melalui std::function melibatkan pemanggilan tidak langsung (mirip dengan fungsi virtual). Ini lebih lambat daripada pemanggilan lambda langsung. Hindari penggunaannya di jalur yang sering dijalankan.

Kapan Menggunakan std::function

Gunakan ketika:

  • Menyimpan callback dalam kontainer atau anggota kelas
  • Mengembalikan objek yang dapat dipanggil dari suatu fungsi
  • Membangun pengaya atau sistem peristiwa

std::function Kosong

std::function yang dibuat secara bawaan berada dalam keadaan kosong. Memanggilnya akan melempar std::bad_function_call.

std::function<void()> f;
if (f) f(); else std::cout << "no callback set";

Pointer Fungsi Anggota

Ikat fungsi anggota dengan std::bind atau bungkus dalam lambda.

struct Obj { void greet(int) {} };
Obj o;
std::function<void(int)> cb = [&](int n) { o.greet(n); };

Perbandingan dengan Pointer Fungsi

Pointer fungsi tidak dapat menyimpan status. std::function dapat menyimpannya — dengan konsekuensi berupa pemanggilan tidak langsung.

Perbandingan dengan Templat

Templat dengan parameter yang dapat dipanggil dispesialisasikan pada waktu kompilasi — paling cepat. std::function menyelesaikannya pada waktu berjalan — lebih lambat, tetapi fleksibel.

template <typename F>
void run(F f) { f(); }            // compile-time, no overhead

void run(std::function<void()> f) { f(); }   // runtime, type erasure

std::function dalam C++23: std::function_ref

C++23 menambahkan std::function_ref — tampilan non-pemilik untuk objek yang dapat dipanggil. Ini menghindari alokasi heap ketika masa hidupnya terbatas.

Alternatif

Tersedia alternatif yang lebih ringan: std::move_only_function (C++23), tl::function_ref, dan folly::Function. Pilih berdasarkan kebutuhan.

Pemeriksaan Singkat

Apa kelemahan utama std::function?

Rangkuman

std::function<Signature> menyimpan objek apa pun yang dapat dipanggil dengan tanda tangan yang cocok. Ini berguna untuk callback, pengaya, dan polimorfisme waktu berjalan pada objek yang dapat dipanggil — dengan konsekuensi berupa pemanggilan tidak langsung.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “std::function: Callable dengan Penghapusan Tipe” gratis?

Ya — teks lengkap “std::function: Callable dengan Penghapusan Tipe” 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 “std::function: Callable dengan Penghapusan Tipe”?

Sembunyikan tipe di balik std::function dan pahami optimasi buffer kecil 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 4 dari 4.

Berapa lama pelajaran “std::function: Callable dengan Penghapusan Tipe” 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. Objek Fungsi dan Functor
  2. Capture Lambda berdasarkan Nilai, Referensi, dan Mutable
  3. Lambda Generik dan Closure C++14
  4. std::function: Callable dengan Penghapusan Tipe
← Kembali ke C++ Academy