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

by“value”表示通过值传输的参数，通过引用“引用”。

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

Answer 1

由于它是静态范围的，您可以更改函数内的变量名称，以避免问题意图混淆。我将p1中的y替换为p1y，p1中的p2替换为p1p2，p1p2中的x替换为p1p2x，p2中的x替换为p2x（尽管现在看起来更加丑陋）。我也略微改变了格式。

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

由于这是家庭作业，你应该能够轻松地从这里学习，使用他们教你的任何方法（逐行执行，绘制一个堆栈等）。但最终答案是肯定的，它将无限循环，打印4 6 8等等。

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);
            }
        }
    }

}

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

2 个答案: