三元运算符？：vs if…else

在C ++中，？：运算符是否比if（）... else语句快？它们在编译后的代码之间有什么区别吗？

取决于您的编译器，但是取决于任何现代编译器，通常没有什么区别。这是您不应该担心的事情。专心于代码的可维护性。

它并不快。当您可以根据某些表达式初始化常量变量时​​，有一个区别：

const int x = (a<b) ? b : a;

您无法使用进行相同操作if-else。

我已经看到了GCC将条件运算符转换为cmov（条件移动）指令，而将if语句转换为分支，这意味着在我们的情况下，使用条件运算符时代码会更快。但这是几年前的事，而今天最有可能的是，两者都将编译为相同的代码。

不能保证它们将编译为相同的代码。如果您需要性能，请像往常一样测量。并且，当您测量并发现1.您的代码太慢时，以及2.正是这部分特殊代码才是罪魁祸首，然后研究编译器生成的汇编代码并自己检查发生了什么。

不要相信“如果我使用条件运算符，编译器将始终生成更高效的代码”之类的黄金规则。

它们是相同的，但是，三元运算符可以在难以使用if / else的地方使用：

printf("Total: %d item%s", cnt, cnt != 1 ? "s" : "");

用if / else执行该语句将生成完全不同的编译代码。

8年后更新...

实际上，我认为这样会更好：

printf(cnt == 1 ? "Total: %d item" : "Total: %d items", cnt);

（实际上，我很确定您可以将第一个字符串中的“％d”替换为“一个”）

只是有点左撇子...

x ? y : x = value

将分配值给ÿ如果X不为0（假）。

不管编译的代码如何，它们在语义上都是不同的。<cond>?<true expr>:<false expr>是一个表达式，if..else..是一个语句。

尽管条件表达式的语法看起来很尴尬，但这是一件好事。您被迫提供a，<false expr>并且对两个表达式进行类型检查。

if..else..Haskell与基于表达式的功能语言（如Lisp）等效，是? :用C ++而不是if..else..语句。

您不必被迫将所有内容放在一起：

x = y==1 ?
    2
    :// else
    3;

它比if / else清晰得多，因为您可以立即看到两个分支都导致将x分配给了x。

我希望在大多数编译器和目标平台上，有时“ if”更快，而？：更快。在某些情况下，一种形式比另一种形式更紧凑。哪种情况偏爱一种形式，另一种情况偏爱编译器和平台。如果要在嵌入式微型计算机上编写对性能至关重要的代码，请查看编译器在每种情况下生成的内容，然后看看哪种更好。在“主流” PC上，由于缓存问题，查看哪种更好的唯一方法是在类似于真实应用程序的基准中对这两种形式进行基准测试。

在CA三元运算符中，“？：”可用于构造形式的条件表达式

exp1 ? exp2:exp3

其中exp1，exp2和exp3是表达式

例如

        a=20;
        b=25;
        x=(a>b)?a:b;

        in the above example x value will be assigned to b;

可以使用if..else语句编写，如下所示

            if (a>b)
             x=a;
             else
             x=b;

**因此，两者之间没有区别。这对于程序员来说很容易编写，但是对于编译器来说都是相同的。*

在反转一些代码（几年前我不记得了）的过程中，我发现机器代码之间的单行差异是：？还有if-else。 Don't remember much but it is clear that implementation of both is different.

但我建议您不要选择其中之一来提高效率，而是根据代码的可读性或方便性来选择。快乐编码

三元运算符始终返回一个值。因此，在需要从结果中获得一些输出值并且只有两个条件的情况下，最好使用三元运算符。如果上述任何条件都不成立，请使用if-else。

我认为在某些情况下，内联if可以由于其作用范围而产生“更快”的代码。创建和销毁对象的成本很高，因此请考虑以下情形：

class A{
    public:
    A() : value(0) {
        cout << "Default ctor" << endl;
    }
    A(int myInt) : value(myInt)
    {
        cout << "Overloaded ctor" << endl;
    }

    A& operator=(const A& other){
        cout << "= operator" << endl;
        value = other.value; 
    }

    ~A(){
        cout << "destroyed" << std::endl;
    }

    int value;

};


int main()
{
   {
       A a;
       if(true){
           a = A(5);
       }else{
           a = A(10);
       }
   }

   cout << "Next test" << endl;
   {
        A b = true? A(5) : A(10);
   }
   return 0;
}

使用此代码，输出将是：

Default ctor                                                                                                                                                                                                                      
Overloaded ctor                                                                                                                                                                                                                   
= operator                                                                                                                                                                                                                        
destroyed                                                                                                                                                                                                                         
destroyed                                                                                                                                                                                                                         
Next test                                                                                                                                                                                                                         
Overloaded ctor                                                                                                                                                                                                                   
destroyed  

因此，通过内联if，我们节省了大量操作，以保持a与相同的作用域b。尽管两种情况下的条件评估速度极有可能相等，但是更改范围会迫使您考虑其他因素，因为如果inline允许您避免使用这种因素。

现在，我无法为您提供帮助，也许可以解决下面的第二个问题，我想使用它吗？如果您只想了解速度，请忽略我的评论。

我只能说请谨慎使用三元组？：运算符。与可读性的诅咒一样，这可能是一种祝福。

在使用它之前先问问自己是否觉得这更容易阅读

int x = x == 1 ? x = 1 : x = 1;

if (x == 1)
{
   x = 1
}
else
{
   x = 2
}

if (x == 1)
    x = 1
else
    x = 1

是的，使代码100％伪造看起来很愚蠢。但是这个小技巧帮助我分析了代码的可读性。这是您在此样本中看到的操作员的可读性，而不是内容的可读性。

它看起来很干净，但普通的马桶座圈和门把手也很干净

根据我的经验，这是有限的，我看到很少有人能够快速引渡三元运算符所需的信息，除非100％确信会更好，否则请避免。我认为，当它也被bug修复时，这很痛苦

不，它们将转换为完全相同的可执行代码。