Question

我刚刚阅读this

class biggerThan 
      {
        public:
        const int testValue;
        biggerThan(int x) : testValue(x) { }

        bool operator()(int val) const 
        { return val > testValue; }
  };

现在说它用过像

  std::list<int>::iterator firstBig =
     std::find_if(aList.begin(), aList.end(), biggerThan(12));

OR

就像这样更大的对象（12）

现在当使用largeThan（12）时，它可以调用constrcutor来初始化testvalue或者（）运算符被重载并且12被传递给函数（bool operator（）（int val）const）以便它返回一个布尔。

首先发生哪一个/它是如何工作的

是否会导致任何歧义，或者对重叠运算符的调用是否以某种方式发生，如

object.operator（）。（12）。

请明确我的不足之处。

Answer 1

也许the following code会说清楚：

#include <iostream>
#include <algorithm>

class biggerThan 
      {
        public:
        const int testValue;
        biggerThan(int x) : testValue(x) { 
            std::cout << "Construction of biggerThan object with value " 
                      << x << std::endl;
        }

        bool operator()(int val) const 
        { 
            if (val > testValue) {
                std::cout << val << " is bigger than " << testValue 
                          << std::endl;
                return true;
            }
            else {
                std::cout << val << " is *not* bigger than " << testValue 
                          << std::endl;
                return false;
            }
        }
};

int main() {
    int data[] = {0,1,2,3,4,5,6,7,8,9};
    std::for_each(data, data+10, biggerThan(4));
}

输出结果为：

Construction of biggerThan object with value 4
0 is *not* bigger than 4
1 is *not* bigger than 4
2 is *not* bigger than 4
3 is *not* bigger than 4
4 is *not* bigger than 4
5 is bigger than 4
6 is bigger than 4
7 is bigger than 4
8 is bigger than 4
9 is bigger than 4

会发生什么：

std::for_each的最后一个参数是biggerThan类型的对象，它使用参数4构建。
为operator()(int)中的每个元素调用此biggerThan - 对象的data（实际上是它的副本）。

您使用的算法（std::find_if）在这方面的工作原理相同。

Answer 2

当biggerThan(12)使用它时，它可以调用构造函数来初始化testvalue

是。 biggerThan(12)创建biggerThan类的实例，其中testvalue设置为12。

当std::find_if()调用该仿函数时，它将调用该实例的operator()(int val)成员函数。

Answer 3

biggerThan(12)会在std::find_if(aList.begin(), aList.end(), biggerThan(12));行传递一个更大的对象;

调用operator（）就是这样;

biggerThan obj(12); //This is a constructor call
biggerThan(13); //This is function operator call

@ std::find_if(aList.begin(), aList.end(), biggerThan(12));传递的第三个参数是temporary object of biggerThan initialized with 12

Answer 4

一般来说，你可以使用更大的＆lt;＆gt;来完成同样的事情。和bind2nd＆lt;＆gt ;,在＆lt; functional＆gt;

中

list<int>::iterator firstBig = find_if(aList.begin(), aList.end,
                                       bind2nd(greater<int>(), 12));

bind2nd会转换任何二元函数对象，例如更大的＆lt; int＆gt;进入一元函数对象。在更大的＆lt; int＆gt;的情况下它有效地创建了一个小于运算符的函数对象

 bool operator>(const int& arg)
 {
    return functor.operator>(arg, 12); 
 }

其中functor更大＆lt; int＆gt;

函数对象和构造函数

4 个答案: