functor 是什么？
在阅读Tensorflowy源码时看到了这个，后来明白这是个命名空间，但查了一下原来functor并不简单，以后很可能会用到，特此转载记下。
下面是转载的作者原文：
引子
有一次在美团面试的时候，第二轮面试官问道：“听说过functor吗？”，妈呀，6年了，竟然没听说过这个概念，今天就学习了一会，哎，天不遂人愿，老天弄人啊，其实这个东西我们大家都不止一次的在使用它。举个例子（注意for_each的第三个参数）：
- // for_each example
- #include <iostream> // std::cout
- #include <algorithm> // std::for_each
- #include <vector> // std::vector
- void myfunction (int i) { // function:
- std::cout << ' ' << i;
- }
- struct myclass { // function object type:
- void operator() (int i) {std::cout << ' ' << i;}
- } myobject;
- int main () {
- std::vector<int> myvector;
- myvector.push_back(10);
- myvector.push_back(20);
- myvector.push_back(30);
- std::cout << "myvector contains:";
- for_each (myvector.begin(), myvector.end(), myfunction);
- std::cout << '\n';
- // or:
- std::cout << "myvector contains:";
- for_each (myvector.begin(), myvector.end(), myobject);
- std::cout << '\n';
- return 0;
- }
是的，这就是functor的思想。
补充一下functor的实现（各个人实现可能不一样哦，不同的库，不同的语言也可能不一样哦），仅供参考：
- template<class InputIterator, class Function>
- Function for_each(InputIterator first, InputIterator last, Function fn)
- {
- while (first!=last) {
- fn (*first);
- ++first;
- }
- return fn; // or, since C++11: return move(fn);
- }
什么是functor？
functor的英文解释为something that performs a function，即其行为类似函数的东西。C++中的仿函数是通过在类中重载()运算符实现，使你可以像使用函数一样来创建类的对象。
为什么使用仿函数（functor）
迭代和计算逻辑分离
使用仿函数可以使迭代和计算分离开来。因而你的functor可以应用于不同场合，在STL的算法中就大量使用了functor.
参数可设置
可以很容易通过给仿函数（functor）设置参数，来实现原本函数指针才能实现的功能.
有状态
与普通函数另一个区别是仿函数（functor）是有状态的.
性能
我们看一下代码：
std::transform(in.begin(), in.end(), out.begin(), add_x(1));编译器可以准确知道std::transform需要调用哪个函数（add_x::operator）。这意味着它可以内联这个函数调用。而如果使用函数指针，编译器不能直接确定指针指向的函数，而这必须在程序运行时才能得到并调用。
一个例子就是比较std::sort 和qsort ，STL的版本一般要快5-10倍。
#include <iostream> #include <math.h> using namespace std; class Pow { public: double operator()(double x, int y) {
double xx = x; for (int i = 0; i < y-1; i++) x *=xx; return x; } }; int main() { int a = 5; cout << pow(a, 2) << endl; Pow mypow; cout << "mypow:" << mypow(a, 2); return 0; }
for (auto itr = vi.begin(); itr != vi.end(); ++itr) { cout << *itr << endl; }
for (auto i:vi) { cout << i << endl; }
转载于:https://www.cnblogs.com/aelite/p/11306579.html
functor就是一个重载了 operator()的类，用这个类生成的实例就像一个函数。（functor就是一个作为函数用的类），在c++11后可以用lambda函数实现同样的功能。
参考链接：stackoverflow
// this is a functor
struct add_x {
add_x(int x) : x(x) {}
int operator()(int y) const { return x + y; }
private:
int x;
};
// 这也是一个functor
struct inc{
int operator()(int _i) { return _i + 1;}
};
// Now you can use it like this:
add_x add42(42); // create an instance of the functor class
int i = add42(8); // and "call" it
assert(i == 50); // and it added 42 to its argument, 检查i是否等于50
std::vector<int> in; // assume this contains a bunch of values)
std::vector<int> out(in.size());
// Pass a functor to std::transform, which calls the functor on every element
// in the input sequence, and stores the result to the output sequence
// add_x(1), 相当于创建了 add_x add1(1)
// add1 相当于一个函数，传入一个int参数， 这个int 会加上 1
std::transform(in.begin(), in.end(), out.begin(), add_x(1));
//相当于
inc i_1;
std::transform(in.begin(), in.end(), out.begin(), i_1);
// 效果和下面这句相同
std::transform(in.begin(), in.end(), out.begin(), [](int x){ return x + 1;});
assert(out[i] == in[i] + 1); // for all i
定义：是一个容器，也是个普通函数，实现了flapMap接口（map函数），在遍历每个值得时候生成新的对象。
这个过程是无副作用地、不可变的访问和修改操作。包裹不安全的值，提升代码健壮性。避免程序异常中断。
隔离不纯、合并判空逻辑、避免异常、支持函数组合Functor函子
/** * 不能使用箭头函数 * 箭头函数没有constructor和prototype * @constructor */ interface Functor<T> { (arg: T): T, of: any, prototype: object, } // 创建一个容器 const Functor = function <Functor>(val) { this.value = val; } // 添加of接口，省略new去创建 Functor.of = function (val) { // @ts-ignore return new Functor(val); } // 实现map接口 Functor.prototype.map = function (fn) { return Functor.of(fn(this.value)); } const v = Functor.of(2); const t = Functor.of({a: 1}); const r = Functor.of([1, 2]); console.log(v, t, r); // Functor { value: 2 } Functor { value: { a: 1 } } Functor { value: [ 1, 2 ] } console.log(v.map((x)=> { return x * x }).map((x)=> { return x + x; })); // Functor { value: 8 }Maybe
集中管理无效数据的检查，可合并判空，避免异常，（增加了判空逻辑）但是无法详细的给出错误的位置
/** * 创建一个MayBe容器 * @param val * @constructor */ const MayBe = function <Functor>(val) { this.value = val; }; // 添加of接口，省略new去创建 MayBe.of = function (val) { // @ts-ignore return new MayBe(val); }; /** * 定义isNothing函数 判断数据是否为空 */ MayBe.prototype.isNothing = function () { return this.value !== undefined && this.value !== null; }; /** * 重写map函数 * @param fn */ MayBe.prototype.map = function (fn) { return this.isNothing() ? MayBe.of(null) : MayBe.of(fn(this.value)); }; // 测试代码 const n = MayBe.of(null).map((v) => { return v * 1; }).map((v) => { return v; }); console.log(n); // MayBe { value: null }Either函子
可从故障中恢复，并给出具体的错误位置（增加了异常捕获），可延迟抛出异常，使代码可正常执行
/** * Either函子 */ // 创建一个Either容器 const Either = function <Functor>(val) { this.value = val; }; // 添加of接口，省略new去创建 Either.of = function (val) { // @ts-ignore return new Either(val); }; // 创建一个Nothing容器 包裹错误信息 const Nothing = function <Functor>(val) { this.value = val; }; // 添加of接口，省略new去创建 Nothing.of = function (val) { // @ts-ignore return new Nothing(val); }; // 定义map接口 Nothing.prototype.map = function (fn) { return this; }; Either.Nothing = Nothing; /** * 定义map接口 * @param fn */ Either.prototype.map = function (fn) { try { return Either.of(fn(this.value)); } catch (e) { return Either.Nothing.of(e); } }; // 测试代码 const e = Either.of(undefined).map((v) => { return v.length / 0; }).map((v) => { return v; }); console.log(e); // Nothing { // value: TypeError: Cannot read property 'length' of undefined // at ... // 以下代码 会打印出来 不会中断程序执行 console.log(4444); // 4444 console.log(6666); // 6666
