C++【STL】 | 仿函数的应用以及如何规范要求

就是让一个类的使用看起来像一个类函数。实际上，实现就是实现一个类operator()，这一类有类似函数的行为，即仿函数类；

class Func { 
         public:  void operator() () const { 
           statements;  } }; 

STL仿函数也涉及很多，有时使用仿函数是为了函数为了实现安全传性质函数指针、依据函数生成对象、甚至在函数之间继承关系，函数运算和操作的效果；

//less的定义 template<typename _Tp>  struct less : public binary_function<_Tp, _Tp, bool> { 
               bool operator()(const _Tp& __x, const _Tp& __y) const        { 
         return __x < __y; } };   //set的申明 template<typename _Key,      typename _Compare = std::less<_Key>,     typename _Alloc = std::allocator<_Key>> class set; 

• 比一般函数灵巧，可拥有状态；对于仿函数，可同时拥有两个状态不同的实体；
• 每个仿函数都有其型别，可使用template来传参；
• 阔以使用内联函数，执行速度通常比函数指针更快；
• 阔以使用成员变量，以免去对一些公共变量的维护，也可以使重复使用的代码独立出来；
• 也阔以进行依赖、组合与继承；

在开发过程经常需要使用已序的对象置于容器中，但我们一般不使用operator来排序，从而使用仿函数来操作；

class FuncSort { 
        
public:
	/** 可自定义排序准则 */
	void operator() (const Person& p2) const { 
        
		return num < p2.num;
	}
};

/*---------------------------------------------------------------------- > File Name: test.cpp > Author: Jxiepc > Mail: Jxiepc > Created Time: Mon 07 Mar 2022 04:08:01 PM CST ----------------------------------------------------------------------*/

#include 
#include 
#include 

class Func { 
        
    public:
        Func(int val) : m_val(val) { 
        
        }

        int operator() () { 
        
            return m_val++;
        }
    private:
        int m_val;
};

int main(int argc, char* argv[])
{ 
        
    std::list<int> coll;
    std::generate_n(std::back_inserter(coll),
            9,
            Func(4));

    for(auto& i:coll) { 
        
        std::cout << i << " ";
    }
    std::cout <<  std::endl;
    return 0;
}

根据以上实例，仿函数可维持内部val的数值，进而叠加；

当使用传值时，算法不会改变随参数而来的仿函数状态，若改变只是其中的副本；

int main(int argc, char* argv[])
{ 
        
    std::list<int> coll;
	Func f(1);
	std::generate_n(std::back_inserter(coll),
       		9,
       		f);
	std::generate_n(std::back_inserter(coll),
       		9,
       		f);
    for(auto& i:coll) { 
        
        std::cout << i << " ";
    }
    std::cout << std::endl;
    return 0;
}

当使用引用传参（或使用for_each）时，即可从中获取结果或反馈；

int main(int argc, char* argv[])
{ 
        
    std::list<int> coll;
	Func f(1);
	std::generate_n<std::back_insert_iterator<std::list<int> >, int, Func&> (std::back_inserter(coll), 9, f);
	std::generate_n(std::back_inserter(coll),
       		9,
       		f);
    for(auto& i:coll) { 
        
        std::cout << i << " ";
    }
    std::cout << std::endl;
    return 0;
}

出现了该函数可代替引用传参的方式，来获取存储的最终状态；

// 返回值为仿函数类型，在仿函数内部提供一个状态返回即可通过该返回值进行查询；
template<typename InputIterator, typename Function>
Function for_each(InputIterator beg, InputIterator end, Function f) { 
        
  while(beg != end) 
    f(*beg++);
}

即返回布尔值的一个函数或者仿函数；

为了保证这一点需要将operator声明为const成员函数；

其中通过操作数进行划分为一元和二元，通过功能划分为算术、关系、逻辑运算；

必须定义相应的型别，为了让配置器能够萃取出类型；
该型别通过typedef设定，该操作于编译器即完成，不会影响效率及带来负担；
需要的型别有哪些呢？STL提供了unary_function和binary_function分别为一元二元的型别；

unarg_function

template<class Arg, class Result>
struct unary_function { 
        
	typedef Arg argument_type;
	typedef Result result_type;
};

binary_function

template<class Arg1, class Arg2, class Result>
struct binary_function { 
        
	typedef Arg1 first_argument_type;
	typedef Arg2 second_argument_type;
	typedef Result result_type;
};

这些型别在我们真正使用仿函数时一般用不到，那用在何处呢？？？

一般用在适配器上；

template<class Operation>
class binder1st { 
        
protected:
	Operation op;
	typename Operation::first_argument_type value;
public:
	typename Operation::result_type operator()(const typename Opreator::second_argument_type& x) const { 
        
		// ....
	}
};

此类函数为STL了提供了间接性；
【identity】：证同函数，数值通过该函数，不会有任何变化；使用在map、set中告诉该类key如何得到；
【select】：选择函数，接收pair返回第一个或第二个参数；
【project】：投射函数，传回第一个或第二参数；

identity

template<class T>
struct identity : public unary_function<T, T> { 
        
    const T& operator()(const T& x) const { 
         return x; }
};

select

template<class Pair>
struct select1st : public unary_function<Pair, typename Pair::first_type>{ 
        
    const typename Pair::first_type& operator()(const Pair& x) const { 
        
        return x.first;
    }
};

template<class Pair>
struct select2nd : public unary_function<Pair, typename Pair::second_type>{ 
        
    const typename Pair::second_type& operator()(const Pair& x) const { 
        
        return x.seond;
    }
};

project

template<class Args1, class Args2>
struct project1st : public binary_function<Args1, Args2, Args1> { 
        
    Args1 operator()(const Args1& x, const Args2&) const { 
         return x;}
};

template<class Args1, class Args2>
struct project2nd : public binary_function<Args1, Args2, Args2> { 
        
    Args2 operator()(const Args1&, const Args2& y) const { 
         return y;}
};

头文件为：functional；