有人请解释这个程序是如何执行的？下面

Question

处于静态范围的语言的程序：

program main 
    int x, y; 
    void p1(value int y, void q(reference int)) { 
     void p2(reference int x) { 
      x := y + 2; 
      print(x); 
      q(y); 
      } 
     if x = y then q(y) else p1(y+1, p2) 
     } 
    void p2(reference int x) { 
     x := y + 2; 
     print(x); 
     } 
    x := 2; 
    y := x; 
    p1(0, p2); 
end main 

由“值”，则意味着通过参考由值参数发送，“参考”。

在p2中函数调用“q（y）”会导致无限循环吗？

Answer 1

因为它是静态的作用域，你可以改变内部功能变量名称，以避免问题的预期的混乱。我用p1y替换p1中的y，用p1p2替换p1中的p2，用p1p2替换p1p2中的x，用p2x替换p2中的x（尽管如此，它现在看起来更加丑陋）。我也稍微改变了格式。

program main 
    int x, y; 
    void p1(value int p1y, void q(reference int)) { 
    void p1p2(reference int p1p2x) { 
     p1p2x := p1y + 2; 
     print(p1p2x); 
     q(p1y); 
    } 

    if x = p1y then { 
     q(p1y); 
    } else { 
     p1(p1y+1, p1p2); 
    } 
    } 

    void p2(reference int p2x) { 
    p2x := y + 2; 
    print(p2x); 
    } 

    x := 2; 
    y := x; 
    p1(0, p2); 
end main 

因为这是家庭作业，你应该能够把它从这里轻松地使用他们教你任何方法（遵循行的执行线，画一个堆栈等）。但最终答案是肯定的，它会无限循环，打印468等等。

Answer 2

它打印4.在Java：

import java.util.concurrent.atomic.AtomicInteger; 

public class Test { 

    public static void main(String... a) { 
     new Test().run(); 
    } 

    AtomicInteger x = new AtomicInteger(0); 
    AtomicInteger y = new AtomicInteger(0); 

    void run() { 
     x.set(2); 
     y.set(x.get()); 
     new P1().p1(new AtomicInteger(0), new P2()); 
    } 

    interface Q { 
     void q(AtomicInteger x); 
    } 

    class P2 implements Q { 
     public void q(AtomicInteger x) { 
      x.set(y.get() + 2); 
      System.out.println(x.get()); 
     } 
    } 

    class P1 implements Q { 
     public void q(AtomicInteger x) { 
      x.set(y.get() + 2); 
      System.out.println(x.get()); 
     } 
     void p1(AtomicInteger y, Q q) { 
      if (x.get() == y.get()) { 
       q.q(y); 
      } else { 
       p1(new AtomicInteger(y.get()+1), this); 
      } 
     } 
    } 

}