Essential C++学习记录&笔记整理29（实现一个function object）

快来打我* 2023-03-13 03:52 11阅读 0赞

*  **所谓函数对象就是一种提供有函数调用运算符的类**
 *  如果编译器遇到了一个函数调用，比如`lt(ival);`,那么lt这可能是个函数名或函数指针、也可能是个提供了函数调用运算符的的函数对象，如果lt是个类对象，那么编译器就会在内部将此语句转换为`lt.operator(ival);`
 *  函数调用运算符可以接受任意个参数。比如它可以支持矩阵(Matrix）这个类的多维度下标操作，而下标运算符只能接受一个参数。
 *  话不多说，咱们给一个代码示例！

//LessThan.h文件
    #ifndef _LESSTHAN_H_
    #define _LESSTHAN_H_
    
    #include<iostream>
    #include<vector>
    using namespace std;
    class LessThan
    {
        
    public:
        LessThan(int val):_val(val){
        };//采用成员初始化列表语法形式的LEssThan类构造函数
        int comp_val()const
        {
        
            return _val;//因为这个类的每个类对象在定义的时候都必须提供一个参照数（你跟谁比，比它小还是大的怎么怎么着）(comp_val)，因此这是参照数的读取
        }
        void comp_val(int nval)
        {
        
            _val=nval;//参照数的写入，这是一个重载函数（comp_val重载函数）
        }
        bool operator()(int value)const;//运算符函数的声明，供LessThan(参数)这样的()运算的表达式使用。定义放在程序代码文件里。
    private:
        int _val;//供public定义的函数用。
    };
    int count_less_than(const vector<int>&vec,int comp);
    void print_less_than(const vector<int>&vec,int comp,ostream &os=cout);
    //在LessThan.h所附属的.cpp文件里的两个非成员函数的声明在此
    #endif // _LESSTHAN_H_
    
    
    //LessThan.cpp文件
    #include"LessThan.h"
    #include<iostream>
    #include<vector>
    #include<algorithm>
    using namespace std;
    inline bool LessThan::
    operator()(int value)const//最好函数声明和定义的参数表的参数名一致。
    {
        
        return value<_val;//小于return true,否则return false
    }
    //函数调用运算符的实现。然而重载运算符的运算符函数的定义必须和用到的重载运算符的
    //地方或函数要放在一个文件里，否则编译器报错
    int count_less_than(const vector<int>&vec,int comp)
    {
        
        //从vector容器里挑出比某个参照数小的元素，计数有多少个这样的元素
        LessThan lt(comp);//定义LessThan类对象。（就像LessThan lt10(10);）
        //（和定义一般对象一样的定义方式，只是这个类对象需要有一个参照数（初始值，即类对象定义的时候就被初始化了）
        int count=0;
        for(int ix=0;ix<vec.size();ix++)
        {
        
            if(lt( vec[ix] ))//()运算符重载（针对了lt这个类对象在()前的形式的重载），所以这个就是个判断vector容器里的某个元素是否比comp这个参照数小，
            //这里提示了undefined reference to `LessThan::operator()(int) const'|||error: ld returned 1 exit status|
            //小的话if(true)，否则if(false)
            {
        
                ++count;//比参照数小，计入count里
            }//否则什么也不做
        }
        return count;//返回有多少个比参照数小的元素个数
    
    
    }
    
    void print_less_than(const vector<int>&vec,int comp,ostream &os)//②默认值**只能指定一次**，在函数声明或定义，不能全给指定了，这是
    //默认参数值的提供的两个规则之一，另一个是①默认值的解析操作从最右边开始进行，
    //也就是说我们给某个参数提供了默认值则其右边的所有参数必须拥有默认值！（该规则主要体现在函数声明或定义中）
    //否则编译器报错
    {
        
        LessThan lt(comp);//定义LessThan类对象。（就像LessThan lt10(10);）
        //（和定义一般对象一样的定义方式，只是这个类对象需要有一个参照数（初始值，即类对象定义的时候就被初始化了）
        vector<int>::const_iterator iter=vec.begin(),it_end=vec.end();//常量型泛型指针的定义（常量型泛型指针不会改变指向的容器的内容，
        //同时这么写会告诉程序读者我不会改变泛型指针指向的容器的内容。
        os<<"elemts less than "<<lt.comp_val()<<endl;//调用类对象里的public（公共）成员函数
        while((iter = find_if(iter,it_end,lt))!=it_end)//找出第一个比lt类对象里的参照数小的元素（关于find_if()这个泛型算法的函数原型请查阅资料）
        //那个（）注意不要括错了,会有
        //error: no match for 'operator=' (operand types are 'std::vector<int>::const_iterator {aka __gnu_cxx::__normal_iterator<const int*, std::vector<int> >}' and 'bool')|
        //这样的报错
        //资料：（注意，用了泛型算法，得包含#include<algorithm>!!!!!!!!!!
        /** template<class InputIterator, class Predicate>
      InputIterator find_if ( InputIterator first, InputIterator last, Predicate pred )
      {
        for ( ; first!=last ; first++ ) if ( pred(*first) ) break;
        return first;
      }
         */
        //它在区间[first,end)中搜寻使一元判断式pred为true的第一个元素。如果没找到，返回end。
        //通常我们把函数对象当作参数传给泛型算法，就体现在了find_if()这一行。
        {
        
            os<<*iter<<' ';//输出小于参照数的vector容器的元素。
            ++iter;//泛型指针迭代，辅助输出符合条件的元素
        }
    }
    
    
    //main.cpp文件
    #include<iostream>
    #include<vector>
    #include"LessThan.h"
    #include<algorithm>
    using namespace std;
    
    int main()//测试。
    {
        
        int ia[16]={
        17,12,44,9,18,45,6,14,23,67,9,0,27,55,8,16};
        vector<int>vec(ia,ia+16);
        //vector容器的建立和初始化
        int comp_val=20;//参照数的设置
        cout<<"Numeber of elements less than "<<comp_val<<" are "<<count_less_than(vec,comp_val)<<endl;
        //小于参照数的vector容器里的元素有多少个
        print_less_than(vec,comp_val);//输出上述的这些个元素
        return 0;
    }

*  注意几点编译器报错信息：  
    ①**重载运算符的运算符函数的定义最好和用到的重载运算符的地方或函数要放在一个文件里**，否则编译器报错说undefined reference to \`LessThan::operator()(int) const’|  
    ②（）注意不要括错了,会有

error: no match for 'operator=' (operand types are 'std::vector<int>::const_iterator {aka __gnu_cxx::__normal_iterator<const int*, std::vector<int> >}' and 'bool')

这样的报错

③（注意，用了泛型算法，得包含`#include<algorithm>`!!!）  
④默认值**只能指定一次**，**在函数声明或定义，不能全给指定了，这是默认参数值的提供的两个规则之一**，另一个是①默认值的解析操作从最右边开始进行，也就是说我们给某个参数提供了默认值则其右边的所有参数必须拥有默认值！（该规则主要体现在函数声明或定义中）  
否则编译器报错`error: default argument given for parameter 3 of 'void print_less_than(const std::vector<int>&, int, std::ostream&)' [-fpermissive]|`

程序运行结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTkxMDQwOA_size_16_color_FFFFFF_t_70]  
好了，如何实现一个函数对象就在代码里解释了，多揣摩多写写就明白了。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTkxMDQwOA_size_16_color_FFFFFF_t_70]: /images/20230312/8af97c3e37a940b09a9f39bb51a8bb8e.png