在C ++中,是否可以使用三元运算符在if语句中选择比较运算符?

时间:2019-11-22 12:45:14

标签: c++ conditional-operator comparison-operators

虽然重构代码可以最大程度地减少代码行数,但我想知道是否可以将两个相似的if语句组合在一起,唯一的区别是比较运算符,例如

if (a > b) a=b;
if (a < b) a=b;

使用三元运算符(?)选择比较运算符,例如

if (a (c?<:>) b) a=b;

我的编译器没有抛出任何错误或警告,但我想知道它是否真的有意工作。

8 个答案:

答案 0 :(得分:4)

您可以使用null?std::less

std::greater

请注意,这是一种不好的做法,因为它非常不可读,因此除非有特殊原因,否则不应在生产代码中使用。

答案 1 :(得分:3)

lambdas解决方案:

const auto lt = [](int a, int b) { return a < b; };
const auto gt = [](int a, int b) { return a > b; };

if ((c ? +lt : +gt)(a, b))
    a = b;

+将lambda转换为函数指针,因此+less+greater具有相同的类型。

答案 2 :(得分:3)

一种C ++ 17方式:

if (auto s = 2 * !!c - 1; s * a > s * b) a = b;

sc的符号,并且将a的{​​{1}}和b乘以s会有效地反转{{1} }。但是,一种危险是尝试最小否定2的补码符号类型。

答案 3 :(得分:2)

不。 <>是运算符,而不是表达式。运算符?:带有3个表达式。

  

条件运算符表达式的格式为E1 ? E2 : E3

     

对条件运算符的第一个操作数求值并在上下文中转换为bool。在完成第一个操作数的值评估和所有副作用之后,如果结果为true,则对第二个操作数进行评估。如果结果为假,则对第三个操作数求值。

答案 4 :(得分:1)

我在这里不使用三元运算符,而是为if使用一个普通的无聊条件:

if ( (c && a < b) || (!c && a > b) ) a = b;

我承认,这是否比读者决定的其他内容更具可读性。

答案 5 :(得分:1)

从您的示例中,我会简单地做

a = (c ? std::max(a, b) : std::min(a, b));

答案 6 :(得分:0)

要解救的算法!!!

if((a-b)*(((int) c)*2 - 1) < 0)
    a=b;

我希望<是正确的方法。

答案 7 :(得分:0)

只是为了好玩,我可以建议以下语法:

if (a, cmp(c, std::less{}, std::greater{}), b) ...

近似于

if (a (c ? < : >) b) ...

实施:

template<class True, class False>
class cmp {
public:
    cmp(bool flag, True if_true, False if_false)
        : flag_(flag), if_true_(if_true), if_false_(if_false) {}       

private:
    template<class Lhs>
    class Proxy {
    public:
        Proxy(const Lhs& lhs, cmp comparator) 
            : lhs_(lhs), comparator_(comparator) {}

        template<class Rhs>
        bool operator,(const Rhs& rhs) {
            if (comparator_.flag_)
                return comparator_.if_true_(lhs_, rhs);
            else
                return comparator_.if_false_(lhs_, rhs);
        }

    private:
        const Lhs& lhs_;
        const cmp comparator_;
    };

    template<class Lhs>
    friend auto operator,(const Lhs& lhs, cmp comparator) {
        return Proxy<Lhs>(lhs, comparator);
    }

    const bool flag_;
    const True if_true_;
    const False if_false_;
};