0Pricing
C++ Academy · บทเรียน

std::function และออบเจ็กต์เรียกใช้ที่ลบชนิด

ซ่อนชนิดไว้เบื้องหลัง std::function และทำความเข้าใจการเพิ่มประสิทธิภาพบัฟเฟอร์ขนาดเล็ก

std::function และออบเจ็กต์เรียกใช้ที่ลบชนิด เป็นบทเรียน C++ Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน C++ Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส C++ Academy มีบทเรียนทั้งหมด 4 บทเรียน

ปัญหา: ชนิดเดียวสำหรับสิ่งที่เรียกใช้งานได้หลายแบบ

แลมบ์ดาแต่ละตัวมีชนิดเฉพาะ ตัวชี้ฟังก์ชันแต่ละตัวก็มีชนิดต่างกัน เราต้องการชนิดเดียวที่เก็บสิ่งเหล่านี้ได้ทั้งหมด นั่นคือ std::function

พารามิเตอร์แม่แบบ

std::function<Signature> รับชนิดผลลัพธ์และชนิดของพารามิเตอร์ โดยรับสิ่งใด ๆ ที่เรียกใช้งานได้ตามลายเซ็นนั้น

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

การจัดเก็บสิ่งที่เรียกใช้งานได้ต่างชนิดกัน

ตัวแปร std::function เดียวกันสามารถเก็บแลมบ์ดา ตัวชี้ฟังก์ชัน หรือฟังก์เตอร์ได้ ตราบใดที่ลายเซ็นตรงกัน

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

การลบชนิด

ภายใน std::function ใช้การลบชนิด จึงจัดเก็บสิ่งที่เรียกใช้งานได้ทุกชนิดและซ่อนชนิดจริงไว้เบื้องหลังส่วนเชื่อมต่อแบบเดียวกัน โดยมักทำงานด้วยการจัดสรรหน่วยความจำบนฮีปขนาดเล็ก

ต้นทุนด้านประสิทธิภาพ

การเรียกผ่าน std::function เกี่ยวข้องกับการเรียกทางอ้อม ซึ่งคล้ายกับฟังก์ชันเสมือน และช้ากว่าการเรียกแลมบ์ดาโดยตรง หลีกเลี่ยงการใช้ในเส้นทางการทำงานที่สำคัญต่อประสิทธิภาพ

เมื่อใดควรใช้ std::function

ใช้เมื่อ:

  • จัดเก็บการเรียกกลับไว้ในคอนเทนเนอร์หรือสมาชิกของคลาส
  • คืนค่าสิ่งที่เรียกใช้งานได้จากฟังก์ชัน
  • สร้างระบบปลั๊กอินหรือระบบเหตุการณ์

std::function ว่าง

std::function ที่สร้างด้วยค่าเริ่มต้นจะว่างเปล่า การเรียกใช้งานจะทำให้เกิดข้อยกเว้น std::bad_function_call

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

ตัวชี้ฟังก์ชันสมาชิก

ผูกฟังก์ชันสมาชิกด้วย std::bind หรือห่อฟังก์ชันนั้นไว้ในแลมบ์ดา

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

เปรียบเทียบกับตัวชี้ฟังก์ชัน

ตัวชี้ฟังก์ชันไม่สามารถเก็บสถานะได้ แต่ std::function ทำได้ โดยต้องแลกกับการเรียกทางอ้อม

เปรียบเทียบกับแม่แบบ

แม่แบบที่มีพารามิเตอร์เป็นสิ่งที่เรียกใช้งานได้จะสร้างรูปแบบเฉพาะขณะคอมไพล์ จึงเร็วที่สุด ส่วน std::function จะตัดสินใจขณะทำงาน จึงช้ากว่าแต่ยืดหยุ่นกว่า

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

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

std::function ใน C++23: std::function_ref

C++23 เพิ่ม std::function_ref ซึ่งเป็นมุมมองแบบไม่ถือครองสิทธิ์ของสิ่งที่เรียกใช้งานได้ จึงหลีกเลี่ยงการจัดสรรหน่วยความจำบนฮีปได้เมื่อกำหนดอายุการใช้งานไว้อย่างชัดเจน

ทางเลือกอื่น

มีทางเลือกน้ำหนักเบา เช่น std::move_only_function (C++23), tl::function_ref และ folly::Function เลือกใช้ตามความต้องการ

ตรวจสอบความเข้าใจ

ข้อเสียหลักของ std::function คืออะไร

สรุป

std::function<Signature> จัดเก็บสิ่งที่เรียกใช้งานได้ทุกชนิดที่มีลายเซ็นตรงกัน มีประโยชน์สำหรับการเรียกกลับ ปลั๊กอิน และพหุสัณฐานขณะทำงานกับสิ่งที่เรียกใช้งานได้ แต่ต้องแลกกับการเรียกทางอ้อม

คำถามที่พบบ่อย

บทเรียน “std::function และออบเจ็กต์เรียกใช้ที่ลบชนิด” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “std::function และออบเจ็กต์เรียกใช้ที่ลบชนิด” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส C++ Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส C++ Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “std::function และออบเจ็กต์เรียกใช้ที่ลบชนิด”

ซ่อนชนิดไว้เบื้องหลัง std::function และทำความเข้าใจการเพิ่มประสิทธิภาพบัฟเฟอร์ขนาดเล็ก คุณปฏิบัติ C++ Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน C++ Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน C++ Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน

บทเรียน “std::function และออบเจ็กต์เรียกใช้ที่ลบชนิด” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน C++ Academy นี้ได้ไหม

ได้ บทเรียน C++ Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. ออบเจ็กต์ฟังก์ชันและฟังก์เตอร์
  2. การจับค่าของแลมบ์ดาแบบค่า แบบรีเฟอเรนซ์ และ mutable
  3. แลมบ์ดาทั่วไปและคลอเชอร์ใน C++14
  4. std::function และออบเจ็กต์เรียกใช้ที่ลบชนิด
← กลับไปที่ C++ Academy