C++ Academy · Pelajaran

std::function

Simpan callable apa pun

std::function 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.

Apa Itu std::function

std::function adalah pembungkus dengan penghapusan tipe yang dapat menampung objek apa pun yang dapat dipanggil dan cocok dengan tanda tangan tertentu: fungsi bebas, lambda, funktor, atau ekspresi terikat.

Dideklarasikan menggunakan tanda tangan tujuan.
Tersedia dalam <functional>.

#include <iostream>
#include <functional>

int add(int a, int b) { return a + b; }

int main() {
    std::function<int(int, int)> f = add;
    std::cout << f(2, 3) << '\n';
    return 0;
}

Menyimpan Lambda

Berbeda dari penunjuk fungsi mentah, std::function dapat menyimpan lambda dengan mudah, bahkan lambda yang memiliki tangkapan.

#include <iostream>
#include <functional>

int main() {
    int offset = 10;
    std::function<int(int)> f = [offset](int x) { return x + offset; };
    std::cout << f(5) << '\n';
    return 0;
}

Menyimpan Funktor

Funktor adalah objek dengan operator(). std::function dapat membungkusnya dan memanggil operator tersebut saat dipanggil.

#include <iostream>
#include <functional>

struct Multiplier {
    int factor;
    int operator()(int x) const { return x * factor; }
};

int main() {
    std::function<int(int)> f = Multiplier{3};
    std::cout << f(4) << '\n';
    return 0;
}

Menetapkan Ulang Sasaran

Satu variabel std::function dapat merujuk ke objek yang dapat dipanggil berbeda selama masa hidupnya, sehingga berguna untuk menukar perilaku saat program berjalan.

#include <iostream>
#include <functional>

int main() {
    std::function<int(int)> f = [](int x) { return x + 1; };
    std::cout << f(10) << '\n';
    f = [](int x) { return x * x; };
    std::cout << f(10) << '\n';
    return 0;
}

std::function Kosong

std::function yang dibuat secara bawaan tidak menyimpan apa pun. Memanggilnya akan menghasilkan std::bad_function_call, jadi periksa terlebih dahulu.

#include <iostream>
#include <functional>

int main() {
    std::function<void()> f;
    if (f) {
        f();
    } else {
        std::cout << "empty\n";
    }
    return 0;
}

Sebagai Parameter

Fungsi dapat menerima parameter std::function untuk menerima objek apa pun yang dapat dipanggil dan cocok, sehingga API menjadi fleksibel.

#include <iostream>
#include <functional>

void repeat(int n, const std::function<void(int)>& action) {
    for (int i = 0; i < n; ++i) action(i);
}

int main() {
    repeat(3, [](int i) { std::cout << "step " << i << '\n'; });
    return 0;
}

Menyimpan Fungsi Panggil Balik

Salah satu penggunaan umum adalah menyimpan fungsi panggil balik sebagai anggota kelas agar dapat dipanggil nanti saat suatu peristiwa terjadi.

#include <iostream>
#include <functional>

struct Button {
    std::function<void()> onClick;
    void click() { if (onClick) onClick(); }
};

int main() {
    Button b;
    b.onClick = [] { std::cout << "clicked!\n"; };
    b.click();
    return 0;
}

Vektor Objek yang Dapat Dipanggil

Karena memiliki satu tipe yang sama, objek yang dapat dipanggil dengan jenis berbeda dapat disimpan bersama dalam sebuah wadah dan dipanggil secara bergantian.

#include <iostream>
#include <functional>
#include <vector>

int inc(int x) { return x + 1; }

int main() {
    std::vector<std::function<int(int)>> ops;
    ops.push_back(inc);
    ops.push_back([](int x) { return x * 2; });
    for (auto& op : ops) std::cout << op(10) << ' ';
    std::cout << '\n';
    return 0;
}

Biaya Penghapusan Tipe

std::function mungkin mengalokasikan memori dan menambahkan pemanggilan tidak langsung, sehingga sedikit lebih lambat daripada pemanggilan langsung atau objek yang dapat dipanggil berbasis templat. Gunakan std::function saat Anda memerlukan penyimpanan yang seragam.

#include <iostream>
#include <functional>

int main() {
    std::function<int()> f = [] { return 42; };
    int total = 0;
    for (int i = 0; i < 5; ++i) total += f();
    std::cout << total << '\n';
    return 0;
}

Mengembalikan std::function

Fungsi pembuat dapat membuat dan mengembalikan objek yang dapat dipanggil dengan konfigurasi tertentu, sehingga pemanggil dapat memperoleh perilaku yang disesuaikan.

#include <iostream>
#include <functional>

std::function<int(int)> adder(int n) {
    return [n](int x) { return x + n; };
}

int main() {
    auto add5 = adder(5);
    std::cout << add5(10) << '\n';
    return 0;
}

Membandingkan dengan Penunjuk Fungsi

std::function lebih fleksibel daripada penunjuk fungsi karena dapat menyimpan keadaan, tetapi fleksibilitas tersebut sedikit mengurangi kinerja dan mungkin memerlukan alokasi.

#include <iostream>
#include <functional>

int main() {
    int base = 7;
    std::function<int(int)> stateful = [base](int x) { return x + base; };
    std::cout << "Stateful result: " << stateful(3) << '\n';
    return 0;
}

Pemeriksaan Singkat

Uji pemahaman Anda tentang std::function.

Ringkasan

Anda telah mempelajari bahwa std::function:

membungkus objek apa pun yang dapat dipanggil dan cocok dengan tandanya, termasuk lambda dan funktor yang memiliki keadaan
dapat ditetapkan ulang, disimpan dalam wadah, dan dikembalikan dari fungsi pembuat
menghasilkan bad_function_call saat kosong
menimbulkan sedikit biaya tambahan akibat penghapusan tipe

Selanjutnya, Anda akan menggunakan std::bind untuk mengisi sebagian argumen objek yang dapat dipanggil terlebih dahulu.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “std::function” gratis?

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

Simpan callable apa pun 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 “std::function” 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