std::function 和 std::bind-ag真人游戏

std::function 仿函数对象

std::function  用来声明函数对象的，换句话说，就和函数指针、lambda表达式、函数名是一个东西 。

#include 
#include 
// 传统c函数
int c_function(int a, int b)
{
    return a   b;
}
int main(int argc, char** argv)
{
    // 万能可调用对象类型
    std::function callableobject;
    
    callableobject = c_function;   // 可以用传统c函数指针直接赋值
    std::cout << callableobject(3, 3) << std::endl;
    return 0;
}

输出结果为：7

std::bind 就是将一个函数对象绑定成为另一个函数对象，std::bind的返回值类型是std::function 。

头文件 #include
命名空间 std、std::placeholders

bind使用时的注意细节：
① bind的第一个参数必须要加取地址符号&
② 必须加上using namespace std::placeholders，否则找不到占位符

全局函数、静态全局函数 :

static void show(const std::string& a, const std::string& b, const std::string& c)
{
	std::cout << a << "; " << b << "; " << c << std::endl;
}
int main()
{
	using namespace std::placeholders; // 由于std::placeholders，可以将参数传递给绑定函数的顺序更改
	auto x = std::bind(&show, _1, _2, _3);
	auto y = std::bind(&show, _3, _1, _2);
	auto z = std::bind(&show, "hello", _2, _1);
	auto e = std::bind(&show, _3, _3, _3);
	x("one", "two", "three");   // one; two; three
	y("one", "two", "three");   // three; one; two
	z("one", "two");            // hello; two; one
	e("one", "two", "three");   // three; three; three
}

输出结果：

类的static成员函数 :

class a
{
  public:
	 static void show(const std::string& a, const std::string& b, const std::string& c)
	  {
		std::cout << a << "; " << b << "; " << c << std::endl;
	  }
};
int main()
{
	using namespace std::placeholders;   // 由于std::placeholders，可以将参数传递给绑定函数的顺序更改
	auto x = bind(&a::show, _1, _2, _3);
	auto y = bind(&a::show, _3, _1, _2);
	auto z = bind(&a::show, "hello", _2, _1);
	auto e = bind(&a::show, _3, _3, _3);
	x("one", "two", "three");   // one; two; three
	y("one", "two", "three");   // three; one; two
	z("one", "two");            // hello; two; one
	e("one", "two", "three");   // three; three; three
	return 0;
}

输出结果：

类的非static成员函数（注意：_1必须是某个对象的地址）

结论： 对类的非static成员函数bind时，除了需要加上作用域a::之外，还要多加一个类对象参数

class a{
public:
	void show(const std::string& a, const std::string& b, const std::string& c)
	{
		std::cout << a << "; " << b << "; " << c << std::endl;
	}
};
int main()
{
	using namespace std::placeholders;  // 由于std::placeholders，可以将参数传递给绑定函数的顺序更改
	a aa;
	auto x = bind(&a::show, aa, _1, _2, _3);  //多加一个类对象
	auto y = bind(&a::show, aa, _3, _1, _2);
	auto z = bind(&a::show, aa, "hello", _2, _1);
	auto e = bind(&a::show, aa, _3, _3, _3);
	x("one", "two", "three");  // one; two; three
	y("one", "two", "three");  // three; one; two
	z("one", "two");           // hello; two; one
	e("one", "two", "three");  // three; three; three
	return 0;
}

输出结果：

std::function 和 std::bind  配合使用

#include 
#include 
void showall(int a, double b, const std::string& c)
{
	std::cout << a << "; " << b << "; " << c << std::endl;
}
int main(int argc, char** argv)
{
	using namespace std::placeholders;
	std::function output = 
				std::bind(&showall, _1, _2, "kobe");
	output(1, 2);  //调用函数
    return 0;
}

输出结果为：1; 2; kobe