C语言中的函数++-yiteyi-C++库

请注意标题是函子（不是功能）！！

null

考虑只使用一个参数的函数。然而，在调用这个函数时，我们有很多信息想要传递给这个函数，但是我们不能，因为它只接受一个参数。我们能做些什么？

一个显而易见的答案可能是全局变量。然而，良好的编码实践并不提倡使用全局变量，并表示只有在没有其他选择的情况下才能使用它们。

函子可以将对象视为函数或函数指针。在以下情况下，函子最常用于STL：

以下程序使用 STL中的transform（）向arr[]的所有元素添加1。

                     // A C++ program uses transform() in STL to add                   
                     // 1 to all elements of arr[]                   
                     #include <bits/stdc++.h>                   
                     using                               namespace                               std;                   
                             
                     int                               increment(                               int                               x) {                               return                               (x+1); }                   
                             
                     int                               main()                   
                     {                   
                                         int                               arr[] = {1, 2, 3, 4, 5};                   
                                         int                               n =                               sizeof                               (arr)/                               sizeof                               (arr[0]);                   
                             
                                         // Apply increment to all elements of                   
                                         // arr[] and store the modified elements                   
                                         // back in arr[]                   
                                         transform(arr, arr+n, arr, increment);                   
                             
                                         for                               (                               int                               i=0; i<n; i++)                   
                                         cout << arr[i] <<                               " "                               ;                   
                             
                                         return                               0;                   
                     }                   

输出：

2 3 4 5 6

此代码段仅向arr[]的内容添加一个值。现在假设我们想在arr[]的内容中添加5。

看到发生什么了吗？由于转换需要一个数组的一元函数（一个只接受一个参数的函数），所以我们不能将数字传递给increment（）。实际上，这将使我们编写几个不同的函数来添加每个数字。真是一团糟。这就是函子开始使用的地方。

函子（或函数对象）是一个C++类，它的作用类似于函数。函子是使用相同的旧函数调用语法调用的。要创建函子，我们需要创建一个重载 操作员（） .

The line,
MyFunctor(10);

Is same as
MyFunctor.operator()(10);

让我们深入研究并理解如何将其与STL结合使用。

                     // C++ program to demonstrate working of                   
                     // functors.                   
                     #include <bits/stdc++.h>                   
                     using                               namespace                               std;                   
                             
                     // A Functor                   
                     class                               increment                   
                     {                   
                     private                               :                   
                                         int                               num;                   
                     public                               :                   
                                         increment(                               int                               n) : num(n) {  }                   
                             
                                         // This operator overloading enables calling                   
                                         // operator function () on objects of increment                   
                                         int                               operator () (                               int                               arr_num)                               const                               {                   
                                         return                               num + arr_num;                   
                                         }                   
                     };                   
                             
                     // Driver code                   
                     int                               main()                   
                     {                   
                                         int                               arr[] = {1, 2, 3, 4, 5};                   
                                         int                               n =                               sizeof                               (arr)/                               sizeof                               (arr[0]);                   
                                         int                               to_add = 5;                   
                             
                                         transform(arr, arr+n, arr, increment(to_add));                   
                             
                                         for                               (                               int                               i=0; i<n; i++)                   
                                         cout << arr[i] <<                               " "                               ;                   
                     }                   

输出：

6 7 8 9 10

因此，增量是一个函子，一个充当函数的C++类。


The line,
transform(arr, arr+n, arr, increment(to_add));

is the same as writing below two lines,
// Creating object of increment
increment obj(to_add); 

// Calling () on object
transform(arr, arr+n, arr, obj);

因此，一个对象 A. 创建了一个重载 操作员（） 因此，函数可以有效地与C++ STL结合使用。

本文由 苏普里亚·斯利瓦萨 .如果你喜欢GeekSforgek，并且想贡献自己的力量，你也可以写一篇文章，并将文章邮寄到contribute@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。

如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写评论

文章版权归作者所有，未经允许请勿转载。

THE END