Neste artigo, você aprenderá sobre sobrecarga de função, quando precisamos de sobrecarga de função e como sobrecarregar com exemplos.
Duas ou mais funções com o mesmo nome, mas argumento (s) diferente (s) são conhecidas como funções sobrecarregadas.
Por que precisamos de sobrecarga de função?
Imagine que você está desenvolvendo um jogo de tiro onde o jogador pode atacar seus inimigos usando uma faca, uma lâmina e uma arma. Sua solução para a funcionalidade de ataque pode ser definir as ações em funções como:
func attack() ( //… print("Attacking with Knife") ) func attack() ( //… print("Attacking with Blade") ) func attack() ( //… print("Attacking with Gun") )
Mas ao tentar executar o programa acima, você obterá um erro de tempo de compilação no Swift como 'attack ()' declarado anteriormente aqui . No entanto, outra solução pode ser definir nomes de função diferentes para a funcionalidade específica como:
struct Knife ( ) struct Gun ( ) struct Blade ( ) func attackUsingKnife(weapon:Knife) ( //… print("Attacking with Knife") ) func attackUsingBlade(weapon:Blade) ( //… print("Attacking with Blade") ) func attackUsingGun(weapon:Gun) ( //… print("Attacking with Gun") )
Não se preocupe se você não souber o que é estrutura. Por enquanto, pense nisso como algo que cria um objeto físico na programação, então você está criando uma faca, arma e lâmina. Se você quiser saber mais, consulte Swift Struct. Caso contrário, voltaremos a ele nos capítulos posteriores.
O único problema com essa solução é que você precisa lembrar os nomes das funções para chamar aquela ação de ataque específica. Além disso, conforme o nível sobe, o jogador pode ter recursos adicionais para ataque usando bomba, granada, espingarda, etc.
A criação de funções com nomes diferentes consome tempo e aumenta a sobrecarga de lembrar o nome da função para chamá-la. Em suma, não é intuitivo.
Seria muito melhor se você pudesse criar funções diferentes com o mesmo nome, mas implementações diferentes para cada arma. Desta forma, lembrar o nome de uma função é suficiente e você não precisa se preocupar com os nomes das funções de outras armas.
O que é sobrecarga de função?
O processo que acabamos de descrever é conhecido como sobrecarga de função. Por definição, o processo de criação de duas ou mais funções com o mesmo nome, mas com número ou tipos diferentes de parâmetros passados, é conhecido como sobrecarga de função.
Vamos ver isso no exemplo abaixo:
Exemplo 1: sobrecarga de função
struct Knife ( ) struct Gun ( ) struct Blade ( ) func attack(with weapon:Knife) ( print("Attacking with Knife") ) func attack(with weapon:Gun) ( print("Attacking with Gun") ) func attack(with weapon:Blade) ( print("Attacking with Blade") ) attack(with: Gun()) attack(with: Blade()) attack(with: Knife())
Quando você executa o programa acima, a saída será:
Ataque com arma de fogo, ataque com lâmina, ataque com faca
No programa acima, criamos três funções diferentes com o mesmo nome attack. No entanto, ele aceita diferentes tipos de parâmetros. Desta forma, attackbasta lembrar o nome para chamar a função.
- A chamada
attack(with: Gun())aciona a instrução dentro da funçãofunc attack(with weapon:Gun). - A chamada
attack(with: Blade())aciona a instrução dentro da funçãofunc attack(with weapon:Blade). - A
attack(with: Knife())instrução de chamada dentro da funçãofunc attack(with weapon:Knife).
Exemplo 2: sobrecarga de função com base em diferentes tipos de parâmetros
func output(x:Int) ( print("The int value is (x)") ) func output(x:String) ( print("The string value is (x)") ) output(x: 2) output(x: "Swift")
Quando você executa o programa acima, a saída será:
O valor interno é 2 O valor da string é Swift
No programa acima, temos duas funções com o mesmo nome output()e mesmo número de parâmetros. No entanto, a primeira output()função usa um número inteiro como parâmetro e a segunda output()função usa Stringcomo parâmetro.
Semelhante ao Exemplo 1,
- a chamada para
output(x: 2)aciona a instrução dentro da funçãofunc output(x:Int)e - a chamada para
output(x: "Swift")aciona a instrução dentro da funçãofunc output(x:String).
Exemplo 3: Sobrecarga de função com base em diferentes números de parâmetros
func output() ( print("Good Morning!") ) func output(text:String) ( print(text) ) func output(text:String, num:Int) ( print("(text)(num)!") ) output() output(text: "Good Evening!") output(text1: "Good N", num: 8)
Quando você executa o programa acima, a saída será:
Bom Dia! Boa noite! Boa noite!
No programa acima, a função output()foi sobrecarregada com base no número de argumentos.
O primeiro output()não usa parâmetros, o segundo output()usa um único parâmetro: Stringe o terceiro output()usa dois parâmetros: Stringe Int.
Vamos tentar sobrecarregar alterando o nome do parâmetro, mas mantendo o rótulo do argumento igual a:
Exemplo 4: sobrecarga de função com o mesmo rótulo de argumento
func output(value text:String) ( print(text) ) func output(value num:Int) ( print(num) ) output(value: 2) output(value: "Hello")
Quando você executa o programa acima, a saída será:
2 olá
Como você pode ver, no programa acima, você pode usar o mesmo rótulo de argumento para as funções sobrecarregadas. No entanto, como a sobrecarga exige, você deve ter um número diferente de parâmetros ou diferentes tipos de parâmetros.
