码迷，mamicode.com
首页 > 编程语言 > 详细

【足迹C++primer】48、函数引用操作符

时间：2014-07-20 10:32:09      阅读：380      评论：0      收藏：0      [点我收藏+]

标签：操作符重载   函数引用操作符   标准库函数   库函数类型   lambda   

函数引用操作符

struct absInt
{
    int operator()(int val) const
    {
        cout<<val<<"<->!!!"<<endl;
        return val<0 ? -val : val;
    }
};


void fun1()
{
    int i=-42;
    absInt absObj;
    int ui=absObj(i);
}


bubuko.com,布布扣

Function-Object Classes with State
函数对象类的状态

class PrintString
{
public:
    PrintString(ostream &o=cout, char c=' '):os(o), sep(c) {}   //构造函数
    void operator()(const string &s) const {os<<">>>>-----<<<<"<<s<<sep<<"yeah!"<<endl;}   //函数操纵符
    void operator()(const int i, const string &s1, const string &s2) const
    {
        if(i)
        {
            os<<"3 个参数 cutter_point-"<<s1<<endl;
        }
        else
        {
            os<<"3 个参数 cutter_point-"<<s2<<endl;
        }
    }

private:
    ostream &os;    //输出流
    char    sep;
};

void fun2()
{
    string s="cutter_point";
    PrintString printer;        //默认构造函数
    printer(s);     //调用操作符函数,输出:>>>>-----<<<<cutter_point yeah!
    PrintString errors(cerr, '\n'); //上面yeah!前面变成换行
    errors(s);

    vector<string> vs;
    for(size_t i=0 ; i != 7 ; ++i)
    {
        stringstream ss;
        ss<<i<<"-cutter_point";
        vs.push_back(ss.str());
    }
    for_each(vs.begin(), vs.end(), PrintString(cerr, '\n'));

    PrintString three;
    three(1, "我就是这么屌！", "没有，也就一般般啦！");
}

14.8.1. Lambdas Are Function Objects

void fun3()
{
    vector<string> words;
    for(size_t i=0 ; i != 7 ; ++i)
    {
        stringstream ss;
        ss<<i<<"-cutter_point";
        words.push_back(ss.str());
    }
    stable_sort(words.begin(), words.end(), [](const string &a, const string &b){return a.size()<b.size();});
    for_each(words.begin(), words.end(), PrintString(cout, '3'));
}

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

void fun4()
{
    vector<string> words;
    for(size_t i=8 ; i != -1 ; --i)
    {
        stringstream ss;
        ss<<i<<"-cutter_point";
        words.push_back(ss.str());
    }
    words.push_back("test排序");

    stable_sort(words.begin(), words.end(), ShorterString());
    for(vector<string>::iterator it=words.begin() ; it != words.end() ; ++it)
        cout<<*it<<"\t";
}

bubuko.com,布布扣

Classes Representing Lambdas with Captures

void fun5()
{
    vector<string> words;
    vector<string>::size_type sz=5;
    for(size_t i=8 ; i != -1 ; --i)
    {
        stringstream ss;
        ss<<i<<"-cutter_point";
        words.push_back(ss.str());
    }
    words.push_back("test排序");

    //得到一个指向第一个s.size()>sz的元素
    auto wc=find_if(words.begin(), words.end(), [sz](const string &a){return a.size() >= sz;});
    for(vector<string>::iterator it=words.begin() ; it != words.end() ; ++it)
        cout<<*it<<"\t";
    if(wc != words.end())
    {
        cout<<"wc:"<<*wc<<endl;
    }

}

class SizeComp
{
public:
    SizeComp(size_t n):sz(n) {} //构造函数
    bool operator()(const string &s) const {return s.size()>=sz;}
private:
    size_t sz;
};

void fun6()
{
    vector<string> words;
    vector<string>::size_type sz=6;
    for(size_t i=8 ; i != -1 ; --i)
    {
        stringstream ss;
        ss<<i<<"-cutter_point";
        words.push_back(ss.str());
    }
    words.push_back("test排序");

    //得到一个指向第一个s.size()>sz的元素
    auto wc=find_if(words.begin(), words.end(), SizeComp(sz));
    ///这里为什么会引用operator()操作呢？？

    cout<<endl;
    if(wc != words.end())
    {
        cout<<"wc:"<<*wc<<endl;
    }
}

bubuko.com,布布扣

14.8.2. Library-Defined Function Objects

bubuko.com,布布扣
void fun7()
{
    plus<int> intAdd;       //这个是可以加两个int型数字
    negate<int> intNegate;  //求相反数
    int sum=intAdd(10, 20); //结果30
    cout<<sum<<endl;
    sum=intNegate(intAdd(10, 20));  //结果-30
    cout<<sum<<endl;
    sum=intAdd(10, intNegate(10));  //结果0
    cout<<sum<<endl;
}

Using a Library Function Object with the Algorithms
void fun8()
{
    vector<string> svec={"i","like","china","so","much","I","can","just","do","it"};
    //通过一个临时的函数对象应用<操作对两个string
    sort(svec.begin(), svec.end(), greater<string>());
    //输出结果按字典位置排序，然后大写在后,递减排序
    for_each(svec.begin(), svec.end(), [](string &s){cout<<s<<"\t";});
}

通过指针直接操作内存的地址，来改变排序

void fun9()
{
    vector<string> svec={"i","like","china","so","much","I","can","just","do","it"};
    vector<string*> nameTable;
    for(vector<string>::iterator it=svec.begin() ; it != svec.end() ; ++it)
    {
        string* s=new string;   //这里new string一定要加！！,为了给s分配空间
        *s=*it;
        nameTable.push_back(s);
    }

//    sort(nameTable.begin(), nameTable.end(), [](string* a, string* b){return a<b;});
    sort(nameTable.begin(), nameTable.end(), less<string*>());
    //输出的是按内存位置来输出的
    for(vector<string*>::iterator it=nameTable.begin() ; it != nameTable.end() ; ++it)
        cout<<*(*it)<<"\t";
}

bubuko.com,布布扣

14.8.3. Callable Objects and function
可调用对象和函数


Different Types Can Have the Same Call Signature


int add(int i, int j) {return i+j;}
void fun10()
{
    auto mod=[](int i, int j){return i%j;};
}
struct div2 //这里不要用div好像是和stdlib.h冲突了
{
    int operator()(int denominator, int divisor){return denominator/divisor;}
};

//上面三个都是int(int, int)类型的

我们可以定义一个map，用string类型来关联相应的函数，用string作为标识
void fun11()
{
    auto mod=[](int i, int j){return i%j;};
    map<string, int(*)(int, int)> binops;   //这是一个函数指针,返回一个int类型
    //这里add是一个指向+运算的指针,div是不能这样加的，它不是指针
    binops.insert({"+", add});
    binops.insert({"%", mod});
//    binops.insert({"/", div2});
}

库函数类型

bubuko.com,布布扣
void fun12()
{
    function<int(int, int)> f1=add;     //函数指针,这个是加法
    function<int(int, int)> f2=div2();   //调用()操作符,这个是除法
    function<int(int, int)> f3=[](int i, int j) {return i*j;};  //lambda返回乘法
    cout<<f1(4,2)<<endl;    //6
    cout<<f2(4,2)<<endl;    //2
    cout<<f3(4,2)<<endl;    //8
}

void fun13()
{
    auto mod=[](int i, int j){return i%j;};
    map<string, function<int(int, int)>> binops=
    {
        {"+", add},{"-", std::minus<int>()},{"/", div2()},{"*", [](int i, int j){return i*j;}},
        {"%", mod}
    };  //这个map有五个元素，当我们索引这个map的时候，我们可以调用这五个函数类型

    cout<<"+ <--->"<<binops["+"](10, 5)<<endl;
    cout<<"- <--->"<<binops["-"](10, 5)<<endl;
    cout<<"/ <--->"<<binops["/"](10, 5)<<endl;
    cout<<"* <--->"<<binops["*"](10, 5)<<endl;
    cout<<"% <--->"<<binops["%"](10, 5)<<endl;
}

bubuko.com,布布扣

Overloaded Functions and function
重载的函数和功能

void fun14()
{
    map<string, function<int(int, int)>> binops;
    int (*fp)(int, int)=add;
    binops.insert({"+", fp});   //用函数指针来避免重载,或者同名函数的含糊不清
    //含有一个很好的办法就是使用lambda来消除歧义是非常好的
    binops.insert({"+", [](int a, int b){return add(a,b);}});

}

在新的库函数类是不相关的类命名为
unary_function和binary_function是较早的版本的一部分
标准库。这些类被更一般的结合使用函数取代

全代码！


/**
* 功能:函数引用操作符
* 时间:2014年7月18日16:11:45
* 作者:cutter_point
*/

#include<iostream>
#include<cstring>
#include<vector>
#include<algorithm>
#include<sstream>
#include<string>
#include<map>
#include<functional>

using namespace std;

struct absInt
{
    int operator()(int val) const
    {
        cout<<val<<"<->!!!"<<endl;
        return val<0 ? -val : val;
    }
};

void fun1()
{
    int i=-42;
    absInt absObj;
    int ui=absObj(i);
}

/**
Function-Object Classes with State
函数对象类的状态
*/
class PrintString
{
public:
    PrintString(ostream &o=cout, char c=' '):os(o), sep(c) {}   //构造函数
    void operator()(const string &s) const {os<<">>>>-----<<<<"<<s<<sep<<"yeah!"<<endl;}   //函数操纵符
    void operator()(const int i, const string &s1, const string &s2) const
    {
        if(i)
        {
            os<<"3 个参数 cutter_point-"<<s1<<endl;
        }
        else
        {
            os<<"3 个参数 cutter_point-"<<s2<<endl;
        }
    }

private:
    ostream &os;    //输出流
    char    sep;
};

void fun2()
{
    string s="cutter_point";
    PrintString printer;        //默认构造函数
    printer(s);     //调用操作符函数,输出:>>>>-----<<<<cutter_point yeah!
    PrintString errors(cerr, '\n'); //上面yeah!前面变成换行
    errors(s);

    vector<string> vs;
    for(size_t i=0 ; i != 7 ; ++i)
    {
        stringstream ss;
        ss<<i<<"-cutter_point";
        vs.push_back(ss.str());
    }
    for_each(vs.begin(), vs.end(), PrintString(cerr, '\n'));

    PrintString three;
    three(1, "我就是这么屌！", "没有，也就一般般啦！");
}

/**
14.8.1. Lambdas Are Function Objects
*/
void fun3()
{
    vector<string> words;
    for(size_t i=0 ; i != 7 ; ++i)
    {
        stringstream ss;
        ss<<i<<"-cutter_point";
        words.push_back(ss.str());
    }
    stable_sort(words.begin(), words.end(), [](const string &a, const string &b){return a.size()<b.size();});
    for_each(words.begin(), words.end(), PrintString(cout, '3'));
}

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

void fun4()
{
    vector<string> words;
    for(size_t i=8 ; i != -1 ; --i)
    {
        stringstream ss;
        ss<<i<<"-cutter_point";
        words.push_back(ss.str());
    }
    words.push_back("test排序");

    stable_sort(words.begin(), words.end(), ShorterString());
    for(vector<string>::iterator it=words.begin() ; it != words.end() ; ++it)
        cout<<*it<<"\t";
}

/**
Classes Representing Lambdas with Captures
*/
void fun5()
{
    vector<string> words;
    vector<string>::size_type sz=5;
    for(size_t i=8 ; i != -1 ; --i)
    {
        stringstream ss;
        ss<<i<<"-cutter_point";
        words.push_back(ss.str());
    }
    words.push_back("test排序");

    //得到一个指向第一个s.size()>sz的元素
    auto wc=find_if(words.begin(), words.end(), [sz](const string &a){return a.size() >= sz;});
    for(vector<string>::iterator it=words.begin() ; it != words.end() ; ++it)
        cout<<*it<<"\t";
    if(wc != words.end())
    {
        cout<<"wc:"<<*wc<<endl;
    }

}

class SizeComp
{
public:
    SizeComp(size_t n):sz(n) {} //构造函数
    bool operator()(const string &s) const {return s.size()>=sz;}
private:
    size_t sz;
};

void fun6()
{
    vector<string> words;
    vector<string>::size_type sz=6;
    for(size_t i=8 ; i != -1 ; --i)
    {
        stringstream ss;
        ss<<i<<"-cutter_point";
        words.push_back(ss.str());
    }
    words.push_back("test排序");

    //得到一个指向第一个s.size()>sz的元素
    auto wc=find_if(words.begin(), words.end(), SizeComp(sz));
    ///这里为什么会引用operator()操作呢？？

    cout<<endl;
    if(wc != words.end())
    {
        cout<<"wc:"<<*wc<<endl;
    }
}

/**************************************
14.8.2. Library-Defined Function Objects
**************************************/
void fun7()
{
    plus<int> intAdd;       //这个是可以加两个int型数字
    negate<int> intNegate;  //求相反数
    int sum=intAdd(10, 20); //结果30
    cout<<sum<<endl;
    sum=intNegate(intAdd(10, 20));  //结果-30
    cout<<sum<<endl;
    sum=intAdd(10, intNegate(10));  //结果0
    cout<<sum<<endl;
}

/**************************************
Using a Library Function Object with the Algorithms
**************************************/
void fun8()
{
    vector<string> svec={"i","like","china","so","much","I","can","just","do","it"};
    //通过一个临时的函数对象应用<操作对两个string
    sort(svec.begin(), svec.end(), greater<string>());
    //输出结果按字典位置排序，然后大写在后,递减排序
    for_each(svec.begin(), svec.end(), [](string &s){cout<<s<<"\t";});
}

//通过指针直接操作内存的地址，来改变排序
void fun9()
{
    vector<string> svec={"i","like","china","so","much","I","can","just","do","it"};
    vector<string*> nameTable;
    for(vector<string>::iterator it=svec.begin() ; it != svec.end() ; ++it)
    {
        string* s=new string;   //这里new string一定要加！！,为了给s分配空间
        *s=*it;
        nameTable.push_back(s);
    }

//    sort(nameTable.begin(), nameTable.end(), [](string* a, string* b){return a<b;});
    sort(nameTable.begin(), nameTable.end(), less<string*>());
    //输出的是按内存位置来输出的
    for(vector<string*>::iterator it=nameTable.begin() ; it != nameTable.end() ; ++it)
        cout<<*(*it)<<"\t";
}

/**************************************
14.8.3. Callable Objects and function
可调用对象和函数
**************************************/

/**
Different Types Can Have the Same Call Signature
*/
int add(int i, int j) {return i+j;}
void fun10()
{
    auto mod=[](int i, int j){return i%j;};
}
struct div2 //这里不要用div好像是和stdlib.h冲突了
{
    int operator()(int denominator, int divisor){return denominator/divisor;}
};

//上面三个都是int(int, int)类型的

/*
我们可以定义一个map，用string类型来关联相应的函数，用string作为标识
*/
void fun11()
{
    auto mod=[](int i, int j){return i%j;};
    map<string, int(*)(int, int)> binops;   //这是一个函数指针,返回一个int类型
    //这里add是一个指向+运算的指针,div是不能这样加的，它不是指针
    binops.insert({"+", add});
    binops.insert({"%", mod});
//    binops.insert({"/", div2});
}

/**
库函数类型
*/
void fun12()
{
    function<int(int, int)> f1=add;     //函数指针,这个是加法
    function<int(int, int)> f2=div2();   //调用()操作符,这个是除法
    function<int(int, int)> f3=[](int i, int j) {return i*j;};  //lambda返回乘法
    cout<<f1(4,2)<<endl;    //6
    cout<<f2(4,2)<<endl;    //2
    cout<<f3(4,2)<<endl;    //8
}

void fun13()
{
    auto mod=[](int i, int j){return i%j;};
    map<string, function<int(int, int)>> binops=
    {
        {"+", add},{"-", std::minus<int>()},{"/", div2()},{"*", [](int i, int j){return i*j;}},
        {"%", mod}
    };  //这个map有五个元素，当我们索引这个map的时候，我们可以调用这五个函数类型

    cout<<"+ <--->"<<binops["+"](10, 5)<<endl;
    cout<<"- <--->"<<binops["-"](10, 5)<<endl;
    cout<<"/ <--->"<<binops["/"](10, 5)<<endl;
    cout<<"* <--->"<<binops["*"](10, 5)<<endl;
    cout<<"% <--->"<<binops["%"](10, 5)<<endl;
}

/**
Overloaded Functions and function
重载的函数和功能
*/
void fun14()
{
    map<string, function<int(int, int)>> binops;
    int (*fp)(int, int)=add;
    binops.insert({"+", fp});   //用函数指针来避免重载,或者同名函数的含糊不清
    //含有一个很好的办法就是使用lambda来消除歧义是非常好的
    binops.insert({"+", [](int a, int b){return add(a,b);}});

}

/*
在新的库函数类是不相关的类命名为
unary_function和binary_function是较早的版本的一部分
标准库。这些类被更一般的结合使用函数取代
*/

int main()
{
    cout<<">>----------------fun1---------------------<<"<<endl;
    fun1();
    cout<<">>----------------fun2---------------------<<"<<endl;
    fun2();
    cout<<">>----------------fun3---------------------<<"<<endl;
    fun3();
    cout<<">>----------------fun4---------------------<<"<<endl;
    fun4();
    cout<<">>----------------fun5---------------------<<"<<endl;
    fun5();
    cout<<">>----------------fun6---------------------<<"<<endl;
    fun6();
    cout<<">>----------------fun7---------------------<<"<<endl;
    fun7();
    cout<<">>----------------fun8---------------------<<"<<endl;
    fun8();
    cout<<">>----------------fun9---------------------<<"<<endl;
    fun9();
    cout<<">>----------------fun12---------------------<<"<<endl;
    fun12();
    cout<<">>----------------fun13---------------------<<"<<endl;
    fun13();

    system("pause");
    return 0;
}

PS：今天早上有点晚了，不行，以后每天早上坚持至少8点开始，7点起床！！！努力，我要学的东西还很多，远远不够，时间如此紧迫，怎可徒费光阴！！！




【足迹C++primer】48、函数引用操作符

标签：操作符重载   函数引用操作符   标准库函数   库函数类型   lambda   

原文地址：http://blog.csdn.net/cutter_point/article/details/37988551
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！