?
目錄
函數指針
?編輯
實例
函數指針作為某個函數的參數
實例
?std::function輕松實現回調函數
綁定一個函數
作為回調函數
?作為函數入參
函數指針
函數指針是指向函數的指針變量。
通常我們說的指針變量是指向一個整型、字符型或數組等變量，而函數指針是指向函數。
函數指針可以像一般函數一樣，用于調用函數、傳遞參數。
函數指針類型的聲明：
typedef type (*fun_ptr)(type,type); // 聲明一個指向同樣參數、返回值的函數指針類型
實例
以下實例聲明了函數指針變量 p，指向函數 max：
#include <stdio.h>
#define _CRT_SECURE_NO_WARNINGS
typedef int(*func_ptr)(int, int);int max(int x, int y)
{return x > y ? x : y;
}int main(void)
{//p是指向max的函數指針func_ptr p = &max;//也可以寫成 func_ptr p = max;int a, b, c, d;printf("請輸入三個數字：");scanf("%d %d %d", &a, &b, &c);/* 與直接調用函數等價，d = max(max(a, b), c) */d = p(p(a, b), c);printf("最大的數字是： %d\n", d);return 0;
}
函數指針作為某個函數的參數
函數指針變量可以作為某個函數的參數來使用的，回調函數就是一個通過函數指針調用的函數。
簡單講：回調函數是由別人的函數執行時調用你實現的函數。
以下是來自知乎作者常溪玲的解說：
你到一個商店買東西，剛好你要的東西沒有貨，于是你在店員那里留下了你的電話，過了幾天店里有貨了，店員就打了你的電話，然后你接到電話后就到店里去取了貨。在這個例子里，你的電話號碼就叫回調函數，你把電話留給店員就叫登記回調函數，店里后來有貨了叫做觸發了回調關聯的事件，店員給你打電話叫做調用回調函數，你到店里去取貨叫做響應回調事件。
實例
實例中?populate_array()?函數定義了三個參數，其中第三個參數是函數的指針，通過該函數來設置數組的值。
實例中我們定義了回調函數?getNextRandomValue()，它返回一個隨機值，它作為一個函數指針傳遞給?populate_array()?函數。
populate_array()?將調用?10?次回調函數，并將回調函數的返回值賦值給數組。
#include <stdlib.h>
#include <stdio.h>void populate_array(int* array, size_t arraySize, int (*getNextValue)(void))
{for (size_t i = 0; i < arraySize; i++)array[i] = getNextValue();
}// 獲取隨機值
int getNextRandomValue(void)
{return rand();
}int main(void)
{int myarray[10];populate_array(myarray, 10, getNextRandomValue);//函數的名稱就是函數的地址for (int i = 0; i < 10; i++) {printf("%d ", myarray[i]);}printf("\n");return 0;
}
?std::function輕松實現回調函數
#include <functional>
#include <iostream>struct Foo
{Foo(int num) : num_(num) {}void print_add(int i) const { std::cout << num_ + i << '\n'; }int num_;
};void print_num(int i)
{std::cout << i << '\n';
}struct PrintNum
{void operator()(int i) const{std::cout << i << '\n';}
};int main()
{// store a free functionstd::function<void(int)> f_display = print_num;f_display(-9);// store a lambdastd::function<void()> f_display_42 = []() { print_num(42); };f_display_42();// store the result of a call to std::bindstd::function<void()> f_display_31337 = std::bind(print_num, 31337);f_display_31337();// store a call to a member functionstd::function<void(const Foo&, int)> f_add_display = &Foo::print_add;const Foo foo(314159);f_add_display(foo, 1);f_add_display(314159, 1);// store a call to a data member accessorstd::function<int(Foo const&)> f_num = &Foo::num_;std::cout << "num_: " << f_num(foo) << '\n';// store a call to a member function and objectusing std::placeholders::_1;std::function<void(int)> f_add_display2 = std::bind(&Foo::print_add, foo, _1);f_add_display2(2);// store a call to a member function and object ptrstd::function<void(int)> f_add_display3 = std::bind(&Foo::print_add, &foo, _1);f_add_display3(3);// store a call to a function objectstd::function<void(int)> f_display_obj = PrintNum();f_display_obj(18);auto factorial = [](int n){// store a lambda object to emulate "recursive lambda"; aware of extra overheadstd::function<int(int)> fac = [&](int n) { return (n < 2) ? 1 : n * fac(n - 1); };// note that "auto fac = [&](int n) {...};" does not work in recursive callsreturn fac(n);};for (int i{5}; i != 8; ++i)std::cout << i << "! = " << factorial(i) << "; ";std::cout << '\n';
}
綁定一個函數
#include <functional>
#include <iostream>//普通函數
void func(void)
{std::cout << __FUNCTION__ << std::endl;
}
//靜態類成員函數
class Foo
{
public:static int foo_func(int a){std::cout << __FUNCTION__ << "(" << a << ") ->:";return a;}
};int main(void)
{std::function<void(void)> fr = func;fr();std::function<int(int)> fr1 = Foo::foo_func;std::cout << fr1(456) << std::endl;
}
作為回調函數
#include <functional>
#include <iostream>
class A
{
std::function<void()> callback_;
public:A(const std::function<void()>& f) :callback_(f) {};
void notify(void)
{callback_();}
};
class Foo {
public:
void operator()(void)
{
std::cout << __FUNCTION__ << std::endl;}
};
int main(void)
{Foo foo;
A aa(foo);aa.notify();
}?作為函數入參
#include <functional>
#include <iostream>
void call_when_even(int x, const std::function<void(int)>& f)
{
if (!(x & 1)){f(x);}
}
void output(int x)
{
std::cout << x << " ";
}
int main(void)
{
for (int i = 0; i < 10; ++i){call_when_even(i, output);}
std::cout << std::endl;
}一些AI給出的回答
`std::function`是C++標準庫中的一個通用、可調用、多態的函數封裝器，可以用來存儲任何可調用對象的引用，如函數指針、函數對象、Lambda表達式等。它的主要作用是將函數作為參數傳遞，實現回調函數的功能。
下面是一個簡單的實例，演示了如何使用`std::function`存儲一個函數，并調用它：`?
?
在這個例子中，我們定義了
#include <iostream>
#include <functional>void print_hello() {std::cout << "Hello, world!" << std::endl;
}int main() {std::function<void()> func = print_hello;func();return 0;
}一個名為`print_hello`的函數，用于打印"Hello, world!"。然后，我們創建了一個`std::function<void()>`類型的變量`func`，并將`print_hello`函數的地址賦值給`func`。最后，我們調用`func`，輸出"Hello, world!"。
在C++中，`std::function`是一個通用、可調用、多態的函數封裝器，可以用來存儲任何可調用對象的引用，如函數指針、函數對象、Lambda表達式等。`std::function`的模板參數`T`表示存儲的函數的參數類型，當`T`是一個函數指針類型時，`std::function`可以用來存儲一個函數指針；當`T`是一個函數對象類型時，`std::function`可以用來存儲一個函數對象；當`T`是一個Lambda表達式類型時，`std::function`可以用來存儲一個Lambda表達式。
下面是一些例子：
// 存儲一個接受兩個int參數的函數
std::function<int(int, int)> func1;// 存儲一個接受一個int參數并返回一個int的函數
std::function<int(int)> func2;// 存儲一個不接受任何參數的函數
std::function<void()> func3;// 存儲一個Lambda表達式
std::function<int(int)> func4 = [](int x) { return x * 2; };
在這些例子中，`func1`和`func2`可以用來存儲任何接受相應參數類型的函數，`func3`可以用來存儲任何不接受任何參數的函數，`func4`可以用來存儲一個接受一個int參數并返回一個int的Lambda表達式。
?
#include <iostream>
#include <functional>class A {
public:A(const std::function<void()>& f) :callback_(f) {};void print() {callback_();}private:std::function<void()> callback_;
};int main() {A obj([&]() {std::cout << "Hello, World!" << std::endl;});obj.print();return 0;
}
在這個例子中，我們定義了一個名為A的類，它有一個構造函數，接受一個名為callback_的std::function<void()>類型的參數。我們還定義了一個名為print的方法，用于調用callback_函數。在main函數中，我們創建了一個A類的對象，并將一個Lambda表達式作為其構造函數的參數傳遞。然后我們調用obj的print方法，輸出"Hello, World!"
)
