C++ Pirmer : 第十四章 : 重载运算符与类型转换之函数调用运算符与标准库的定义的函数对象

函数调用运算符

struct test {
	int operator()(int val) const { return (i > 0 ? i : -i); }
};

所谓的函数调用就是一个类重载了函数调用符，类在使用重载函数调用符时接受相应参数。这一过程就像是使用一个函数一样，因此叫做函数调用。

上面的类test，它重载了函数调用符()， 接受一个int类型参数，返回它的绝对值。

我们就可以将一个test类对象当做一个函数来使用：

int main(void) 
{
	test t;
	int val = -3;
	std::cout << "abs(val) = " << t(val) << std::endl;
	return 0;
}

使用函数重载调用符时，直接在类名后面跟括号，括号里加所需参数即可，看起来就和一个普通的函数调用一样。 我们称这样的类为“ 行为像函数一样的类”。

如果类定义了函数调用运算符，则该类的对象称作 函数对象。 函数调用运算符必须是成员函数。

函数对象常常作为泛型算法的实参。我们可以定义一个函数对象，作用为输出实参内容，我们将其作为标准库定义的for_each的实参：

class printString {
public:
	printString(std::ostream& o = std::cout) : os(o) {}
	void operator()(const std::string& s) { os << "s = " << s << std::endl; }
private:
	std::ostream& os;
};

int main(void)
{
	std::vector<std::string> vec = { "Hello", "World" };
	printString ps;
	for_each(vec.begin(), vec.end(), ps);
	return 0;
}

lambda是函数对象

当编写一个lambda表达式时， 编译器将该表达式翻译成一个未命名类的未命名对象。例如：

stable_sort(words.begin(), words.end(), [](const std::string& a, const std::string& b) { return a.size() < b.size(); });

编译器会为我们生成一个类似这样的一个类的对象(未命名的)：

class Shorter {
public:
	bool operator()(const std::string& a, const std::string& b) const { return a.size() < b.size(); }
	
};

因为默认的lambda是不可以修改捕获参数的，因此上面这个生成的类似的类的函数调用运算符是一个const成员函数。

如果lambda声明捕获参数是可变的(mutable)， 则翻译成的类的函数调用运算符就不是const的了。

捕获的变量被拷贝到lambda中，因此， 这种lambda产生的类必须为每个值的变量建立对应的数据成员，同时创建构造函数：

auto wc = find_if(words.begin(), words.end(), [sz](const std::string& a) { return a.size() >= sz; });

该lambda产生的类形如：

class SizeComp {
public:
	SizeComp(size_t n) : sz(n) {}
	bool operator()(const std::string& a) const { return a.size() >= sz; }
	
private:
	size_t sz
};

lambda产生的类不含默认构造函数、赋值运算符及默认析构函数，它是否有默认的拷贝/移动构造函数则视捕获的数据成员的类型决定。

习题14.38

class CheckString {
public:
	bool operator()(const std::string& s) { return (s.size() >= 1 && s.size() <= 10); }
	
	size_t operator()(std::vector<std::string>& vec, size_t length) {
		size_t num = 0;
		for (const auto& elmt : vec)
			(elmt.size() == length) ? ++num : num;
		return num;
	}
	
};


int main()
{
	CheckString ck;
	std::string s{"HelloWorld"};
	std::vector<std::string> vec = { "hello", "world", "i", "love", "you", "but", "you", "is", "what" }; 

	std::cout << "s.size() >= 1 && s.size() <= 10 ?" << ck(s) << std::endl;

	size_t n = 1;
	std::cout << "size == 1 has " << ck(vec, n) << std::endl;

	return 0;
}

标准库定义的函数对象

在头文件 <functional>中，定义了一组表示算术运算符、关系运算符和逻辑运算符的类，每个类分别定义了一个执行命名操作的调用运算符。 这些类都被定义成模板的形式。

算术：
plus<Type>  // 加法
minus<Type>  // 减法
multiplies<Type>  // 乘法
divides<Type>  // 除法
modulus<Type>  // 取模
negate<Type>  //  取反

关系：
equal_to<Type>  // 等于
not_equal_to<Type>  // 不等于
greater<Type>  // 大于
greater_equal<Type>  // 大于等于
less<Type>  // 小于
less_equal<Type>  // 小于等于

逻辑：
logical_and<Type>  // 逻辑与
logical_or<Type>  // 逻辑或
logical_not<Type>  // 逻辑非

这些函数对象对于指针同样适用。

比较两个无关指针会产生未定义的行为，如果希望通过比较指针的地址来sort指针的vector，直接这样做会产生未定义的行为。不过我们可以使用标准库定义的函数对象来比较，标准库规定指针的less是定义良好的。

std::vector<std::string*> vec;
// 未定义行为!
sort(vec.begin(), vec.end(), [](std::string* a, std::string* b){ return a < b; });

sort(vec.begin(), vec.end(), less<std::string*>());

关联容器使用less<key_type>对元素排序。

可调用对象与function

标准库function定义在头文件 <functional>中

functional<T> f;	f是一个用来存储可调用对象的空function，这些可调用对象的调用形式应该与函数类型T相同
functional<T> f(nullptr);	显示的构造一个空function
functional<T> f(obj);	在f中存储可调用对象obj的副本
f	将f做为条件，当f含有一个可调用对象时为真，否则为假
f(args)	调用f中的对象，参数是args

定义为function<T>的成员的类型
result_type		该function类型的可调用对象返回的类型
argument_type	当T有一个或两个实参时定义的类型，当T有一个实参时，argument_type是该类型的同义词
first_argument_type		当有两个实参时，first_argument_type和second_argument_type分别代表两个实参类型
second_argument_type

function是一个模板， 创建一个function时必须指定它的类型。

int add(int i, int j) { return i / j; }
auto mod = [](int x, int y){ return x % y; };
struct divide {
	int operator()(int a, int b) { return a / b; }
};

std::function<int(int, int)> f1 = add;
std::function<int(int, int)> f2 = divide();
std::function<int(int, int)> f3 = [](int x, int y){ return x % y; };

std::cout << f1(4, 2) << std::endl;
std::cout << f2(4, 2) << std::endl;
std::cout << f3(4, 2) << std::endl;

对于重载的函数，不能直接放入function类型对象中：

int add(int i, int j) { return i / j; }
Sales_data add(const Sales_data&, const Sales_data&);

int add(int i, int j) { return i / j; }
Sales_data add(const Sales_data&, const Sales_data&);

std:map<std::string, std::function<int(int, int)>> mp;
mp.insert({"+", add});  // 错误，哪个add?

可以使用函数指针来避免二义性的问题：

int (*fp)(int, int) = add;
mp.insert({"+", fp});

或者还可以使用lambda来消除二义性。