标签: operator-precedence

if(a && b)
{
  do something;
}

有没有可能从右到左评估论点(b - > a)？

如果"是",影响评估顺序的是什么？

(我正在使用VS2008)

以下查询中的评估顺序是什么:

UPDATE tbl SET q = q + 1, p = q;

也就是说,将"tbl"."p"被设置为q或q + 1？此处的评估顺序是否受SQL标准的约束？

谢谢.

UPDATE

在考虑了Migs的回答之后,我对我能找到的所有数据库进行了一些测试.虽然我不知道标准是什么,但实施方式各不相同.

特定

CREATE TABLE tbl (p INT NOT NULL, q INT NOT NULL);
INSERT INTO tbl VALUES (1, 5);   -- p := 1, q := 5
UPDATE tbl SET q = q + 1, p = q;

我发现的价值"p"和"q"分别为:

database           p   q
-----------------+---+---
Firebird 2.1.3   | 6 | 6  -- But see …

在MySQL中执行子句的预定义顺序是什么？有些是在运行时决定的,这个顺序是否正确？

• FROM clause
• WHERE clause
• GROUP BY clause
• HAVING clause
• SELECT clause
• ORDER BY clause

我已经查看了一系列有关序列点的问题,并且无法x*f(x)确定f修改后的评估顺序是否有保证x,这是不同的f(x)*x.

考虑以下代码:

#include <iostream>

int fx(int &x) {
  x = x + 1;
  return x;
}

int f1(int &x) {
  return fx(x)*x; // Line A
}

int f2(int &x) {
  return x*fx(x); // Line B
}

int main(void) {
  int a = 6, b = 6;
  std::cout << f1(a) << " " << f2(b) << std::endl;
}

这打印49 42在g ++ 4.8.4(Ubuntu 14.04)上.

我想知道这是保证行为还是未指明.

具体来说,在这个程序中,fx两次x=6都被调用两次,并且两次都返回7次.所不同的是线A计算7×7(取的值x之后 …

考虑:

int f () {
    static int i = 0;
    return i++;
}

struct Test {
    int a, b;
    Test () : a(f()), b(f()) {}
};

Test t;

我知道a之前b由于其声明的顺序而被初始化struct.

我也知道这两次打电话都没有f参加g(f(), f()).

所以我想知道是否保证t.a == 0和t.b == 1？

我对直接赋值和三元条件运算符优先级感到困惑:

#include<stdio.h>
int main(void)
{
    int j, k;

    j = k = 0;
    (1 ? j : k) = 1; // first
    printf("%d %d\n", j, k);

    j = k = 0;
    1 ? j : k = 1; // second
    printf("%d %d\n", j, k);
    return 0;
}

我希望输出为:

1 0
1 0

但它碰巧是:

1 0
0 0

另外我得到这个警告:

main.cpp:20:warning:语句无效

这是我评论的第二行.

由于直接赋值运算符的优先级低于三元条件运算符,因此我期望将第一行和第二行注释为等效的行.但实际情况并非如此.

我用g ++ --version(Ubuntu 4.4.3-4ubuntu5)4.4.3尝试了这个

我正在解决有关主教在棋盘上移动的问题。在代码的某一时刻，我有以下语句：

std::cout << (abs(c2-c1) == abs(r2-r1)) ? 1 : 2 << std::endl;

这将产生以下错误：

error: invalid operands of types 'int' and '<unresolved overloaded function type>' to binary 'operator<<'

Run Code Online (Sandbox Code Playgroud)

但是，我通过在代码中包含一个附加变量来立即修复此错误：

error: invalid operands of types 'int' and '<unresolved overloaded function type>' to binary 'operator<<'

三元运算符如何工作，以及如何确定其返回类型（如编译器称为<unresolved overloaded function type>）？

我刚刚开始使用Scala,我刚学会了如何使方法成为正确关联(而不是在命令式面向对象语言中常见的更传统的左关联性).

首先,当我cons在Scala中看到列表的示例代码时,我注意到每个示例总是在右侧有List:

println(1 :: List(2, 3, 4))
newList = 42 :: originalList

然而,即使在一遍又一遍地看到这一点之后,我也没有三思而后行,因为我不知道(当时)这::是一种方法List.我只是假设它是一个运算符(再次,在Java中的运算符意义上),并且关联性并不重要.List在示例代码中始终出现在右侧的事实似乎巧合(我认为它可能只是"首选样式").

现在我知道的更好:它必须以这种方式编写,因为它::是正确联想的.

我的问题是,能够定义右关联方法的重点是什么？

这纯粹是出于审美原因,还是在某些情况下,权利关联实际上可以带来某些与左联结相关的好处？

从我(新手)的角度来看,我真的不知道如何

1 :: myList

比任何更好

myList :: 1

但这显然是一个微不足道的例子,我怀疑这是一个公平的比较.

我最近遇到了一些我认为我立即理解的东西,但是想更多关于它我想了解为什么它按照它的方式工作.

请考虑以下代码.该(x-- == 9)显然得到评估,而(y++ == 11)不是.我的第一个想法是,逻辑上的&&启动,看到表达式已经变为假,并在评估表达式的第二部分之前开始.

我想的越多,我就越不明白为什么会这样做.据我了解,逻辑运算符按优先级顺序低于增量运算.不(y++ == 11)应该评估,即使整体表达已经变为假？

换句话说,操作的顺序是否应该(y++ == 11)在if语句实现整个表达式之前进行评估将是错误的？

#include <iostream>
using namespace std;

int main( int argc, char** argv )
{
    int x = 10;
    int y = 10;

    if( (x-- == 9) && (y++ == 11) )
    {
        cout << "I better not get here!" << endl;
    }

    cout << "Final X: " << x << endl;
    cout << "Final Y: " << …

根据此Java运算符优先级和关联性表,成员访问优先级高于new运算符.

但是,给定一个类myClass和一个非静态成员函数myFunction,以下代码行是有效的:

new myClass().myFunction();

如果.之前评估过new,该行怎么执行？换句话说,为什么不需要括号？

(new myClass()).myFunction();

我的猜测是,由于()共享优先.,因此myClass()首先进行评估,因此编译器甚至在评估new关键字之前就知道myClass正在调用具有零参数的构造函数.然而,这似乎仍然暗示第一行应该是相同的new (myClass().myFunction());,但事实并非如此.