struct成员变量#

struct成员变量分为实例成员变量和静态成员变量(使用static修饰符修饰)

二者访问上的区别在于实例成员变量只能通过struct实例(说a是T类型的实例, 指的是a是一个T类型的值)访问, 静态成员变量只能通过struct类型名访问

实例成员变量定义时可以不设置初值(但必须标注类型, 如上例中的width和height), 也可以设置初值, 例如:

1
struct Rectangle {
2
    let width = 10
3
    let height = 20
4
}

仓颉中, strcut也可以定义静态成员变量, 但与C++不同的是, 仓颉中的静态成员变量只能通过struct名访问

struct静态初始化器#

struct支持定义静态初始化器, 并在静态初始化器中 通过赋值表达式来对静态成员变量进行初始化

静态初始化器以关键字组合**static init开头, 后跟无参参数列表和函数体, 且不能被访问修饰符修饰**

函数体中必须完成对所有未初始化的静态成员变量的初始化, 否则编译报错

1
struct Rectangle {
2
    static let degree: Int64
3
    static init() {
4
        degree = 180
5
    }
6
}

一个struct中最多允许定义一个静态初始化器, 否则报重定义错误

1
struct Rectangle {
2
    static let degree: Int64
3
    static init() {
4
        degree = 180
5
    }
6
    static init() {                   // Error, 静态初始化函数重定义
7
        degree = 180
8
    }
9
}

仓颉中, 使用静态初始化器: static init() {}对静态成员变量进行初始化

且, 需要在静态初始化器中 对所有静态成员变量完成初始化, 否则编译报错

且struct中只能定义一个静态初始化器

struct构造函数#

struct支持两类构造函数: 普通构造函数和主构造函数

普通构造函数以关键字init开头, 后跟参数列表和函数体

函数体中必须完成对所有未初始化的实例成员变量的初始化(如果参数名和成员变量名无法区分, 可以在成员变量前使用this加以区分, this表示struct的当前实例), 否则编译报错

1
struct Rectangle {
2
    let width: Int64
3
    let height: Int64
4

5
    public init(width: Int64, height: Int64) {            // Error, 'height' 在构造函数中未初始化
6
        this.width = width
7
    }
8
}

仓颉struct, 使用init作为构造函数的函数名

函数体内必须 完成所有未初始化成员变量的初始化

构造函数的形参可以与已存在的成员变量同名, 此时在函数体内可以使用this.变量名访问成员变量, 否则就是形参

一个struct中可以定义多个普通构造函数, 但它们必须构成重载(参见函数重载), 否则报重定义错误

1
struct Rectangle {
2
    let width: Int64
3
    let height: Int64
4

5
    public init(width: Int64) {
6
        this.width = width
7
        this.height = width
8
    }
9

10
    public init(width: Int64, height: Int64) {            // Ok, 与第一个 init 函数构成重载
11
        this.width = width
12
        this.height = height
13
    }
14

15
    public init(height: Int64) {                          // Error, 与第一个 init 函数重定义
16
        this.width = height
17
        this.height = height
18
    }
19
}

仓颉struct的init函数之间可以构成重载

除了可以定义若干普通的以init为名字的构造函数外, struct内还可以定义最多一个主构造函数

主构造函数的名字和struct类型名相同, 它的参数列表中可以有两种形式的形参: 普通形参和成员变量形参(需要在参数名前加上let或var), 成员变量形参同时扮演定义成员变量和构造函数参数的功能

使用主构造函数通常可以简化struct的定义, 例如, 上述包含一个init构造函数的Rectangle可以简化为如下定义:

1
struct Rectangle {
2
    public Rectangle(let width: Int64, let height: Int64) {}
3
}

主构造函数的参数列表中也可以定义普通形参, 例如:

1
struct Rectangle {
2
    public Rectangle(name: String, let width: Int64, let height: Int64) {}
3
}

仓颉struct可以存在一个 主构造函数

主构造函数与struct同名, 且 主构造函数可以参数列表中可以定义成员变量形参

什么是成员变量形参呢?

仓颉struct的主构造函数中, 可以通过使用let或var修饰形参, 实现在参数列表中定义成员变量

成员变量形参与普通形参的区别, 就只在是否使用let和var修饰

NOTE

仓颉中, 主构造函数会在编译时 自动转换为对应的init构造函数

同时要保证 主构造函数对应的init构造函数, 需要与其他显式定义的init函数构成重载

如果struct定义中不存在自定义构造函数(包括主构造函数), 并且所有实例成员变量都有初始值, 则会自动为其生成一个无参构造函数(调用此无参构造函数会创建一个所有实例成员变量的值均等于其初值的对象); 否则, 不会自动生成此无参构造函数

例如, 对于如下struct定义, 注释中给出了自动生成的无参构造函数:

1
struct Rectangle {
2
    let width: Int64 = 10
3
    let height: Int64 = 10
4
    /* : 自动生成的无参构造函数
5
    public init() {
6
    }
7
    */
8
}

仓颉struct也可以不显式定义构造函数

仓颉规定, 只要struct的所有成员变量在定义时均有初始值, 那么编译器就会生成一个无参构造函数

struct成员函数#

struct成员函数分为实例成员函数和静态成员函数(使用static修饰符修饰), 二者的区别在于:

实例成员函数只能通过struct实例访问, 静态成员函数只能通过struct类型名访问

静态成员函数中不能访问实例成员变量, 也不能调用实例成员函数, 但在实例成员函数中可以访问静态成员变量以及静态成员函数

下例中, area是实例成员函数, typeName是静态成员函数

1
struct Rectangle {
2
    let width: Int64 = 10
3
    let height: Int64 = 20
4

5
    public func area() {
6
        this.width * this.height
7
    }
8

9
    public static func typeName(): String {
10
        "Rectangle"
11
    }
12
}

实例成员函数中可以通过this访问实例成员变量, 例如:

1
struct Rectangle {
2
    let width: Int64 = 1
3
    let height: Int64 = 1
4

5
    public func area() {
6
        this.width * this.height
7
    }
8
}

仓颉的成员函数, 拥有实例成员函数和静态成员函数

静态成员函数内, 不能调用实例成员函数和实例成员变量, 且在struct外 只能通过struct名访问

struct成员的访问修饰符#

struct的成员(包括成员变量、成员属性、构造函数、成员函数、操作符函数(详见操作符重载章节))用4种访问修饰符修饰: private、internal、protected和public, 缺省的修饰符是internal

• private表示在struct定义内可见

• internal表示仅当前包及子包(包括子包的子包, 详见包章节)内可见

• protected表示当前模块(详见包章节)可见

• public表示模块内外均可见

下面的例子中, width是public修饰的成员, 在类外可以访问, height是缺省访问修饰符的成员, 仅在当前包及子包可见, 其他包无法访问

1
package a
2
public struct Rectangle {
3
    public var width: Int64
4
    var height: Int64
5
    private var area: Int64
6
    ...
7
}
8

9
func samePkgFunc() {
10
    var r = Rectangle(10, 20)
11
    r.width = 8                       // Ok, public 'width' 可以在这里访问
12
    r.height = 24                     // Ok, 'height' 没有显式修饰符, 可以在此处访问
13
    r.area = 30                       // Error, private 'area' 在此处不可访问
14
}

1
package b
2
import a.*
3
main() {
4
    var r = Rectangle(10, 20)
5
    r.width = 8                       // Ok, public 'width' 可以在这里访问
6
    r.height = 24                     // Error, 'height' 没有显式修饰符 在此处不可访问
7
    r.area = 30                       // Error, private 'area' 在此处不可访问
8
}

仓颉中, 成员默认是被internal修饰的

除此之外, 成员还可以被private、protected和public修饰, 分别表示不同的可访问性:

• private表示在struct定义内可见

  即, 仅能在struct定义内访问

• internal表示仅当前包及子包(包括子包的子包, 详见包章节)内可见

  即, 仅能在struct定义所在包, 以及其子包内访问

• protected表示当前模块(详见包章节)可见

  即, 与internal不同, 被protected修饰的成员, 可以在父包、当前包以及子包访问

• public表示模块内外均可见

  被public修饰的成员的访问, 只要可以见到, 不受任何限制

禁止递归struct#

递归和互递归定义的struct均是非法的

例如:

1
struct R1 {                   // Error, 'R1' 递归引用自身
2
    let other: R1
3
}
4
struct R2 {                   // Error, 'R2' 和 'R3' 相互递归
5
    let other: R3
6
}
7
struct R3 {                   // Error, 'R2' 和 'R3' 相互递归
8
    let other: R2
9
}

struct是值类型的, 在使用时需要确定类型具体的大小, 所以不能自递归以及互递归

mut函数定义#

mut函数与普通的实例成员函数相比, 多一个mut关键字来修饰

例如, 下例中在函数g之前增加mut修饰符之后, 即可在函数体内修改成员变量i的值

1
struct Foo {
2
    var i = 0
3

4
    public mut func g() {
5
        i += 1                                        // Ok
6
    }
7
}

mut只能修饰实例成员函数, 不能修饰静态成员函数

1
struct A {
2
    public mut func f(): Unit {}                      // Ok
3
    public mut operator func +(rhs: A): A {           // Ok
4
        A()
5
    }
6
    public mut static func g(): Unit {}               // Error, 静态成员函数不能用 'mut' 修饰
7
}

mut函数中的this不能被捕获, 也不能作为表达式

mut函数中的lambda或嵌套函数, 不能对struct的实例成员变量进行捕获

示例:

1
struct Foo {
2
    var i = 0
3

4
    public mut func f(): Foo {
5
        let f1 = { => this }                          // Error, mut 函数中的 'this' 无法被捕获
6
        let f2 = { => this.i = 2 }                    // Error, mut 函数中的 实例成员变量 无法被捕获
7
        let f3 = { => this.i }                        // Error, mut 函数中的 实例成员变量 无法被捕获
8
        let f4 = { => i }                             // Error, mut 函数中的 实例成员变量 无法被捕获
9
        this                                          // Error, mut 函数中的 'this' 不能用作表达式
10
    }
11
}

mut函数定义时要使用mut关键字修饰

但, 静态成员变量禁止被mut修饰

仓颉规定mut函数中的this以及实例成员变量, 不能被捕获, this也不能被捕获

mut函数内可以修改var成员变量

接口中的mut函数#

接口中的实例成员函数, 也可以使用mut修饰

struct类型在实现interface的函数时必须保持一样的mut修饰

struct以外的类型实现interface的函数时不能使用mut修饰

示例:

1
interface I {
2
    mut func f1(): Unit
3
    func f2(): Unit
4
}
5

6
struct A <: I {
7
    public mut func f1(): Unit {}               // Ok: 在interface中, 使用了 'mut' 修饰符
8
    public func f2(): Unit {}                   // Ok: 在interface中, 没有使用 'mut' 修饰符
9
}
10

11
struct B <: I {
12
    public func f1(): Unit {}                   // Error, 'f1' 在interface中用 'mut' 修饰, 但在struct中没有
13
    public mut func f2(): Unit {}               // Error, 'f2' 在interface中没有被 'mut' 修饰, 但在struct中被修饰
14
}
15

16
class C <: I {
17
    public func f1(): Unit {}                   // Ok
18
    public func f2(): Unit {}                   // Ok
19
}

当interface中定义有mut函数时:

1. 如果struct实现此interface, 那么 实现接口函数也需要使用mut修饰

2. 如果class实现此interface, 那么 实现接口函数不能使用mut修饰

当struct的实例赋值给interface类型时是拷贝语义, 因此interface的mut函数并不能修改struct实例的值

示例:

1
interface I {
2
    mut func f(): Unit
3
}
4
struct Foo <: I {
5
    public var v = 0
6
    public mut func f(): Unit {
7
        v += 1
8
    }
9
}
10
main() {
11
    var a = Foo()
12
    var b: I = a
13
    b.f()                                       // 通过'b'调用'f()'不能修改'a'的值
14
    println(a.v)                                // 0
15
}

程序输出结果为:

1
0

拿struct实例 赋值给interface变量, 是拷贝语义

此时, 如果使用interface变量调用mut函数, 也无法修改原struct实例成员

mut函数的使用限制#

因为struct是值类型, 所以如果一个变量是struct类型且使用let声明, 那么不能通过这个变量访问该类型的mut函数

示例:

1
interface I {
2
    mut func f(): Unit
3
}
4
struct Foo <: I {
5
    public var i = 0
6
    public mut func f(): Unit {
7
        i += 1
8
    }
9
}
10
main() {
11
    let a = Foo()
12
    a.f()                                       // Error, 'a' 是struct, 并且使用 'let' 声明, 因此不能通过 'a' 访问 'mut' 函数
13
    var b = Foo()
14
    b.f()                                       // Ok
15
    let c: I = Foo()
16
    c.f()                                       // Ok, 变量 c 为接口 I 类型, 非 struct 类型, 此处允许访问
17
}

let修饰的struct变量, 无法访问mut成员函数

为避免逃逸, 如果一个变量的类型是struct类型, 那么这个变量不能将该类型使用mut修饰的函数作为一等公民来使用, 只能调用这些mut函数

示例:

1
interface I {
2
    mut func f(): Unit
3
}
4

5
struct Foo <: I {
6
    var i = 0
7

8
    public mut func f(): Unit {
9
        i += 1
10
    }
11
}
12

13
main() {
14
    var a = Foo()
15
    var fn = a.f                                // Error, mut 函数 'f' 不能作为 'a' 的一等公民使用
16
    var b: I = Foo()
17
    fn = b.f                                    // Ok
18
}

struct变量只能调用mut成员函数, 不能尝试将mut成员函数作为一等公民使用

为避免逃逸, 非mut的实例成员函数(包括lambda表达式)不能直接访问所在类型的mut函数, 反之可以

示例:

1
struct Foo {
2
    var i = 0
3

4
    public mut func f(): Unit {
5
        i += 1
6
        g()                                     // Ok
7
    }
8

9
    public func g(): Unit {
10
        f()                                     // Error, mut 函数不能在非 mut 函数中调用
11
    }
12
}
13

14
interface I {
15
    mut func f(): Unit {
16
        g()                                     // Ok
17
    }
18

19
    func g(): Unit {
20
        f()                                     // Error, mut 函数不能在非 mut 函数中调用
21
    }
22
}

非mut实例成员函数 禁止直接访问同类型的mut实例成员函数

这是为了防止mut函数逃逸