ใน C ++ คุณใช้ฟังก์ชันโทรกลับเมื่อใดและอย่างไร

แก้ไข:
ฉันต้องการจะดูตัวอย่างง่ายๆในการเขียนฟังก์ชั่นการโทรกลับ

หมายเหตุ: คำตอบส่วนใหญ่ครอบคลุมฟังก์ชั่นพอยน์เตอร์ซึ่งเป็นความเป็นไปได้หนึ่งในการบรรลุตรรกะ "การเรียกกลับ" ใน C ++ แต่ ณ วันนี้ไม่ใช่สิ่งที่ดีที่สุดที่ฉันคิด

อะไรคือ callbacks (?) และทำไมถึงใช้มัน (!)

การเรียกกลับเป็นcallable (ดูเพิ่มเติมลง) รับการยอมรับจากชั้นเรียนหรือฟังก์ชั่นที่ใช้ในการปรับแต่งตรรกะปัจจุบันขึ้นอยู่กับการโทรกลับที่

เหตุผลหนึ่งที่ใช้ callbacks คือการเขียนรหัสทั่วไปซึ่งเป็นอิสระจากตรรกะในฟังก์ชั่นที่เรียกว่าและสามารถนำกลับมาใช้กับการเรียกกลับที่แตกต่างกัน

ฟังก์ชั่นมากมายของห้องสมุดอัลกอริธึมมาตรฐาน<algorithm>ใช้การเรียกกลับ ตัวอย่างเช่นfor_eachอัลกอริทึมจะใช้การโทรกลับแบบ unary กับทุกรายการในช่วงตัววนซ้ำ:

template<class InputIt, class UnaryFunction>
UnaryFunction for_each(InputIt first, InputIt last, UnaryFunction f)
{
  for (; first != last; ++first) {
    f(*first);
  }
  return f;
}

ซึ่งสามารถนำมาใช้เพื่อเพิ่มครั้งแรกแล้วพิมพ์เวกเตอร์โดยผ่าน callables ที่เหมาะสมเช่น:

std::vector<double> v{ 1.0, 2.2, 4.0, 5.5, 7.2 };
double r = 4.0;
std::for_each(v.begin(), v.end(), [&](double & v) { v += r; });
std::for_each(v.begin(), v.end(), [](double v) { std::cout << v << " "; });

ซึ่งพิมพ์

5 6.2 8 9.5 11.2

แอปพลิเคชันอื่นของการเรียกกลับคือการแจ้งเตือนผู้โทรของเหตุการณ์บางอย่างซึ่งทำให้มีความยืดหยุ่นในเวลาที่กำหนด

ส่วนตัวแล้วฉันใช้ไลบรารี่เพิ่มประสิทธิภาพท้องถิ่นที่ใช้การโทรกลับสองแบบ

• การเรียกกลับครั้งแรกจะถูกเรียกใช้ถ้าต้องการค่าฟังก์ชันและการไล่ระดับสีตามเวกเตอร์ของค่าอินพุตที่ต้องการ (การโทรกลับแบบลอจิก: การกำหนดค่าฟังก์ชัน / การไล่ระดับสีที่ได้มา)
• การเรียกกลับที่สองถูกเรียกหนึ่งครั้งสำหรับแต่ละขั้นตอนวิธีและรับข้อมูลบางอย่างเกี่ยวกับการรวมกันของอัลกอริทึม (การเรียกกลับการแจ้งเตือน)

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

นอกจากนี้การเรียกกลับสามารถเปิดใช้งานพฤติกรรมรันไทม์แบบไดนามิก

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

void player_jump();
void player_crouch();

class game_core
{
    std::array<void(*)(), total_num_keys> actions;
    // 
    void key_pressed(unsigned key_id)
    {
        if(actions[key_id]) actions[key_id]();
    }
    // update keybind from menu
    void update_keybind(unsigned key_id, void(*new_action)())
    {
        actions[key_id] = new_action;
    }
};

ฟังก์ชั่นkey_pressedนี้ใช้การเรียกกลับที่เก็บไว้ในactionsการรับพฤติกรรมที่ต้องการเมื่อกดปุ่มบางปุ่ม หากผู้เล่นเลือกที่จะเปลี่ยนปุ่มสำหรับกระโดดเครื่องยนต์สามารถเรียก

game_core_instance.update_keybind(newly_selected_key, &player_jump);

และเปลี่ยนพฤติกรรมของการโทรเป็นkey_pressed(ซึ่งการโทรplayer_jump) เมื่อกดปุ่มนี้ในเกมครั้งต่อไป

callablesใน C ++ คืออะไร(11)?

ดูแนวคิด C ++: Callable on cppreference สำหรับคำอธิบายที่เป็นทางการมากขึ้น

ฟังก์ชั่นการโทรกลับสามารถรับรู้ได้ในหลายวิธีใน C ++ (11) ตั้งแต่สิ่งที่แตกต่างกันหลายเปิดออกเพื่อจะcallable * :

• ตัวชี้ฟังก์ชั่น (รวมถึงตัวชี้ไปยังฟังก์ชั่นสมาชิก)
• std::function วัตถุ
• นิพจน์แลมบ์ดา
• ผูกมัดนิพจน์
• วัตถุฟังก์ชัน (คลาสที่มีตัวดำเนินการเรียกฟังก์ชันมากเกินไปoperator())

_{* หมายเหตุ: ตัวชี้ไปยังข้อมูลสมาชิกสามารถเรียกใช้ได้เช่นกัน แต่ไม่มีฟังก์ชั่นใด ๆ เลย}

วิธีสำคัญหลายวิธีในการเขียนรายละเอียดการโทรกลับ

• X.1 "การเขียน" การโทรกลับในโพสต์นี้หมายถึงไวยากรณ์ที่จะประกาศและตั้งชื่อประเภทการโทรกลับ
• X.2 "Calling" การโทรกลับหมายถึงไวยากรณ์เพื่อเรียกวัตถุเหล่านั้น
• X.3 "การใช้" การโทรกลับหมายถึงไวยากรณ์เมื่อส่งอาร์กิวเมนต์ไปยังฟังก์ชันที่ใช้การโทรกลับ

หมายเหตุ: ตั้งแต่ C ++ 17 การโทรเช่นf(...)สามารถเขียนได้std::invoke(f, ...)ซึ่งยังจัดการตัวชี้ไปยังกรณีที่สมาชิก

1. พอยน์เตอร์ฟังก์ชั่น

ตัวชี้ฟังก์ชั่นคือ 'ง่ายที่สุด' (ในแง่ทั่วไป, ในแง่ของการอ่านเนื้อหาที่เลวร้ายที่สุด) ประเภทโทรกลับสามารถมี

มามีฟังก์ชั่นง่าย ๆfooกัน:

int foo (int x) { return 2+x; }

1.1 การเขียนตัวชี้ฟังก์ชัน / สัญกรณ์ประเภท

ประเภทตัวชี้ฟังก์ชั่นที่มีสัญกรณ์

return_type (*)(parameter_type_1, parameter_type_2, parameter_type_3)
// i.e. a pointer to foo has the type:
int (*)(int)

โดยที่ประเภทตัวชี้ฟังก์ชั่นที่มีชื่อจะมีลักษณะเช่น

return_type (* name) (parameter_type_1, parameter_type_2, parameter_type_3)

// i.e. f_int_t is a type: function pointer taking one int argument, returning int
typedef int (*f_int_t) (int); 

// foo_p is a pointer to function taking int returning int
// initialized by pointer to function foo taking int returning int
int (* foo_p)(int) = &foo; 
// can alternatively be written as 
f_int_t foo_p = &foo;

usingประกาศจะช่วยให้เราเลือกที่จะทำในสิ่งที่เล็กน้อยอ่านได้มากขึ้นตั้งแต่typedefสำหรับf_int_tยังสามารถเขียนเป็น:

using f_int_t = int(*)(int);

โดยที่ (อย่างน้อยสำหรับฉัน) เป็นที่ชัดเจนว่าf_int_tเป็นนามแฝงประเภทใหม่และการรับรู้ของประเภทตัวชี้ฟังก์ชั่นก็ง่ายขึ้น

และการประกาศฟังก์ชันที่ใช้การเรียกกลับของฟังก์ชันประเภทตัวชี้จะเป็น:

// foobar having a callback argument named moo of type 
// pointer to function returning int taking int as its argument
int foobar (int x, int (*moo)(int));
// if f_int is the function pointer typedef from above we can also write foobar as:
int foobar (int x, f_int_t moo);

1.2 สัญกรณ์โทรกลับ

สัญกรณ์การโทรเป็นไปตามไวยากรณ์การเรียกใช้ฟังก์ชันอย่างง่าย:

int foobar (int x, int (*moo)(int))
{
    return x + moo(x); // function pointer moo called using argument x
}
// analog
int foobar (int x, f_int_t moo)
{
    return x + moo(x); // function pointer moo called using argument x
}

1.3 รูปแบบการใช้งานโทรกลับและประเภทที่รองรับ

ฟังก์ชั่นการโทรกลับใช้ตัวชี้ฟังก์ชั่นสามารถเรียกใช้ฟังก์ชั่นพอยน์เตอร์

การใช้ฟังก์ชั่นที่ใช้การโทรกลับของตัวชี้ฟังก์ชั่นนั้นค่อนข้างง่าย:

 int a = 5;
 int b = foobar(a, foo); // call foobar with pointer to foo as callback
 // can also be
 int b = foobar(a, &foo); // call foobar with pointer to foo as callback

1.4 ตัวอย่าง

ฟังก์ชั่น ca สามารถเขียนได้โดยไม่ต้องพึ่งพาวิธีการโทรกลับ:

void tranform_every_int(int * v, unsigned n, int (*fp)(int))
{
  for (unsigned i = 0; i < n; ++i)
  {
    v[i] = fp(v[i]);
  }
}

ที่เป็นไปได้การเรียกกลับเป็นไปได้

int double_int(int x) { return 2*x; }
int square_int(int x) { return x*x; }

ใช้เหมือน

int a[5] = {1, 2, 3, 4, 5};
tranform_every_int(&a[0], 5, double_int);
// now a == {2, 4, 6, 8, 10};
tranform_every_int(&a[0], 5, square_int);
// now a == {4, 16, 36, 64, 100};

2. ชี้ไปยังฟังก์ชันสมาชิก

ตัวชี้ไปยังฟังก์ชั่นสมาชิก (บางคลาสC) เป็นตัวชี้ฟังก์ชั่นชนิดพิเศษ (และซับซ้อนยิ่งขึ้น) ซึ่งต้องใช้วัตถุประเภทCเพื่อดำเนินการ

struct C
{
    int y;
    int foo(int x) const { return x+y; }
};

2.1 การเขียนตัวชี้ไปยังฟังก์ชันสมาชิก / สัญลักษณ์ชนิด

ชี้ไปยังสมาชิกประเภทฟังก์ชั่นสำหรับการเรียนบางส่วนTมีสัญกรณ์

// can have more or less parameters
return_type (T::*)(parameter_type_1, parameter_type_2, parameter_type_3)
// i.e. a pointer to C::foo has the type
int (C::*) (int)

โดยที่ตัวชี้ที่ตั้งชื่อไว้กับฟังก์ชั่นสมาชิกจะ - คล้ายกับตัวชี้ฟังก์ชัน - มีลักษณะดังนี้:

return_type (T::* name) (parameter_type_1, parameter_type_2, parameter_type_3)

// i.e. a type `f_C_int` representing a pointer to member function of `C`
// taking int returning int is:
typedef int (C::* f_C_int_t) (int x); 

// The type of C_foo_p is a pointer to member function of C taking int returning int
// Its value is initialized by a pointer to foo of C
int (C::* C_foo_p)(int) = &C::foo;
// which can also be written using the typedef:
f_C_int_t C_foo_p = &C::foo;

ตัวอย่าง: การประกาศฟังก์ชันที่ใช้ตัวชี้ไปยังฟังก์ชันสมาชิกเรียกกลับเป็นหนึ่งในอาร์กิวเมนต์:

// C_foobar having an argument named moo of type pointer to member function of C
// where the callback returns int taking int as its argument
// also needs an object of type c
int C_foobar (int x, C const &c, int (C::*moo)(int));
// can equivalently declared using the typedef above:
int C_foobar (int x, C const &c, f_C_int_t moo);

2.2 สัญกรณ์โทรกลับ

ตัวชี้ไปยังฟังก์ชันสมาชิกของCสามารถถูกเรียกใช้ด้วยความเคารพกับวัตถุชนิดCโดยใช้การดำเนินการเข้าถึงสมาชิกบนตัวชี้การลงทะเบียน หมายเหตุ: ต้องใส่วงเล็บ!

int C_foobar (int x, C const &c, int (C::*moo)(int))
{
    return x + (c.*moo)(x); // function pointer moo called for object c using argument x
}
// analog
int C_foobar (int x, C const &c, f_C_int_t moo)
{
    return x + (c.*moo)(x); // function pointer moo called for object c using argument x
}

หมายเหตุ: หากตัวชี้ไปยังCพร้อมใช้งานไวยากรณ์จะเท่ากัน (โดยที่ตัวชี้ไปยังCต้องถูกยกเลิกการลงทะเบียนด้วย):

int C_foobar_2 (int x, C const * c, int (C::*meow)(int))
{
    if (!c) return x;
    // function pointer meow called for object *c using argument x
    return x + ((*c).*meow)(x); 
}
// or equivalent:
int C_foobar_2 (int x, C const * c, int (C::*meow)(int))
{
    if (!c) return x;
    // function pointer meow called for object *c using argument x
    return x + (c->*meow)(x); 
}

2.3 รูปแบบการใช้โทรกลับและประเภทที่รองรับ

ฟังก์ชั่นการโทรกลับการชี้ฟังก์ชันสมาชิกของชั้นเรียนสามารถเรียกใช้ตัวชี้ฟังก์ชันสมาชิกของชั้นเรียนTT

การใช้ฟังก์ชันที่ใช้เป็นตัวชี้ไปยังฟังก์ชันการเรียกกลับของสมาชิกคือ - ในการเปรียบเทียบกับฟังก์ชันตัวชี้ - ค่อนข้างง่ายเช่นกัน:

 C my_c{2}; // aggregate initialization
 int a = 5;
 int b = C_foobar(a, my_c, &C::foo); // call C_foobar with pointer to foo as its callback

3. std::functionวัตถุ (ส่วนหัว<functional>)

std::functionชั้นเป็นเสื้อคลุมฟังก์ชั่นในการจัดเก็บ polymorphic คัดลอกหรือวิงวอน callables

3.1 การเขียนstd::functionสัญกรณ์วัตถุ / ประเภท

ประเภทของstd::functionวัตถุที่จัดเก็บ callable ดูเหมือนว่า:

std::function<return_type(parameter_type_1, parameter_type_2, parameter_type_3)>

// i.e. using the above function declaration of foo:
std::function<int(int)> stdf_foo = &foo;
// or C::foo:
std::function<int(const C&, int)> stdf_C_foo = &C::foo;

3.2 สัญกรณ์โทรกลับ

คลาสstd::functionได้operator()กำหนดไว้ซึ่งสามารถใช้เพื่อเรียกใช้เป้าหมาย

int stdf_foobar (int x, std::function<int(int)> moo)
{
    return x + moo(x); // std::function moo called
}
// or 
int stdf_C_foobar (int x, C const &c, std::function<int(C const &, int)> moo)
{
    return x + moo(c, x); // std::function moo called using c and x
}

3.3 รูปแบบการใช้โทรกลับและชนิดที่เข้ากันได้

การstd::functionเรียกกลับเป็นแบบทั่วไปมากกว่าตัวชี้ฟังก์ชั่นหรือตัวชี้ไปยังฟังก์ชั่นสมาชิกเนื่องจากประเภทที่แตกต่างกันสามารถส่งผ่านและแปลงเป็นstd::functionวัตถุโดยปริยาย

3.3.1 ตัวชี้ฟังก์ชั่นและตัวชี้ไปยังฟังก์ชั่นสมาชิก

ตัวชี้ฟังก์ชั่น

int a = 2;
int b = stdf_foobar(a, &foo);
// b == 6 ( 2 + (2+2) )

หรือตัวชี้ไปยังฟังก์ชันสมาชิก

int a = 2;
C my_c{7}; // aggregate initialization
int b = stdf_C_foobar(a, c, &C::foo);
// b == 11 == ( 2 + (7+2) )

สามารถใช้ได้.

3.3.2 การแสดงออกของแลมบ์ดา

การปิดไม่มีชื่อจากการแสดงออกแลมบ์ดาสามารถเก็บไว้ในstd::functionวัตถุ:

int a = 2;
int c = 3;
int b = stdf_foobar(a, [c](int x) -> int { return 7+c*x; });
// b == 15 ==  a + (7*c*a) == 2 + (7+3*2)

3.3.3 std::bindนิพจน์

ผลลัพธ์ของstd::bindนิพจน์สามารถส่งผ่านได้ ตัวอย่างเช่นโดยการผูกพารามิเตอร์กับการเรียกตัวชี้ฟังก์ชั่น:

int foo_2 (int x, int y) { return 9*x + y; }
using std::placeholders::_1;

int a = 2;
int b = stdf_foobar(a, std::bind(foo_2, _1, 3));
// b == 23 == 2 + ( 9*2 + 3 )
int c = stdf_foobar(a, std::bind(foo_2, 5, _1));
// c == 49 == 2 + ( 9*5 + 2 )

โดยที่วัตถุสามารถถูกผูกไว้เป็นวัตถุสำหรับการภาวนาของตัวชี้ไปยังฟังก์ชั่นสมาชิก:

int a = 2;
C const my_c{7}; // aggregate initialization
int b = stdf_foobar(a, std::bind(&C::foo, my_c, _1));
// b == 1 == 2 + ( 2 + 7 )

3.3.4 ฟังก์ชั่นวัตถุ

วัตถุของคลาสที่มีการoperator()โอเวอร์โหลดที่เหมาะสมสามารถเก็บไว้ภายในstd::functionวัตถุได้เช่นกัน

struct Meow
{
  int y = 0;
  Meow(int y_) : y(y_) {}
  int operator()(int x) { return y * x; }
};
int a = 11;
int b = stdf_foobar(a, Meow{8});
// b == 99 == 11 + ( 8 * 11 )

3.4 ตัวอย่าง

การเปลี่ยนตัวอย่างตัวชี้ฟังก์ชันที่จะใช้ std::function

void stdf_tranform_every_int(int * v, unsigned n, std::function<int(int)> fp)
{
  for (unsigned i = 0; i < n; ++i)
  {
    v[i] = fp(v[i]);
  }
}

ให้ประโยชน์กับฟังก์ชั่นนั้นมากขึ้นเพราะ (ดู 3.3) เรามีความเป็นไปได้ที่จะใช้มันมากขึ้น:

// using function pointer still possible
int a[5] = {1, 2, 3, 4, 5};
stdf_tranform_every_int(&a[0], 5, double_int);
// now a == {2, 4, 6, 8, 10};

// use it without having to write another function by using a lambda
stdf_tranform_every_int(&a[0], 5, [](int x) -> int { return x/2; });
// now a == {1, 2, 3, 4, 5}; again

// use std::bind :
int nine_x_and_y (int x, int y) { return 9*x + y; }
using std::placeholders::_1;
// calls nine_x_and_y for every int in a with y being 4 every time
stdf_tranform_every_int(&a[0], 5, std::bind(nine_x_and_y, _1, 4));
// now a == {13, 22, 31, 40, 49};

4. ประเภทการโทรกลับ Templated

การใช้เทมเพลตการเรียกรหัสการติดต่อกลับอาจเป็นเรื่องทั่วไปมากกว่าการใช้std::functionวัตถุ

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

4.1 การเขียน (สัญลักษณ์ชนิด) และการโทรกลับที่โทรเข้า templated

การใช้งานทั่วไปเช่นstd_ftransform_every_intโค้ดจากด้านบนสามารถทำได้โดยใช้เทมเพลต:

template<class R, class T>
void stdf_transform_every_int_templ(int * v,
  unsigned const n, std::function<R(T)> fp)
{
  for (unsigned i = 0; i < n; ++i)
  {
    v[i] = fp(v[i]);
  }
}

ด้วยรูปแบบทั่วไปที่มากขึ้น (รวมทั้งที่ง่ายที่สุด) สำหรับประเภทการโทรกลับเป็นอาร์กิวเมนต์ templated แบบธรรมดา, to-be-deduced:

template<class F>
void transform_every_int_templ(int * v, 
  unsigned const n, F f)
{
  std::cout << "transform_every_int_templ<" 
    << type_name<F>() << ">\n";
  for (unsigned i = 0; i < n; ++i)
  {
    v[i] = f(v[i]);
  }
}

หมายเหตุ: Fการส่งออกรวมถึงการพิมพ์ชื่อประเภทอนุมานสำหรับประเภทเทมเพลต การดำเนินการของtype_nameจะได้รับในตอนท้ายของโพสต์นี้

การใช้งานทั่วไปส่วนใหญ่สำหรับการแปลงเอกนารีของช่วงนั้นเป็นส่วนหนึ่งของไลบรารีมาตรฐานstd::transformซึ่งก็คือเทมเพลตที่เกี่ยวกับประเภทที่ซ้ำกัน

template<class InputIt, class OutputIt, class UnaryOperation>
OutputIt transform(InputIt first1, InputIt last1, OutputIt d_first,
  UnaryOperation unary_op)
{
  while (first1 != last1) {
    *d_first++ = unary_op(*first1++);
  }
  return d_first;
}

4.2 ตัวอย่างการใช้การโทรกลับ templated และประเภทที่เข้ากันได้

ประเภทที่เข้ากันได้สำหรับstd::functionวิธีการโทรกลับtemplated stdf_transform_every_int_templจะเหมือนกับประเภทที่กล่าวถึงข้างต้น (ดู 3.4)

อย่างไรก็ตามการใช้เวอร์ชันเทมเพลตลายเซ็นของการโทรกลับที่ใช้อาจมีการเปลี่ยนแปลงเล็กน้อย:

// Let
int foo (int x) { return 2+x; }
int muh (int const &x) { return 3+x; }
int & woof (int &x) { x *= 4; return x; }

int a[5] = {1, 2, 3, 4, 5};
stdf_transform_every_int_templ<int,int>(&a[0], 5, &foo);
// a == {3, 4, 5, 6, 7}
stdf_transform_every_int_templ<int, int const &>(&a[0], 5, &muh);
// a == {6, 7, 8, 9, 10}
stdf_transform_every_int_templ<int, int &>(&a[0], 5, &woof);

หมายเหตุ: std_ftransform_every_int(รุ่นที่ไม่ใช่เทมเพลต; ดูด้านบน) ทำงานด้วยแต่ไม่ได้ใช้foomuh

// Let
void print_int(int * p, unsigned const n)
{
  bool f{ true };
  for (unsigned i = 0; i < n; ++i)
  {
    std::cout << (f ? "" : " ") << p[i]; 
    f = false;
  }
  std::cout << "\n";
}

พารามิเตอร์ templated ธรรมดาของtransform_every_int_templสามารถเป็นได้ทุกประเภท callable

int a[5] = { 1, 2, 3, 4, 5 };
print_int(a, 5);
transform_every_int_templ(&a[0], 5, foo);
print_int(a, 5);
transform_every_int_templ(&a[0], 5, muh);
print_int(a, 5);
transform_every_int_templ(&a[0], 5, woof);
print_int(a, 5);
transform_every_int_templ(&a[0], 5, [](int x) -> int { return x + x + x; });
print_int(a, 5);
transform_every_int_templ(&a[0], 5, Meow{ 4 });
print_int(a, 5);
using std::placeholders::_1;
transform_every_int_templ(&a[0], 5, std::bind(foo_2, _1, 3));
print_int(a, 5);
transform_every_int_templ(&a[0], 5, std::function<int(int)>{&foo});
print_int(a, 5);

พิมพ์รหัสข้างต้น:

1 2 3 4 5
transform_every_int_templ <int(*)(int)>
3 4 5 6 7
transform_every_int_templ <int(*)(int&)>
6 8 10 12 14
transform_every_int_templ <int& (*)(int&)>
9 11 13 15 17
transform_every_int_templ <main::{lambda(int)#1} >
27 33 39 45 51
transform_every_int_templ <Meow>
108 132 156 180 204
transform_every_int_templ <std::_Bind<int(*(std::_Placeholder<1>, int))(int, int)>>
975 1191 1407 1623 1839
transform_every_int_templ <std::function<int(int)>>
977 1193 1409 1625 1841

type_name การใช้งานที่ใช้ข้างต้น

#include <type_traits>
#include <typeinfo>
#include <string>
#include <memory>
#include <cxxabi.h>

template <class T>
std::string type_name()
{
  typedef typename std::remove_reference<T>::type TR;
  std::unique_ptr<char, void(*)(void*)> own
    (abi::__cxa_demangle(typeid(TR).name(), nullptr,
    nullptr, nullptr), std::free);
  std::string r = own != nullptr?own.get():typeid(TR).name();
  if (std::is_const<TR>::value)
    r += " const";
  if (std::is_volatile<TR>::value)
    r += " volatile";
  if (std::is_lvalue_reference<T>::value)
    r += " &";
  else if (std::is_rvalue_reference<T>::value)
    r += " &&";
  return r;
}

นอกจากนี้ยังมีวิธี C ในการโทรกลับ: ตัวชี้ฟังก์ชั่น

//Define a type for the callback signature,
//it is not necessary, but makes life easier

//Function pointer called CallbackType that takes a float
//and returns an int
typedef int (*CallbackType)(float);  


void DoWork(CallbackType callback)
{
  float variable = 0.0f;

  //Do calculations

  //Call the callback with the variable, and retrieve the
  //result
  int result = callback(variable);

  //Do something with the result
}

int SomeCallback(float variable)
{
  int result;

  //Interpret variable

  return result;
}

int main(int argc, char ** argv)
{
  //Pass in SomeCallback to the DoWork
  DoWork(&SomeCallback);
}

ตอนนี้ถ้าคุณต้องการผ่านในคลาสเมธอดเป็น callbacks การประกาศไปยังพอยน์เตอร์ของฟังก์ชันเหล่านั้นมีการประกาศที่ซับซ้อนมากขึ้นเช่น:

//Declaration:
typedef int (ClassName::*CallbackType)(float);

//This method performs work using an object instance
void DoWorkObject(CallbackType callback)
{
  //Class instance to invoke it through
  ClassName objectInstance;

  //Invocation
  int result = (objectInstance.*callback)(1.0f);
}

//This method performs work using an object pointer
void DoWorkPointer(CallbackType callback)
{
  //Class pointer to invoke it through
  ClassName * pointerInstance;

  //Invocation
  int result = (pointerInstance->*callback)(1.0f);
}

int main(int argc, char ** argv)
{
  //Pass in SomeCallback to the DoWork
  DoWorkObject(&ClassName::Method);
  DoWorkPointer(&ClassName::Method);
}

Scott Meyers เป็นตัวอย่างที่ดี:

class GameCharacter;
int defaultHealthCalc(const GameCharacter& gc);

class GameCharacter
{
public:
  typedef std::function<int (const GameCharacter&)> HealthCalcFunc;

  explicit GameCharacter(HealthCalcFunc hcf = defaultHealthCalc)
  : healthFunc(hcf)
  { }

  int healthValue() const { return healthFunc(*this); }

private:
  HealthCalcFunc healthFunc;
};

ฉันคิดว่าตัวอย่างพูดมันทั้งหมด

std::function<> เป็นวิธี "ทันสมัย" ในการเขียนกลับ C ++

ฟังก์ชั่นการโทรกลับเป็นวิธีการที่ถูกส่งผ่านเป็นประจำและเรียกในบางจุดโดยประจำการที่มันจะผ่าน

สิ่งนี้มีประโยชน์มากสำหรับการทำซอฟต์แวร์ที่นำมาใช้ซ้ำได้ ตัวอย่างเช่น API ระบบปฏิบัติการจำนวนมาก (เช่น Windows API) ใช้การเรียกกลับอย่างมาก

ตัวอย่างเช่นหากคุณต้องการทำงานกับไฟล์ในโฟลเดอร์ - คุณสามารถเรียกใช้ฟังก์ชัน API พร้อมรูทีนของคุณเองและรูทีนของคุณจะรันหนึ่งครั้งต่อไฟล์ในโฟลเดอร์ที่ระบุ สิ่งนี้ทำให้ API มีความยืดหยุ่นมาก

คำตอบที่ยอมรับนั้นมีประโยชน์มากและค่อนข้างครอบคลุม อย่างไรก็ตามสถานะ OP

ฉันต้องการดูตัวอย่างง่ายๆในการเขียนฟังก์ชันการโทรกลับ

ดังนั้นที่นี่คุณไปจาก C ++ 11 คุณstd::functionมีไม่จำเป็นต้องมีตัวชี้ฟังก์ชั่นและสิ่งที่คล้ายกัน:

#include <functional>
#include <string>
#include <iostream>

void print_hashes(std::function<int (const std::string&)> hash_calculator) {
    std::string strings_to_hash[] = {"you", "saved", "my", "day"};
    for(auto s : strings_to_hash)
        std::cout << s << ":" << hash_calculator(s) << std::endl;    
}

int main() {
    print_hashes( [](const std::string& str) {   /** lambda expression */
        int result = 0;
        for (int i = 0; i < str.length(); i++)
            result += pow(31, i) * str.at(i);
        return result;
    });
    return 0;
}

ตัวอย่างนี้เป็นจริงอย่างใดเพราะคุณต้องการเรียกใช้ฟังก์ชั่นที่print_hashesมีการใช้งานที่แตกต่างกันของฟังก์ชั่นแฮชเพื่อจุดประสงค์นี้ฉันให้ง่าย ๆ มันได้รับสตริงส่งคืน int (ค่าแฮชของสตริงที่ให้ไว้) และสิ่งที่คุณต้องจำจากส่วนของไวยากรณ์คือstd::function<int (const std::string&)>ซึ่งจะอธิบายฟังก์ชันดังกล่าวเป็นอาร์กิวเมนต์อินพุตของฟังก์ชันที่จะเรียกใช้

ไม่มีแนวคิดชัดเจนของฟังก์ชั่นการโทรกลับใน C ++ กลไกการโทรกลับมักจะใช้งานผ่านตัวชี้ฟังก์ชันวัตถุ functor หรือวัตถุติดต่อกลับ โปรแกรมเมอร์ต้องออกแบบและใช้ฟังก์ชันการเรียกกลับอย่างชัดเจน

แก้ไขตามข้อเสนอแนะ:

แม้จะมีความคิดเห็นเชิงลบคำตอบนี้ได้รับมันไม่ผิด ฉันจะพยายามอธิบายให้ดีกว่าว่ามาจากไหน

C และ C ++ มีทุกสิ่งที่คุณต้องการในการใช้ฟังก์ชั่นการโทรกลับ วิธีที่ใช้กันทั่วไปและไม่สำคัญในการใช้ฟังก์ชั่นการโทรกลับคือการส่งตัวชี้ฟังก์ชันเป็นอาร์กิวเมนต์ของฟังก์ชัน

อย่างไรก็ตามฟังก์ชั่นการโทรกลับและตัวชี้ฟังก์ชั่นไม่ได้มีความหมายเหมือนกัน ตัวชี้ฟังก์ชั่นเป็นกลไกภาษาในขณะที่ฟังก์ชั่นการโทรกลับเป็นแนวคิดความหมาย พอยน์เตอร์ของฟังก์ชั่นไม่ใช่วิธีเดียวที่จะใช้ฟังก์ชั่นการโทรกลับ - คุณยังสามารถใช้ฟังก์ชั่นและแม้แต่ฟังก์ชั่นเสมือนที่หลากหลายของสวน สิ่งที่ทำให้ฟังก์ชั่นการโทรกลับไม่ได้เป็นกลไกที่ใช้ในการระบุและเรียกใช้ฟังก์ชั่น แต่บริบทและความหมายของการโทร การพูดอะไรบางอย่างเป็นฟังก์ชันการเรียกกลับหมายถึงการแยกมากกว่าปกติระหว่างฟังก์ชั่นการโทรและฟังก์ชั่นที่เฉพาะเจาะจงที่ถูกเรียกว่าการมีเพศสัมพันธ์ที่หลวมความคิดระหว่างผู้โทรและ callee กับผู้โทรมีการควบคุมอย่างชัดเจน

ตัวอย่างเช่นเอกสาร. NET สำหรับIFormatProviderบอกว่า"GetFormat เป็นวิธีการโทรกลับ"ถึงแม้ว่ามันจะเป็นเพียงวิธีการติดต่อแบบ run-of-the-mill ฉันไม่คิดว่าทุกคนจะโต้แย้งว่าการเรียกใช้เมธอดเสมือนทั้งหมดเป็นฟังก์ชันการโทรกลับ สิ่งที่ทำให้ GetFormat เป็นวิธีการโทรกลับไม่ใช่กลไกของวิธีการส่งผ่านหรือเรียกใช้ แต่ความหมายของผู้โทรเลือกวิธีการ GetFormat ของวัตถุที่จะเรียก

บางภาษามีคุณสมบัติที่มีความหมายอย่างชัดเจนของการติดต่อกลับซึ่งโดยทั่วไปเกี่ยวข้องกับเหตุการณ์และการจัดการเหตุการณ์ ตัวอย่างเช่น C # มีประเภทเหตุการณ์ที่มีไวยากรณ์และความหมายที่ออกแบบมาอย่างชัดเจนรอบแนวคิดของการโทรกลับ Visual Basic มีของจับประโยคที่ชัดเจนบอกวิธีการที่จะเป็นฟังก์ชั่นการโทรกลับในขณะที่สรุปออกไปแนวคิดของผู้ได้รับมอบหมายหรือตัวชี้ฟังก์ชั่น ในกรณีเหล่านี้แนวคิดเชิงความหมายของการติดต่อกลับถูกรวมเข้ากับภาษาของตัวเอง

ในทางกลับกัน C และ C ++ ไม่ได้ฝังแนวคิดเชิงความหมายของฟังก์ชันการโทรกลับไว้เกือบจะชัดเจน กลไกอยู่ที่นั่นความหมายรวมไม่ได้ คุณสามารถใช้ฟังก์ชั่นการโทรกลับดีเพียง แต่จะได้รับสิ่งที่มีความซับซ้อนมากขึ้นซึ่งรวมถึงความหมายโทรกลับอย่างชัดเจนคุณจะต้องสร้างมันอยู่ด้านบนของสิ่งที่ C ++ ให้เช่นสิ่งที่น่ารักของพวกเขาทำกับสัญญาณและเครื่องหยอดเหรียญ

โดยสรุป C ++ มีสิ่งที่คุณต้องใช้ในการโทรกลับซึ่งมักจะใช้ตัวชี้ฟังก์ชั่นค่อนข้างง่ายและไม่สำคัญ อะไรที่มันไม่ได้เป็นคำหลักและให้บริการที่มีความหมายเฉพาะเจาะจงที่จะเรียกกลับเช่นเพิ่ม , ปล่อย , จับ , เหตุการณ์ + =ฯลฯ ถ้าคุณมาจากภาษาที่มีประเภทที่ขององค์ประกอบการสนับสนุนการเรียกกลับพื้นเมืองใน C ++ จะรู้สึก neutered

ฟังก์ชั่นการโทรกลับเป็นส่วนหนึ่งของมาตรฐาน C ดังนั้นจึงเป็นส่วนหนึ่งของ C ++ ด้วย แต่ถ้าคุณทำงานกับ C ++ ฉันขอแนะนำให้คุณใช้รูปแบบการสังเกตการณ์แทน: http://en.wikipedia.org/wiki/Observer_pattern

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

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

นี่คือวิธีที่คุณสามารถใช้โทรกลับใน C ++ สมมติว่า 4 ไฟล์ คู่ของไฟล์. CPP / .H สำหรับแต่ละคลาส คลาส C1 เป็นคลาสที่มีเมธอดที่เราต้องการเรียกกลับ C2 โทรกลับไปที่วิธีการของ C1 ในตัวอย่างนี้ฟังก์ชั่นการโทรกลับใช้เวลา 1 พารามิเตอร์ที่ฉันเพิ่มเพื่อประโยชน์ของผู้อ่าน ตัวอย่างจะไม่แสดงวัตถุใด ๆ ที่ถูกยกตัวอย่างและใช้งาน กรณีใช้งานหนึ่งสำหรับการใช้งานนี้คือเมื่อคุณมีคลาสหนึ่งที่อ่านและเก็บข้อมูลลงในพื้นที่ชั่วคราวและอีกชั้นหนึ่งที่โพสต์ประมวลผลข้อมูล ด้วยฟังก์ชั่นการโทรกลับสำหรับทุกแถวของข้อมูลอ่านการเรียกกลับสามารถประมวลผลได้ เทคนิคนี้ตัดลึกหนาบางเหนือค่าใช้จ่ายของพื้นที่ชั่วคราวที่จำเป็น เป็นประโยชน์อย่างยิ่งสำหรับการสืบค้น SQL ที่ส่งคืนข้อมูลจำนวนมากซึ่งจะต้องมีการดำเนินการภายหลัง

/////////////////////////////////////////////////////////////////////
// C1 H file

class C1
{
    public:
    C1() {};
    ~C1() {};
    void CALLBACK F1(int i);
};

/////////////////////////////////////////////////////////////////////
// C1 CPP file

void CALLBACK C1::F1(int i)
{
// Do stuff with C1, its methods and data, and even do stuff with the passed in parameter
}

/////////////////////////////////////////////////////////////////////
// C2 H File

class C1; // Forward declaration

class C2
{
    typedef void (CALLBACK C1::* pfnCallBack)(int i);
public:
    C2() {};
    ~C2() {};

    void Fn(C1 * pThat,pfnCallBack pFn);
};

/////////////////////////////////////////////////////////////////////
// C2 CPP File

void C2::Fn(C1 * pThat,pfnCallBack pFn)
{
    // Call a non-static method in C1
    int i = 1;
    (pThat->*pFn)(i);
}

ของ Boost signals2ช่วยให้คุณสามารถสมัครสมาชิกฟังก์ชันทั่วไป (ไม่มีแม่!) และในทางด้าย

ตัวอย่าง: สัญญาณมุมมองเอกสารสามารถใช้เพื่อสร้างสถาปัตยกรรมมุมมองเอกสารที่ยืดหยุ่น เอกสารจะมีสัญญาณที่แต่ละมุมมองสามารถเชื่อมต่อได้ คลาส Document ต่อไปนี้กำหนดเอกสารข้อความแบบง่ายที่รองรับมุมมองแบบ mulitple โปรดทราบว่าจะเก็บสัญญาณเดียวซึ่งมุมมองทั้งหมดจะเชื่อมต่อ

class Document
{
public:
    typedef boost::signals2::signal<void ()>  signal_t;

public:
    Document()
    {}

    /* Connect a slot to the signal which will be emitted whenever
      text is appended to the document. */
    boost::signals2::connection connect(const signal_t::slot_type &subscriber)
    {
        return m_sig.connect(subscriber);
    }

    void append(const char* s)
    {
        m_text += s;
        m_sig();
    }

    const std::string& getText() const
    {
        return m_text;
    }

private:
    signal_t    m_sig;
    std::string m_text;
};

ต่อไปเราสามารถเริ่มกำหนดมุมมอง คลาส TextView ต่อไปนี้ให้มุมมองแบบง่ายของข้อความเอกสาร

class TextView
{
public:
    TextView(Document& doc): m_document(doc)
    {
        m_connection = m_document.connect(boost::bind(&TextView::refresh, this));
    }

    ~TextView()
    {
        m_connection.disconnect();
    }

    void refresh() const
    {
        std::cout << "TextView: " << m_document.getText() << std::endl;
    }
private:
    Document&               m_document;
    boost::signals2::connection  m_connection;
};

คำตอบที่ได้รับการยอมรับนั้นมีความครอบคลุม แต่เกี่ยวข้องกับคำถามที่ฉันต้องการยกตัวอย่างง่ายๆที่นี่ ฉันมีรหัสที่ฉันเขียนเมื่อนานมาแล้ว ฉันต้องการสำรวจต้นไม้ด้วยวิธีการในการสั่งซื้อ (ซ้าย - โหนดจากนั้นรูตโหนดจากนั้นขวา - โหนด) และเมื่อใดก็ตามที่ฉันถึงหนึ่งโหนดฉันต้องการที่จะเรียกฟังก์ชั่นโดยพลการเพื่อให้มันสามารถทำทุกอย่าง

void inorder_traversal(Node *p, void *out, void (*callback)(Node *in, void *out))
{
    if (p == NULL)
        return;
    inorder_traversal(p->left, out, callback);
    callback(p, out); // call callback function like this.
    inorder_traversal(p->right, out, callback);
}


// Function like bellow can be used in callback of inorder_traversal.
void foo(Node *t, void *out = NULL)
{
    // You can just leave the out variable and working with specific node of tree. like bellow.
    // cout << t->item;
    // Or
    // You can assign value to out variable like below
    // Mention that the type of out is void * so that you must firstly cast it to your proper out.
    *((int *)out) += 1;
}
// This function use inorder_travesal function to count the number of nodes existing in the tree.
void number_nodes(Node *t)
{
    int sum = 0;
    inorder_traversal(t, &sum, foo);
    cout << sum;
}

 int main()
{

    Node *root = NULL;
    // What These functions perform is inserting an integer into a Tree data-structure.
    root = insert_tree(root, 6);
    root = insert_tree(root, 3);
    root = insert_tree(root, 8);
    root = insert_tree(root, 7);
    root = insert_tree(root, 9);
    root = insert_tree(root, 10);
    number_nodes(root);
}