Question

I am working on learning c++ and I was wondering if I could pass in a method as a parameter in another method?

A rough outline of what I wanted to do is something like this:

void insertionSort() {
   //perform sort
}

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

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

Is there a way to do something like this?

Edit:

I appreciate the replies. I have another question though. In my actual code, this is all happening in a class called dataStructure and I am creating an instance of it elsewhere and calling these methods.

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

When I try to implement some of the solutions posted I am getting this error:

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

I’m not really understanding why creating instances would affect this. Can anyone explain?

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

Edit 2:

I’m going to post more or less my exact code for this portion:

//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;
}

There is more but I think this is all that relates to the problem

Answer 1

Yes, something like:

#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';
}

Since you probably don’t want global data (which a parameterless function like insertionSort requires), you might do something like:

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

Now you have to pass the data to be sorted in. You can do this with std::bind or better C++11 lambdas. Then, as noted in Yakk’s answer, we could templatize the timer function so it natively accepts std::functions, lambdas, functors (classes with operator() overloaded), or function pointers:

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

Here’s the full program:

#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';
}

Combine the last two lines (which use C++11 lambdas) as such:

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

But of course, in non-homework code, you should use the built-in sort functions rather than rolling your own.

---

Regarding your update: The first line is actually a function definition, not an instantiation of the class:

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

In C++ the rule is, if something can be interpreted as a function prototype, it will be. Drop the paretheses and you’ll be fine:

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

---

In answer to your comment, as long as it can’t be interpreted as a prototype, you’re good. Consider:

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  
}

---

Update for your Edit 2:

Change this line:

als.timeOperation(als.insertionSort());

to:

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

or (less preferred, but if you don’t have lambdas):

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