C++ Academy · Pelajaran

std::function

Simpan sebarang objek boleh panggil

Pelajaran 2 daripada 413 langkah

std::function ialah pelajaran C++ Academy percuma di CoddyKit. Ini ialah pelajaran 2 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran C++ Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus C++ Academy merangkumi sejumlah 4 pelajaran.

Apakah std::function?

std::function ialah pembungkus yang menyembunyikan jenis konkrit dan boleh menyimpan apa-apa objek boleh panggil yang sepadan dengan tandatangan tertentu: fungsi bebas, fungsi lambda, funktor atau ungkapan terikat.

Diisytiharkan menggunakan tandatangan sasaran.
Ditetapkan 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 Fungsi Lambda

Berbeza daripada penuding fungsi biasa, std::function boleh menyimpan fungsi lambda dengan mudah, termasuk fungsi lambda yang mempunyai 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 ialah objek yang mempunyai operator(). std::function boleh membungkusnya dan memanggil operatornya apabila ia 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 Semula Sasaran

Satu pemboleh ubah std::function boleh merujuk kepada objek boleh panggil yang berbeza sepanjang hayatnya, yang berguna untuk menukar tingkah laku semasa masa jalan.

#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 dibina secara lalai tidak menyimpan apa-apa. Memanggilnya akan melontar std::bad_function_call, jadi uji dahulu.

#include <iostream>
#include <functional>

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

Sebagai Parameter

Fungsi boleh menerima parameter std::function untuk menerima apa-apa objek boleh panggil yang sepadan, lalu menjadikan antara muka pengaturcaraan lebih 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 Panggilan Balik

Salah satu kegunaan biasa ialah menyimpan panggilan balik sebagai ahli kelas supaya ia boleh dipanggil kemudian apabila sesuatu peristiwa berlaku.

#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 Boleh Panggil

Oleh sebab semuanya berkongsi satu jenis, objek boleh panggil yang berbeza boleh disimpan bersama dalam bekas dan dipanggil satu demi satu.

#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;
}

Kos Pemadaman Jenis

std::function mungkin memperuntukkan memori dan menambah panggilan tidak langsung, jadi ia sedikit lebih perlahan berbanding panggilan terus atau objek boleh panggil berasaskan templat. Gunakannya apabila anda memerlukan penyimpanan 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;
}

Memulangkan std::function

Fungsi kilang boleh membina dan memulangkan objek boleh panggil yang telah dikonfigurasi, lalu membolehkan pemanggil mendapatkan tingkah laku tersuai.

#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 Penuding Fungsi

std::function lebih fleksibel daripada penuding fungsi kerana ia boleh menyimpan keadaan, tetapi fleksibiliti itu mengurangkan sedikit prestasi dan mungkin memerlukan peruntukan memori.

#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;
}

Semakan Pantas

Uji pemahaman anda tentang std::function.

Jawab dalam pelajaran interaktif

Imbas Kembali

Anda telah mempelajari bahawa std::function:

membungkus apa-apa objek boleh panggil yang sepadan dengan tandatangannya, termasuk fungsi lambda berkeadaan dan funktor
boleh ditetapkan semula, disimpan dalam bekas dan dipulangkan daripada fungsi kilang
melontar bad_function_call apabila kosong
menanggung sedikit lebihan daripada pemadaman jenis

Seterusnya, anda akan menggunakan std::bind untuk mengisi awal argumen objek boleh panggil.

Percuma untuk bermula

Pelajari C++ dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 51
Pelajaran: 203

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “std::function” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran C++ Academy, termasuk “std::function”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus C++ Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “std::function”?

Simpan sebarang objek boleh panggil Anda berlatih C++ Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan C++ Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran C++ Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 2 daripada 4.

Berapa lamakah pelajaran “std::function” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran C++ Academy ini?

Ya. Setiap pelajaran C++ Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke C++ Academy