๐ฅ Generic(์ ๋ค๋ฆญ)
- ํ์
์ ์์กดํ์ง ์๋ ๋ฒ์ฉ ์ฝ๋๋ฅผ ์์ฑํ ๋ ์ฌ์ฉ๋๋ค.
๐ ์ ๋ค๋ฆญ ํจ์
- ๋ง์ฝ ๋ด๊ฐ ์ธ์๋ก ๋ค์ด์ค๋ int๊ฐ์ ์๋ก swapํ๋ ํจ์๋ฅผ ๋ง๋ ๋ค๊ณ ๊ฐ์ ํด๋ณด์. ๊ทธ๋ฌ๋ฉด ์๋์ ๊ฐ์ด ํจ์ ์ฝ๋๋ฅผ ์์ฑํ ์๋ค.
func swapTwoInts(_ a: inout Int, _ b: inout Int) {
let tempA = a
a = b
b = tempA
}
- ๊ทธ๋ฆฌ๊ณ , ๋ง์ฝ ๋ด๊ฐ String๊ฐ์ ์๋ก swapํ๋ ํจ์๋ฅผ ๋ง๋ ๋ค๊ณ ๊ฐ์ ์ ํ๋ค๋ฉด?
func swapTwoStrings(_ a: inout String, _ b: inout String) {
let tempA = a
a = b
b = tempA
}
- ์ฆ, ์์ ๊ฐ์ด type ๋ณ๋ก ๊ฐ์ ๊ธฐ๋ฅ์ ํ๋ ํจ์๋ฅผ ๋ง๋ค์ด์ค์ผ๋๋ค.
- ๊ทธ๋ฌ๋, ์๋์ ๊ฐ์ด ์ ๋ค๋ฆญ ํจ์๋ฅผ ์ฌ์ฉํ๋ฉด ํ์
์ ์๊ด์์ด ํ๋์ ํจ์๋ง์ ์ฌ์ฉํ์ฌ ๊ธฐ๋ฅ์ ๊ตฌํํ ์ ์๋ค.
T
⇒ Type Parameter๋ผ๊ณ ๋ถ๋ฅธ๋ค.
func swapTwoValues<T>(_ a: inout T, _ b: inout T) {
let tempA = a
a = b
b = tempA
}
๐ ์ ๋ค๋ฆญ ํ์
- ์ ๋ค๋ฆญ ํจ์๋ฟ๋ง ์๋๋ผ, ์ ๋ค๋ฆญ์ ์ฌ์ฉํ์ฌ ํ์
์ ์์ฑํด ์ค ์๋ ์๋ค.
- ์ ๋ค๋ฆญ์ ํ์ฉํ์ฌ stack์ ๋ง๋ค์ด๋ณด์.
struct Stack<T> {
let data: [T] = []
mutating func push(_ data: T) {
... }
mutating func pop() -> T {
... }
}
- ๊ทธ๋ฆฌ๊ณ ์ ๋ค๋ฆญ ํ์
์ ์ธ์คํด์ค๋ฅผ ์์ฑํด์ฃผ๊ธฐ ์ํด์๋ <>์ ํตํ์ฌ ํ์
์ ๋ช
์ํด์ฃผ์ด์ผ๋๋ค.
let intStack: Stack<Int> = .init()
or
let intStack = Stack<Int>.init()
- ๊ทธ๋ฐ๋ฐ, ์์ ๊ฐ์ ํ์์ ์ฐ๋ฆฌ๊ฐ ํ์์ array๋ฅผ ๋ง๋ค๋ ์ฌ์ฉํ๋ ๋ฐฉ์๊ณผ ๋๊ฐ๋ค.
- ์๋ํ๋ฉด, array๋ generic์ด๊ฑฐ๋ !
let intArray: Array<Int> = .init()
or
let intArray = Array<Int>.init()
๐ ํ์
์ ์ฝ์ฃผ๊ธฐ
- ์ ๋ค๋ฆญ ํจ์ ๋ฐ ํ์
์ ์ฌ์ฉํ ๋์ ํน์ ํ ํด๋์ค๋ง ํน์ ํ๋กํ ์ฝ์ ์ค์ํ๋ ํ์
๋ง ๋ฐ์ ์ ์๊ฒ ์ ์ฝ์ ์ค ์ ์๋ค.
๐ซง ํ๋กํ ์ฝ ์ ์ฝ
- Type Parameter ์์ ํ๋กํ ์ฝ์ ์ถ๊ฐํ์ฌ, ํด๋น ํ๋กํ ์ฝ์ ๋ง์กฑํ๋ ํ๋ผ๋ฏธํฐ๋ง ๋ฐ์ ์ ์๊ฒ ์ค์ ํ ์ ์๋ค.
func isSameValues<T: Equatable>(_ a: T, _ b: T) -> Bool {
return a == b
}
๐ซง ํด๋์ค ์ ์ฝ
- Type Parameter ์์ ํด๋์ค๋ฅผ ์ถ๊ฐํ์ฌ, ํด๋น ํด๋์ค ํน์ ํด๋น ํด๋์ค์ ํ์ ํด๋๋ง ํ๋ผ๋ฏธํฐ๋ง ๋ฐ์ ์ ์๊ฒ ์ค์ ํ ์ ์๋ค.
- ์๋์ ์๋, Human class ํน์ Human class์ ํ์ ํด๋์ค๋ง ํ๋ผ๋ฏธํฐ๋ก ๋ฐ์ ์ ์๋ค.
func function<T: Human>(_ a: T) { }
+) ์ ๋ค๋ฆญ ํ์
์ ํ ์ฃผ๊ธฐ
- ์๋์ ๊ฐ์ด ์ ๋ค๋ฆญ ํ์
์ผ ๊ฒฝ์ฐ, ๋ชจ๋ ํ์
์ ํ์ฉํ๋ ๊ฒ์ด ์๋, ํน์ ํ์
(Double)๋ง์ ๋ฐ๋๋ก ํ๊ณ ์ถ๋ค๋ฉด?
- ์๋์ ๊ฐ์ด Element type์ CalculateItem protocol์ ์ฑํํ๊ฒ ํด์ฃผ์.
struct CalculatorItemQueue<Element: CalculateItem> {
var elements = [Element]()
}
- ๊ทธ๋ฆฌ๊ณ , ์ํ๋ ํ์
์ด ํด๋น ํ๋กํ ์ฝ์ ์ฑํํ๊ฒ ํ๋ค. ์ฆ, Double์ CalculateItem protocol์ ๋ง์กฑํ๋ฏ๋ก, Element์ Double ํ์
์ด ๋ค์ด๊ฐ๋ ๋๋ ๊ฒ์ด๋ค!
protocol CalculateItem { }
extension Double: CalculateItem { }
๐ ์ฐธ๊ณ ์๋ฃ
Swift) ์ ๋ค๋ฆญ(Generic) ์ ๋ณตํ๊ธฐ