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

std::bind

ผูกอาร์กิวเมนต์เข้ากับสิ่งที่เรียกใช้งานได้

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

std::bind คืออะไร

std::bind สร้างสิ่งที่เรียกใช้งานได้ใหม่โดยกำหนดอาร์กิวเมนต์บางส่วนไว้ล่วงหน้าให้กับสิ่งที่มีอยู่เดิม การทำเช่นนี้เรียกว่าการประยุกต์บางส่วน

  • อยู่ใน <functional>
  • ส่งคืนออบเจ็กต์ที่เรียกใช้งานได้ซึ่งไม่ได้ระบุชนิด
#include <iostream>
#include <functional>

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

int main() {
    auto add10 = std::bind(add, 10, 5);
    std::cout << add10() << '\n';
    return 0;
}

ตัวแทนอาร์กิวเมนต์

ตัวแทนอาร์กิวเมนต์ เช่น std::placeholders::_1 ใช้ระบุอาร์กิวเมนต์ที่จะส่งให้ภายหลังเมื่อเรียกใช้ออบเจ็กต์ที่ผูกไว้

#include <iostream>
#include <functional>

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

int main() {
    using namespace std::placeholders;
    auto add10 = std::bind(add, 10, _1);
    std::cout << add10(7) << '\n';
    return 0;
}

การจัดลำดับอาร์กิวเมนต์ใหม่

ตัวแทนอาร์กิวเมนต์สามารถปรากฏในลำดับใดก็ได้ ทำให้คุณสลับตำแหน่งของอาร์กิวเมนต์ที่ผู้เรียกส่งมาได้

#include <iostream>
#include <functional>

int sub(int a, int b) { return a - b; }

int main() {
    using namespace std::placeholders;
    auto flipped = std::bind(sub, _2, _1);
    std::cout << flipped(3, 10) << '\n';
    return 0;
}

การผูกอาร์กิวเมนต์หลายตัว

คุณสามารถกำหนดอาร์กิวเมนต์หลายตัวไว้ล่วงหน้าพร้อมกัน และปล่อยตัวอื่นไว้เป็นตัวแทนอาร์กิวเมนต์ได้

#include <iostream>
#include <functional>

int volume(int l, int w, int h) { return l * w * h; }

int main() {
    using namespace std::placeholders;
    auto box = std::bind(volume, 2, _1, 5);
    std::cout << box(3) << '\n';
    return 0;
}

การเก็บผลลัพธ์

ออบเจ็กต์ที่ std::bind ส่งคืนสามารถเก็บไว้ใน std::function เพื่อให้มีชนิดที่เป็นรูปธรรมและมีชื่อเรียกได้

#include <iostream>
#include <functional>

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

int main() {
    using namespace std::placeholders;
    std::function<int(int)> add100 = std::bind(add, 100, _1);
    std::cout << add100(1) << '\n';
    return 0;
}

การผูกฟังก์ชันสมาชิก

std::bind สามารถกำหนดเป้าหมายเป็นฟังก์ชันสมาชิกได้ โดยส่งพอยน์เตอร์สมาชิกและออบเจ็กต์หรือตัวแทนอาร์กิวเมนต์สำหรับ this

#include <iostream>
#include <functional>

struct Counter {
    int add(int x) { return value += x; }
    int value = 0;
};

int main() {
    using namespace std::placeholders;
    Counter c;
    auto bump = std::bind(&Counter::add, &c, _1);
    std::cout << bump(5) << ' ' << bump(3) << '\n';
    return 0;
}

การผูกด้วยค่าเทียบกับการอ้างอิง

โดยค่าเริ่มต้น อาร์กิวเมนต์ที่ผูกไว้จะถูกคัดลอก ให้ห่ออาร์กิวเมนต์หนึ่งตัวด้วย std::ref เพื่อผูกด้วยการอ้างอิงและทำให้มองเห็นการเปลี่ยนแปลงได้

#include <iostream>
#include <functional>

void addTo(int& target, int amount) { target += amount; }

int main() {
    using namespace std::placeholders;
    int total = 0;
    auto acc = std::bind(addTo, std::ref(total), _1);
    acc(5);
    acc(10);
    std::cout << total << '\n';
    return 0;
}

การใช้สิ่งที่เรียกใช้งานได้ที่ผูกไว้ในอัลกอริทึม

สิ่งที่เรียกใช้งานได้ที่ผูกไว้สามารถใช้เป็นเงื่อนไขหรือการดำเนินการในอัลกอริทึมมาตรฐานได้

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

bool greaterThan(int x, int limit) { return x > limit; }

int main() {
    using namespace std::placeholders;
    std::vector<int> v = {1, 5, 8, 2, 9};
    auto over4 = std::bind(greaterThan, _1, 4);
    std::cout << std::count_if(v.begin(), v.end(), over4) << '\n';
    return 0;
}

การซ้อนการผูก

นิพจน์การผูกสามารถประกอบเข้าด้วยกันได้ แต่จะอ่านได้ยากอย่างรวดเร็ว ตัวแทนอาร์กิวเมนต์แต่ละตัวยังคงอ้างถึงอาร์กิวเมนต์ของผู้เรียกในขั้นสุดท้าย

#include <iostream>
#include <functional>

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

int main() {
    using namespace std::placeholders;
    auto f = std::bind(add, std::bind(times, 2, _1), 3);
    std::cout << f(5) << '\n';
    return 0;
}

การละเว้นอาร์กิวเมนต์ส่วนเกิน

หากการเรียกที่ผูกไว้ใช้ตัวแทนอาร์กิวเมนต์เพียงบางตัว อาร์กิวเมนต์ส่วนเกินที่ส่งในขณะเรียกใช้จะถูกละเว้นไปโดยอัตโนมัติ

#include <iostream>
#include <functional>

int show(int a) { return a; }

int main() {
    using namespace std::placeholders;
    auto f = std::bind(show, _1);
    std::cout << f(42, 99, 100) << '\n';
    return 0;
}

เมื่อแลมบ์ดาอ่านเข้าใจง่ายกว่า

C++ สมัยใหม่มักเลือกใช้แลมบ์ดาแทน std::bind เพราะอ่านเข้าใจได้ง่ายกว่า และคอมไพเลอร์ปรับปรุงประสิทธิภาพให้ได้ดีกว่า

#include <iostream>
#include <functional>

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

int main() {
    auto add10 = [](int x) { return add(10, x); };
    std::cout << add10(5) << '\n';
    return 0;
}

ตรวจสอบอย่างรวดเร็ว

ทดสอบความเข้าใจของคุณเกี่ยวกับตัวแทนอาร์กิวเมนต์

สรุปทบทวน

คุณได้เรียนรู้วิธีทำงานของ std::bind:

  • กำหนดอาร์กิวเมนต์บางตัวไว้ล่วงหน้า และใช้ตัวแทนอาร์กิวเมนต์ _1, _2 สำหรับส่วนที่เหลือ
  • สามารถจัดลำดับอาร์กิวเมนต์ใหม่ ผูกฟังก์ชันสมาชิก และใช้ std::ref ได้
  • สามารถเก็บผลลัพธ์ไว้ใน std::function และใช้ในอัลกอริทึมได้
  • แลมบ์ดามักอ่านเข้าใจได้ง่ายกว่าใน C++ สมัยใหม่

ถัดไป คุณจะเปรียบเทียบแลมบ์ดา การผูก และพอยน์เตอร์ฟังก์ชัน เพื่อเลือกเครื่องมือที่เหมาะสม

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

บทเรียน “std::bind” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “std::bind”

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

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

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

บทเรียน “std::bind” ใช้เวลานานแค่ไหน

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

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

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

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

  1. พอยน์เตอร์ฟังก์ชัน
  2. std::function
  3. std::bind
  4. การเลือกสิ่งที่เรียกใช้งานได้
← กลับไปที่ C++ Academy