ํฐ์คํ ๋ฆฌ ๋ทฐ
[iOS] - protocol์ ๋ฉ์๋ ์์ด extension์์ ๋ฉ์๋ ๊ตฌํํ๊ธฐ vs protocol์ ๋ฉ์๋๋ฅผ ์ ์ ํ extension์ ๊ตฌํํ๊ธฐ
B_log 2021. 4. 27. 23:09๐ protocol์ ๋ฉ์๋ ์์ด extension์์ ๋ฉ์๋ ๊ตฌํํ๊ธฐ vs protocol์ ๋ฉ์๋๋ฅผ ์ ์ ํ extension์ ๊ตฌํํ๊ธฐ
๐ฏ ๊ฐ๋ ์ดํดํ๊ธฐ
protocol default implementation์ ํ๊ธฐ ์ํด protocol์ extension์ ํตํด ๋ฉ์๋๋ฅผ ๊ตฌํํ๋ค๊ฐ ๋ณด๋ฉด ๋๊ฐ์ง ์ต์ ์ด ์๊น๋๋ค. ์์๋ฅผ ํตํด ๋ฌธ์ ๋ฅผ ์ ์ํด๋ณด๊ฒ ์ต๋๋ค.
protocol Bank { // ์ด ๋ถ๋ถ ์์ด ๊ตฌํ ๊ฐ๋ฅ func openAlert() func closeAlert() // } extension Bank { func openAlert() { print("์ํ ๊ฐ์ ") } func closeAlert() { print("์ํ ํ์ ") } }
์ํ์ ๊ฐ์ ๊ณผ ํ์ ์ ์๋ฆฌ๋ ๋ฉ์๋ openAlert์ closeAlert๋ฅผ ๊ตฌํํ ๋
- protocol Bank์ ๋ฉ์๋๋ฅผ ์ ์ํ๊ณ ๊ตฌํํ๋ ๋ฐฉ๋ฒ
- protocol Bank์ ๋ฉ์๋ ์ ์ ์์ด extension์์ ๊ตฌํ๋ง ํ๋ ๋ฐฉ๋ฒ
์ ์ต์ ์ด ์์ต๋๋ค.
์ฐ์ 1๋ฒ์ ๋ํ ์ค๋ช ์ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
Declaring the function as part of the protocol definition instructs the compiler to use dynamic dispatch when calling the function, as the compiler would expect types implementing the protocol to give an implementation for that function. This is called a
method requirement
. Now, if the type doesn't define the method, then the runtime resolves the method call to the method declared in the protocol extension.ํด์ํด๋ณด๋ฉด ํ๋กํ ์ฝ์ ํจ์๋ฅผ ์ ์ํ๋ฉด ํจ์๊ฐ ํธ์ถ๋ ๋ ์ปดํ์ผ๋ฌ์๊ฒ dynamic dispatch (ํ๋จ์ ์ค๋ช ) ๋ฅผ ์ฌ์ฉํ๋๋ก ํ๋ค๋ ์๋ฏธ์ ๋๋ค. ์ด๋ ๊ฒ ๋๋ฉด ์ปดํ์ผ๋ฌ๋ ํ๋กํ ์ฝ์ ๊ตฌํํ๋ ํ์ ์ด ๊ทธ ํจ์๋ฅผ ๊ตฌํํด๋จ๊ธฐ๋ฅผ ๊ธฐ๋ํ๊ฒ ๋ฉ๋๋ค. ์ด๊ฒ์ method requirement๋ผ๊ณ ๋ถ๋ฆ ๋๋ค. ํ์ง๋ง ๋ง์ฝ ๋ฉ์๋๊ฐ ํ์ ์ ๊ตฌํ์ด ๋์ด์์ง ์์ผ๋ฉด, ๋ฐํ์์ด ํ๋กํ ์ฝ ์ต์คํ ์ ์ ๊ตฌํ๋ ๋ฉ์๋๋ฅผ ๋ถ๋ฅด๊ฒ ๋ฉ๋๋ค. ์ฆ, ์ฐ์ ์์๊ฐ ๊ตฌํ๋ ํ์ ์ ๋ฉ์๋์ด๋ฉฐ, ๋ฉ์๋๊ฐ ๊ตฌํ๋์ง ์์์ ๊ฒฝ์ฐ extension์ ๋ฉ์๋๋ฅผ ๊ฐ์ ธ์ค๋ ๊ฐ๋ ์ ๋๋ค.
์ด์ 2๋ฒ์ ๋ํ ์ค๋ช ์ ๋ณด๊ฒ ์ต๋๋ค.
However, declaring the function in the protocol extension only tells the compiler that he doesn't need to use the dynamic dispatch, and instead it uses the static dispatch, which is faster, but doesn't work very well with polymorphism, as the protocol extension implementation will be called even if the types conforming to the protocol also implement the method.
protocol ์์๋ ์๊ณ extension์๋ง ๊ตฌํ๋ ๋ฉ์๋์ ๊ฒฝ์ฐ๋ ์ปดํ์ผ๋ฌ๊ฐ dynamic dispatch๋ฅผ ์ฌ์ฉํ ์ด์ ๊ฐ ์์ต๋๋ค. ๋์ ์ static dispatch๋ฅผ ์ฌ์ฉํ๊ฒ ๋๋๋ฐ, ์ด ๊ฒฝ์ฐ protocol์ ์ฑํํ๋ ํ์ ์ ๋์ผํ ๋ฉ์๋๊ฐ ๊ตฌํ๋์ด ์๋ค๊ณ ํ๋๋ผ๋ protocol extension์ ์กด์ฌํ๋ ๋ฉ์๋๊ฐ ์ฐ์ ์ ์ผ๋ก ํธ์ถ๋๊ฒ ๋ฉ๋๋ค.
๐ ์์๋ก ์ดํดํ๊ธฐ
์๋์ ์ฝ๋๋ฅผ ํตํด ์์ ๊ฐ๋ ์ ์ดํดํด๋ณด๊ฒ ์ต๋๋ค.
protocol Fruit { func draw() } extension Fruit { func draw(){ print("This is a Fruit") } } struct Apple: Fruit { func draw() { print("This is an Apple") } } struct Orange: Fruit { func draw() { print("This is an Orange") } } let fruits: [Fruit] = [Apple(), Orange()] for fruit in fruits { fruit.draw() }
๊ณผ์ผ์ ๊ทธ๋ ค๋ณด๋ ํ๋ก๊ทธ๋จ์ ๊ตฌํํ์ต๋๋ค. ์์ ๊ตฌ์กฐ๋ฅผ ์ดํด๋ณด๋ฉด ๊ฐ๋ ์ค๋ช 1์ ํด๋นํ๋ ํ๋กํ ์ฝ ๋ด์ ํจ์๋ฅผ ์ ์ํ๊ณ extension์ ํจ์๋ฅผ ๊ตฌํํ ๊ตฌ์กฐ์ ๋๋ค. ์ด ๊ฒฝ์ฐ compiler๊ฐ protocol์ ๋ฉ์๋๋ฅผ ๋ณด๋ ์๊ฐ dynamic dispatch๋ฅผ ์ ์ฉํ์ฌ Fruit protocol์ conformํ๋ Apple, Orange ์์ ๋ฉ์๋๋ฅผ ์ฐ์ ์ ์ผ๋ก ํธ์ถํ๊ฒ ๋ฉ๋๋ค. ๊ทธ๋์ ์ถ๋ ฅ ๊ฒฐ๊ณผ๋
This is an Apple
This is an Orange
๊ฐ ๋ฉ๋๋ค.
์ด๋ฒ์๋ Fruit protocol์ ๋น์์ ์ ์ํด๋ณด๊ฒ ์ต๋๋ค.
protocol Fruit { // ๋ฉ์๋ ์์ } ...
์๋์ ์ฝ๋๋ ๋ชจ๋ ๋์ผํ๋ค๊ณ ํ ๋, ์ด๋ฒ์๋ ์ปดํ์ผ๋ฌ๊ฐ static dispatch๋ก ์๋ํ์ฌ extension Fruit๋ฅผ ๋จผ์ ์ฒดํฌํฉ๋๋ค. ์ด ๊ฒฝ์ฐ ๋ฉ์๋๊ฐ ์กด์ฌํ๊ณ , ์ด ๋ฉ์๋๊ฐ ํธ์ถ๋์ด Fruit๋ฅผ ์ฑํํ๋ Apple๊ณผ Orange์ ์กด์ฌํ๋ ๋์ผ ์ด๋ฆ์ ๋ฉ์๋๋ ํธ์ถ๋์ง ์์ต๋๋ค. ๊ทธ๋์ ๊ฒฐ๊ณผ๋
This is a Fruit
This is a Fruit
๊ฐ ๋ฉ๋๋ค.
๐ ๊ฒฐ๋ก
- ๊ฒฐ๊ณผ์ ์ผ๋ก ์ ๋ฆฌํ๋ฉด protocol์ ๋ฉ์๋๋ฅผ ๊ฐ์ง ์ํ์์ extension์ ๋ฉ์๋๋ฅผ ๊ตฌํํ๋ ๊ฒ๊ณผ, extension์๋ง ๋ฉ์๋๋ฅผ ๊ตฌํํ๋ ๊ฒ์ ๊ทธ ๋ฉ์๋๊ฐ ํธ์ถ๋๋ ์ฐ์ ์์์์ ์ฐจ์ด๊ฐ ๋ฐ์ํฉ๋๋ค. protocol์ ์ฑํํ๋ ํ์ ์ด ๊ฐ์ง ๋ฉ์๋๋ฅผ ์ฐ์ ์ ์ผ๋ก ํธ์ถํ๊ณ ์ถ๋ค๋ฉด protocol์ด ๊ฐ์ ธ์ผํ๋ ๋ฉ์๋๋ฅผ ์ค์ ํด์, compiler๊ฐ ๊ทธ ํ๋กํ ์ฝ์ ๋ณผ ๋ ๋ฐ๋์ ํ์ํ ๋ฉ์๋๋ฅผ ์ธ์์์ผ ํ์ ์ ์กด์ฌํ๋ ๋ฉ์๋๋ฅผ ํธ์ถํ๊ฒ ํ๊ณ , ๊ทธ ๋ฐ๋์ ๊ฒฝ์ฐ๋ extension์๋ง ๋ฉ์๋๋ฅผ ๊ตฌํํ๋ฉด ๋ฉ๋๋ค.
๐ธ Dispatch
dispatch๋ ํ๋ก๊ทธ๋จ์ด ์ด๋ค ๋ฉ์๋๋ฅผ ํธ์ถํ ๊ฒ์ธ๊ฐ๋ฅผ ๊ฒฐ์ ํ์ฌ ๊ทธ๊ฒ์ ์คํํ๋ ๊ณผ์ ์ ์๋ฏธํฉ๋๋ค. dispatch๋ ํฌ๊ฒ ๋๊ฐ์ง๋ก ๋๋ ์ ์์ต๋๋ค.
Static Dispatch(์ ์ ๋์คํจ์น)
์ปดํ์ผ ์์ ์์ ์ปดํ์ผ๋ฌ๊ฐ ํน์ ๋ฉ์๋๋ฅผ ํธ์ถํ ๊ฒ์ด๋ผ๋ ๊ฑธ ์ ํํ๊ฒ ์๊ณ ์๋ ๊ฒฝ์ฐ ๋ฐํ์(์คํ ์์ )์ด ๋์ง ์์๋ ๋ฏธ๋ฆฌ ๊ฒฐ์ ํ ์ ์๋๋ฐ ์ด๊ฒ์ ์ ์ ๋์คํจ์น๋ผ๊ณ ํฉ๋๋ค.
Dynamic Dispatch(๋์ ๋์คํจ์น)
ํน์ ๋ฉ์๋๊ฐ ์ปดํ์ผ ์์ ์ด ์๋๋ผ ๋ฐํ์ ์์ ์ ํธ์ถ์ด ๊ฒฐ์ ๋ ๊ฒฝ์ฐ Dynamic Dispatch๋ผ๊ณ ํฉ๋๋ค.
'iOS ์ฑ๊ฐ๋ฐ > iOS' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
- Total
- Today
- Yesterday
- filter#isalnum#lower
- ํ ํ๋ก์ ํธ#๋ฐฑ์ค์๊ณ ๋ฆฌ์ฆ#Python
- django
- Swift#Tuples#Range
- ์ฟผ๋ํธ๋ฆฌ#BOJ#๋ถํ ์ ๋ณต#Python
- ๋์ ์๋ฅด๊ธฐ#์ด๋ถํ์#BOJ#Python
- django#slicing
- API#lazy#
- ๋ฏธ๋ก ํ์#๋ฐฑ์ค์๊ณ ๋ฆฌ์ฆ#Python
- ๊ณต์ ๊ธฐ ์ค์น#BOJ#์ด๋ถํ์#Python
- PassingCars#Codility#Python
- ์ฌ์๊ฐ์#๋ฐฑ์ค์๊ณ ๋ฆฌ์ฆ#Python
- ๋ฆฌ๋ชจ์ปจ#์์ ํ์#BOJ#Python
- ํ์ด์ฌ์๊ณ ๋ฆฌ์ฆ์ธํฐ๋ทฐ#4์ฅ
- Brackets#Stacks and Queues#Codility#Python
- ๋ฐ๋ณต์์ด#๋ฐฑ์ค์๊ณ ๋ฆฌ์ฆ#Python
- Distinct#Codility#Python
- ๋๋ฌด์๋ฅด๊ธฐ#BOJ#์ด๋ถํ์#Python
- ๋ ์ง ๊ณ์ฐ#BOJ#์์ ํ์#Python
- ํฐํ๋น์น#๋ฆฌ์ฝ#xbox#controller
- ํ ๋งํ #๋ฐฑ์ค์๊ณ ๋ฆฌ์ฆ#Python
- ๋ณ๋ ๋์ดํธ#BOJ#ํ์๋ฒ#Python
- NumberofDiscIntersections#Codility#Sort#Python
- ์์ด์ฌ์ดํด#BOJ#Python
- ๋ฐฐ์ดํฉ์น๊ธฐ#๋ถํ ์ ๋ณต#BOJ#Python
- ๋ฐฑ์ค ์๊ณ ๋ฆฌ์ฆ#BackTracking
- N์ผ๋ก ํํ#DP#Programmers#Python
- ์ํธ์ฝ๋#dp#BOJ#Python
- Triangle#Sorting#Codility#Python
- ์ข ์ด์๋ฅด๊ธฐ#๋ถํ ์ ๋ณต#BOJ#Python
์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | 2 | |||||
3 | 4 | 5 | 6 | 7 | 8 | 9 |
10 | 11 | 12 | 13 | 14 | 15 | 16 |
17 | 18 | 19 | 20 | 21 | 22 | 23 |
24 | 25 | 26 | 27 | 28 | 29 | 30 |