标签: operator-precedence

我不确定它的真正含义const vector<int *>所以我编写了下面的代码来获得一个想法但现在更加困惑.

vector<int *> v;
int x = 1, y = 2;
v.push_back(&x);
v.push_back(&y);

const vector<int *> w = v;
w[0] = &y;   //failed. Element is a constant pointer?
*(w[0]) ++;  //failed. Element pointer references to constant value?

如果我在这里停下来,我会假设这const vector<int *>是一个向量const int * const,但后来我尝试了以下与这个假设明显矛盾的方法.

*(w[0]) += 3; //passed. Value not constant?
*(w[0]) = 20; //passed. Why...

现在,*(w[0])对于未知的原因我明明对待++,并+=和分配方式不同.我确信自己const vector只声明了vector类的一个常量对象,并且上面的结果可能取决于运算符重载vector类的实际实现.但我无法绕过这个.有人可以帮忙解释一下吗？

如果它是相关的,我在Mac上使用g ++ 4.2.

Python如何评估表达式1+++2？

我介绍了多少+,它是打印3作为答案.请任何人都可以解释这种行为

因为1--2它是印刷3,因为1---2它是印刷-1

MDN声明 Javscript中有两个操作符具有最高优先级:

• 左关联成员运算符: foo.bar
• 右关联新运算符: new Foo()

我通常明确地将两者分开:(new Date()).toString()
但我经常看到它们两者合二为一:new Date().toString()

根据这个答案,第二种方式起作用的原因在于,当两个运算符具有相同的优先级时,它是第二个运算符的关联性.在这种情况下,成员运算符是左关联的,这意味着new Date()首先评估.

但是,如果是这样的话,为什么会new Date.toString()失败呢？毕竟new Date是只是语法糖的new Date().上述论点说它应该有用,但显然不行.

我错过了什么？

此代码取自此处的讨论.

someInstance.Fun(++k).Gun(10).Sun(k).Tun();

这段代码是否定义明确？是否++k在kSun()之前评估过Fun ()？

如果k是用户定义的类型,而不是内置类型怎么办？以上函数调用顺序的方式与此不同:

eat(++k);drink(10);sleep(k);

据我所知,在这两种情况下,每个函数调用后都存在一个序列点.如果是这样,为什么第一个案例也不能像第二个案例那样明确定义？

C++ ISO标准的1.9.17部分对序列点和功能评估进行了说明:

在调用函数时(无论函数是否为内联函数),在评估函数体中任何表达式或语句之前发生的所有函数参数(如果有) 之后,都会有 一个序列点.在复制返回值之后和执行函数外部的任何表达式之前,还有一个 序列点.

是否&& ||保证逻辑运算符()的从左到右的评估？

假设我有这个:

SDL_Event event;

if (SDL_PollEvent(&event)) {
    if (event.type == SDL_QUIT) {
            // do stuff
    }
}

这保证与此相同吗？

SDL_Event event;

if (SDL_PollEvent(&event) && event.type == SDL_QUIT) {
    // do stuff
}

这也很重要,假设我们有两个要求,a并且b.因此,要求a更有可能失败b.然后说它if (a && b)比说更有效率if (b && a).

这是一个简单的C++代码段:

int x1 = 10, x2=20, y1=132, y2=12, minx, miny, maxx, maxy;
x1<=x2 ? minx=x1,maxx=x2 : minx=x2,maxx=x1;
y1<=y2 ? miny=y1,maxy=y2 : miny=y2,maxy=y1;
cout<<"minx="<<minx<<"\n";
cout<<"maxx="<<maxx<<"\n";
cout<<"miny="<<miny<<"\n";
cout<<"maxy="<<maxy<<"\n";

我认为结果应该是:

minx=10
maxx=20
miny=12
maxy=132

但实际上结果是:

minx=10
maxx=10
miny=12
maxy=132

有人可以解释为什么maxx不是20？谢谢.

假设在Python中从左到右计算函数参数是否安全？

参考说明它发生的方式,但也许有一些方法来改变这个可能会破坏我的代码的顺序.

我想要做的是为函数调用添加时间戳:

l = []
l.append(f(), time.time())

我知道我可以按顺序评估参数:

l = []
res = f()
t = time.time()
l.append(res, t)

但它看起来不那么优雅,所以如果我可以依赖它,我更喜欢第一种方式.

假设我这样做

setTimeout(foo, 0);

...

setTimeout(bar, 0);

我可以确定foo会在开始执行之前吗？如果不是0,我会使用1,10或100的超时来表示条形码？

简单的实验表明,在超时值相等的情况下,超时目标的执行顺序与setTimeouts本身相同,但依赖此行为是否安全？

介绍

在C/C++的每本教科书中,您都可以找到运算符优先级和关联表,如下所示:

http://en.cppreference.com/w/cpp/language/operator_precedence

StackOverflow上的一个问题是这样的:

以下函数的执行顺序如下:

f1() * f2() + f3();
f1() + f2() * f3();

参考上面的图表,我自信地回答说函数具有从左到右的关联性,因此在前面的语句中,在这两种情况下都会像这样评估:

f1() - > f2() - > f3()

评估函数后,您完成评估,如下所示:

(a1*a2)+ a3
a1 +(a2*a3)

令我惊讶的是,很多人告诉我,我错了.决心证明他们错了,我决定转向ANSI C11标准.我再一次惊讶地发现在运算符优先级和关联性方面提到的很少.

问题

1. 如果我认为函数总是从左到右进行评估是错误的,那么表中涉及函数优先级和关联性的真正含义是什么？
2. 谁定义了运算符优先级和关联性,如果它不是ANSI？如果是ANSI的定义,为什么很少提到运算符优先级和关联性？运算符优先级和关联性是从ANSI C标准推断还是在数学中定义？

考虑以下因素:

std::string make_what_string( const std::string &id );

struct basic_foo
{
    basic_foo( std::string message, std::string id );
};

struct foo
    : public basic_foo
{
    foo::foo( std::string id)
        : basic_foo( make_what_string( id ), std::move( id ) ) // Is this valid?
    {
    }
};

因为C++中的参数评估顺序是未指定的,所以我想知道是否该行

basic_foo( make_what_string( id ), std::move( id ) )

在上面的代码是有效的.

我知道这std::move只不过是一个演员,但什么时候执行std :: string move ctor？在评估完所有参数之后,是否应该调用基础构造函数？或者这是在评估参数期间完成的？换一种说法:

编译器是否这样做:

std::string &&tmp2 = std::move(id);
std::string tmp1 = make_what_string(id);
basic_foo(tmp1, tmp2);

这是有效的.或这个:

std::string tmp2 = std::move(id);
std::string tmp1 = make_what_string(id);
basic_foo(tmp1, …