Swift函数重载

In questo articolo, imparerai il sovraccarico di funzione, quando è necessario il sovraccarico di funzione e come sovraccaricare un esempio.

funzioni con lo stesso nome ma con parametri diversidue o piùchiamato funzione sovraccarica.

Perché ci serve il sovraccarico di funzione?

Immagina di essere mentre sviluppi un gioco di tiro, dove il giocatore può attaccare l'avversario con coltelli, spade e pistole. La tua soluzione per la funzione di attacco potrebbe essere definire l'operazione come funzione:

func attacca() {
　　　　//..
　　　　print("使用刀攻击")
}
func attacca() {
　　　　//..
　　　　print("使用剑攻击")
}
func attacca() {
　　　　//..
　　　　print("使用枪攻击")
}

Ma, quando tenti di eseguire il programma sopra, riceverai degli errori di compilazione in Swift come 'attack()' precedentemente dichiarato quiMa, un'altra soluzione potrebbe essere definire nomi di funzione diversi per funzioni specifiche, come segue:

struct Knife {
}
struct Gun {
}
struct Blade {
}
func attaccaConColtello(arma:Knife) {
　　　　//..
　　　　print("使用刀攻击")
}
func attaccaConLama(arma:Blade) {
　　　　//..
　　　　print("使用剑攻击")
}
func attaccaConPistola(arma:Gun) {
　　　　//..
　　　　print("使用枪攻击")
}

Se non conosci struct, non preoccuparti. Ora, pensa a esso come qualcosa che crea oggetti fisici nel programming, quindi stai creando una lama, una pistola e una spada.

L'unico problema di questa soluzione è che devi ricordare i nomi delle funzioni per chiamare l'operazione di attacco specifica. Allo stesso modo, man mano che il livello aumenta, il giocatore potrebbe avere altre funzioni di attacco come bombe, granate, fucili a pompa, ecc.

Creare funzioni con nomi diversi è lungo e aumenta il costo di memoria per ricordare i nomi delle funzioni da chiamare. In sintesi, non è molto intuitivo.

Se è possibile creare funzioni diverse con lo stesso nome per ogni tipo di arma, sarebbe meglio. In questo modo, ricordare un nome di funzione è sufficiente, non devi preoccuparti dei nomi delle funzioni delle altre armi.

Cos'è il sovraccarico di funzione?

Il processo che abbiamo descritto è chiamato sovraccarico di funzione. Secondo la definizione, il processo di creazione di due o più funzioni con lo stesso nome ma con un numero o tipo di parametri diversi si chiama sovraccarico di funzione.

Vediamo questo in un esempio sottostante:

Esempio 1: sovraccarico di funzione

struct Knife {
}
struct Gun {
}
struct Blade {
}
func attacca(con arma:Knife) {
　　　　print("使用刀攻击")
}
func attacca(con arma:Gun) {
　　　　print("使用枪攻击")
}
func attacca(con arma:Blade) {
　　　　print("使用剑攻击")
}
attack(with: Gun())
attack(with: Blade())
attack(with: Knife())

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

Attacco con pistola
Attacco con spada
Attacco con rasoio

Nel programma sopra, abbiamo creato tre funzioni attack() con lo stesso nome ma diversi tipi di parametri. In questo modo, è possibile chiamare la funzione utilizzando solo il nome attack.

• Chiamare attack(with: Gun()) attiverà la statement func attack(with weapon: Gun) all'interno della funzione.

• Chiamare attack(with: Blade()) attiverà la statement func attack(with weapon: Blade) all'interno della funzione.

• Chiamare attack(with: Knife()) attiverà la statement func attack(with weapon: Knife) all'interno della funzione.

Esempio 2: Soverlapamento di funzioni basato su diversi tipi di parametri

func output(x: Int) {
　　　　print("Il valore dell'intero è \(x)")
}
func output(x: String) {
　　　　print("Il valore della stringa è \(x)")
}
output(x: 2)
output(x: "Swift")

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

Il valore dell'intero è 2
Il valore della stringa è "Swift"

Nel programma sopra, abbiamo due funzioni output() con lo stesso nome e numero di parametri. Ma la prima funzione output() accetta un intero come parametro, mentre la seconda funzione output() accetta un parametro di tipo String.

Simile a esempio 1:

• Chiamare output(x: 2) attiverà la statement func output(x: Int) all'interno della funzione

• Chiamare output(x: "Swift") attiverà la statement func output(x: String) all'interno della funzione.

Esempio 3: Soverlapamento di funzioni basato su un numero diverso di parametri

func output() {
　　　　print("Buon giorno!")
}
func output(text: String) {
　　　　print(text)
}
func output(text: String, num: Int) {
　　　　print("(text)(num)!")
}
output()
output(text: "Buona sera!")
output(text1: "Buona N", num: 8)

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

Buon giorno!
Buona sera!
Buona notte!

在上面的程序中，该函数output()已根据参数数量重载。

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

让我们尝试通过更改参数名称来重载，但参数标签保持不变，如下所示：

示例4：具有相同参数标签的函数重载

func output(value text: String) {
　　　　print(text)
}
func output(value num: Int) {
　　　　print(num)
}
output(value: 2)
output(value: "Ciao")

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

2
Ciao

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