函数调用运算符

Posted 2021-03-05 xiaojianliu

如果类重载了函数调用运算符，则可以像使用函数一样使用该类的对象，因为这样的类同时也能存储状态，所以与普通函数相比它们更加灵活。

struct absInt{
    int operator()(int val) const{
        return val < 0 ? -val : val;
    }
};

上面的类只定义了一种操作：函数调用运算符，它负责接受一个int类型的形参，然后返回该实参的绝对值。

int i = -42;
absInt absObj;
int ui = absObj(i); //i被传递给absObj.operator()

即使 absObj是一个对象而非函数，也能调用该对象，调用对象实际上是在运行重载的调用运算符。

函数调用运算符必须是成员函数，一个类可以定义多个不同版本的调用运算符，相互之间在参数数量和参数类型上应该有所区别。

如果类定义了调用运算符，则该类的对象称作函数对象，因为可以调用这种对象，所以这些对象的行为像函数一样。

含有状态的函数对象类

函数对象除了 operator() 之外也可以包含其他成员。

class PrintString{
public:
    PrintString(ostream &o = cout,char c = ' '):os(o),sep(c){ }
    void operator()(const string &s)const{os<<s<<sep;}
private:
    ostream &os;
    char sep;
};

使用：

PrintString printer;
printer(s);     //cout中打印s，后面跟一个空格
PrintString errors(cerr,'
');
errors(s);      //cerr中打印s，后面跟一个换行符

函数对象通常是作为泛型算法的实参：

for_each(vs.begin(),vs.end(),PrintString(cerr,"
"));

lambda 是函数对象

编写了一个 lambda 后，编译器将该表达式翻译成一个未命名类的未命名对象。

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

其行为类似下面这个类的一个未命名对象：

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

使用上面的类重写 stable_sort :

stable_sort(words.begin(),words.end(),ShorterString());

表示 lambda 及相应捕获行为的类

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

该 lambda 表达式产生的类将形如：

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

auto wc = find_if(words.begin(),words.end(),SizeComp(sz))

标准库定义的函数对象

标准库定义了一组表示算术运算符、关系运算符和逻辑运算符的类，每个类分别定义了一个执行命名操作的调用运算符。

plus<int> intAdd;   //可执行int加法的函数对
negate<int> intNegate;  //可对int值取反的函数对象
int sum = intAdd(10,20);    //sum=30
sum = intAdd(10,intNegate(10)); //sum=0

定义在 functional 头文件中的函数对象：

在算法中使用标准库函数对象

// 传入一个临时函数对象用于执行两个 string 对象的比较运算
sort(svec.begin(),svec.end(),greater<string>());

标准库规定其函数对象对于指针同样适用：

vector<string *> nameTable; //指针的vector
//错误：nameTable 中的指针彼此之间没有任何关系，所以 < 将产生未定义的行为
sort(nameTable.begin(),nameTable.end(),[](string *a,string *b){return a < b;}) ;
//正确，标准库规定指针的 less 定义是良好的
sort(nameTable.begin(),nameTable.end(),less<string*>());

可调用对象与 function

C++ 中的可调用对象包括：函数、函数指针、lambda 表达式、bind 创建的对象以及重载了函数调用运算符的类。

可调用对象也有类型，labmda 有自己唯一的未命名类型，函数及函数指针的类型由其返回值类型和实参类型决定。两个不同类型的可调用对象却可能共享同一种调用形式，调用形式指明了返回类型以及传递给调用的实参类型，一种调用形式对应一个函数类型：

int (int,int)   //是一个函数类型，它接受两个int，返回一个int

不同的类型可能具有相同类型的调用方式

int add(int i,int j){return i + j;}
auto mod = [](int i,int j){return i % j;}
struct divide{
    int operator()(int denminator,int divisor){
        return denminator / divisor;
    }
};

尽管这些可调用对象对其参数执行了不同的算术运算，尽管它们的类型各不相同，但是共享一种调用形式：

int (int,int)

构建实现不同运算的函数表：

map<string,int(*)(int,int)> binops;
binops.insert({"+",add});

binops.insert({"%",mod});   //错误，mod不是函数指针

标准库 function 类型

function 定义在 functional 头文件中：

function 是一个模板，创建具体的 function 类型时需要提供额外的信息。

function<int(int,int)>

function<int(int,int)> f1 = add;        //函数指针
function<int(int,int)> f2 = divide;     //函数对象类的对象
function<int(int,int)> f3 = [](int i,int j){return i * j;}      //lambda

//调用
cout<<f1(4,2)<<endl;
cout<<f2(4,2)<<endl;
cout<<f3(4,2)<<endl;

使用 function 重新定义上面的函数表：

map<string,function<int(int,int)>> binops = 
{
    {"+",add},      //函数指针
    {"-",std::minus<int>()},        //标准库函数对象
    {"/",divide},       //自定义函数对象
    {"*",[](int i,int j){return i * j;}},           //未命名lambda表达式
    {"%",mod},              //命名lambda表达式
};

调用：

binops["+"](10,5);
binops["-"](10,5);
binops["/"](10,5);
binops["*"](10,5);
binops["%"](10,5);

重载的函数与 function

不能直接将重载函数的名字存入 function 类型的对象中。

int add(int i,int j){return i + j;}
Sales_data add(const Sales_data&,const Sales_data&)；
map<string,funciton<int(int,int)>> binops;
binops.insert({"+",add});       //错误，不能区分是哪个add 

解决上面问题的有效途径是存储函数指针而非函数名字：

int (*fp) (int,int) = add;
binops.insert("add",fp);    //正确，fp指向正确的add版本

同样，也可以使用 lambda 来指定希望使用的 add 版本：

binops.insert({"+"},[](int a,in b){return add(a,b);});