Gyors funkció túlterhelés (példákkal)

Ebben a cikkben megismerheti a függvények túlterhelését, mikor kell a függvények túlterhelése és hogyan lehet példákkal túlterhelni.

Két vagy több azonos nevű, de eltérő argumentumú függvényt túlterhelt függvénynek nevezünk.

Miért van szükség a funkció túlterhelésére?

Képzelje el, hogy lövöldözős játékot fejleszt, ahol a játékos késsel, pengével és fegyverrel támadhatja meg ellenségeit. A támadási funkció megoldása lehet, hogy a műveleteket funkciókként határozza meg:

 func attack() ( //… print("Attacking with Knife") ) func attack() ( //… print("Attacking with Blade") ) func attack() ( //… print("Attacking with Gun") ) 

De amikor megpróbálja futtatni a fenti programot, fordítási időhibát kap a Swift-ben, mint korábban itt deklarált 'támadás ()' . Lehet azonban egy másik megoldás, ha az adott funkcióhoz különböző függvényneveket határozunk meg:

 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") ) 

Ne aggódjon, ha nem tudja, mi a struktúra. Most csak úgy gondoljon rá, mint valamire, amely fizikai objektumot hoz létre a programozás során, tehát egy kést, fegyvert és pengét hoz létre. Ha többet szeretne megtudni, olvassa el a Swift Structúrát. Ha nem, akkor visszatérünk rá a későbbi fejezetekben.

Az egyetlen probléma ezzel a megoldással az, hogy emlékeznie kell a függvénynevekre az adott támadási művelet meghívásához. A szint emelkedésével a játékosnak további tulajdonságai is lehetnek a bombával, gránáttal, puskával stb. Történő támadáshoz.

Különböző nevű függvény létrehozása időigényes, és megnöveli a funkció nevének meghívásakor történő emlékezés költségeit. Összességében ez nem intuitív.

Sokkal jobb lenne, ha különböző funkciókat hozhatna létre ugyanazzal a névvel, de az egyes fegyverekhez eltérő megvalósítást. Ily módon elegendő megjegyezni egy függvénynevet, és nem kell aggódnia más fegyverek függvénynevei miatt.

Mi a függvény túlterhelése?

Az imént leírt folyamatot függvény-túlterhelésnek nevezzük. Definíció szerint két vagy több, azonos névvel rendelkező, de eltérő számú vagy típusú paramétert átadó függvény létrehozásának folyamata funkciótúlterhelésnek nevezhető.

Lássuk ezt az alábbi példában:

1. példa: Funkció túlterhelés

 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()) 

A fenti program futtatásakor a kimenet a következő lesz:

 Támadás fegyverrel Támadás pengével késsel 

A fenti programban három különböző funkciót hoztunk létre ugyanazzal a névvel attack. Ugyanakkor különböző paramétertípusokat fogad el. Így attackelegendő megjegyezni a nevet a függvény meghívásához.

• A hívás attack(with: Gun())elindítja a függvényen belüli utasítást func attack(with weapon:Gun).
• A hívás attack(with: Blade())elindítja a függvényen belüli utasítást func attack(with weapon:Blade).
• A attack(with: Knife())függvényen belüli hívás utasítás func attack(with weapon:Knife).

2. példa: Funkció Túlterhelés különböző paramétertípusok alapján

 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") 

A fenti program futtatásakor a kimenet a következő lesz:

 Az int értéke 2 A karakterlánc értéke Swift 

A fenti programban két függvényünk van, azonos névvel output()és azonos számú paraméterrel. Az első output()függvény azonban egész számot vesz paraméterként, a második output()függvény Stringparamétert vesz fel.

Az 1. példához hasonlóan

• a output(x: 2)függvényen belüli utasítást kiváltó hívás func output(x:Int)és
• a output(x: "Swift")függvényen belüli utasítás elindítása func output(x:String).

3. példa: Funkció Túlterhelés különböző számú paraméter alapján

 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) 

A fenti program futtatásakor a kimenet a következő lesz:

Jó reggelt kívánok! Jó estét! Jó éjszakát!

A fenti programban a függvény output()túlterhelt az argumentumok száma alapján.

Az első output()nem veszi be a paramétereket, a második output()egyetlen paramétert vesz fel:, Stringa harmadik output()pedig két paramétert vesz fel: Stringés Int.

Megpróbáljuk túlterhelni a paraméter nevének megváltoztatásával, de az argumentum címkéjét megtartva:

4. példa: Funkció túlterhelése ugyanazzal az argumentumcímkével

 func output(value text:String) ( print(text) ) func output(value num:Int) ( print(num) ) output(value: 2) output(value: "Hello") 

A fenti program futtatásakor a kimenet a következő lesz:

 2 Hello

Mint látható, a fenti programban ugyanazt az argumentumcímkét használhatja a túlterhelt függvényekhez. Mivel azonban a túlterhelés megköveteli, vagy különböző számú paraméterrel, vagy más típusú paraméterekkel kell rendelkeznie.