C++ 将递增/递减运算符传递给函数

我有相同的函数，唯一的区别是它要么递增，要么递减。我想从中概括一下

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

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

模板
无效f（内部和外部操作）{
op（i）；
}
int main（）{
int i；
f（i，运算符++）；
f（i，运算符--）；
返回0；
}

我怎样才能做到这一点

我的另一个选择是使用functional std:：plus或有两个函数，但如果可能的话，我更喜欢这个解决方案。谢谢。

只需使用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;
}

模板
无效f（内部和外部操作）{
op（i）；
}
int main（）{
int i；
f（i，[]（int&x）{++x；}）；
f（i，[]（int&x）{--x；}）；
返回0；
}

此外，还不清楚您是想要后增量还是预增量

正如@T.C.所指出的，如果您想保留普通运算符的语义，可以添加return语句。

这里有一个选项（有许多可能的解决方案）也适用于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; }

enum OpType{increment，decrement}；
模板f（内部和内部）；
模板void f（int&i）{++i；}
模板void f（int&i）{--i；}

用法：

f<increment>(i);

f（i）；

---

为了保持代码库整洁，您可能需要使用一些作用域，因此可以使用C++11中的作用域枚举或命名空间。

在您给出的用例中，typename O是一个没有状态的一元函数，可以使用简单的函数指针建模：

#include <iostream>

int& increment(int& i) {
    ++i;
    return i;
}

int& decrement(int& i) {
    --i;
    return i;
}

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

using namespace std;

int main()
{
    int i = 0;
    f(i, increment);
    cout << i << endl;

    f(i, decrement);
    cout << i << endl;
    return 0;
}

---

只需编写自己的函子。（如果您只需编写

operator++

，就不需要

std:：plus

..）我认为您无法对本机类型执行此操作。

f（I，[]（int&v）{++v；}）f（i，x=>x++），那不是很好吗

@cdhowie

s/int/auto/

，可能还想返回一些内容：）

1
0