标签: expression-evaluation

我在C#和Java中发现了一些奇怪的东西.我们来看看这个C++代码:

#include <iostream>
using namespace std;

class Simple
{
public:
    static int f()
    {
        X = X + 10;
        return 1;
    }

    static int X;
};
int Simple::X = 0;

int main() {
    Simple::X += Simple::f();
    printf("X = %d", Simple::X);
    return 0;
}

在控制台中,您将看到X = 11(在此处查看结果 - IdeOne C++).

现在让我们看一下C#上的相同代码:

class Program
{
    static int x = 0;

    static int f()
    {
        x = x + 10;
        return 1;
    }

    public static void Main()
    {
        x += f(); …

在Haskell中,我可能会这样实现if:

if' True  x y = x
if' False x y = y
spin 0 = ()
spin n = spin (n - 1)

这表现我的期望:

haskell> if' True  (spin 1000000) ()  -- takes a moment
haskell> if' False (spin 1000000) ()  -- immediate

在Racket中,我可以实现这样的缺陷if:

(define (if2 cond x y) (if cond x y))
(define (spin n) (if (= n 0) (void) (spin (- n 1))))

这表现我的期望:

racket> (if2 …

规则

编写一个接受字符串作为参数的函数,以骰子表示法返回表达式的计算值,包括加法和乘法.

为了清楚起来,EBNF对法律表达的定义如下:

roll ::= [positive integer], "d", positive integer
entity ::= roll | positive number
expression ::= entity { [, whitespace], "+"|"*"[, whitespace], entity }

示例输入:

• "3d6 + 12"
• "4*d12 + 3"
• "D100"

不禁止使用eval函数或类似函数,但我鼓励在不使用这些函数的情况下求解.欢迎重新入门.

我无法提供测试用例,因为输出应该是随机的;).

格式化答案的标题:语言,n个字符(重要说明 - 没有评估等)

我的红宝石溶液,92 81个字符,使用eval:

def f s
eval s.gsub(/(\d+)?d(\d+)/i){eval"a+=rand $2.to_i;"*a=($1||1).to_i}
end

另一种红宝石的解决方案,而不是更短(92个字符),但我觉得很有意思-它仍然使用eval但这次颇有创意的方式.

class Fixnum
def**b
eval"a+=rand b;"*a=self
end
end
def f s
eval s.gsub(/d/,'**')
end

我尝试使用XOR在不使用第三个变量的情况下在Java中交换两个整数的代码.

以下是我尝试的两个交换函数:

package lang.numeric;

public class SwapVarsDemo {

    public static void main(String[] args) {
        int a = 2984;
        int b = 87593;
        swapDemo1(a,b);
        swapDemo2(a,b);
    }

    private static void swapDemo1(int a, int b) {
        a^=b^=a^=b;
        System.out.println("After swap: "+a+","+b);
    }

    private static void swapDemo2(int a, int b) {
        a^=b;
        b^=a;
        a^=b;
        System.out.println("After swap: "+a+","+b);
    }

}

此代码生成的输出如下:

After swap: 0,2984
After swap: 87593,2984

我很想知道,为什么这句话:

        a^=b^=a^=b;

与此不同？

        a^=b;
        b^=a;
        a^=b;

strictfp根据JLS,我知道修饰符在方法(和类)上的含义:

JLS 8.4.3.5,strictfp方法:

strictfp修饰符的作用是使方法体内的所有float或double表达式都是显式FP-strict(第15.4节).

JLS 15.4 FP严格表达式:

在FP-strict表达式中,所有中间值必须是浮点值集或双值集的元素,这意味着所有FP严格表达式的结果必须是IEEE 754算法在使用单格式和双格式表示的操作数上预测的结果.

在不是FP-strict的表达式中,为实现授予了一些余地,以使用扩展指数范围来表示中间结果; 粗略地说,净效应是在独占使用浮点值集或双值集可能导致上溢或下溢的情况下,计算可能会产生"正确答案".

我一直试图找到一种方法来获得strictfp方法中的表达式与非方法中的表达式之间的实际差异strictfp.我在两台笔记本电脑上试过这个,一台配备英特尔酷睿i3 CPU,另一台配备英特尔酷睿i7 CPU.我不能有任何区别.

很多帖子都表明原生浮点(不使用strictfp)可以使用80位浮点数,并且在最小可能的java双精度(最接近零)或高于最高可能的64位java双精度之下具有额外的可表示数字.

我使用和不使用strictfp修饰符尝试了下面的代码,它给出了完全相同的结果.

public static strictfp void withStrictFp() {
    double v = Double.MAX_VALUE;
    System.out.println(v * 1.0000001 / 1.0000001);
    v = Double.MIN_VALUE;
    System.out.println(v / 2 * 2);
}

实际上,我认为任何差异只会在代码编译成程序集时出现,所以我使用-XcompJVM参数运行它.但没有区别.

我发现另一篇文章解释了如何获取HotSpot生成的汇编代码(OpenJDK文档).我正在运行我的代码java -Xcomp -XX:+UnlockDiagnosticVMOptions -XX:+PrintAssembly.v * 1.0000001 / 1.0000001带有strictfp修饰符的第一个表达式(),如果没有它,则编译为:

  0x000000010f10a0a9: movsd  -0xb1(%rip),%xmm0        # 0x000000010f10a000
                                                ;   {section_word}
  0x000000010f10a0b1: …

C++ 11标准(5.17,expr.ass)表明了这一点

在所有情况下,在右和左操作数的值计算之后,以及在赋值表达式的值计算之前,对赋值进行排序.对于不确定序列的函数调用,复合赋值的操作是单个评估

据我了解,作为给定赋值的一部分的所有表达式将在赋值本身之前进行求值.即使我在同一个赋值中修改了两次相同的变量,这条规则也应该有效,我相当肯定,之前是未定义的行为.

请问代码:

int a = 0;
a = (a+=1) = 10;

if ( a == 10 ) {
    printf("this is defined");
} else {
    printf("undefined"); 
}

总是评价到a==10？

什么是第二次s.get()返回"ONE"的解释？

String x = "one";
Supplier<String> s = x::toUpperCase;
System.out.println("s.get() = " + s.get());
x = "two";
System.out.println("s.get() = " + s.get());

更新:

比较它:

String x = "one";
Supplier<String> s = () -> x.toUpperCase();
System.out.println("s.get() = " + s.get());
x = "two";
System.out.println("s.get() = " + s.get());

它会抛出一个编译错误.

鉴于这一系列的Haskell代码,我的任务是将其评估为最简单的形式.

let g h k = (\x -> k (h x)) in g (+1) (\x -> x+x) 20

我已经得到了答案(当然在GHCI中我自己进行了评估): 42

但是,我希望更好地了解评估在这里如何运作.一般来说,我想我知道如何(简单)让表达式工作:

例

a = let y = 5 in y * 5  -- a == 25

该计算结果为25,因为我们绑定y到的价值5和a被分配到的值y*5(后部分in).绑定y = 5仅在范围内有效let.

到目前为止,唯一的解释(至少评估为42)如下:

let g h k = (\x -> k (h x)) in g (+1) (\x -> x+x) 20

• g 是 (\x -> k (h x)) …

给定一个f1() + f2()*f3()带有3个方法调用的表达式，java首先计算加法运算（的操作数）：

int result = f1() + f2()*f3();

f1 working
f2 working
f3 working

我（错误地）期望f2()首先被呼叫，然后被呼叫f3()，最后被呼叫f1()。因为乘法应在加法之前求值。

所以，我在这里不了解JLS-我想念什么？

15.7.3。评估尊重括号和优先权

Java编程语言遵守 由括号显式表示和由运算符优先级隐式表示的评估顺序。

int result = f1() + f2()*f3() + f4() + f5()*f6() + (f7()+f8());

f1 working
f2 working
f3 working
f4 working …