精华内容
下载资源
问答
  • 函数对象

    千次阅读 2007-09-12 12:01:00
    利用C++标准模板库的算法可以为我们减轻许多负担,但这些算法大都需要函数或函数对象作为参数,比如用于排序的sort算法,它的接口定义如下:template void sort (RandomAccessIterator first, RandomAccessIterator ...
    利用C++标准模板库的算法可以为我们减轻许多负担,但这些算法大都需要函数或函数对象作为参数,比如用于排序的sort算法,它的接口定义如下:
    template <class RandomAccessIterator>
    void sort (RandomAccessIterator first,
               RandomAccessIterator last);
    template <class RandomAccessIterator, class Compare>
    void sort (RandomAccessIterator first,
               RandomAccessIterator last, Compare comp);
    第1种语法只适合对属于基本数据类型的对象排序,它使用<作为排序比较规则,第2种语法则是根据指定排序规则comp来进行排序,其中comp参数就是一个函数对象。如果要排序的对象不是如int,float等简单类型或不想使用<作为排序规则的话就得使用第2种语法,指定一个函数对象来作为排序规则(函数对象)进行排序,那函数对象究竟是什么了,其实简单地说它就是一些使用起来像调用函数一样的对象,如:一般的函数,函数指针,或重载了()运算符的类的实例等,使用这些对象的方式好像调用函数一样所以称这些对象为函数对象,如下就是函数对象定义:
    //一般函数
     void print(int x)
    {
           if(x>=0&&x<=100) cout<<x<<” ”;
    }
           //函数对象指针
    typedef void(*ptPrint)(int x);
    ptPrint prt=print;
    //一个重载了()运算符得类
    class isOk
    {
     public:
     bool operator () (int val)
     {
           if(val<0||val>100)
    {
           return false;
    }
     return true;
    }
    };
    有了上面得定义后,我们就可以以函数调用的形式使用上面的函数对象了,如: for_each(vectorA.begin(),vectorA.end(),print)打印大于等于0小于等于100的数, transform(vectorA.begin(),vectorA.end(),vectorB.begin(),isOk())判断向量vectorA中值x的范围是否在0之100之间,如果在则向量vectorB对应的值为真,否则为假,其中vectorB中的数据类型为bool。在实际中往往会根据调用函数对象时参数的多少将函数对象分为三种形式,,无参函数对象,一元函数对象和二元函数对象,刚才的isOK()就是一个无参函数对象。无参函数对象与一元,二元函数对象有很大的区别,一元,二元函数对象的定义需要继承以下函数原型:
           //一元函数对象函数原型
    template <class Arg, class Result>
    struct unary_function {
     typedef Arg argument_type;
     typedef Result result_type;
    };
           //二元函数对象函数原型
    template <class Arg1, class Arg2, class Result>
    struct binary_function {
     typedef Arg1 first_argument_type;
     typedef Arg2 second_argument_type;
     typedef Result result_type;
    };
    Result为函数返回值,如果我们要定义一元或二元函数对象的话需要继承这两个函数对象的原型,如:
    class gradeCompare : binary_function<Grade,Grade, bool> {
    public:
     bool operator () (Grade X,Grade Y) const
         {
            return X.Score>Y.Score;
         }
    };
    上面就是一个二元函数对象的类,该类的实例就是二元函数对象,考虑如下情况:      
    有许多学生的成绩情况以对象的形式存在于一个向量vector中,现在我们需要对这些学生成绩进行排序,使用标准模板库的sort算法,学生成绩包含许多字段,如学号,姓名,成绩三个字段,成绩情况的对象定义如下:
    class Grade
    {
    public:
        Grade(int id,string name,int score)
        {
            ID=id;
            Name=name;
            Score=score;
        }
        int ID;
        string Name;
        int Score;
    };
     
    根据sort算法的原型,我们就必须定义一个用于比较学生成绩的函数对象如下:
    class gradeCompare : binary_function<Grade,Grade, bool> {
    public:
     bool operator () (Grade X,Grade Y) const
         {
            return X.Score>Y.Score;
         }
    };
     
    当定义了用于排序的函数对象后就可以直接调用sort算法进行排序了。
     
    sort(finalGrade.begin(),finalGrade.end(),gradeCompare());//finalGrade是用来存储学生成绩的向量
     
    整个源代码如下:
    //---------------------------------------------------------------------------
    #include <vector>
    #include <string>
    #include <algorithm>
    #include <iostream>
    using namespace std; //使用标准模板库的命名空间
     
    //---------------------------------------------------------------------------
     
    #pragma argsused
    class Grade
    {
    public:
        Grade(int id,string name,int score)
        {
            ID=id;
            Name=name;
            Score=score;
        }
        int ID;
        string Name;
        int Score;
    };
           //打印学生成绩
    void printScore(Grade grade)
    {
        cout<<grade.ID<<" "<<grade.Name<<" "<<grade.Score<<endl;
    }
           //定义函数对象用来排序
    class gradeCompare : binary_function<Grade,Grade, bool> {
    public:
     bool operator () (Grade X,Grade Y) const
         {
            return X.Score>Y.Score;
         }
    };
     
    int main(int argc, char* argv[])
    {
        vector<Grade>finalGrade;
        finalGrade.push_back(Grade(1,"A",56));
        finalGrade.push_back(Grade(2,"B",57));
        finalGrade.push_back(Grade(3,"C",58));
        sort(finalGrade.begin(),finalGrade.end(),gradeCompare());
        for_each(finalGrade.begin(),finalGrade.end(),printScore);
        return 0;
    }
     
    结果如下:
    3 C 58
    2 B 57
    1 A 56
     
     
    展开全文
  • STL函数对象函数对象适配器

    千次阅读 2013-08-18 17:14:58
    函数对象Functor 函数对象是重载了函数调用操作符的类的对象。因为这个对象重载了函数调用操作符,所以你可以像调用函数一样使用这个对象。 #include using namespace std; class A { public:  int operator...

    函数对象Functor

    函数对象是重载了函数调用操作符的类的对象。因为这个对象重载了函数调用操作符,所以你可以像调用函数一样使用这个对象。

    #include <iostream>
    using namespace std;

    class A
    {
    public:
     int operator() (int x,int y)
     {
      
      return x>y?x:y;
     }
    };
    void main()
    {
     A a;
     cout<<a(1,2);
    }

     

    STL中提供了一元和二元函数的两种Functor,通过unary_function和binary_function提供了这两种不同参数数量的Functor的基本结构,在这两个类型中,分别内嵌定义一元和二元函数操作在模版推演的时候需要用到的typedef.

    //一元函数的定义为
    template<class _A, class _R>
    struct unary_function {
    typedef _A argument_type;
    typedef _R result_type;
    };


    //二元函数的定义为
    template<class _A1, class _A2, class _R>
    struct binary_function {
    typedef _A1 first_argument_type;
    typedef _A2 second_argument_type;
    typedef _R result_type;
    };

    其他的一元和二元Functor可以从这两个基本结构继承,同时也就可以推演出函数的参数和返回值的类型,STL在上述这两个结构的基础上,实现了很多一元和二元的Functor.

    //一元
    negate

    //二元
    plus
    minus
    multiplies
    divides
    modulus
    equal_to
    not_equal_to
    greater
    greater_equal
    less
    less_equal
    logical_and
    logical_or
    logical_not

    上面的这些Functor都是基于模版实现的,可以象下面那样使用的方式:

    plus<int> int_plus;
    cout << int_plus(111,222) << endl;


    函数对象适配器

    函数对象适配器的作用就是使函数转化为函数对象,或是将多参数的函数对象转化为少参数的函数对象。


    1)bind

    bind1st //通过绑定第一个参数,使二元的函数对象转化为一元的函数对象
    bind2nd //通过绑定第二个参数,使二元的函数对象转化为一元的函数对象
    not1 //对一元的函数对象取反
    not2 //对二元的函数对象取反

    使用的方式:
    bind1st( less<int>(), 10)(20);
    not2( less<int() )(10,20);

    这些Functor看起来好像好像用处不大,但是在和STL中的容器和算法结合在一起使用的时候,就会使得程序显得很简洁.

    int i;
    vector<int> lv;
    for(i = 0; i < 100; i++)
    {
    lv.push_back(i);
    }
    //对vector中小于20的数进行记数
    cout << count_if(lv.begin(), lv.end(), bind2nd(less<int>(), 20)) << endl;

    //由大到小排序
    sort(lv.begin(), lv.end(), not2(less<int>()) ) ;
    for (i = 0; i < 100; i++)
    {
    cout << lv.at(i) << endl;
    }


    2)ptr_fun

    ptr_fun是指将现有的函数转换为Functor的功能.在STL中提供了这个功能的Functor,就是pointer_to_unary_function和pointer_to_binary_function这两个类,这两个类对应一元

    和二元两种函数,也就是说,对于调用参数为3个或者多于3个的函数,STL提供的Functor类,无法配接.

    基本使用方法:

    int u_func(int a)
    {
    int ret = a;
    return ret;
    }

    int b_func(int a,int b)
    {
    return a+b;
    }

    void call()
    {
    pointer_to_unary_function<int,int> uf(u_func);
    cout << uf(100) << endl;

    pointer_to_binary_function<int,int,int> bf(b_func);
    cout << bf(111,222) << endl;

    //或者
    cout << ptr_fun(u_func)(100) << endl;
    cout << ptr_fun(b_func)(111,222) << endl;

    }
    可以看到,上面的方法改进了原先C和C++中通过函数指针来间接调用函数的方法,将函数指针封装到了类中.


    问题:

    第一部分中的Functor中是自己定义操作符(),但是在ptr_fun中,是将已经有的function转为Functor调用就会存在一个调用方式的问题.

    c++中的函数,按调用方式可以分为__cdecl, __stdcall,__fastcall 三种,ptr_fun如何正确的识别给定的function的调用方式就会有问题.

    其中:
    vc6中的STL的ptr_fun代码中,统一将function认为是__cdecl调用方式. 而Dev-cpp中使用的SGI的代码中没有明确指明函数的调用方式,所以将使用编译器的确省设置.
    但是如果将上面的b_func函数改为
    int __stdcall b_func(int a,int b)
    {
    return a+b;
    }
    上面的使用代码在DEV-CPP中无法编译通过.

    3)mem_fun

    mem_fun是将某个类中的成员函数转变为Functor的功能.

    一般的使用方法
    struct mem_fun_struct
    {
    int n_mem_fun() {
    cout << "mem_fun_struct::n_mem_fun()" << endl;
    return 0;
    }

    int u_mem_fun(int a) {
    cout << "mem_fun_struct::u_mem_fun(int) " << a << endl;
    return a;
    }

    int b_mem_fun(int a,int b) {
    cout << "mem_fun_struct::b_mem_fun(int,int)" << a << " " << b << endl;
    return a+b;
    }
    };

    void call()
    {
    mem_fun_struct ls;
    mem_fun(&mem_fun_struct::n_mem_fun)(&ls);
    mem_fun(&mem_fun_struct::u_mem_fun)(&ls, 10);
    //mem_fun(&mem_fun_struct::u_mem_fun)(&ls, 10, 20);
    }

    上面的代码在dev-cpp 4.9.9中编译通过,SGI STL中没有提供二元成员函数的mem_fun,vc6中提供了mem_fun(无参数成员函数)和mem_fun1(一元参数成员函数), 而在vs2003中改变了用法.但是我看MSDN好像也只支持到一个参数.

    总结

    STL中提供了基本的一元和二元参数的Functor, 同时提供了相应的适配器可以对Functor进行修饰,Functor可以很好的和 STL容器,STL算法结合使用.

    但是仍有问题:
    1)上面说到的调用方式
    2) 多参数函数对象适配

    对于我们比较复杂的stl不能满足要求的问题,我们可以是用boost或loki来解决。

    展开全文
  • 一、函数对象 1、函数对象(function object)也称为仿函数(functor) 2、一个行为类似函数的对象,它可以没有参数,也可以带有若干参数。 3、任何重载了调用运算符operator()的类的对象都满足函数对象的特征 4...

    一、函数对象

    1、函数对象(function object)也称为仿函数(functor)


    2、一个行为类似函数的对象,它可以没有参数,也可以带有若干参数。


    3、任何重载了调用运算符operator()的类的对象都满足函数对象的特征


    4、函数对象可以把它称之为smart function。


    5、STL中也定义了一些标准的函数对象,如果以功能划分,可以分为算术运算、关系运算、逻辑运算三大类。为了调用这些标准函数对象,需要包含头文件<functional>。


    二、自定义函数对象

     C++ Code 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    #include <iostream>
    using namespace std;
    class CFunObj
    {
    public:
        void operator()()
        {
            cout << "hello,function object!" << endl;
        }
    };
    int main()
    {
        CFunObj fo;
        fo();
        CFunObj()();
        return 0;
    }

    注意:CFunObj()(); 表示先构造一个匿名对象,再调用operator();


    三、函数对象与容器


    在这边举map 容器的例子,大家都知道map 在插入元素的时候会自动排序,默认是根据key 从小到大排序,看map 的定义:

     C++ Code 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    // TEMPLATE CLASS map
    template < class _Kty,
             class _Ty,
             class _Pr = less<_Kty>,
             class _Alloc = allocator<pair<const _Kty, _Ty> > >
    class map
        : public _Tree<_Tmap_traits<_Kty, _Ty, _Pr, _Alloc, false> >
    {
        // ordered red-black tree of {key, mapped} values, unique keys
    };

    假设现在我们这样使用 map< int, string > mapTest; 那么默认的第三个参数 _Pr = less<int>,再者,map 继承的其中一个类


     _Tmap_traits 中有个成员:


     _Pr  comp;// the comparator predicate for keys 


    跟踪进insert 函数,其中有这样一句:


    if (_DEBUG_LT_PRED(this->comp, _Key(_Where._Mynode()), this->_Kfn(_Val)))


    已知 #define _DEBUG_LT_PRED(pred, x, y) pred(x, y) 很明显地,comp 在这里当作函数对象使用,传入两个参数,回头看less 类的


    模板实现:

     C++ Code 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    // TEMPLATE STRUCT less
    template<class _Ty>
    struct less
            : public binary_function<_Ty, _Ty, bool>
    {
        // functor for operator<
        bool operator()(const _Ty &_Left, const _Ty &_Right) const
        {
            // apply operator< to operands
            return (_Left < _Right);
        }
    };

    即实现了operator() 函数,左操作数小于右操作数时返回为真。


    我们也可以在定义的时候传递第三个参数,如map< int, string, greater<int> > mapTest; 则插入时按key 值从大到小排序(less,


     greater 都是STL内置的类,里面实现了operator() 函数),甚至也可以自己实现一个类传递进去,如下面例程所示:

     C++ Code 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    #include <map>
    #include <string>
    #include <iostream>

    using namespace std;

    struct MyGreater
    {
        bool operator()(int left, int right)
        {
            return left > right;
        }
    };

    int main(void)
    {
        map < int, string, /*greater<int> */MyGreater > mapTest;
        mapTest.insert(map<int, string>::value_type(1"aaaa"));
        mapTest.insert(map<int, string>::value_type(3"cccc"));
        mapTest.insert(map<int, string>::value_type(2"bbbb"));


        for (map < int, string, /*greater<int> */MyGreater >::const_iterator it = mapTest.begin(); it != mapTest.end(); ++it)
        {
            cout << it->first << " " << it->second << endl;
        }

        return 0;
    }

    输出为:

    3 cccc

    2 bbbb

    1 aaaa


    MyGreater 类并不是以模板实现,只是比较key 值为int 类型的大小。


    四、函数对象与算法

    在STL一些算法中可以传入函数指针,实现自定义比较逻辑或者计算,同样地这些函数也可以使用函数对象来代替,直接看例程再稍

    作分析:

     C++ Code 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    #include <vector>
    #include <string>
    #include <iostream>
    #include <algorithm>

    using namespace std;

    void PrintFun(int n)
    {
        cout << n << ' ';
    }

    void Add3(int &n)
    {
        n += 3;
    }

    class PrintObj
    {
    public:
        void operator()(int n)
        {
            cout << n << ' ';
        }
    };

    class AddObj
    {
    public:
        AddObj(int number) : number_(number)
        {

        }
        void operator()(int &n)
        {
            n += number_;
        }

    private:
        int number_;
    };

    class GreaterObj
    {
    public:
        GreaterObj(int number) : number_(number)
        {

        }
        bool operator()(int n)
        {
            return n > number_;
        }
    private:
        int number_;
    };


    int main(void)
    {
        int a[] = {12345};
        vector<int> v(a, a + 5);

        /*for_each(v.begin(), v.end(), PrintFun);
        cout<<endl;*/


        for_each(v.begin(), v.end(), PrintObj());
        cout << endl;

        /*for_each(v.begin(), v.end(), Add3);
        for_each(v.begin(), v.end(), PrintFun);
        cout<<endl;*/


        for_each(v.begin(), v.end(), AddObj(5));
        for_each(v.begin(), v.end(), PrintFun);
        cout << endl;


        cout << count_if(a, a + 5, GreaterObj(3)) << endl; //计算大于3的元素个数

        return 0;
    }

    输出为:

    1 2 3 4 5

    6 7 8 9 10

    2


    回顾for_each 的源码,其中有这样一句: _Func(*_ChkFirst); 也就是将遍历得到的元素当作参数传入函数。


    上面程序使用了函数对象,实际上可以这样理解 PrintObj()(*_ChkFirst); 即 PrintObj() 是一个匿名的函数对象,传入参


    数,调用了operator() 函数进行打印输出。使用函数对象的好处是比较灵活,比如直接使用函数Add3,那么只能将元素加3,而


    使用函数对象Addobj(x), 想让元素加上多少就传递给Addobj类,构造一个对象即可,因为它可以保存一种状态(类成员)。


    count_if 中的 GreaterObj(3) 就类似了,将遍历的元素当作参数传递给operator(), 即若元素比3大则返回为真。



    五、STL内置的函数对象类



    参考:

    C++ primer 第四版
    Effective C++ 3rd
    C++编程规范



    展开全文
  • C++:函数对象(函数符)

    千次阅读 2019-04-16 00:21:08
    C++:函数对象(函数符)1、什么是函数对象2、重载了()运算符的类对象 1、什么是函数对象 函数对象也叫函数符,函数符是可以以函数方式与()结合使用的任意对象。这包括函数名、指向函数的指针和重载了()运算符的...

    1、什么是函数对象

    函数对象也叫函数符,函数符是可以以函数方式与()结合使用的任意对象。这包括函数名、指向函数的指针和重载了()运算符的类对象

    上面这句话的意思是指:函数名、指向函数的指针和重载了括号运算符的类对象与括号结合,从而以函数方式实现某种功能。

    2、重载了()运算符的类对象

    该示例摘自《C++ Primer》 第六版。

    #include <iostream>
    using namespace std;
    
    class Linear{
    
    private:
    	double slope;
    	double y0;
    public:
    	//构造函数
    	Linear(double sl_ = 1,double y_ = 0):slope(sl_),y0(y_){}
    	//重载()运算符
    	double operator()(double x)
    	{
    		return y0 +slope*x;
    	}
    };
    
    int main()
    {
    	Linear f1;
    	Linear f2(2.5,10.0);
    	
    	//在此处Linear类的对象 f1和f2利用重载的()运算符以函数的方式实现了 y0 +slope*x 功能
    	//因此 f1和f2 可以成为函数对象(或函数符)
    	double y1 = f1(12.5);
    	double y2 = f2(0.4);
    
    	cout<<"y1: "<< y1 <<endl;
    	cout<<"y2: "<< y2 <<endl;
    
    	return 0;
    }
    

    运行结果:
    在这里插入图片描述

    展开全文
  • Python之函数对象

    千次阅读 2019-06-11 11:10:17
    python中,一切皆对象。 在 Python 中万物皆为对象,函数也不例外,函数作为对象可以赋值给一个变量、可以...把函数内部的变量看成函数的一个属性,使用赋值语句将一个变量添加为该函数对象的属性。 注意:只有...
  • lambda生成一个函数对象。该函数参数为x,y,返回值为x+y。函数对象赋给func。 func的调用与正常函数无异。 上面的代码等价于: def fun2(x, y): return x + y 二、函数作为参数 函数可以作为一个对象,进行...
  • 函数指针怎么声明?能用来做什么?什么时候用? 函数指针变量名称一定要和函数名字一样吗?... 函数对象的实质是什么?怎么理解这个东西? 怎么调用函数对象函数对象和函数指针的比较? C...
  • 函数对象的函数适配器

    千次阅读 2012-09-12 16:09:52
    1. 在这里举一个算术函数对象类型的例子:plus 对2个给定元素进行 + 运算,它定义了调用操作符的类模板,所以是二元函数对象; 要对数值1和2进行加法运算,可以写如下代码: plus add; //定义加法运算的类模板的...
  • 重构笔记——以函数对象取代函数

    千次阅读 2015-01-09 07:58:46
    本文将介绍“以函数对象取代函数”这种重构手法。  下面让我们来学习这种重构手法吧。 开门见山  发现:你有一个大型函数,其中对局部变量的使用使你无法采用“提炼函数”这种重构手法。  解决:将这个函数...
  • 函数对象 和 函数指针 的区别

    千次阅读 2013-04-06 21:17:07
    函数对象(也称“算符”)是重载了“()”操作符的普通类对象。因此从语法上讲,函数对象与普通的函数行为类似。 用函数对象代替函数指针有几个优点: 1. 首先,因为对象可以在内部修改而不用改动外部接口,因此...
  • python函数对象与闭包详解

    千次阅读 2017-10-27 23:24:59
    print "hello world"当代码执行遇到def以后,会现在内存中生成一个函数对象,这个函数对象被定义为这个函数的名字。当我们调用函数时就要指定函数的名字,通过函数名才能找到这个函数。 函数的代码段在定义时是不会...
  • STL 函数对象

    万次阅读 2013-01-02 16:18:51
    函数对象(Functor) STL中提供了一元和二元函数的两种Functor,通过unary_function和binary_function提供了这两种不同参数数量的Functor的基本结构,在这两个类型中,分别内嵌定义一元和二元函数操作在模版推演的...
  • 什么叫函数对象(仿函数)

    千次阅读 2015-12-22 09:58:18
    仿函数(functors)在C++标准中采用的名称是函数对象(function objects)。仿函数主要用于STL中的算法中,虽然函数指针虽然也可以作为算法的参数,但是函数指针不能满足STL对抽象性的要求,也不能满足软件积木的...
  • C++类成员函数转换成函数对象

    千次阅读 2016-09-15 19:39:27
    C++中,类的成员函数(member_function)通常不能直接作为函数对象来使用,最常见的就是创建线程时,不能使用非静态的成员函数来初始化一个线程。 这个主要是因为没有传入this指针,而下面的转换或者绑定,本质是将类...
  • C++函数对象operator()

    万次阅读 多人点赞 2016-10-29 21:59:50
    函数对象:定义了调用操作符()的类对象。当用该对象调用此操作符时,其表现形式如同普通函数调用一般,因此取名叫函数对象。举个最简单的例子: class A { public: int operator() ( int val ) { return ...
  • 全栈工程师开发手册 (作者:栾鹏) js系列教程4-函数、函数...函数对象属性【length属性】 在js函数参数文章中介绍过,arguments对象的length属性表示实参个数,而函数的length属性则表示形参个数function add(x,y){
  • 函数对象与Lambda

    千次阅读 2011-12-06 12:34:31
    该篇展示两个基本的概念:函数对象和lambda,其中函数对象是构建Nana的基础。 函数对象(英文上叫function object或functor)就是能像函数那样调用的对象,一般地讲,就是定义了函数调用操作符operator()的类对象。...
  • 有时我们需要将一个文件的信息(类、函数及变量)保存到文件,我们不能直接保存函数对象,而是将其转化为fn.__name__,问题来了,当我们想通过读取文件的形式重新配置这些类、函数时,该如何把这些字符串转换为对应...
  • js函数对象

    万次阅读 2010-10-15 12:22:00
    通过函数对象的性质,可以很方便的将一个函数赋值给一个变量或者将函数作为参数传递。在继续讲述之前,先看一下函数的使用语法:以下是引用片段:function func1(…){…} var func2=function(…){…}; var func3=...
  • C++11 lambda表达式与函数对象

    万次阅读 多人点赞 2017-06-02 18:02:41
    C++ lambda表达式与函数对象 lambda表达式是C++11中引入的一项新技术,利用lambda表达式可以编写内嵌的匿名函数,用以替换独立函数或者函数对象,并且使代码更可读。但是从本质上来讲,lambda表达式只是一种语法...
  • 内建函数对象 内建函数对象意义 概念: STL内建了一些函数对象 分类: 算术仿函数 关系仿函数 逻辑仿函数 用法: 这些仿函数所产生的对象,用法和一般函数完全相同 使用内建函数对象,需要...
  • 认识js函数对象(Function Object)

    千次阅读 2018-08-09 15:42:39
    这些都是代码给用户的印象,而在JavaScript解释执行的时候,实际上每个函数都是被维护为一个对象,这就是本小节将要介绍的函数对象(Function Object)。   函数对象与其它用户所定义的对象有着本质的区别,这一...
  • 深入探讨JavaScript函数对象

    千次阅读 2014-04-25 15:19:00
    深入探讨JavaScript函数对象 人人生而平等,但有些人比其他人更加平等——奥威尔 函数是进行模块化程序设计的基础,编写复杂的Ajax应用程序,必须对函数有更深入的了解。  javascript中的函数...
  • STL- 函数对象 函数对象 函数对象概念 函数对象使用 谓词 谓词概念 一元谓词 二元谓词 STL- 函数对象 函数对象 函数对象概念 概念: 重载函数调用操作符的类,其对象常称为函数对象 函数对象使用...
  • JavaScript函数对象

    千次阅读 2008-02-19 23:40:00
    随后无论参数的变化如何,调用次数多少:使用的都是同一个函数对象语法:function functionName(param1,...paramN){ function statements;} 2:匿名函数//每次请求调用时,都解析(动态重构)语法:var variab
  • 在平常的C/C++代码编程中, 我们经常会碰到函数指针(Function Pointer)这个概念, 在很多C++代码中,经常使用函数对象(Functors,Function Objects)等特性,也的甚至还会看到更高级的比如boost::bind, std::...
  • 本章将介绍函数指针的使用、函数对象的定义、引入目的、使用方法,C++98 标准和C++11标准下 STL 内置函数对象的详细介绍、适配器类的使用。包括 bind1st bind2nd not1 not2 mem_fun mem_fun_ref ptr_fun bind ref ...
  • 函数对象及适配器

    千次阅读 2007-10-23 11:18:00
    定义了调用操作符的类,其对象常称作函数对象(function object),即它们的行为表现出类似于函数的行为。 函数对象通常用作泛型算法的实参,如标准库中大量泛型算法有需要函数对象的版本。函数对象使用起来可以比...
  • 这一章节我们来讨论一下函数对象的其中一个方面:间接调用函数 在讨论之前,我们先来说一下函数为什么是对象?因为在python的定义里面,他所有都是对象,所以函数也是对象,在执行的时候已经存在内存空间里面的 >>...
  • JavaScript对象系统深入剖析-2.函数对象

    万次阅读 热门讨论 2012-01-30 15:34:46
    2. 函数对象(Function Object) @吴穹Adam (新浪微博) 注意:阅读2之前,请先阅读1.对象:http://blog.csdn.net/adwu73/article/details/7219044 函数对象首先是一个对象,所以,它也有__proto__链接,也有...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 409,266
精华内容 163,706
关键字:

函数对象