如何将数字运算符作为参数传递?
How to pass numeric operator as a parameter?
在C++中,我们可以做如下的事情,
template <class OP>
int f(OP op){
return op(1,2);
}
int main(){
int res1 = f(std::plus<int>{});
int res2 = f(std::multiplies<int>{});
}
我怎么能用简单的数字运算符做同样的事情,
int main(){
int res1 = f(+);
int res2 = f(*);
}
对了,我想知道的是函数f中'return'这行怎么写。
How could I do the same thing with simple numeric operator,
你不能;不使用函数模板。运算符不是可以作为参数传递或存储在对象中的东西。
what I want to know is how to write the line of 'return' in function f.
您无法将 f
编写为使 f(+)
工作的函数模板,因为 f(+)
在句法上的格式不正确。
如 所示,可以使用宏来完成:
#define MY_MACRO_WITH_UNIQUE_NAME(op) \
[]{ \
return 1 op 2; \
}()
int res1 = MY_MACRO_WITH_UNIQUE_NAME(+);
int res2 = MY_MACRO_WITH_UNIQUE_NAME(*);
#undef MY_MACRO_WITH_UNIQUE_NAME
请注意,宏很容易发生名称冲突,因此请确保您选择的名称未被他人使用或可能被他人使用。
除了使用您最初编写的模板和 std::plus
之外,没有理由这样做。例如,宏对于定义一组相同的运算符重载很有用,因为在这种情况下您无法避免使用运算符符号。这是我写的东西:
#define FOO_DEFINE_OP(op, trait) \
template <class T, class = std::enable_if_t<trait<T>::value> > \
constexpr bool operator op(const foo<T>& lhs, const foo<T>& rhs) \
{ \
return lhs.t op rhs.t; \
}
FOO_DEFINE_OP(==, boost::has_equal_to)
FOO_DEFINE_OP(!=, boost::has_not_equal_to)
FOO_DEFINE_OP(<, boost::has_less)
FOO_DEFINE_OP(<=, boost::has_less_equal)
FOO_DEFINE_OP(>, boost::has_greater)
FOO_DEFINE_OP(>=, boost::has_greater_equal)
#undef FOO_DEFINE_OP
随着 C++20 中默认比较运算符的引入,这应该会变得越来越不需要。
在C++中,我们可以做如下的事情,
template <class OP>
int f(OP op){
return op(1,2);
}
int main(){
int res1 = f(std::plus<int>{});
int res2 = f(std::multiplies<int>{});
}
我怎么能用简单的数字运算符做同样的事情,
int main(){
int res1 = f(+);
int res2 = f(*);
}
对了,我想知道的是函数f中'return'这行怎么写。
How could I do the same thing with simple numeric operator,
你不能;不使用函数模板。运算符不是可以作为参数传递或存储在对象中的东西。
what I want to know is how to write the line of 'return' in function f.
您无法将 f
编写为使 f(+)
工作的函数模板,因为 f(+)
在句法上的格式不正确。
如
#define MY_MACRO_WITH_UNIQUE_NAME(op) \
[]{ \
return 1 op 2; \
}()
int res1 = MY_MACRO_WITH_UNIQUE_NAME(+);
int res2 = MY_MACRO_WITH_UNIQUE_NAME(*);
#undef MY_MACRO_WITH_UNIQUE_NAME
请注意,宏很容易发生名称冲突,因此请确保您选择的名称未被他人使用或可能被他人使用。
除了使用您最初编写的模板和 std::plus
之外,没有理由这样做。例如,宏对于定义一组相同的运算符重载很有用,因为在这种情况下您无法避免使用运算符符号。这是我写的东西:
#define FOO_DEFINE_OP(op, trait) \
template <class T, class = std::enable_if_t<trait<T>::value> > \
constexpr bool operator op(const foo<T>& lhs, const foo<T>& rhs) \
{ \
return lhs.t op rhs.t; \
}
FOO_DEFINE_OP(==, boost::has_equal_to)
FOO_DEFINE_OP(!=, boost::has_not_equal_to)
FOO_DEFINE_OP(<, boost::has_less)
FOO_DEFINE_OP(<=, boost::has_less_equal)
FOO_DEFINE_OP(>, boost::has_greater)
FOO_DEFINE_OP(>=, boost::has_greater_equal)
#undef FOO_DEFINE_OP
随着 C++20 中默认比较运算符的引入,这应该会变得越来越不需要。