c++ - 将一个方法作为参数传递给另一个方法的可能性

Question

我正在学习 C++，我想知道我是否可以将一个方法作为参数传递给另一个方法？

我想做的事情的大致轮廓是这样的:

void insertionSort() {
   //perform sort
}

int timeOfOperation(methodInQuestion) {
    // time 1
    methodInQuestion;
    //time 2
    return time2-time;
}

int main() {
   cout << timeOfOperation(insertionSort());
   return 0;
}

有没有办法做这样的事情？

编辑:

感谢您的回复。不过我还有一个问题。在我的实际代码中，这一切都发生在一个名为 dataStructure 的类中，我正在其他地方创建它的一个实例并调用这些方法。

dataStructure ds();
ds.timeOperation(ds.insertionSort());

当我尝试实现发布的一些解决方案时，我收到此错误:

IntelliSense: no instance of function template
"dataStructure::timeOperation" matches the argument list argument
types are: (void) object type is: dataStructure

我不太明白为什么创建实例会影响这一点。谁能解释一下？

============================================= ==============

编辑 2:

我将或多或少地发布这部分的确切代码:

//main.cpp

#include "arrayList.h"
#include "arrayListStructure.h"
#include "Person.h"

using namespace std;

int main() {

    arrayList<Person> *al = new arrayList<Person>(length);
    arrayListStructure als(al);
    //als.fillStructure(data);
    als.timeOperation(als.insertionSort());

return 0;
}


//arrayListStructure.cpp

#include "arrayListStructure.h"
#include <functional>

double arrayListStructure::timeOperation(std::function<void()> operation) {...}
void arrayListStructure::insertionSort() {...}

arrayListStructure::arrayListStructure(arrayList<Person> *al)
{
this -> al = al;
}

还有更多，但我认为这就是与问题相关的所有内容

Answer 1

是的，类似于:

#include <functional>
#include <ctime>
#include <iostream>

void insertionSort() { /*...*/ }

std::clock_t timeOfOperation( std::function<void()> operation ) 
{
    const std::clock_t start = std::clock();
    operation();
    return std::clock() - start;
}

int main() 
{
    std::cout << timeOfOperation(insertionSort) << '\n';
}

因为您可能不想要全局数据(这是像 insertionSort 这样的无参数函数所需要的)，您可以这样做:

template<class Container>
void insertionSort( Container& c ) 
{ 
   /*sort the contents of c*/ 
}

现在您必须传递要排序的数据。您可以使用 std::bind 或更好的 C++11 lambda 来完成此操作。然后，正如 Yakk 的回答中所述，我们可以模板化计时器函数，使其 native 接受 std::functions、lambdas、仿函数(重载 operator() 的类)或函数指针:

template<class Operation>
std::clock_t timeOfOperation( Operation&& operation ) 
{/*...*/ }

完整程序如下:

#include <functional>
#include <iostream>
#include <iterator>
#include <vector>
#include <algorithm> // for generate
#include <ctime> // for clock
#include <cstdlib> // for rand

template<class Container>
void insertionSort( Container& c ) 
{ 
   /*sort the contents of c*/ 
}

template<class Operation>
std::clock_t timeOfOperation( Operation&& operation ) // or just timeOfOperation( Operation&& operation )
{
    const std::clock_t start = std::clock();
    operation();
    return std::clock() - start;
}

int main() 
{
    std::vector<int> v( 100 );
    std::generate( v.begin(), v.end(), std::rand );
    auto op = [&]() { insertionSort( v ); };
    std::cout << timeOfOperation( op ) << '\n';
}

将最后两行(使用 C++11 lambda)合并为这样:

std::cout << timeOfOperation( [&]() { insertionSort( v ); } ) << '\n';

当然，在非家庭作业代码中，您应该使用内置的排序函数而不是自己动手。

---

关于您的更新:第一行实际上是函数定义，而不是类的实例化:

dataStructure ds(); // function, not an instance!
ds.timeOperation(ds.insertionSort()); // insertionSort returns void. 
// Can't convert void to a template param that can be called with the () operator

在 C++ 中的规则是，如果某些东西可以解释为函数原型(prototype)，它就会被解释。去掉括号，你会没事的:

dataStructure ds; // <-- note
ds.timeOperation(ds.insertionSort());

---

在回答你的评论时，只要它不能被解释为原型(prototype)，你就很好。考虑:

struct S {};

struct dataStructure
{
   dataStructure() {}
   dataStructure(int) {}
   dataStructure(S) {}
   void go() {}
};

int main()
{
    dataStructure ds1 = dataStructure();
    dataStructure ds2(10);
    dataStructure ds3( S() ); 
    dataStructure ds4( (S()) ); // Extra parens clarify for the compiler


    ds1.go(); // Ok  
    ds2.go(); // Ok  
    ds3.go(); // Doh! ds3 is a function prototype
    ds4.go(); // Ok  
}

---

您的编辑 2 的更新:

改变这一行:

als.timeOperation(als.insertionSort());

到:

als.timeOperation([&](){als.insertionSort()});

或(不太受欢迎，但如果您没有 lambda 表达式):

als.timeOperation( std::bind( &arrayListStruction::insertionSort, als ) );