ํฐ์คํ ๋ฆฌ ๋ทฐ
[Swift] - ํด๋์ค(Class) vs ๊ตฌ์กฐ์ฒด(Struct) vs ์ด๊ฑฐํ(Enum)
B_log 2021. 3. 30. 18:36Classes, Structures, Enumerations
๐ ์ ์ฌ์ (Similarity)
ํด๋์ค(Class), ๊ตฌ์กฐ์ฒด(Struct), ์ด๊ฑฐํ(Enum)์ Swift์ ๊ธฐ๋ณธ ์๋ฃ๊ตฌ์กฐ ๋ธ๋ญ์ ๋๋ค.(These are the 3 fundamental building blocks of data structures in Swift)
์ธ๊ฐ์ง ๊ตฌ์กฐ ๋ชจ๋ ๊ฐ์ ๋ฐฉ์์ผ๋ก ์ ์๋ฉ๋๋ค.
// ํค์๋ + ์ด๋ฆ + {} class testClass { } struct testStruct { } enum Op { }
์ธ๊ฐ์ง ์๋ฃ๊ตฌ์กฐ ๋ชจ๋ ํ๋กํผํฐ(Properties)์ ํจ์(Functions)๋ฅผ ๊ฐ์ง ์ ์์ต๋๋ค.
ํ์ง๋ง ์ด๊ฑฐํ(Enum)์ ์ ์ฅ ํ๋กํผํฐ(Stored Property)๋ฅผ ๊ฐ์ง ์ ์์ต๋๋ค. ํด๋์ค์ ๊ตฌ์กฐ์ฒด๋ง ์ ์ฅ ํ๋กํผํฐ๋ฅผ ๊ฐ์ง ์ ์์ต๋๋ค. ํ์ง๋ง ๊ณ์ฐ ํ๋กํผํฐ(Computed Properties)๋ ํด๋์ค์ ๊ตฌ์กฐ์ฒด์ฒ๋ผ ์ด๊ฑฐํ๋ ๊ฐ์ง ์ ์์ต๋๋ค. enum์ ์ฐ๊ด๊ฐ(associated value)๋ก์ ๊ฐ์ ์ ์ฅํ๊ณ ์์ต๋๋ค.
์์ฑ๊ฐ์ ์ ๊ทผํ ์ ์๋ ๋ฐฉ๋ฒ์ ์ ๊ณตํ๋ ์๋ธ์คํฌ๋ฆฝํธ(Subscript)๋ฅผ ์ ์ํ ์ ์์ต๋๋ค.
ํ์ฅ(Extension)์ ํตํด ๊ธฐ๋ฅ์ ํ์ฅ์ํฌ ์ ์์ต๋๋ค.
ํ๋กํ ์ฝ(Protocol)์ ์ฑํ(Conform)ํ ์ ์์ต๋๋ค.
๐ฏ ์ฐจ์ด์ (Differences)
์ด๊ธฐํํจ์(Initializer):
Class์ Struct๋ ์ด๊ธฐํํจ์(Initializer)๋ฅผ ๊ฐ์ง๋ง Enum์ ์ด๊ธฐํ ํจ์๋ฅผ ๊ฐ์ง ์์ต๋๋ค. ์๋ํ๋ฉด ์ด๊ฑฐํ(Enum)์ ์ฐ๊ด๊ฐ์ ๊ตฌ๋ณ๋๋ ๊ฐ(discrete values)๋ค์ ํ ๋นํ๊ธฐ ๋๋ฌธ์ ๋๋ค. ํด๋์ค๋ ๊ตฌ์กฐ์ฒด์์ ์ธ์คํด์ค๋ฅผ ์์ฑํ ๋ ์ ์ฅ๋ ํ๋กํผํฐ๊ฐ ์ด๊ธฐํ๋์ง ์์ผ๋ฉด ์ธ์คํด์ค๋ฅผ ์์ฑํ ์ ์๋ ๋ฑ์ ๋ฌธ์ ๊ฐ ๋ฐ์ํด์ ๊ธฐ๋ณธ์ ์ผ๋ก ์ด๊ธฐํ์ ํ์ํ ์ ๋ณด๋ค์ ์ ํ ํ ํจ์๊ฐ ํ์ํฉ๋๋ค. ํ์ง๋ง Enum์ ๊ฒฝ์ฐ ๊ฐ case๊ฐ ์ ์ด๋ถํฐ ๊ตฌ๋ณ๋๋ rawValue๋ฅผ ๊ฐ์ง๋ฉฐ ์ค์ ์ด ์๋๋๋ผ๋ default๋ก ์ ์๊ฐ์ด ํ ๋น๋๋ฏ๋ก ์ด๊ธฐํ์ ํ์์ฑ์ด ์์ต๋๋ค.
์์(Inheritance):
Class์์๋ ์์์ด ๊ฐ๋ฅํ์ง๋ง Struct๋ Enum์์๋ ๋ถ๊ฐ๋ฅํฉ๋๋ค.
๊ฐ ํ์ (Value Type) vs ์ฐธ์กฐ ํ์ (Reference Type)
Struct์ Enum์ ๊ฐ ํ์ ์ด์ง๋ง Class๋ ์ฐธ์กฐ ํ์ ์ ๋๋ค. Class๋ ์ฐธ์กฐ ํ์ ์ผ๋ก์ ํฌ์ธํฐ(๋ฉ๋ชจ๋ฆฌ ์ฃผ์)๋ก ์ ๋ฌ๋๊ณ ์ ๋ณด๋ heap ๋ฉ๋ชจ๋ฆฌ ์์ญ์ ์ ์ฅํฉ๋๋ค.
- heap ์์ญ: ๋์ ์ผ๋ก ํ ๋น๋๋ ๋ฉ๋ชจ๋ฆฌ ์์ญ์ ๋๋ค.
- ๋์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น: ํ๋ก๊ทธ๋จ ์คํ ์๊ฐ ๋์ ์ฌ์ฉํ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ํ ๋นํ๋ ๊ฒ์ ๋งํฉ๋๋ค. ์ฌ์ฉ์ด ๋๋๋ฉด ์ด์์ฒด์ ๊ฐ ์ธ ์ ์๋๋ก ๋ฐ๋ฉํ๊ณ ๋ค์์ ์๊ตฌ๊ฐ ์ค๋ฉด ์ฌํ ๋น์ ๋ฐ์ ์ ์์ต๋๋ค.
- ์ ์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น: ํ๋ก๊ทธ๋จ์ ์คํํ๋ ์๊ฐ ํ๋ก๊ทธ๋จ์ด ์ฌ์ฉํ ๋ฉ๋ชจ๋ฆฌ ํฌ๊ธฐ๋ฅผ ๊ณ ๋ คํ์ฌ ๋ฉ๋ชจ๋ฆฌ์ ํ ๋น์ด ์ด๋ฃจ์ด์ง๋ ๊ฒ์ ๋งํฉ๋๋ค. ํด์ ํ์ง ์์์ผ๋ก ์ธํ ๋ฉ๋ชจ๋ฆฌ ๋์์ ๊ฐ์ ๋ฌธ์ ๋ฅผ ์ ๊ฒฝ์ฐ์ง ์์๋ ๋ฉ๋๋ค. ํ์ง๋ง ๋ฉ๋ชจ๋ฆฌ์ ํฌ๊ธฐ๊ฐ ํ๋ ์ฝ๋ฉ๋์ด ์์ด์ ๋์ค์ ์กฐ์ ํ ์ ์์ต๋๋ค. ๋ํ ์คํ ์์ญ์ ํ ๋น๋ ๋ฉ๋ชจ๋ฆฌ์ด๋ฏ๋ก ๋์ ํ ๋น์ ๋นํด ํ ๋น ๋ฐ์ ์ ์๋ ์ต๋ ๋ฉ๋ชจ๋ฆฌ์ ์ ์ฝ์ ๋ฐ์ต๋๋ค.
๐ฌ ๊ฐ ํ์ ์ ํจ์์์ ์ธ์๋ก ์ ๋ฌ๋ ๋ ๋ณต์ฌ๋ฉ๋๋ค. ๋ํ ๋ค๋ฅธ ๋ณ์์ ํ ๋น๋ ๋ ์ญ์ ๋ณต์ฌ๋ฉ๋๋ค(Copied when passed as an argument to a function and when assigned to a different variable). ์ฆ, x = y์ ์ฐ์ฐ์์ x๋ y ์์ฒด๋ฅผ ๊ฐ์ ธ์ค๋ ๊ฒ์ด ์๋๋ผ y์ ๊ฐ์ ๋ณต์ฌํด์ ๊ฐ์ ธ์ค๊ธฐ ๋๋ฌธ์ ์ฐ์ฐ ์ดํ์ x์ ๊ฐ์ ๋ณ๊ฒฝํ๊ฑฐ๋ Array์ ๊ฒฝ์ฐ ์ถ๊ฐํ๋ค๊ณ ํด๋ y์๋ ๋ณํ๊ฐ ์ผ์ด๋์ง ์์ต๋๋ค. Array๋ Dictionary ๋ฑ์ ์๋ฃ๊ตฌ์กฐ๋ struct๋ก ๊ตฌํ๋์ด ์์ผ๋ฏ๋ก ๊ฐํ์ ์ด๊ณ , let์ผ๋ก ํน์ ์์์ ํ ๋นํด์ค๋ค๋ฉด ์ถํ์ ๋ณ๊ฒฝ ๋ถ๊ฐ๋ฅํฉ๋๋ค.
ํจ์์ ๋ชจ๋ ์ธ์๋ ์์์ ๋๋ค. ๋ณต์ฌ ๊ฐ๋ ์ด ์๋ํ๋ ๋ฐฉ์๋๋ฌธ์, struct๋ enum์ ๊ฐ์ง๊ณ ์๋ค๋ฉด Swift๋ ๋ชจ๋ ํจ์์ ๊ตฌ์กฐ์ฒด๋ enum์ด ๋ฐ๋์ง๋ ๋ชจ๋ฅธ๋ค๊ณ ํ์๋ฅผ ํ๊ฒ ๋ง๋ญ๋๋ค. ์ด ๋ ๋ฐ๋๋ ํจ์๋ผ๋ ์๋ฏธ๋ก mutating์ด๋ผ๋ ํค์๋๋ฅผ ์ฌ์ฉํฉ๋๋ค. ๋ค์๋งํ๋ฉด, mutating func์ ๊ฒฝ์ฐ ์ด ํจ์๊ฐ ๊ตฌ์กฐ์ฒด๋ฅผ ๋ฐ๊ฟ์ ์๋ ํจ์๋ผ๋ ์๋ฏธ๋ฅผ ๊ฐ์ต๋๋ค. ์๋ํ๋ฉด Swift๊ฐ ๊ฐ์ ๋ณต์ฌํ ๋, ์ค์ ๋ก ๊ทธ ๊ฐ์ ๋ณต์ฌํ๊ณ ์ถ์ง ์์ต๋๋ค. ๋ค๋ฅธ ํฌ์ธํฐ๋ก ๊ทธ ๊ฐ์ ์ฐธ์กฐํ๊ณ ์๋ค๊ฐ, ๊ฐ์ด ๋ฐ๋๋ ค๊ณ ํ ๋ ์ค์ ๋ณต์ฌ๊ฐ ์ผ์ด๋ฉ๋๋ค. ์ฆ, ๊ฐ ํ์ ์ด๋ผ๊ณ ํ๋๋ผ๋ ์ฆ๊ฐ์ ์ธ ๋ณต์ฌ๊ฐ ์ผ์ด๋์ง ์์ต๋๋ค. ์ด๋ ์ฑ๋ฅ ํฅ์์ ์ํ ์ ์ฐจ์ ๋๋ค. ๋ง์ฝ ๊ฐ ํ์ ์ผ๋ก ๋ณต์ฌ๋ ๊ฐ๋ ์ด์ง๋ง ์ค์ ๋ก๋ ์ฐธ์กฐํ๊ณ ์๋ ์ํฉ์ด๊ณ , ๊ฐ์ด ๋ณ๊ฒฝ๋์์ ๋ ๊ณ์ ์ฐธ์กฐ ์ํ๋ผ๋ฉด ๋ณ๊ฒฝ์ด ์๊ตฌ๋์ง ์๋ ๊ฐ ์ญ์ ๋ณ๊ฒฝ๋ ์ ์์ต๋๋ค. ๊ทธ๋์ ํน์ ํจ์๋ฅผ ์ฌ์ฉํ ๋ ๊ทธ ํจ์๊ฐ mutating์ด๋ผ๋ฉด ์์ ํ ๋ณต์ฌ๊ฐ ๋จผ์ ์ผ์ด๋์ผํ๋ฏ๋ก mutating ํค์๋๊ฐ ํ์ํฉ๋๋ค.
๐ฌ ์ฐธ์กฐ ํ์ ์ ํ ์์ญ์ ์ ์ฅ๋๋ฉฐ ์๋์ ์ผ๋ก reference count๋ฅผ ํฉ๋๋ค(Stored in the heap and reference counted automatically). reference count๋ ํด๋น ์ ๋ณด๋ฅผ ๋ช๊ฐ์ ํฌ์ธํฐ๊ฐ ์ฐธ์กฐํ๊ณ ์๋์ง ๊ทธ ๊ฐ์๋ฅผ ์ธ๋ ์ญํ ์ ํฉ๋๋ค. ๊ทธ ๋ง์ Swift์์๋ Garbage Collection์ด ์๋ค๋ ๊ฒ์ ๋ปํฉ๋๋ค. ์๋ํ๋ฉด reference count๊ฐ 0์ด ๋๋ฉด, ์ด ์์ญ์ ์ฐธ์กฐํ๋ ํฌ์ธํฐ๊ฐ ์๋ค๋ ๋ป์ด๋ฏ๋ก 0์ด ๋๋ ์๊ฐ ์ฆ์ ํ ์์ญ์์ ์ ๊ฑฐ๋ฉ๋๋ค. ์ด๋ ๊ฒ ํ๋ฉด ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ๊ฐ ์์ธก ๊ฐ๋ฅํด์ง๊ณ ์๋ํ๋ฉ๋๋ค.
์์๋ก ์ ์ธ๋ ์ฐธ์กฐ ํ์ ์ ๊ฒฝ์ฐ์๋ ๊ฐ์ ๋ณ๊ฒฝํ ์ ์์ต๋๋ค. x = y๋ก ์ ์ธํ๋ฉด ์ด๋ ๊ฐ์ ์ฃผ์๋ฅผ ๊ณต์ ํ๊ณ x์ ๊ฐ์ด ๋ณ๊ฒฝ๋๋ฉด y์ ๊ฐ ์ญ์ ๋ณ๊ฒฝ๋ฉ๋๋ค. ์ฐธ์กฐ ํ์ ์ด ์์๋ก ์ ์ธ๋ ๊ฒ์ ๊ทธ ํฌ์ธํฐ๊ฐ ์์๋ก์ ๋ณํ์ง ์๋๋ค๋ ๋ป์ด์ง ๊ทธ ํฌ์ธํฐ๊ฐ ๊ฐ๋ฅดํค๋ ๊ฐ์ด ์์์ฌ์ ๋ณํ ์ ์๋ค๋ ๋ป์ ์๋๋๋ค.
Garbage Collection: ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ ๊ธฐ๋ฒ ์ค์ ํ๋๋ก ํ๋ก๊ทธ๋จ์ด ๋์ ์ผ๋ก ํ ๋นํ๋ ๋ฉ๋ชจ๋ฆฌ ์์ญ ์ค์์ ์ฌ์ฉํ์ง ์๋, ํ์ ์๊ฒ ๋ ์์ญ์ ํด์ ํ๋ ๊ธฐ๋ฅ์ ๋๋ค. GC๋ ๋ค์์ ๋ฌด์จ ์ผ์ด ์ผ์ด๋๊ณ ์๋์ง ๋ณด๊ณ ์๋ค๊ฐ ์ค๋ซ๋์ ํ ๋ฉ๋ชจ๋ฆฌ์ ๋จธ๋ฌผ๊ณ ์๋ ๊ฒ๋ค์ ํ๊บผ๋ฒ์ ์์งํด์ผ ํฉ๋๋ค.
ํ์ ์บ์คํ (Type Casting):
ํด๋์ค๋ ์คํ ์ ์ปดํ์ผ๋ฌ๊ฐ ํด๋์ค ์ธ์คํด์ค์ ํ์ ์ ๋ฏธ๋ฆฌ ํ์ ํ๊ณ ๊ฒ์ฌํ ์ ์์ต๋๋ค.
์๋ฉธํ ๊ตฌ๋ฌธ(deinit):
ํด๋์ค๋ ์ธ์คํด์ค๊ฐ ์๋ฉธ๋๊ธฐ ์ง์ ์ ์ฒ๋ฆฌํด์ผํ ๊ตฌ๋ฌธ๋ค์ ๋ฏธ๋ฆฌ ๋ฑ๋กํ ์ ์์ต๋๋ค.
๋ฉค๋ฒ์์ด์ฆ ์ด๊ธฐํ(memberwise init):
๊ตฌ์กฐ์ฒด๋ memberwise init์ ํตํด ์๋์ผ๋ก ์ด๊ธฐํ ๊ตฌ๋ฌธ์ ์์ฑํด์ค๋๋ค. ๊ฐ์ด ์ ์๋์ด์์ง ์์ ํ๋กํผํฐ๊ฐ ์กด์ฌํ ๋(์ต์ ๋ ํฌํจ), struct์ ๊ฒฝ์ฐ ์๋์ผ๋ก ์ธ์คํด์ค ์์ฑ์ ํด๋น ํ๋กํผํฐ์ ๊ฐ์ ์ ๋ ฅ๋ฐ๋ init์ ์์ฑํ์ง๋ง class์ ๊ฒฝ์ฐ init์ ๋ฐ๋ก ์ ์ํด์ฃผ์ง ์์ผ๋ฉด ์ค๋ฅ๊ฐ ๋ฐ์ํฉ๋๋ค.
๐ง ์ struct๋ง ์๋ ์์ฑ init์ด ์กด์ฌํ๊ณ class์๋ ์ด ํธํ ๊ธฐ๋ฅ์ ๋ฃ์ด์ฃผ์ง ์์์๊น?
The logic behind it could be because a
struct
is not subclassable, making it obvious that a complete initializer would be required, and as such it was made implicit by the language.On the other hand, a
class
is subclassable, and as such you may want to design it so that it can only be initialized from subclasses, and as such an implicit initializer was not provided by the language.Ref: ์ถ์ฒ
struct๋ ์์์ด ๋ถ๊ฐ๋ฅํ๊ธฐ ๋๋ฌธ์ ํด๋น struct์์ init์ ๊ผญ ํ์๋กํฉ๋๋ค. ๊ทธ๋์ Swift ์์ฒด์์ ์๋ํ๋ ๊ธฐ๋ฅ์ ์ ๊ณตํฉ๋๋ค. ํ์ง๋ง class์ ๊ฒฝ์ฐ ์์์ด ๊ฐ๋ฅํ๋ฏ๋ก, ์ค๊ณ์ ํด๋น ํด๋์ค๊ฐ ์๋ธํด๋์ค์์๋ง ์ด๊ธฐํ๋์ผํ ํ์์ฑ์ด ์์ ์ ์์ต๋๋ค. ์ฆ, ์์ ๊ฐ๋ฅ์ฑ์์ ์ฐจ์ด๊ฐ ๋ฐ์ํฉ๋๋ค.
๐โโ๏ธ ๋ฌด์์ ์ฌ์ฉํด์ผํ๋?(Choosing which to use?)
์ผ๋ฐ์ ์ผ๋ก ๊ฐ์ฒด์งํฅ์์ ์ฌ์ฉํ๋ class๋ฅผ ์ฌ์ฉํ๋ฉด ๋์ง๋ง struct๋ ์ข ๋ ๊ธฐ๋ณธ์ ์ธ(fundamental) ํ์ ์ผ๋ก ์ฌ์ฉ๋ฉ๋๋ค. ์ฌ๊ธฐ์ ๊ธฐ๋ณธ์ ์ธ ํ์ ์ด๋ String, Double, Int, Array, Dictionary์ ๊ทธ๋ฆผ์ ๊ทธ๋ฆฌ๊ธฐ ์ํ ์ , ์ง์ฌ๊ฐํ ๊ฐ์ด ํด๋์ค๋ณด๋ค๋ ๋ ์์ง๋ง ์ค์ค๋ก ์๋ฆฝํ๋ฉฐ(self-contained) ๊ฐ์ผ๋ก ๋ณต์ฌ๋๋๊ฒ ๋ง์ด ๋๊ณ ๊ฐ ํ์ ์ ์ํ๋ ์์ญ๋ค ์ ๋๋ค. ์ฆ, ์ ๋ฌํ๊ณ ๋ค๋ ๋ ๊ฐ ๊ฐ๋ ์ ์ํ๋ ์ํฉ์ ์๋ฏธํฉ๋๋ค. enum์ ๊ตฌ๋ณ๋๋ ๊ฐ์ ๊ฐ์ง ํ์ ์ ์ฌ์ฉํ ๊ฒฝ์ฐ ์ฌ์ฉํฉ๋๋ค.
์๋ฌธ: Usually you will choose class over struct. struct tends to be more for fundamental types. Use of enum is situational (any time you have a type of data with discrete values).
Reference:
Stanford CS193p by Paul Hegarty
https://ko.wikipedia.org/wiki/%EB%8F%99%EC%A0%81_%EB%A9%94%EB%AA%A8%EB%A6%AC_%ED%95%A0%EB%8B%B9
'iOS ์ฑ๊ฐ๋ฐ > Swift Basic' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
- Total
- Today
- Yesterday
- ๊ณต์ ๊ธฐ ์ค์น#BOJ#์ด๋ถํ์#Python
- django#slicing
- ํ ํ๋ก์ ํธ#๋ฐฑ์ค์๊ณ ๋ฆฌ์ฆ#Python
- PassingCars#Codility#Python
- ๋ ์ง ๊ณ์ฐ#BOJ#์์ ํ์#Python
- Triangle#Sorting#Codility#Python
- ๋ฐฐ์ดํฉ์น๊ธฐ#๋ถํ ์ ๋ณต#BOJ#Python
- NumberofDiscIntersections#Codility#Sort#Python
- ๋์ ์๋ฅด๊ธฐ#์ด๋ถํ์#BOJ#Python
- Swift#Tuples#Range
- ๋ฏธ๋ก ํ์#๋ฐฑ์ค์๊ณ ๋ฆฌ์ฆ#Python
- ์ฟผ๋ํธ๋ฆฌ#BOJ#๋ถํ ์ ๋ณต#Python
- filter#isalnum#lower
- API#lazy#
- ์ํธ์ฝ๋#dp#BOJ#Python
- ๋ฆฌ๋ชจ์ปจ#์์ ํ์#BOJ#Python
- ์์ด์ฌ์ดํด#BOJ#Python
- ๋๋ฌด์๋ฅด๊ธฐ#BOJ#์ด๋ถํ์#Python
- N์ผ๋ก ํํ#DP#Programmers#Python
- ๋ฐฑ์ค ์๊ณ ๋ฆฌ์ฆ#BackTracking
- ์ข ์ด์๋ฅด๊ธฐ#๋ถํ ์ ๋ณต#BOJ#Python
- ์ฌ์๊ฐ์#๋ฐฑ์ค์๊ณ ๋ฆฌ์ฆ#Python
- Distinct#Codility#Python
- ํ์ด์ฌ์๊ณ ๋ฆฌ์ฆ์ธํฐ๋ทฐ#4์ฅ
- ๋ฐ๋ณต์์ด#๋ฐฑ์ค์๊ณ ๋ฆฌ์ฆ#Python
- django
- Brackets#Stacks and Queues#Codility#Python
- ํฐํ๋น์น#๋ฆฌ์ฝ#xbox#controller
- ๋ณ๋ ๋์ดํธ#BOJ#ํ์๋ฒ#Python
- ํ ๋งํ #๋ฐฑ์ค์๊ณ ๋ฆฌ์ฆ#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 |