Befunge 详解：奇特的二维栈式编程语言

 

一、Befunge 的起源与定位

Befunge 是一种极具特色的栈式编程语言，由克里斯・普雷布尔（Chris Pressey）于 1993 年设计开发。它的诞生源于对传统编程语言结构的反叛，普雷布尔希望创造一种打破线性执行流程、充满趣味性和挑战性的语言，同时探索编程语言设计的边界。

与大多数编程语言按照线性顺序执行指令不同，Befunge 的指令被排列在一个二维网格中，程序的执行方向可以在运行时动态改变，这使得 Befunge 的代码结构极具灵活性和迷惑性。这种独特的设计让 Befunge 成为一种 “二维编程语言”，也使其成为代码高尔夫（Code Golf）和编程谜题领域的热门选择。

Befunge 的定位更偏向于一种实验性和娱乐性的语言，而非用于实际生产开发。它的设计初衷是挑战程序员的思维方式，展示编程语言设计的多样性。尽管如此，Befunge 的设计理念对后来的一些编程语言产生了影响，尤其是在探索非传统执行模型方面。

二、Befunge 的核心特性

（一）二维网格代码结构

Befunge 的代码不是像传统语言那样以线性文本形式存在，而是被组织在一个二维网格中，每个网格单元包含一个指令字符。程序的执行从网格的左上角（坐标 (0,0)）开始，初始方向为向右。这种二维结构使得程序的执行路径可以像迷宫一样复杂，极大地增加了编程的趣味性和挑战性。

例如，一个简单的 Befunge 程序网格可能如下：

>987v>.v

v456< :

>321 ^ _@

这个程序的执行路径会根据指令的要求在网格中上下左右移动，执行相应的操作。

（二）动态改变执行方向

在 Befunge 中，程序的执行方向可以通过特定的指令进行改变，这是其最核心的特性之一。初始方向为向右（→），但可以通过^（上）、v（下）、<（左）、>（右）等指令改变当前的移动方向。此外，还有一些条件指令（如?、_、|）可以根据栈顶元素的值来决定执行方向，进一步增加了程序执行的灵活性。

例如，_指令会弹出栈顶元素，如果该元素为 0，则方向变为向右；否则，方向变为向左。|指令类似，但控制的是上下方向。

（三）栈式数据结构

Befunge 使用栈作为主要的数据存储和操作结构，所有的数据操作都通过栈来完成。栈是一种后进先出（LIFO）的数据结构，这意味着最后压入栈的元素会最先被弹出。Befunge 提供了一系列指令用于栈操作，如压入数字、弹出元素、交换栈顶两个元素、复制栈顶元素等。

例如，数字指令（0-9）会将相应的数字压入栈中；+指令会弹出栈顶的两个元素，将它们相加后再压入栈中；*指令则执行乘法操作。

（四）隐式程序终止

Befunge 程序没有显式的结束语句，当程序执行到@指令时，程序会立即终止。@通常被放置在程序网格的某个位置，当执行路径到达该位置时，程序结束运行。

（五）代码与数据的混合

在 Befunge 中，代码和数据没有严格的区分，网格中的任何字符都可以被视为指令或数据。这意味着一些非指令字符（如字母、符号等）在特定情况下可以被当作数据压入栈中（通过"指令进入字符串模式），这种特性使得程序可以更灵活地处理数据，但也增加了代码的复杂性。

三、Befunge 的语法与指令系统

（一）基本语法规则

1. 程序由一个二维网格组成，网格中的每个单元格是一个 ASCII 字符。

1. 程序从坐标 (0,0) 开始执行，初始方向为向右（→）。

1. 每次执行当前单元格的指令后，程序按照当前方向移动到下一个单元格。

1. 当执行到@指令时，程序终止。

1. 栈是主要的数据操作结构，所有数据操作都通过栈进行。

（二）主要指令分类及功能

1. 数字指令（0-9）

这些指令会将对应的数字压入栈中。例如，5指令会将 5 压入栈；9指令会将 9 压入栈。

1. 算术运算指令

• • +：弹出栈顶两个元素 a 和 b（a 是先弹出的元素，b 是后弹出的元素），计算 b + a，将结果压入栈中。

• • -：计算 b - a，将结果压入栈中。

• • *：计算 b * a，将结果压入栈中。

• • /：计算 b 除以 a 的商（整数除法，向零取整），将结果压入栈中。

• • %：计算 b 除以 a 的余数，将结果压入栈中。

• • !：逻辑非运算，弹出栈顶元素 a，如果 a 为 0，则压入 1；否则，压入 0。

• • `：比较运算，弹出栈顶两个元素 a 和 b，如果 b > a，则压入 1；否则，压入 0。

1. 栈操作指令

• • :：复制栈顶元素，将复制的元素压入栈中。如果栈为空，则压入 0。

• • \：交换栈顶两个元素的位置。如果栈中只有一个元素，则该元素与 0 交换位置；如果栈为空，则压入两个 0。

• • $：弹出栈顶元素，并丢弃该元素。

• • .：弹出栈顶元素，并将其以数字形式输出。

• • ,：弹出栈顶元素，并将其以 ASCII 字符形式输出。

1. 方向控制指令

• • ^：将当前方向改为向上（↑）。

• • v：将当前方向改为向下（↓）。

• • <：将当前方向改为向左（←）。

• • >：将当前方向改为向右（→）。

• • ?：随机选择一个方向（上、下、左、右）作为当前方向。

• • _：弹出栈顶元素 a，如果 a 为 0，则方向改为向右；否则，方向改为向左。

• • |：弹出栈顶元素 a，如果 a 为 0，则方向改为向下；否则，方向改为向上。

1. 字符串与输入指令

• • "：切换字符串模式。在字符串模式下，遇到的每个字符（直到再次遇到"）都会被当作 ASCII 值压入栈中，而不是作为指令执行。

• • &：从标准输入读取一个整数，压入栈中。

• • ~：从标准输入读取一个字符，将其 ASCII 值压入栈中。

1. 程序控制指令

• • #：跳过下一个单元格。执行该指令后，程序会按照当前方向移动两步（即跳过下一个单元格）。

• • @：程序终止指令，执行后程序立即停止运行。

1. 其他指令

• • （空格）：空指令，不执行任何操作，程序继续按照当前方向移动。

（三）指令执行示例

为了更好地理解 Befunge 指令的执行过程，下面通过几个简单的例子进行说明。

1. 加法操作示例：

程序网格：12+@

执行过程：

• • 从 (0,0) 开始，方向向右。首先执行1，将 1 压入栈，栈：[1]。

• • 移动到 (0,1)，执行2，将 2 压入栈，栈：[1, 2]。

• • 移动到 (0,2)，执行+，弹出 1 和 2，计算 2 + 1 = 3，将 3 压入栈，栈：[3]。

• • 移动到 (0,3)，执行@，程序终止。最终栈顶元素为 3，但未输出。

1. 输出操作示例：

程序网格：34*..@

执行过程：

• • (0,0) 执行3，栈：[3]。

• • (0,1) 执行4，栈：[3,4]。

• • (0,2) 执行*，弹出 3 和 4，计算 4*3=12，栈：[12]。

• • (0,3) 执行., 弹出 12，输出数字 12，栈为空。

• • (0,4) 执行., 栈为空，弹出 0，输出数字 0。

• • (0,5) 执行@，程序终止。输出结果为 “120”。

1. 方向改变示例：

程序网格：

>v

^<

初始方向向右，从 (0,0) 开始执行>（方向仍为向右），移动到 (0,1) 执行v，方向变为向下，移动到 (1,1) 执行<，方向变为向左，移动到 (1,0) 执行^，方向变为向上，移动到 (0,0)，如此循环，形成一个无限循环。

四、Befunge 的程序结构与执行流程

（一）程序网格的定义

Befunge 程序的网格可以是任意大小的二维数组，行数和列数没有严格限制。网格中的每行可以有不同的长度，较短的行在末尾会被隐含地用空格填充，以与最长的行对齐。例如，一个包含三行的程序：

12+

34*

@

会被视为一个 3 行 3 列的网格：

12+

34*

@

（二）执行流程的控制

Befunge 程序的执行流程由当前位置和当前方向共同决定。每次执行完当前单元格的指令后，程序会按照当前方向移动一个单元格，然后执行新单元格的指令，如此反复，直到遇到@指令。

方向的改变可以是显式的（通过^、v、<、>指令），也可以是条件性的（通过_、|、?指令）。这种灵活的方向控制使得程序的执行路径可以非常复杂，甚至可以在网格中来回穿梭，形成循环、分支等结构。

例如，一个简单的条件分支程序：

3 1_@

^

程序从 (0,0) 开始，方向向右。执行3压入栈，栈：[3]；移动到 (0,1) 执行空格，无操作；移动到 (0,2) 执行1压入栈，栈：[3,1]；移动到 (0,3) 执行_，弹出 1（非 0），方向改为向左；移动到 (0,2) 执行1压入栈，栈：[3,1]；再次移动到 (0,1) 执行空格；移动到 (0,0) 执行3压入栈，栈：[3,1,3]；如此反复，形成循环。

（三）栈的使用与数据处理

栈在 Befunge 中扮演着核心角色，几乎所有的数据处理都依赖于栈的操作。无论是算术运算、输入输出还是条件判断，都需要通过栈来传递和处理数据。

例如，实现一个简单的比较功能，判断两个数是否相等：

5 5-! .@

执行过程：

• 5压栈：[5]

• 5压栈：[5,5]

• -：5-5=0，栈：[0]

• !：0 的逻辑非为 1，栈：[1]

• .：输出 1

• @：程序终止。输出结果为 1，表示两个数相等。

五、Befunge 的高级特性与技巧

（一）字符串处理

通过"指令可以进入字符串模式，在该模式下，所有字符都会被当作 ASCII 值压入栈中，这使得处理字符串变得相对容易。例如，输出 “Hello” 的程序：

"Hello",,,,,@

执行过程：

• 遇到"进入字符串模式，将 'H'（72）、'e'（101）、'l'（108）、'l'（108）、'o'（111）依次压栈，栈：[72,101,108,108,111]。

• 再次遇到"退出字符串模式。

• 五个,指令依次弹出栈顶元素，并以 ASCII 字符形式输出，依次输出 'o'、'l'、'l'、'e'、'H'？显然，这与预期的 “Hello” 顺序相反，因为栈是后进先出的结构。

• 修正后的程序需要调整栈中元素的顺序，例如：

"olleH",,,,,@

这样弹出的元素依次是 'H'、'e'、'l'、'l'、'o'，输出 “Hello”。

（二）循环结构的实现

虽然 Befunge 没有专门的循环指令，但可以通过方向控制指令和条件判断来实现循环结构。例如，实现一个从 1 加到 10 的循环：

v>1+:v

^ _@

这个程序的执行过程较为复杂，大致流程是：

• 初始方向向右，(0,0) 是v，方向改为向下，移动到 (1,0) 是^，方向改为向上，移动到 (0,0)，形成上下循环，直到满足条件进入加法逻辑。

• 当进入加法逻辑后，通过1+实现累加，:复制栈顶元素用于判断，_根据判断结果控制方向，实现循环累加，直到累加完成后执行@终止程序。

（三）代码复用与模块化

由于 Befunge 的二维结构和灵活的执行路径，实现代码复用和模块化相对困难，但可以通过设计特定的代码片段和跳转逻辑来实现类似的功能。例如，将常用的算术运算（如加法、乘法）封装在网格的特定区域，通过控制程序的执行方向跳转到该区域执行，完成后再跳转回原来的执行路径。

（四）输入处理

使用&和~指令可以处理输入。&用于读取整数，~用于读取字符。例如，一个读取用户输入的整数并输出其平方的程序：

&:*^@

执行过程：

• &读取一个整数 n，压栈：[n]

• :复制 n，栈：[n, n]

• *计算 n*n，栈：[n²]

• .输出 n²

• @终止程序。

六、Befunge 的变体与扩展

Befunge 的设计激发了许多变体语言的开发，这些变体在 Befunge 的基础上增加了新的特性或修改了部分规则，以扩展其功能或增加挑战性。

（一）Befunge-98

Befunge-98 是 Befunge 的一个重要变体，于 1998 年推出，它扩展了原始 Befunge 的功能，增加了更多的指令、更大的栈、多栈支持以及更复杂的程序结构（如二维栈、文件操作等）。Befunge-98 的网格可以是任意维度的（不仅仅是二维），还支持浮点数运算，大大增强了语言的表达能力。

（二）Funge-98

Funge-98 是一个更广泛的标准，包含了 Befunge-98 和另一个变体 Language::Funge。它定义了一套通用的规则和指令集，允许不同的 Funge 语言之间有更好的兼容性和互操作性。

（三）其他变体

还有许多其他的 Befunge 变体，如 Trefunge（三维 Befunge）、Hexifunge（六维 Befunge）、Befunge-93（原始版本的扩展）等。这些变体通过增加维度、修改指令集或改变执行模型等方式，进一步探索了非传统编程语言的可能性。

七、Befunge 的应用场景与局限性

（一）应用场景

1. 编程教育与思维训练：Befunge 独特的执行模型和语法结构可以挑战程序员的传统思维方式，帮助学习者理解栈数据结构、程序控制流等概念，培养逻辑思维和问题解决能力。

1. 代码高尔夫：由于 Befunge 的灵活性和简洁的指令集，它常被用于代码高尔夫比赛，参赛者需要用最少的字符编写实现特定功能的程序。

1. 编程谜题与娱乐：Befunge 程序的复杂性和趣味性使其成为编程谜题的热门选择，许多编程爱好者喜欢编写和破解 Befunge 谜题，享受其中的乐趣。

1. 语言设计研究：Befunge 的设计理念为编程语言设计提供了新的思路，研究 Befunge 可以帮助理解非传统执行模型的可能性和局限性。

（二）局限性

1. 可读性差：Befunge 程序的二维结构和复杂的执行路径使得代码非常难以阅读和理解，即使是简单的程序