函数重载定义#

在仓颉编程语言中, 如果一个作用域中, 一个函数名对应多个函数定义, 这种现象称为函数重载

函数重载, 就是同一个作用域中, 可以存在多个同名函数, 但他们的参数列表(参数类型、参数数量、类型顺序)必须不同

如果同名函数的参数列表不同, 则同名函数之间构成重载

否则, 同名函数会发生重复定义, 编译是会报错的

C语言中就不存在函数重载, 同一作用域中 所有函数不能同名

• 函数名相同, 函数参数不同(是指参数个数不同, 或者参数个数相同但参数类型不同)的两个函数构成重载

  示例如下:

  1
  // Scenario 1
  2
  func f(a: Int64): Unit {
  3
  }
  4
  
  5
  func f(a: Float64): Unit {
  6
  }
  7
  
  8
  func f(a: Int64, b: Float64): Unit {
  9
  }
  

对于相同作用域内的普通函数, 只要函数名相同, 参数列表不同(参数类型、参数数量), 就构成重载

• 对于两个同名泛型函数 (详见泛型函数章节))

  如果重命名一个函数的泛型形参后(使泛型参数顺序相同), 其非泛型部分与另一个函数的非泛型部分函数参数不同, 则两个函数构成重载, 否则这两个泛型函数构成重复定义错误(类型变元的约束不参与判断)

  示例如下:

  1
  interface I1{}
  2
  interface I2{}
  3
  
  4
  func f1<X, Y>(a: X, b: Y) {}
  5
  func f1<Y, X>(a: X, b: Y) {}              // Ok: 重命名泛型类型参数后, 它将是 'func f1<X, Y>(a: Y,  b: X)'
  6
  
  7
  func f2<T>(a: T) where T <: I1 {}
  8
  func f2<T>(a: T) where T <: I2 {}         // Error, 不重载
  

对于泛型函数, 重载的判断相对复杂一些

因为, 泛型函数的类型参数列表只是一个标记, 不能表示实际类型

所以, 对于同名泛型函数 即使类型参数列表中 参数名字不一样或顺序不一样, 实际也不能看作是不同的泛型函数

重点还是要看非泛型部分, 即 函数形参列表

具体的分辨方式为: 将同名泛型函数的 类型参数列表 重命名为一样时, 如果对应函数形参列表不同, 则构成重载, 否则就是重定义

且, 泛型类型参数的约束 不参与重载判断, 所以对于泛型函数, 实际也是只看同名函数的参数列表

• 同一个类内的两个构造函数参数不同, 构成重载

  示例如下:

  1
  // Scenario 2
  2
  class C {
  3
      var a: Int64
  4
      var b: Float64
  5
  
  6
      public init(a: Int64, b: Float64) {
  7
          this.a = a
  8
          this.b = b
  9
      }
  10
  
  11
      public init(a: Int64) {
  12
          b = 0.0
  13
          this.a = a
  14
      }
  15
  }
  

• 同一个类内的主构造函数和init构造函数参数不同, 构成重载(认为主构造函数和init函数具有相同的名字)

  示例如下:

  1
  // Scenario 3
  2
  class C {
  3
      C(var a!: Int64, var b!: Float64) {
  4
          this.a = a
  5
          this.b = b
  6
      }
  7
  
  8
      public init(a: Int64) {
  9
          b = 0.0
  10
          this.a = a
  11
      }
  12
  }
  

类的构造函数之间是可以构成重载的, 但要注意主构造函数也参与到init构造函数之间的重载判断

因为主构造函数只是语法糖, 实际上编译器还是会将其转换为init构造函数

• 两个函数名相同, 参数不同的函数定义在不同的作用域, 在两个函数都可见的作用域中构成重载

  示例如下:

  1
  // Scenario 4
  2
  func f(a: Int64): Unit {
  3
  }
  4
  
  5
  func g() {
  6
      func f(a: Float64): Unit {
  7
      }
  8
  }
  

在上述的例子中, g()函数的函数体内, f(Int64)和f(Float64)构成重载, 因为两个函数都在g()函数体内可见

• 如果子类中存在与父类同名的函数, 并且函数的参数类型不同, 则构成函数重载

  示例如下:

  1
  // Scenario 5
  2
  open class Base {
  3
      public func f(a: Int64): Unit {
  4
      }
  5
  }
  6
  
  7
  class Sub <: Base {
  8
      public func f(a: Float64): Unit {
  9
      }
  10
  }
  

对于拥有继承关系的类, 如果子类定义有同名成员函数, 如果形参列表不同, 则构成函数重载

只允许函数声明引入的函数重载, 但是以下情形不构成重载, 不构成重载的两个名字 不能定义或声明 在同一个作用域内:

• class、interface、struct类型的静态成员函数和实例成员函数之间不能重载

• enum类型的constructor、静态成员函数和实例成员函数之间不能重载

如下示例, 两个变量均为函数类型且函数参数类型不同, 但由于它们不是函数声明所以不能重载, 如下示例将编译报错(重定义错):

1
main() {
2
    var f: (Int64) -> Unit
3
    var f: (Float64) -> Unit
4
}

如下示例, 虽然变量f为函数类型, 但由于变量和函数之间不能同名, 如下示例将编译报错(重定义错):

1
main() {
2
    var f: (Int64) -> Unit
3

4
    func f(a: Float64): Unit {                    // Error, 函数和变量不能同名
5
    }
6
}

如下示例, 静态成员函数f与实例成员函数f的参数类型不同, 但由于类内静态成员函数和实例成员函数之间不能重载, 如下示例将编译报错:

1
class C {
2
    public static func f(a: Int64): Unit {
3
    }
4
    public func f(a: Float64): Unit {
5
    }
6
}

首先明确一点, 函数重载只发生在函数声明、定义上!!

仓颉中, 类、结构体、接口的静态成员函数 与 实例成员函数之间 不能构成重载

因此, 静态成员函数 和 实例成员函数之间 禁止同名

而在, enum当中, constructor和静态成员函数以及实例成员函数, 三者之间 不能构成重载

函数重载决议#

函数调用时, 所有可被调用的函数(是指当前作用域可见且能通过类型检查的函数)构成候选集, 候选集中有多个函数, 究竟选择候选集中哪个函数, 需要进行函数重载决议

这句话的意思是, 仓颉中, 函数被调用时, 所有可见且合法的同名函数会构成候选集

在函数调用时, 需要从候选集中选择、决定究竟调用哪个函数, 这就是 函数重载决议

即使 被调用的函数可能并没有发生重载

有如下规则:

• 优先选择作用域级别高的作用域内的函数

  在嵌套的表达式或函数中, 越是内层作用域级别越高

  如下示例中在inner函数体内调用g(Sub())时, 候选集包括inner函数内定义的函数g和inner函数外定义的函数g, 函数决议选择作用域级别更高的inner函数内定义的函数g

  1
  open class Base {}
  2
  class Sub <: Base {}
  3
  
  4
  func outer() {
  5
      func g(a: Sub) {
  6
          print("1")
  7
      }
  8
  
  9
      func inner() {
  10
          func g(a: Base) {
  11
              print("2")
  12
          }
  13
  
  14
          g(Sub())              // Output: 2
  15
      }
  16
  }
  

• 如果作用域级别相对最高的仍有多个函数, 则需要选择最匹配的函数(对于函数f和g以及给定的实参, 如果f可以被调用时g也总是可以被调用的, 但反之不然, 则称f比g更匹配)

  如果不存在唯一最匹配的函数, 则报错

  如下示例中, 两个函数g定义在同一作用域, 选择更匹配的函数g(a: Sub): Unit

  1
  open class Base {}
  2
  class Sub <: Base {}
  3
  
  4
  func outer() {
  5
      func g(a: Sub) {
  6
          print("1")
  7
      }
  8
      func g(a: Base) {
  9
          print("2")
  10
      }
  11
  
  12
      g(Sub())                  // Output: 1
  13
  
  14
  }
  

• 子类和父类认为是同一作用域

  如下示例中, 一个函数g定义在父类中, 另一个函数g定义在子类中, 在调用s.g(Sub())时, 两个函数g当成同一作用域级别决议, 则选择更匹配的父类中定义的函数g(a: Sub): Unit

  1
  open class Base {
  2
      public func g(a: Sub) {
  3
          print("1")
  4
      }
  5
  }
  6
  
  7
  class Sub <: Base {
  8
      public func g(a: Base) {
  9
          print("2")
  10
      }
  11
  }
  12
  
  13
  func outer() {
  14
      let s: Sub = Sub()
  15
      s.g(Sub())                // Output: 1
  16
  }
  

函数重载决议并不复杂:

1. 决议 函数定义作用域等级更高的

   不过实际可以简单理解为 就近匹配, 因为 越内层作用域等级越高

2. 同作用域内, 决议 函数调用更匹配的

   更匹配, 就是函数调用是实参 与 函数形参匹配

3. 子类与父类认为是同一作用域

   是指, 子类实例调用成员函数时, 而非父类

操作符重载函数定义和使用#

定义操作符函数有两种方式:

1. 对于可以直接包含函数定义的类型 (包括struct、enum、class和interface), 可以直接在其内部定义操作符函数的方式实现操作符的重载

2. 使用extend的方式为其添加操作符函数, 从而实现操作符在这些类型上的重载

   对于无法直接包含函数定义的类型(是指除struct、class、enum和interface之外其他的类型)或无法改变其实现的类型

   比如第三方定义的struct、class、enum和interface, 只能采用这种方式(参见 扩展 )

操作符函数重载, 可以在定义一个类型时, 直接及进行定义, 这是能够自己控制、实现的类型

还有就是, 使用第三方库时, 可能无法直接看到类型定义, 但可以使用extend对类型进行扩展, 同样可以实现操作符重载

操作符函数对参数类型的约定如下:

1. 对于一元操作符, 操作符函数没有参数, 对返回值的类型没有要求

2. 对于二元操作符, 操作符函数只有一个参数, 对返回值的类型没有要求

   如下示例中介绍了一元操作符和二元操作符的定义和使用:

   -负号实现对一个Point实例中两个成员变量x和y取负值, 然后返回一个新的Point对象

   +加号实现对两个Point实例中两个成员变量x和y分别求和, 然后返回一个新的Point对象

   1
   open class Point {
   2
       var x: Int64 = 0
   3
       var y: Int64 = 0
   4
       public init (a: Int64, b: Int64) {
   5
           x = a
   6
           y = b
   7
       }
   8
   
   9
       public operator func -(): Point {
   10
           Point(-x, -y)
   11
       }
   12
       public operator func +(right: Point): Point {
   13
           Point(this.x + right.x, this.y + right.y)
   14
       }
   15
   }
   

   接下来, 就可以在Point的实例上直接使用 一元-操作符 和 二元+操作符:

   1
   main() {
   2
       let p1 = Point(8, 24)
   3
       let p2 = -p1                // p2 = Point(-8, -24)
   4
       let p3 = p1 + p2            // p3 = Point(0, 0)
   5
   }
   

仓颉中, 针对一元操作符和二元操作符的重载

一元操作符函数重载没有形参, 所以只能操作自己, 即this

二元操作符函数重载有一个形参, 这个形参就是 操作符的右操作数, 函数内this就是左操作数

3. 索引操作符([])分为取值let a = arr[i]和赋值arr[i] = a两种形式, 它们通过 是否存在特殊的命名参数value 来区分不同的重载

   索引操作符重载不要求同时重载两种形式, 可以只重载赋值不重载取值, 反之亦可

   索引操作符 取值形式, 使用时[]内的参数序列 对应 操作符重载的非命名参数, 可以是1个或多个, 可以是任意类型, 不可以有其他命名参数, 返回类型可以是任意类型

   1
   class A {
   2
       operator func [](arg1: Int64, arg2: String): Int64 {
   3
           return 0
   4
       }
   5
   }
   6
   
   7
   func f() {
   8
       let a = A()
   9
       let b: Int64 = a[1, "2"]
   10
       // b == 0
   11
   }
   

   索引操作符 赋值形式, 使用时[]内的参数序列 对应 操作符重载的非命名参数, 可以是1个或多个, 可以是任意类型

   =右侧的表达式对应操作符重载的命名参数, 有且只能有一个命名参数, 该 命名参数的名称必须是value, 不能有默认值, value可以是任意类型, 返回类型必须是Unit类型

   需要注意的是, value只是一种特殊的标记, 在索引操作符赋值时并不需要使用命名参数的形式调用

   1
   class A {
   2
       operator func [](arg1: Int64, arg2: String, value!: Int64): Unit {
   3
           return
   4
       }
   5
   }
   6
   
   7
   func f() {
   8
       let a = A()
   9
       a[1, "2"] = 0
   10
   }
   

   特别的, 除enum外的不可变类型不支持重载索引操作符赋值形式

仓颉中的[]操作符, 因为存在 取值和赋值 两种使用方式

所以[]操作符重载时 通过一个名为value的命名形参, 来区分取值和赋值的重载

且, []操作符可以存在若干个操作数, 比如[1, 2.0, "3"], 所以[]操作符重载函数可以存在若干个非命名参数

如果是[1, 2.0, "3"], 则重载函数的参数列表可能为(param1: Int64, param2: Float64, param3: String)或(param1: Int64, param2: Float64, param3: String, value!: Type)

使用时[]内的参数序列 对应 操作符重载的非命名参数

如果存在value命名参数, 则可以被赋值, 即为[]的赋值方式

如果不存在value命名参数, 则为[]取值方式

4. 函数调用操作符(())重载函数, 输入参数和返回值类型可以是任意类型

   示例如下:

   1
   open class A {
   2
       public init() {}
   3
   
   4
       public operator func ()(): Unit {}
   5
   }
   6
   
   7
   func test1() {
   8
       let a = A()                           // Ok, A() 是调用A的构造函数
   9
       a()                                   // Ok, a() 是调用操作符()的重载函数
   10
   }
   

   不能使用this或super调用()操作符重载函数

   示例如下:

   1
   open class A {
   2
       public init() {}
   3
       public init(x: Int64) {
   4
           this()                            // Ok, this() 调用 A 的构造函数
   5
       }
   6
   
   7
       public operator func ()(): Unit {}
   8
   
   9
       public func foo() {
   10
           this()                            // Error, this() 调用 A 的构造函数
   11
           super()                           // Error
   12
       }
   13
   }
   14
   
   15
   class B <: A {
   16
       public init() {
   17
           super()                           // Ok, super() 调用父类的构造函数
   18
       }
   19
   
   20
       public func goo() {
   21
           super()                           // Error
   22
       }
   23
   }
   

   对于枚举类型, 当构造器形式和()操作符重载函数形式都满足时, 优先匹配构造器形式

   示例如下:

   1
   enum E {
   2
       Y | X | X(Int64)
   3
   
   4
       public operator func ()(p: Int64) {}
   5
       public operator func ()(p: Float64) {}
   6
   }
   7
   
   8
   main() {
   9
       let e = X(1)                          // Ok, X(1) 是调用构造函数X(Int64)
   10
       X(1.0)                                // Ok, X(1.0) 是调用操作符 () 重载函数
   11
       let e1 = X
   12
       e1(1)                                 // Ok, e1(1) 是调用操作符 () 重载函数
   13
       Y(1)                                  // Ok, Y(1) 是调用操作符 () 重载函数
   14
   }
   

仓颉的自定义类型, 还可以对()操作符进行重载, 然后就可以通过实例()调用对应的函数

C++中也存在, C++实现了()重载函数的类的对象 可以被称为仿函数

仓颉中, 在类型内, 不能通过this和super调用本类和父类的()重载函数

实现了()操作符的类型, 类型实例就可以像函数那样被调用

可以被重载的操作符#

下表列出了所有可以被重载的操作符(优先级从高到低):

Operator	Description
()	函数调用
[]	索引
!	逻辑非
-	符号
**	求幂
*	乘
/	除
%	取模
+	加法
-	减法
<<	左移位
>>	右移位
<	小于
<=	小于等于
>	大于
>=	大于等于
==	判等
!=	判不等
&	按位与
^	按位异或
|	按位或

需要注意的是:

注意:

• 一旦在某个类型上重载了除关系操作符(<、<=、>、>=、==和!=)之外的其他二元操作符, 并且操作符函数的返回类型与左操作数的类型一致或是其子类型, 那么此类型支持对应的复合赋值操作符

  当操作符函数的返回类型与左操作数的类型不一致且不是其子类型时, 在使用对应的复合赋值符号时将报类型不匹配错误

• 仓颉编程语言不支持自定义操作符, 即不允许定义除上表中所列operator之外的其他操作符函数

• 对于类型T, 如果T已经默认支持了上述若干可重载操作符, 那么通过扩展的方式再次为其实现同签名的操作符函数时将报重定义错误

  例如, 为数值类型重载其已支持的同签名算术操作符、位操作符或关系操作符等操作符时, 为Rune重载同签名的关系操作符时, 为Bool类型重载同签名的逻辑操作符、判等或不等操作符时, 等等这些情况, 均会报重定义错误

这一部分了解就好