Passing increment/decrement operator to a function

Question

I have the same function with the only difference that it will either increment or decrement. I would like to generalize from that.

template<typename O>
void f(int& i, O op){
  op(i);
}

int main() {
  int i;
  f(i,operator++);
  f(i,operator--);
  return 0;
}

How can I make this work?

my other option is to use functional std::plus or have two functions but I'd prefer this solution if possible. Thank you.

Answer 1

Simply use a lambda:

template<typename O>
void f(int& i, O op){
  op(i);
}

int main() {
  int i;
  f(i,[] (int& x) { ++x; });
  f(i,[] (int& x) { --x; });
  return 0;
}

Also it is not clear whether you want post- or preincrement.

As noted by @T.C. if you want to keep the semantics of the normal operator you can add the return statement.

Answer 2

Here is one option (there are many possible solutions) that also works pre-C++11:

enum OpType { increment, decrement };

template <OpType op> void f(int &i);
template<> void f<increment>(int &i) { ++i; }
template<> void f<decrement>(int &i) { --i; }

Usage:

f<increment>(i);

To keep your codebase tidy you probably want to use some scoping though, so either use a scoped enum in C++11, or a namespace.