原文： https://www.programiz.com/swift-programming/function-overloading

在本文中，您将了解函数重载，何时需要函数重载以及如何重载示例。

具有相同名称但不同自变量的两个或多个函数被称为重载函数。

为什么需要函数重载？

想象您正在开发一个射击游戏，玩家可以使用刀，刃和枪来攻击敌人。 针对攻击函数的解决方案可能是将操作定义为以下函数：

  1. func attack() {
  2.     //..
  3.     print("Attacking with Knife")
  4. }
  6. func attack() {
  7.     //..
  8.     print("Attacking with Blade")
  9. }
  11. func attack() {
  12.     //..
  13.     print("Attacking with Gun")
  14. }

但是，当您尝试运行上述程序时，由于先前在中声明了attack()而在 Swift 中会出现编译时错误。 但是，另一种解决方案可能是为特定功能定义不同的函数名称，例如：

  1. struct Knife {
  2. }
  3. struct Gun {
  4. }
  5. struct Blade {
  6. }
  8. func attackUsingKnife(weapon:Knife) {
  9.     //..
  10.     print("Attacking with Knife")
  11. }
  13. func attackUsingBlade(weapon:Blade) {
  14.     //..
  15.     print("Attacking with Blade")
  16. }
  18. func attackUsingGun(weapon:Gun) {
  19.     //..
  20.     print("Attacking with Gun")
  21. }

如果您不知道结构是什么，请不要担心。 现在，只需将其视为可以在编程中创建物理对象的对象，那么您就可以创建刀，枪和刀片。 如果您想了解更多信息，请参见 Swift Struct 。 如果没有，我们将在后面的章节中再次讨论。

此解决方案的唯一问题是，您需要记住函数名称以调用特定的攻击操作。 同样，随着等级的提高，玩家可能具有使用炸弹，手榴弹，散弹枪等进行攻击的其他功能。

用不同的名称创建函数很耗时，并且增加了记住函数名称以调用它的开销。 总而言之，这不是直观的。

如果可以为每种武器使用相同的名称但实现不同的功能来创建不同的函数，那就更好了。 这样，记住一个函数名称就足够了，您不必担心其他武器的函数名称。

什么是函数重载？

我们刚刚描述的过程称为函数重载。 根据定义，创建两个或两个以上具有相同名称但传递的参数数量或类型不同的函数的过程称为函数重载。

让我们在下面的示例中看到：

示例 1：函数重载

  1. struct Knife {
  2. }
  3. struct Gun {
  4. }
  5. struct Blade {
  6. }
  8. func attack(with weapon:Knife) {
  9.     print("Attacking with Knife")
  10. }
  12. func attack(with weapon:Gun) {
  13.     print("Attacking with Gun")
  14. }
  16. func attack(with weapon:Blade) {
  17.     print("Attacking with Blade")
  18. }
  20. attack(with: Gun())
  21. attack(with: Blade())
  22. attack(with: Knife())

当您运行上述程序时，输出将是：

  1. Attacking with Gun
  2. Attacking with Blade
  3. Attacking with Knife

在上面的程序中，我们创建了三个具有相同名称attack的不同函数。 但是，它接受不同的参数类型。 这样，记住attack名称即可调用该函数。

  • 调用attack(with: Gun())触发函数func attack(with weapon:Gun)内部的语句。
  • 调用attack(with: Blade())触发函数func attack(with weapon:Blade)内部的语句。
  • 函数func attack(with weapon:Knife)内的调用attack(with: Knife())语句。

示例 2：基于不同参数类型的函数重载

  1. func output(x:Int) {
  2.     print("The int value is \(x)")
  3. }
  5. func output(x:String) {
  6.     print("The string value is \(x)")
  7. }
  9. output(x: 2)
  10. output(x: "Swift")

运行该程序时，输出为：

  1. The int value is 2
  2. The string value is Swift

在上面的程序中，我们有两个名称相同的函数output()和相同数量的参数。 但是，第一个output()函数将整数作为参数，第二个output()函数将String作为参数。

与示例 1 类似，

  • 对output(x: 2)的调用会触发函数func output(x:Int)中的语句，并且
  • 调用output(x: "Swift")会触发函数func output(x:String)中的语句。

示例 3：基于不同参数数量的函数重载

  1. func output() {
  2.     print("Good Morning!")
  3. }
  5. func output(text:String) {
  6.     print(text)
  7. }
  9. func output(text:String, num:Int) {
  10.     print("\(text)\(num)!")
  11. }
  13. output()
  14. output(text: "Good Evening!")
  15. output(text1: "Good N", num: 8)

运行该程序时，输出为：

  1. Good Morning!
  2. Good Evening!
  3. Good Night!

在上面的程序中，函数output()已基于参数数量重载。

第一个output()不带参数，第二个output()带一个参数：String，第三个output()带两个参数：String和Int。

让我们尝试通过更改参数名称但使参数标签与以下内容相同来重载：

示例 4：使用相同参数标签的函数重载

  1. func output(value text:String) {
  2.     print(text)
  3. }
  5. func output(value num:Int) {
  6.     print(num)
  7. }
  9. output(value: 2)
  10. output(value: "Hello")

运行该程序时，输出为：

  1. 2
  2. Hello

如您所见，在上面的程序中，可以对重载函数使用相同的参数标签。 但是，根据重载的要求，您必须具有不同数量的参数或不同类型的参数。