仓颉编程语言程序结构详解:顶层作用域、变量体系、const 常量与作用域规则

原创2026-10-13 19:56:022,295 阅读
文章标签:文档教程

仓颉编程语言程序结构详解:顶层作用域、变量体系、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 实例成员函数等。

值类型变量与引用类型变量

从编译器实现层面看,任何变量总会关联一个值(一般通过内存地址/寄存器关联):

  • 对有些变量,使用时会直接取用这个值本身,称为值类型变量;
  • 对另一些变量,使用时会把这个值作为索引、取用索引指示的数据,称为引用类型变量。

值类型变量通常在线程栈上分配,每个变量都有自己的数据副本;引用类型变量通常在进程堆中分配,多个变量可引用同一数据对象,对一个变量执行的操作可能会影响其他变量。从语言层面看,值类型变量对所绑定的数据/存储空间是独占的,而引用类型变量所绑定的数据/存储空间可以和其它引用类型变量共享。

基于上述原理,两类变量的行为差异主要体现在两点:

  1. 赋值语义不同:给值类型变量赋值时,一般会产生拷贝操作,且原来绑定的数据/存储空间会被覆盖;给引用类型变量赋值时,只是改变了引用关系,原来绑定的数据/存储空间不会被覆盖。
  2. 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. 当前作用域内的绑定对外有效:当前作用域中定义的程序元素与名字的绑定关系,在当前作用域和其内层作用域中有效,可以通过此名字直接访问对应程序元素。
  2. 内层绑定对外无效:内层作用域中定义的程序元素与名字的绑定关系,在外层作用域中无效。
  3. 内层可遮蔽外层:内层作用域可以使用外层作用域中的名字重新定义绑定关系。根据规则 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 对引用类型只约束引用不可变。
  • 作用域与遮蔽:大括号构造作用域,内层可遮蔽外层同名定义,顶层作用域级别最低。

如需继续深入,可参考仓库中的以下章节:

登录后查看全文
cangjie_docs