自增自减表达式#

自增自减表达式是包含自增操作符(++)或自减操作符(--)的表达式

a++与a--分别是a+=1与a-=1的语法糖

自增和自减操作符实现对值的加1和减1操作, 且只能作为后缀操作符使用

++和--是非结合的, 所以类似于a++--这样的在同一个表达式中同时包含两个及以上++/--但未使用圆括号规定计算顺序的表达式是被(从语法上)禁止的

自增(自减)表达式的语法定义为:

1
incAndDecExpression
2
    : postfixExpression ('++' | '--' )
3
    ;

对于表达式expr++(或expr--), 规定如下:

1. expr的类型必须是整数类型
2. 因为expr++(或expr--)是expr += 1(或expr -= 1)的语法糖, 所以此expr同时必须也是可被赋值的(见赋值表达式)
3. expr++(或expr--)的类型为Unit

自增(自减)表达式举例:

1
var i: Int32 = 5
2
i++         // i = 6
3
i--         // i = 5
4
i--++       // syntax error
5
var j = 0
6
j = i--     // semantics error

仓颉规定++和--只能后置, 且只能用于整型, 且变量必须可变

这点和 C/C++很不一样, C++是可以重载++和--运算符的, 且区分前置和后置

算术表达式#

算术表达式是包含算术操作符的表达式

仓颉编程语言支持的算术操作符包括: 一元负号(-)、加(+)、减(-)、乘(*)、除(/)、取余(%)、求幂(**)

除了一元负号是一元前缀操作符, 其他操作符均是二元中缀操作符

它们的优先级和结合性参见下文

算术表达式的语法定义为:

1
prefixUnaryExpression
2
    : prefixUnaryOperator* incAndDecExpression
3
    ;
4

5
prefixUnaryOperator
6
    : '-'
7
    | ...
8
    ;
9

10
additiveExpression
11
    : multiplicativeExpression (additiveOperator multiplicativeExpression)*
12
    ;
13

14
multiplicativeExpression
15
    : exponentExpression (multiplicativeOperator exponentExpression)*
16
    ;
17

18
exponentExpression
19
    : prefixUnaryExpression (exponentOperator prefixUnaryExpression)*
20
    ;
21

22
additiveOperator
23
    : '+' | '-'
24
    ;
25

26
multiplicativeOperator
27
    : '*' | '/' | '%'
28
    ;
29

30
exponentOperator
31
    : '**'
32
    ;

一元负号(-)的操作数只能是数值类型的表达式

一元前缀负号表达式的值等于操作数取负的值, 类型和操作数的类型相同:

1
let num1: Int64 = 8
2
let num2 = -num1      // num2 = -8, with 'Int64' type
3
let num3 = -(-num1)   // num3 =  8, with 'Int64' type

对于二元操作符*, /, %, +和-, 要求两个操作数的类型相同

其中%的操作数只支持整数类型, *, /, +和-的操作数可以是任意数值类型

1
let a = 2 + 3       // add:       5
2
let b = 3 - 1       // sub:       2
3
let c = 3 * 4       // multi:    12
4
let d = 6.6 / 1.1   // division:  6
5
let e = 4 % 3       // mod:       1

特别地, 除法(/)的操作数为整数时, 将非整数值向 0 的方向舍入为整数

整数取余运算a % b的值定义为a - b * (a / b)

1
let q1 =  7 /  3    // integer division:   2
2
let q2 = -7 /  3    // integer division:  -2
3
let q3 =  7 / -3    // integer division:  -2
4
let q4 = -7 / -3    // integer division:   2
5
let r1 =  7 %  3    // integer remainder:  1
6
let r2 = -7 %  3    // integer remainder: -1
7
let r3 =  7 % -3    // integer remainder:  1
8
let r4 = -7 % -3    // integer remainder: -1

如果不确定负数之间的取余结果, 仓颉给定了取余运算的定义, 可以按照此进行计算

**表示求幂运算(如x**y表示计算底数 x 的 y 次幂)

**的左操作数只能为Int64类型或Float64类型, 并且:

1. 当左操作类型为Int64时, 右操作数只能为UInt64类型, 表达式的类型为Int64
2. 当左操作类型为Float64时, 右操作数只能为Int64类型或Float64类型, 表达式的类型为Float64

1
let p1 = 2 ** 3                   // p1 = 8
2
let p2 = 2 ** UInt64(3 ** 2)      // p2 = 512
3
let p3 = 2.0 ** 3.0               // p3 = 8.0
4
let p4 = 2.0 ** 3 ** 2            // p4 = 512.0
5
let p5 = 2.0 ** 3.0               // p5 = 8.0
6
let p6 = 2.0 ** 3.0 ** 2.0        // p6 = 512.0

当左操作类型为Float64, 右操作数类型为Int64时, 存在一些特殊情况需要明确求幂表达式的值

具体罗列为:

1
x ** 0 = 1.0                                   // 对 任意 x
2
0.0 ** n = POSITIVE_INFINITY                   // 对 n < 0 的奇数
3
-0.0 ** n = NEGATIVE_INFINITY                  // 对 n < 0 的奇数
4
0.0 ** n = POSITIVE_INFINITY                   // 对 n < 0 的偶数
5
-0.0 ** n = POSITIVE_INFINITY                  // 对 n < 0 的偶数
6
0.0 ** n = 0.0                                 // 对 n > 0 的偶数
7
-0.0 ** n = 0.0                                // 对 n > 0 的偶数
8
0.0 ** n = 0.0                                 // 对 n > 0 的奇数
9
-0.0 ** n = -0.0                               // 对 n > 0 的奇数
10
POSITIVE_INFINITY ** n = POSITIVE_INFINITY     // 对 n > 0
11
NEGATIVE_INFINITY ** n = NEGATIVE_INFINITY     // 对 n > 0 的奇数
12
NEGATIVE_INFINITY ** n = POSITIVE_INFINITY     // 对 n > 0 的偶数
13
POSITIVE_INFINITY ** n = 0.0                   // 对 n < 0
14
NEGATIVE_INFINITY ** n = -0.0                  // 对 n < 0 的奇数
15
NEGATIVE_INFINITY ** n = 0.0                   // 对 n < 0 的偶数

注: 在上述所列特殊情况之外, 当左操作数的值为NaN时, 无论右操作数取何值, 求幂表达式的值均等于NaN

当左操作类型为Float64, 右操作数类型为Float64时, 同样存在一些特殊情况需要明确求幂表达式的值

具体罗列为:

1
x ** 0.0 = 1.0                              // 对 任意 x
2
x ** -0.0 = 1.0                             // 对 任意 x
3
0.0 ** y = POSITIVE_INFINITY                // 对于 y 的值等于 < 0 的奇数整数
4
-0.0 ** y = NEGATIVE_INFINITY               // 对于 y 的值等于 < 0 的奇数整数
5
0.0 ** NEGATIVE_INFINITY = POSITIVE_INFINITY
6
-0.0 ** NEGATIVE_INFINITY = POSITIVE_INFINITY
7
0.0 ** POSITIVE_INFINITY = 0.0
8
-0.0 ** POSITIVE_INFINITY = 0.0
9
0.0 ** y = 0.0                                 // 对 有限的 y > 0.0 且它的值等于奇数整数时
10
-0.0 ** y = -0.0                               // 对 有限的 y > 0.0 且它的值等于奇数整数时
11
-1.0 ** POSITIVE_INFINITY = 1.0
12
-1.0 ** NEGATIVE_INFINITY = 1.0
13
1.0 ** y = 1.0                                 // 对 任意 y
14
x ** POSITIVE_INFINITY = 0.0                   // 对 -1.0 < x < 1.0
15
x ** POSITIVE_INFINITY = POSITIVE_INFINITY     // 对 任意 < -1.0 的 x 或 任意 > 1.0 的 x
16
x ** NEGATIVE_INFINITY = POSITIVE_INFINITY     // 对 -1.0 < x < 1.0
17
x ** NEGATIVE_INFINITY = 0.0                   // 对 任意 x < -1.0 或 任意 > 1.0 的 x
18
POSITIVE_INFINITY ** y = 0.0                   // 对 y < 0.0
19
POSITIVE_INFINITY ** y = POSITIVE_INFINITY     // 对 y > 0.0
20
NEGATIVE_INFINITY ** y = -0.0                  // 对 有限的 y < 0.0 且它的值等于奇数整数时
21
NEGATIVE_INFINITY ** y = NEGATIVE_INFINITY     // 对 有限的 y > 0.0 且它的值等于奇数整数时
22
NEGATIVE_INFINITY ** y = 0.0                   // 对 有限的 y < 0.0 且它的值不为奇数整数时
23
NEGATIVE_INFINITY ** y = POSITIVE_INFINITY     // 对 有限的 y > 0.0 且它的值不为奇数整数时
24
0.0 ** y = POSITIVE_INFINITY                   // 对 有限的 y < 0.0 且它的值不为奇数整数时
25
-0.0 ** y = POSITIVE_INFINITY                  // 对 有限的 y < 0.0 且它的值不为奇数整数时
26
0.0 ** y = 0.0                                 // 对 有限的 y > 0.0 且它的值不为奇数整数时
27
-0.0 ** y = 0.0                                // 对 有限的 y > 0.0 且它的值不为奇数整数时
28
x ** y = NaN                                   // 对 有限的 x < 0.0 且 有限的 y 的值不为整数时

注: 在上述所列特殊情况之外, 一旦有操作数的值为NaN, 则求幂表达式的值等于NaN

**幂运算符, 是 C/C++中不存在的一个东西

仓颉中**运算符的左、右操作数都是只能为Int64和Float64类型

整型还好, 浮点型有些特殊结果的运算, 比较繁琐, 需要记

算术表达式结果为整数类型时存在整数溢出的可能

仓颉提供了三种属性宏及编译选项来控制整数溢出的处理行为(以下简称为行为)

如下表格所示:

attributes	Options	behavior	explaining for behavior
@OverflowThrowing	--int-overflow throwing	throwing	抛出异常 (默认行为)
@OverflowWrapping	--int-overflow wrapping	wrapping	数值回绕 (达到最大值后从最小值重新开始)
@OverflowSaturating	--int-overflow saturating	saturating	饱和处理 (达到最大值后保持最大值不变)

注:

1. 默认的行为为 throwing
2. 假设属性宏与编译选项同时作用在某一范围, 且代表的行为不相同, 则该范围以属性宏代表的行为为准

行为示例:

1
@OverflowThrowing
2
func test1(x: Int8, y: Int8) { // if x equals to 127 and y equals to 3
3
    let z = x + y // throwing OverflowException
4
}
5

6
@OverflowWrapping
7
func test2(x: Int8, y: Int8) { // if x equals to 127 and y equals to 3
8
    let z = x + y // z equals to -126
9
}
10

11
@OverflowSaturating
12
func test3(x: Int8, y: Int8) { // if x equals to 127 and y equals to 3
13
    let z = x + y // z equals to 127
14
}

仓颉对整型计算时可能出现的溢出, 定义了三种处理方法: 抛异常、数值回绕以及饱和处理

属性宏与编译选项作用范围冲突示例:

1
// 编译: cjc --int-overflow saturating test.cj
2

3
@OverflowWrapping
4
func test2(x: Int8, y: Int8) {
5
    let z = x + y // the behavior is wrapping
6
}
7

8
func test3(x: Int8, y: Int8) {
9
    let z = x + y // the behavior is saturating
10
}

特别地, 对于INT_MIN * -1, INT_MIN / -1和INT_MIN % -1, 规定的行为如下:

Expression	Throwing	Wrapping	Saturating
INT_MIN * -1 or -1 * INT_MIN	throwing OverflowException	INT_MIN	INT_MAX
INT_MIN / -1	throwing OverflowException	INT_MIN	INT_MAX
INT_MIN % -1	0	0	0

需要注意的是, 对于整数溢出行为是 throwing 的场景, 若整数溢出可提前在编译期检测出来, 则编译器会直接给出报错

如果代码中存在属性宏, 但编译时制定了编译选项

那么, 属性宏优先, 编译选项其次

关系表达式#

关系表达式是包含关系操作符的表达式

关系操作符包括6种: 相等(==)、不等(!=)、小于(<)、小于等于(<=)、大于(>)、大于等于(>=)

关系操作符都是二元操作符, 并且要求两个操作数的类型是一样的

关系表达式的类型是Bool类型, 即值只可能是true或false

关系操作符的优先级和结合性见下文

关系表达式的语法定义为:

1
equalityComparisonExpression
2
    : comparisonOrTypeExpression (equalityOperator comparisonOrTypeExpression)?
3
    ;
4

5
comparisonOrTypeExpression
6
    : shiftingExpression (comparisonOperator shiftingExpression)?
7
    | ...
8
    ;
9

10
equalityOperator
11
    : '!=' | '=='
12
    ;
13

14
comparisonOperator
15
    : '<' | '>' | '<=' | '>='
16
    ;

关系表达式举例:

1
main(): Int64 {
2
    3 < 4         // return true
3
    3 <= 3        // return true
4
    3 > 4         // return false
5
    3 >= 3        // return true
6
    3.14 == 3.15  // return false
7
    3.14 != 3.15  // return true
8
    return 0
9
}

需要注意的是, 关系运算符是非结合(non-associative)运算符, 即无法写出类似于a < b < c这样的表达式

1
main(): Int64 {
2
    3 < 4 < 5      // error:`<`is non-associative
3
    3 == 3 != 4    // error:`==`and`!=`are non-associative
4
    return 0
5
}

关系运算符是非结合运算符, 这一点与 C/C++一致, 但仓颉中强制关系表达式为Bool类型且不可类型转换

type test和type cast表达式#

type test表达式是包含操作符is的表达式, type cast表达式是包含操作符as的表达式

is和as的优先级和结合性参见下文

type test和type cast表达式的语法定义为:

1
comparisonOrTypeExpression
2
    : ...
3
    | shiftingExpression ('is' type)?
4
    | shiftingExpression ('as' userType)?
5
    ;

位运算表达式#

位运算表达式是包含位运算操作符的表达式

仓颉编程语言支持 1 种一元前缀位运算操作符: 按位求反(!)

以及 5 种二元中缀位运算操作符: 左移(<<)、右移(>>)、按位与(&)、按位异或(^)和按位或(|)

位运算操作符的操作数只能为整数类型, 通过将操作数视为二进制序列, 然后在每一位上进行逻辑运算(0视为false, 1视为true)或移位操作来实现位运算

&、^和|的操作中, 位与位之间执行的是逻辑操作(参见 [逻辑表达式])

位运算操作符的优先级和结合性参见下文

位运算表达式的语法定义为:

1
prefixUnaryExpression
2
    : prefixUnaryOperator* incAndDecExpression
3
    ;
4

5
prefixUnaryOperator
6
    : '!'
7
    | ...
8
    ;
9

10
bitwiseDisjunctionExpression
11
    : bitwiseXorExpression ( '|' bitwiseXorExpression)*
12
    ;
13

14
bitwiseXorExpression
15
    : bitwiseConjunctionExpression ( '^' bitwiseConjunctionExpression)*
16
    ;
17

18
bitwiseConjunctionExpression
19
    : equalityComparisonExpression ( '&' equalityComparisonExpression)*
20
    ;
21

22
shiftingExpression
23
    : additiveExpression (shiftingOperator additiveExpression)*
24
    ;
25

26
shiftingOperator
27
    : '<<' | '>>'
28
    ;

位运算表达式举例:

1
func foo(): Unit {
2
    !10                 // The result is -11
3
    !20                 // The result is -21
4
    10 << 1             // The result is 20
5
    10 << 1 << 1        // The result is 40
6
    10 >> 1             // The result is 5
7
    10 & 15             // The result is 10
8
    10 ^ 15             // The result is 5
9
    10 | 15             // The result is 15
10
    1 ^ 8 & 15 | 24     // The result is 25
11
}

如果已经熟悉 C/C++中的位运算, 仓颉的位运算应该也不会陌生

对于移位操作符, 要求其操作数必须是整数类型(但两个操作数的类型可以不一样), 并且无论左移还是右移, 右操作数都不允许为负数(对于编译时可检查出的此类错误, 编译报错, 如果运行时发生此错误, 则抛出异常)

对于无符号数的移位操作, 移位和补齐规则是: 左移低位补 0 高位丢弃, 右移高位补 0 低位丢弃

对于有符号数的移位操作, 移位和补齐规则是:

1. 正数和无符号数的移位补齐规则一致
2. 负数左移低位补 0 高位丢弃
3. 负数右移高位补 1 低位丢弃

1
let p: Int8 = -30
2
let q = p << 2      // q = -120
3
let r = p >> 2      // r = -8
4
let r = p >> -2     // error
5
let x: UInt8 = 30
6
let b = x << 3      // b = 240
7
let b = x >> 1      // b = 15

另外, 如果右移或左移的位数(右操作数)等于或者大于操作数的宽度, 则为overshift, 如果编译时可以检测到则报错, 否则运行时抛出异常

1
let x1 : UInt8 = 30     // 0b00011110
2
let y1 = x1 >> 11       // compilation error

仓颉的位运算, 除了移位时超出位数的强制安全措施, 其他运算方式基本与与 C/C++中的一致

区间表达式#

区间表达式是包含区间操作符的表达式

区间表达式用于创建Range实例

区间表达式的语法定义为:

1
rangeExpression
2
    : bitwiseDisjunctionExpression ('..=' | '..') bitwiseDisjunctionExpression (':' bitwiseDisjunctionExpression)?
3
    | bitwiseDisjunctionExpression
4
    ;

区间操作符有两种: ..和..=, 分别用于创建”左闭右开”和”左闭右闭”的Range实例

关于它们的介绍, 请参见 Range 类型

逻辑表达式#

逻辑表达式是包含逻辑操作符的表达式

逻辑操作符的操作数只能为Bool类型的表达式

仓颉编程语言支持 3 种逻辑操作符: 逻辑非(!)、逻辑与(&&)、逻辑或(||)

它们的优先级和结合性参见下文

逻辑表达式的语法定义为:

1
prefixUnaryExpression
2
    : prefixUnaryOperator* incAndDecExpression
3
    ;
4

5
prefixUnaryOperator
6
    : '!'
7
    | ...
8
    ;
9

10
logicDisjunctionExpression
11
    : logicConjunctionExpression ( '||' logicConjunctionExpression)*
12
    ;
13

14
logicConjunctionExpression
15
    : rangeExpression ( '&&' rangeExpression)*
16
    ;

**逻辑非(!)**是一元操作符, 它的作用是对其操作数的布尔值取反: !false的值等于true, !true的值等于false

**逻辑与(&&)和逻辑或(||)**均是二元操作符

对于表达式expr1 && expr2, 只有当expr1和expr2的值均等于true时, 它的值才等于true

对于表达式expr1 || expr2, 只有当expr1和expr2的值均等于false时, 它的值才等于false

&&和||采用短路求值策略:

计算expr1 && expr2时, 当expr1=false则无需对expr2求值, 整个表达式的值为false

计算expr1 || expr2时, 当expr1=true则无需对expr2求值, 整个表达式的值为true

1
main(): Int64 {
2
    let expr1 = false
3
    let expr2 = true
4
    !true                           // Logical NOT, return false.
5
    1 > 2 && expr1                  // Logical AND, return false without computing the value of expr1.
6
    1 < 2 || expr2                  // Logical OR, return true without computing the value of expr2.
7
    return 0
8
}

仓颉中的逻辑操作符, 与 C/C++中的也一致, 包括短路求值策略

coalescing表达式 **#

coalescing表达式是包含coalescing操作符的表达式

coalescing操作符使用??表示, ??是二元中缀操作符

其优先级和结合性参见下文

coalescing表达式的语法定义为:

1
coalescingExpression
2
    : logicDisjunctionExpression ('??' logicDisjunctionExpression)*
3
    ;

coalescing操作符用于Option类型的解构

假设表达式e1的类型是Option<T>, 对于表达式e1 ?? e2, 规定:

1. 表达式e2具有类型T

2. 表达式e1 ?? e2具有类型T

3. 当e1的值等于Option<T>.Some(v)时, e1 ?? e2的值等于v的值(此时, 不会再去对e2求值, 即满足”短路求值”)

   当e1的值等于Option<T>.None时, e1 ?? e2的值等于e2的值

表达式e1 ?? e2是如下match表达式的语法糖:

1
// when e1 is Option<T>
2
match (e1) {
3
    case Some(v) => v
4
    case None => e2
5
}

coalescing表达式使用举例:

1
main(): Int64 {
2
    let v1 = Option<Int64>.Some(100)
3
    let v2 = Option<Int64>.None
4
    let r1 = v1 ?? 0
5
    let r2 = v2 ?? 0
6
    print("${r1}") // output: 100
7
    print("${r2}") // output: 0
8

9
    return 0
10
}

coalescing也就是??是Option类型模式匹配的语法糖

是用来解构Option类型数据的

如果存在e1为Option<T>, 则e1 ?? e2中, e2类型需要为T, 此时:

1. 如果e1是Some(value), 则此表达式值为value, 且不再计算e2
2. 如果e1是None, 则此表达式值为e2

也就是说, 对于Option<T>类型的变量, 如果比较简单就不用再写match匹配模式, 可以直接??进行解构