STL 之函数对象(函数符)

关注

原创最新推荐文章于 2026-03-13 00:57:37 发布 2.4k 阅读 AI 写同款· GEO 优化 ›

【软考中级网络工程师】知识点之常用网络诊断和配置命令本文聚焦软考中级网络工程师必备的网络诊断和配置命令，详细解析 ipconfig、ping、arp 等 11 类核心命令。涵盖各命令的功能、语法、常用参数及应用场景，如 ipconfig 查看配置、ping 测试连通性等。还通过图呈现命令执行逻辑与流程，助读者理解原理。最后结合软考考点回顾重点并提供真题练习，为备考和实际运维提供全面指导，是掌握网络命令的实用参考。阅读详情

函数对象

也叫做 函数符 (functor)。函数符是可以以函数方式与()结合使用的任意对象。这包括函数名、指向函数的指针和重载了()操作符的类对象(即定义了函数operator()()的类)。

    例如，这样定义一个类:
    class Linear
    { private:
         double slope,y0;
      public:
         Linear (double _sl = 1, double _y = 0):slope(_s1),y0(_y) {}
         double operator() (double x) {return y0 + slope * x;}
     };

    重载的()操作符将使得能够像函数那样使用Linear对象:
    Linear f1;
    linear f2 (2.5, 10.0);
    double y1 = f1 (12.5);     // right hand side is f1.operator()(12.5)
    double y2 = f2 (0.4);

其中y1将使用表达式0 + 1 * 12.5来计算，y2将使用表达式10.0 + 2.5 * 0.4来计算。

举例说明函数符调用

函数for_each()，它将指定的函数用于区间中的每个成员:
for_each(books.begin(), books.end(), ShowReview);

通常，第3个参数可以是常规函数，也可以是函数符。如果把它声明为函数指针，则函数指针指定了参数类型。但由于容器可以包含任意类型，而无法预先知道将使用何种参数类型。所以STL通过使用模板来解决这个问题。

    for_each的原型:
   template<class InputIterator, class Function>
   Function for_each(InputIterator first,InputIterator last, Function f);

假设ShowReview()的原型如下:
void ShowReview (const Review &);

那么，标识符ShowReview的类型将为 void (*) (const Review &)，这也是赋给模板参数Function的类型。对于不同的函数调用，Function参数都可以表示具有重载的()操作符的类类型。最终，for_each()代码将具有一个使用f(...)的表达式。

在上面范例中，f是指向函数的指针，而f(...)调用该函数。如果最后的for_each()参数是一个对象，则f(...)将是调用重载的()操作符的对象。

函数符概念

生成器(generator)，是不用参数就可以调用的函数符。

一元函数(unary function)，是用一个参数可以调用的函数符。

二元函数(binary function)，是用两个参数可以调用的函数符。

(例如，提供给for_each()的函数符应当是一元函数，因为它每次用于一个容器元素。)

返回bool值的一元函数是断言 (predicate)。

返回bool值的二元函数是二元断言 (binary predicate)。

list模板有一个将断言作为参数的remove_if()成员，该函数将断言应用于区间中的每个元素，如果断言返回true，则删除这些元素。

    例如，下面的代码删除链表scores中所有大于100的元素:
    bool tooBig(int n) { return n > 100; }
    list<int> scores;
    ...
    scores.remove_if(tooBig);

现在假设又要删除另一个链表中所有大于200的值。就必须重新设计一个断言。如果能将取舍值作为第二个参数传递给tooBig()，则可以使用不同的值调用该函数，但断言又只能有一个参数。不过，如果设计一个tooBig类，则可以使用类成员而不是函数参数，来传递额外的信息:

    template<class T>
    class tooBig
    { private:
         T cutoff;
      public:
         tooBig (const T & t): cutoff(t) {}
         bool operator() (const T & v) { return v > cutoff; }
    };

这里，一个值(V)作为函数参数传递，而第二个参数(cutoff)是由类构造函数设置的。有了该定义后，就可以将不同的tooBig对象初始化为不同的取舍值，供调用remove_if()时使用:
scores.remove_if(tooBig<int>(200));

函数符(tooBig<int>(200))是一个匿名对象，它是由构造函数调用创建的。

拓展设计

    假设已经有了一个接受两个参数的模板函数:
    template <class T>
    bool tooBig (const T & val, const T & lim)
    { return val > lim; }

    则可以使用类将它转换为单个参数的函数对象:
    template <class T>
    class TooBig2
    { private:
         T cutoff;
      public:
         tooBig (const T & t): cutoff(t) {}
         bool operator() (const T & v) { return tooBig<T> (v,cutoff); }
    };

    即可以这样做:
    TooBig2<int> tB100(100);
    int x;
    cin >> x;
    if (tB100(x))          // same as if ( tooBig(x,100) )
        ...

类函数符TooBig2是一个函数适配器，使函数能够满足不同的接口。

预定义的函数符

STL定义了多个基本函数符，它们执行诸如将两个值相加、比较两个值否相等操作。

例如，考虑函数transform()。它有两个版本。第一个版本接受4个参数，前两个参数指定容器区间的迭代器，第三个参数是指定将结果复制到哪里的迭代器，最后一个参数是一个函数符，它被应用于区间中的每个元素，生成结果中的新元素:

    const int LIM = 5;
    double arr1[LIM] = {36,39,42,45,48};
    vector<double> gr8(arr1,arr1+LIM);
    ostream_iterator<double,char> out (cout," ");
    transform(gr8.begin(),gr8.end(),out,sqrt);

上述代码计算每个元素的平方根，并将结果发送到输出流。目标迭代器也可以位于原始区间中。

例如将上述范例中的out替换为gr8.begin()后，新值将覆盖原来的值。

    第二个版本使用一个接受两个参数的函数，并将该函数用于两个区间中的元素。它用另一个参数(即第3个)标识第二个区间的起始位置。
    例如，如果m8是另一个vector<double>对象，mean(double,double)返回两个值的平均值，则下面的代码将输出来自gr8和m8的值的平均值:
    transform(gr8.begin(),gr8.end(),m8.begin(),out,mean);

对于所有内置的算术操作符、关系操作符和逻辑操作符，STL都提供了等价的函数符。

下图列出了这些函数符的名称。它们可以用于处理C++内置类型或任何用户定义类型(如果重载了相应的操作符)。

操作符和相应的函数符

    例如使用plus<>()。它在头文件functional中定义。
    #include <functional>
    ...
    plus<double> add;            // create a plus<double> object
    double y = add(2.2,3.4);   // using plus<double>::operator()()

将它用作函数符:
transform(gr8.begin(),gr8.end(),m8.begin(),out,plus<double>());

这里没有创建命名的对象，而是用plus<double>构造函数构造了一个函数符，括号表示调用默认的构造函数。

自适应函数符和函数适配器

    上图列出的预定义函数符都是自适应的。STL有5个相关的概念:
    自适应生成器   (adaptable generator)
    自适应一元函数 (adaptable unary function)
    自适应二元函数 (adaptable binary function)
    自适应断言     (adaptable predicate)
    自适应二元断言 (adaptable binary predicate)

使函数符成为自适应的原因是，它携带了标识参数类型和返回值类型的typedef成员。这些成员分别是result_type、first_argument_type和second_argument_type。

例如，plus<int>对象的返回值类型被标识为plus<int>::result_type，这是int的typedef。

函数符自适应性的意义在于:函数适配器对象可以使用函数对象，并认为存在这些typedef成员。
例如，接受一个自适应函数符参数的函数可以使用result_type成员来声明一个与函数的返回值类型匹配的变量。

STL提供了使用这些工具的函数适配器类。例如，假设要将矢量gr8的每个元素都增加2.5倍，则需要使用接受一个一元函数参数的transform()版本。multiplies()函数符可以执行乘法，但它是二元函数。因此需要一个函数适配器，将接受两个参数的函数符转换为接受一个参数的函数符。STL使用binderlst和binder2nd类自动完成这一过程，它们将自适应二元函数转换为自适应一元函数。

假设有一个自适应二元函数对象f2()，则可以创建一个binderlst对象，该对象与一个将被用作f2()的第一个参数的特定值(val)相关联:
binderlst (f2,val) f1;

使用单个参数调用f1(x)时，返回的值与将val作为第一参数、将f1()的参数作为第二参数调用f2()返回的值相同。

    STL提供了函数bindlst()，以简化binderlst类的使用。可以用其提供用于构建binderlst对象的函数名称和值，它将返回一个这种类型的对象。
    例如，要将二元函数multiplies()转换为将参数乘以2.5的一元函数，则可以:
    bindlst (multiplies<double>(), 2.5)

    因此，将gr8中的每个元素与2.5相乘，并显示结果的代码如下:
    transform(gr8.begin(), gr8.end(), out,
         bindlst (multiplies<double>(), 2.5) );

binder2nd类与此类似，只是将常数赋给第二个参数，而不是第一个参数。它有一个名为bind2nd的助手函数，该函数的工作方式类似于bindlst。

收录于