C++ C++；通过操作员循环

我有一个总数，例如：

x + y

我还想对相同的两个变量执行减法、乘法和除法：

x - y
x * y
x / y 

轮换四个操作员的最佳方式是什么

我知道这在函数编程语言中是容易做到的，但是在C++中我不确定。

---

提前感谢。

除了显而易见的“写出来”之外，只有一个想法：

intadd（intl，intr）{
返回l+r；
}
内部子（内部l，内部r）{
返回l-r；
}
整数倍（整数倍，整数倍）{
返回l*r；
}
内部分区（内部l、内部r）{
退回信用证；
}
int main（）{
typedef int（*op）（int，int）；
op ops[4]={add，sub，mul，div}；
INTA=10，b=5；
对于（int i=0；i<4；++i）{
行动一（a、b）；
}
}

---

除了显而易见的“写出来”之外，只有一个想法：

intadd（intl，intr）{
返回l+r；
}
内部子（内部l，内部r）{
返回l-r；
}
整数倍（整数倍，整数倍）{
返回l*r；
}
内部分区（内部l、内部r）{
退回信用证；
}
int main（）{
typedef int（*op）（int，int）；
op ops[4]={add，sub，mul，div}；
INTA=10，b=5；
对于（int i=0；i<4；++i）{
行动一（a、b）；
}
}

---

.

如果运算符是用户定义的，则当需要指向函数（成员）的指针时，可以传递它们。对于基本类型，您可能需要编写包装器，如Xeo所示

您还可以接受std:：binary_函数并使用std:：plus等等

在C++0X中，使用std:：function和lambda可以更容易地实现这一点

---

但显然，更准确地了解您想要实现的目标会有所帮助。

如果运算符是用户定义的，那么当需要指向函数（成员）的指针时，可能会传递它们。对于基本类型，您可能需要编写包装器，如Xeo所示

您还可以接受std:：binary_函数并使用std:：plus等等

在C++0X中，使用std:：function和lambda可以更容易地实现这一点

---

但显然，更准确地了解您想要实现的目标会有所帮助。

可能就是这样（类似于函数式编程语言）：

模板
标准：：向量操作（常数T&a、常数T&b）
{
std：：向量结果；
结果：推回（a+b）；
结果：推回（a-b）；
结果：推回（a*b）；
结果。推回（a/b）；
返回结果；
}
int main（）
{
标准：向量res=do_ops（10,5）；
}

可能这就是它的样子（类似于函数式编程语言）：

模板
标准：：向量操作（常数T&a、常数T&b）
{
std：：向量结果；
结果：推回（a+b）；
结果：推回（a-b）；
结果：推回（a*b）；
结果。推回（a/b）；
返回结果；
}
int main（）
{
标准：向量res=do_ops（10,5）；
}

“最佳”在什么意义上？这实际上取决于你打算对结果做什么。当然，按图所示编写四个表达式是最佳方式；很明显，你脑子里还有其他一些限制。你说的“骑自行车”是什么意思？一个接一个地执行它们。“最佳”在什么意义上？这实际上取决于你打算如何处理结果；很明显，你脑子里还有其他一些限制。你说的“骑自行车”是什么意思？一个接一个地执行它们？这看起来并不是“最佳的”。@Kirill：没错，“最佳”的方式就是把它们写在4行中。但这就是我要实现的“循环”。）如果数学函数是内联声明的，那么它可能更为优化。编译器仍然保留不内联它们的权利。这看起来并不是“最优的”。@Kirill：没错，“最优”的方法只是将它们写在4行中。但这就是我要实现的“循环”。）如果数学函数是内联声明的，那么它可能更为优化。编译器仍然保留不内联它们的权利。

int add(int l, int r){
  return l + r;
}

int sub(int l, int r){
  return l - r;
}

int mul(int l, int r){
  return l * r;
}

int div(int l, int r){
  return l / r;
}

int main(){
  typedef int (*op)(int,int);
  op ops[4] = {add, sub, mul, div};

  int a = 10, b = 5;
  for(int i=0; i < 4; ++i){
    ops[i](a,b);
  }
}

template<typename T>
std::vector<T> do_ops( const T& a, const T& b )
{
  std::vector<T> result;
  result.push_back( a + b );
  result.push_back( a - b );
  result.push_back( a * b );
  result.push_back( a / b );
  return result;
}

int main()
{
  std::vector<int> res = do_ops( 10, 5 );  
}