仓颉编程语言程序结构详解:顶层作用域、变量体系、const 常量与作用域规则
仓颉编程语言程序结构详解:顶层作用域、变量体系、const 常量与作用域规则
本文以仓颉(Cangjie)开发者文档中的“程序结构”章节为骨架,系统讲解 .cj 源文件如何组织、顶层作用域与 main 程序入口的关系、变量定义的修饰符体系(let/var/const)、const 编译期常量、值类型与引用类型变量的行为差异,以及作用域与名字遮蔽规则。读完本文,你将能够独立搭建一个规范的仓颉源文件、准确选择变量修饰符、规避编译器保守策略下的初始化报错,并理解跨作用域的访问与遮蔽行为。
从源文件到可执行程序:顶层作用域与程序入口
仓颉程序的源代码保存在扩展名为 .cj 的文本文件中,这些文件和其中的内容分别被称为源代码与源文件。在程序开发的最后阶段,源码会被编译器编译为特定格式的二进制文件(可执行文件或库文件)。
在仓颉程序的顶层作用域中,可以定义一系列的变量、函数和自定义类型(如 struct、class、enum 和 interface),其中的变量和函数分别被称为全局变量和全局函数。如果要将仓颉程序编译为可执行文件,还需要在顶层作用域中定义一个 main 函数作为程序入口。
以下程序在顶层作用域中定义了全局变量 a、全局函数 b、自定义类型 C、D、E,以及作为程序入口的 main 函数:
// example.cj
let a = 2023
func b() {}
struct C {}
class D {}
enum E {
F | G
}
main() {
println(a)
}
main 函数的形态约束
关于 main 函数,程序入口 一节给出了更完整的规定,与“程序结构”章节互为补充:
- 无需
func修饰符:定义main时不需要写func修饰符,直接以main关键字开头。 - 参数可选:
main可以没有参数,也可以带一个Array<String>类型的参数,用于获取程序启动时的命令行参数。 - 返回值类型受限:
main的返回值类型只能是整数类型(如Int64、Int32、Int8)或Unit类型。 - 不可被访问修饰符修饰:
main不能使用private、public等访问修饰符;当一个包被导入时,包中定义的main不会被导入。 - 唯一性约束:编译生成可执行文件时,编译器只在源文件根目录下的顶层查找
main,且最多只能有一个main;如果缺失或存在多个,编译器都会报错。
带命令行参数的 main 写法如下:
// main.cj
main(args: Array<String>): Unit { // OK.
for (arg in args) {
println(arg)
}
}
使用 cjc main.cj 编译完成后,通过命令行执行 ./main Hello, World,将得到如下输出:
Hello,
World
以下均为错误的 main 定义示例:
// main.cj
main(): String { // Error, return type of 'main' is not 'Integer' or 'Unit'.
return ""
}
// main.cj
main(args: Array<Int8>): Int64 { // Error, 'main' cannot be defined with parameter whose type is not Array<String>.
return 0
}
// main.cj
// Error, multiple 'main's are found in source files.
main(args: Array<String>): Int32 {
return 0
}
main(): Int8 {
return 0
}
编译与运行命令方面,默认情况下执行 cjc hello.cj 即可在当前工作目录下生成名为 main 的可执行文件(详见 cjc 使用);也可以配合 -o 选项指定输出文件名,例如 cjc main.cj -o a.out。编译通过后直接运行 ./main 即可看到程序输出。
非顶层作用域中的定义:局部元素与成员元素
在非顶层作用域中,不能定义 struct、class、enum、interface 等自定义类型,但可以定义变量和函数,称之为局部变量和局部函数。特别地,定义在自定义类型内部的变量和函数,被称为成员变量和成员函数。
注意:
enum和interface中仅支持定义成员函数,不支持定义成员变量。
以下程序同时演示了顶层、局部与成员三个层面的定义:在顶层作用域定义全局函数 a 和自定义类型 A;在函数 a 内部定义局部变量 b 和局部函数 c;在自定义类型 A 内部定义成员变量 b 和成员函数 c:
// example.cj
func a() {
let b = 2023
func c() {
println(b)
}
c()
}
class A {
let b = 2024
public func c() {
println(b)
}
}
main() {
a()
A().c()
}
运行以上程序,将输出:
2023
2024
这里有一个值得注意的联动:局部函数 c 可以访问其外层函数 a 中的局部变量 b,这正是后面“作用域”一节所讲的嵌套作用域访问规则;而 class A 中的成员变量 b 与成员函数 c,则只能通过 A 的实例(如 A().c())来访问。关于函数嵌套的更多细节可参考定义函数章节,关于成员访问规则可参考顶层声明的可见性章节。
变量:定义形式与修饰符体系
在仓颉编程语言中,一个变量由对应的变量名、数据(值)和若干属性构成。开发者通过变量名访问变量对应的数据,但访问操作需要遵从相关属性的约束(如数据类型、可变性和可见性等)。
变量定义的具体形式为:
修饰符 变量名: 变量类型 = 初始值
其中修饰符用于设置变量的各类属性,可以有一个或多个,常用的修饰符包括:
- 可变性修饰符:
let与var,分别对应不可变和可变属性。可变性决定了变量被初始化后其值还能否改变,仓颉变量也由此分为不可变变量和可变变量两类。 const修饰符:const是一种特殊的变量修饰符,用于声明常量,要求在声明时必须初始化,一旦被赋值其值就不能再改变。它与let类似都具有不可变特性,但使用上有更严格的限制(详见后文“const变量”小节)。- 可见性修饰符:
private与public等,影响全局变量和成员变量的可引用范围(完整语义见顶层声明的可见性)。 - 静态性修饰符:
static,影响成员变量的存储和引用方式,静态成员变量只能通过类型名访问。
所有变量均支持赋值操作符(=),与类型无关。let 修饰的变量只能被赋值一次(即初始化);var 修饰的变量可以被多次赋值。定义变量时,可变性修饰符是必需的,在此基础上可以按需添加其他修饰符。
定义中各组成部分的约束如下:
- 变量名:必须是合法的仓颉标识符(普通标识符或原始标识符,规则见标识符)。
- 变量类型:指定变量所持有数据的类型。当初始值具有明确类型时可以省略类型标注,由编译器自动推断。
- 初始值:一个仓颉表达式。若标注了变量类型,需保证初始值类型与变量类型一致。全局变量或静态成员变量必须指定初始值;局部变量或实例成员变量可以省略初始值,但此时必须标注变量类型,且必须在变量被引用前完成初始化,否则编译报错。
三类变量的定义与修改示例
下列程序定义了三个 Int64 类型的变量(不可变变量 a、可变变量 b 和 const 变量 c),随后修改 b 的值、将 b 赋值给 a,并打印三者:
main() {
let a: Int64
var b: Int64 = 14
const c: Int64 = 13
b = 12
a = b // A variable modified by let can only be assigned once, that is, initialized
println("${a}, ${b}, ${c}")
}
编译运行此程序,将输出:
12, 12, 13
注意,此处 let a: Int64 在定义时未给出初始值,但它在被引用前已通过 a = b 完成初始化,因此是合法的。如果尝试修改不可变变量,编译时会报错:
main() {
let pi: Float64 = 3.14159
pi = 2.71828 // Error, cannot assign to immutable value
}
类型推断:省略类型标注
当初始值类型明确时,可以省略变量类型标注,编译器会自动推断:
main() {
let a: Int64 = 2023
let b = a
println("a - b = ${a - b}")
}
变量 b 的类型由其初值 a 的类型自动推断为 Int64,程序输出:
a - b = 0
局部变量的延迟初始化
定义局部变量时可以不初始化,但必须在被引用前赋予初值:
main() {
let text: String
text = "仓颉造字"
println(text)
}
编译运行此程序,将输出:
仓颉造字
全局变量与静态成员变量必须初始化
与局部变量不同,全局变量和静态成员变量在定义时必须初始化,否则编译报错:
let global: Int64 // Error, variable in top-level scope must be initialized
main(): Unit{
}
class Player {
static let score: Int32 // Error, static variable 'score' needs to be initialized when declaring
}
编译器的保守初始化策略
仓颉是静态强类型语言(详见初识仓颉语言),当编译器无法判断某些场景是否一定会完成初始化、或无法判断是否重复初始化了不可变变量时,会倾向于采用保守策略直接报错。文档中给出了三类典型场景:
场景一:条件分支。 编译器无法证明 if 分支必然执行,因此认为不可变变量可能未被初始化,随后再赋值即构成“对不可变值的重复赋值”:
func calc(a: Int32) {
println(a)
return a * a
}
main() {
let a: String
if (calc(32) == 0) {
a = "1"
}
a = "2" // Error, cannot assign to immutable value
}
场景二:函数或 lambda 内的静态成员变量赋值。 当静态成员变量的赋值出现在函数或 lambda 内时,编译器在编译期无法确定该函数或 lambda 是否会被执行,因此通常采用保守策略报错:
func foo(a: () -> Unit) {
// 业务逻辑处理
}
class A {
public static var ctx: Int64 // 编译报错,静态变量 ctx 没有初始化
static init() {
let lambda = {=> ctx = 10}
foo(lambda)
}
}
main() {}
场景三:try-catch。 对于 try-catch 场景,编译器会假设 try 块总是全部被执行、且总是抛出异常,从而进行相关报错:
main() {
let a: String
try {
a = "1"
} catch (_) {
a = "2" // Error, cannot assign to immutable value
}
}
理解这些保守策略,有助于写出“一次通过编译”的仓颉代码:在分支、闭包、异常处理等路径不确定的场景下,建议在声明处直接完成初始化,避免依赖“必然在某条路径上赋值”的假设。
const 变量:编译期求值的常量
const 变量是以关键字 const 修饰的特殊变量:它在编译时完成求值,并且在运行时不可改变。例如,下面定义了万有引力常数 G:
const G = 6.674e-11
const 变量的规则要点:
- 可以省略类型标注,但不可省略初始化表达式——这是
const与let/var在定义语法上最显著的区别。 - 可定义的位置:
const变量可以是全局变量、局部变量、静态成员变量。 - 禁止在扩展中定义:
const变量不能在扩展中定义。 - 成员访问能力:
const变量可以访问对应类型的所有实例成员,也可以调用对应类型的所有非mut实例成员函数。
下例定义了一个 struct,记录行星的质量和半径,并定义了一个 const 成员函数 gravity 用来计算该行星对距离为 r、质量为 m 的物体的万有引力:
struct Planet {
const Planet(let mass: Float64, let radius: Float64) {}
const func gravity(m: Float64, r: Float64) {
G * mass * m / r ** 2
}
}
main() {
const myMass = 71.0
const earth = Planet(5.972e24, 6.378e6)
println(earth.gravity(myMass, earth.radius))
}
编译执行得到地球对地面上一个质量为 71 kg 的成年人的万有引力:
695.657257
深度 const 语义:const 变量初始化后,该类型实例的所有成员都是 const 的(深度 const,包含成员的成员),因此不能被用于左值:
main() {
const myMass = 71.0
myMass = 70.0 // Error, cannot assign to immutable value
}
const 变量之所以能在编译期求值,是因为编译器对 const 上下文中的表达式施加了严格限制(避免修改全局状态、I/O 等副作用),并配套提供了 const 函数、const init 等机制,使得常量计算可以在编译期完成、减少运行时开销。更完整的规则可参考const 函数和常量求值章节,例如:const 函数必须使用 const 修饰、const 函数中的表达式必须都是 const 表达式、struct/class 只有定义了 const init 才能定义 const 实例成员函数等。
值类型变量与引用类型变量
从编译器实现层面看,任何变量总会关联一个值(一般通过内存地址/寄存器关联):
- 对有些变量,使用时会直接取用这个值本身,称为值类型变量;
- 对另一些变量,使用时会把这个值作为索引、取用索引指示的数据,称为引用类型变量。
值类型变量通常在线程栈上分配,每个变量都有自己的数据副本;引用类型变量通常在进程堆中分配,多个变量可引用同一数据对象,对一个变量执行的操作可能会影响其他变量。从语言层面看,值类型变量对所绑定的数据/存储空间是独占的,而引用类型变量所绑定的数据/存储空间可以和其它引用类型变量共享。
基于上述原理,两类变量的行为差异主要体现在两点:
- 赋值语义不同:给值类型变量赋值时,一般会产生拷贝操作,且原来绑定的数据/存储空间会被覆盖;给引用类型变量赋值时,只是改变了引用关系,原来绑定的数据/存储空间不会被覆盖。
let的约束范围不同:let要求变量初始化后不能再被赋值。对于引用类型,这只限定了引用关系不可改变,但所引用的数据本身是可以被修改的。
在仓颉中,class 和 Array 等类型属于引用类型;其他基础数据类型(如 Int64、Float64、Bool、String 等)和 struct 等类型属于值类型。
以下程序演示了 struct 与 class 类型变量的行为差异:
struct Copy {
var data = 2012
}
class Share {
var data = 2012
}
main() {
let c1 = Copy()
var c2 = c1
c2.data = 2023
println("${c1.data}, ${c2.data}")
let s1 = Share()
let s2 = s1
s2.data = 2023
println("${s1.data}, ${s2.data}")
}
运行以上程序,将输出:
2012, 2023
2023, 2023
可以看到:对于值类型的 Copy,c2 = c1 总是获取 Copy 实例的拷贝,随后对 c2 成员的修改不影响 c1;对于引用类型的 Share,s2 = s1 建立的是变量与实例之间的引用关系,随后对 s2 成员的修改会传导到 s1。
如果把示例中的 var c2 = c1 改成 let c2 = c1,编译会报错——因为 let 只锁定引用/值本身不可再赋值,而 c2.data = 2023 是对成员的修改,在 let 下禁止:
struct Copy {
var data = 2012
}
main() {
let c1 = Copy()
let c2 = c1
c2.data = 2023 // Error, cannot assign to immutable value
}
作用域:名字绑定、遮蔽与访问规则
除了变量,函数和自定义类型等程序元素也有名字,程序通过这些名字访问对应的元素。但在实际应用中存在三类特殊情况:
- 命名冲突:程序规模较大时,简短的名字很容易重复;
- 作用域失效:某些代码片段中,另一些程序元素是无效的(例如变量在超出其所在作用域之后),对它们的引用会导致运行时错误;
- 包含关系:在某些逻辑构造中,为了表达元素之间的包含关系,不应通过名字直接访问子元素,而要通过其父元素名间接访问。
为应对这些问题,仓颉(与其他现代编程语言一致)引入了作用域概念,将“名字与程序元素的绑定关系”限制在一定范围内。不同作用域之间可以是并列或无关的,也可以是嵌套或包含关系。具体规则有三条:
- 当前作用域内的绑定对外有效:当前作用域中定义的程序元素与名字的绑定关系,在当前作用域和其内层作用域中有效,可以通过此名字直接访问对应程序元素。
- 内层绑定对外无效:内层作用域中定义的程序元素与名字的绑定关系,在外层作用域中无效。
- 内层可遮蔽外层:内层作用域可以使用外层作用域中的名字重新定义绑定关系。根据规则 1,此时内层作用域的命名相当于遮盖了外层作用域中的同名定义,称内层作用域的级别比外层作用域高。
大括号构造作用域
在仓颉中,用一对大括号 {} 包围一段代码即构造了一个新的作用域,其中还可以继续使用大括号构造嵌套作用域,这些作用域均服从上述规则。特别地,在一个仓颉源文件中,不被任何大括号包围的代码所属的作用域被称为顶层作用域,即当前文件中“最外层”的作用域,其作用域级别最低。
注意:
仓颉不允许使用单独的大括号
{},大括号必须依赖if、match、函数体、类体、结构体等其他语法结构存在。这也解释了为什么函数体、类体天然构成作用域边界。
名字遮蔽示例
在名为 test.cj 的源文件中,顶层作用域定义了名字 element(绑定字符串“仓颉”),main 函数体与 if 代码块中也分别定义了 element(对应整数 9 与 2023)。由上述作用域规则:第 4 行 element 的值为“仓颉”,第 8 行 element 的值为 2023,第 10 行 element 的值为 9。
// test.cj
let element = "仓颉"
main() {
println(element)
let element = 9
if (element > 0) {
let element = 2023
println(element)
}
println(element)
}
运行以上程序,将输出:
仓颉
2023
9
这个示例直观展示了“遮蔽”的完整链条:if 块内的 element(2023)遮蔽了 main 函数体内的 element(9),而 main 函数体内的 element(9)又遮蔽了顶层作用域的 element(“仓颉”);一旦离开对应作用域,遮蔽随之解除,名字重新绑定到外层定义。
作用域与包/模块的组织关系
顶层作用域是“一个源文件内”的概念,而仓颉通过**包(package)与模块(module)**进一步组织多文件程序:一个包由一个或多个源码文件组成,同一个包的源码文件必须在同一目录;包可定义子包构成树形结构,root 包及其所有子包构成的整棵树称为模块(详见包和模块管理)。结合顶层声明的可见性可知,全局变量等顶层声明的可访问范围不仅受作用域规则约束,还受 private/internal/protected/public 四种访问修饰符的可见性约束(默认修饰符为 internal,即仅当前包及子包可见)。
小结与延伸阅读
本文完整梳理了仓颉程序的三层结构知识:
- 源文件与程序入口:
.cj文件中的顶层作用域可定义全局变量、全局函数与自定义类型;可执行程序必须在顶层定义main(无func修饰符、参数可选Array<String>、返回Unit或整数类型)。 - 变量体系:定义形式为“修饰符 变量名: 变量类型 = 初始值”,可变性修饰符(
let/var)必须,可按需叠加const、可见性、static;全局/静态变量必须初始化,局部变量可延迟初始化,编译器在分支、闭包、异常等不确定场景下采用保守报错策略。 const常量与值/引用语义:const变量编译期求值、深度 const 不可作左值;值类型变量赋值即拷贝,引用类型变量赋值只改引用关系,let对引用类型只约束引用不可变。- 作用域与遮蔽:大括号构造作用域,内层可遮蔽外层同名定义,顶层作用域级别最低。
如需继续深入,可参考仓库中的以下章节: