ํ‹ฐ์Šคํ† ๋ฆฌ ๋ทฐ

๋ฐ˜์‘ํ˜•

img


Classes, 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)


  1. ์ดˆ๊ธฐํ™”ํ•จ์ˆ˜(Initializer):

    Class์™€ Struct๋Š” ์ดˆ๊ธฐํ™”ํ•จ์ˆ˜(Initializer)๋ฅผ ๊ฐ–์ง€๋งŒ Enum์€ ์ดˆ๊ธฐํ™” ํ•จ์ˆ˜๋ฅผ ๊ฐ–์ง€ ์•Š์Šต๋‹ˆ๋‹ค. ์™œ๋ƒํ•˜๋ฉด ์—ด๊ฑฐํ˜•(Enum)์€ ์—ฐ๊ด€๊ฐ’์„ ๊ตฌ๋ณ„๋˜๋Š” ๊ฐ’(discrete values)๋“ค์— ํ• ๋‹นํ•˜๊ธฐ ๋•Œ๋ฌธ์ž…๋‹ˆ๋‹ค. ํด๋ž˜์Šค๋‚˜ ๊ตฌ์กฐ์ฒด์—์„œ ์ธ์Šคํ„ด์Šค๋ฅผ ์ƒ์„ฑํ•  ๋•Œ ์ €์žฅ๋œ ํ”„๋กœํผํ‹ฐ๊ฐ€ ์ดˆ๊ธฐํ™”๋˜์ง€ ์•Š์œผ๋ฉด ์ธ์Šคํ„ด์Šค๋ฅผ ์ƒ์„ฑํ•  ์ˆ˜ ์—†๋Š” ๋“ฑ์˜ ๋ฌธ์ œ๊ฐ€ ๋ฐœ์ƒํ•ด์„œ ๊ธฐ๋ณธ์ ์œผ๋กœ ์ดˆ๊ธฐํ™”์— ํ•„์š”ํ•œ ์ •๋ณด๋“ค์„ ์…‹ํŒ…ํ•  ํ•จ์ˆ˜๊ฐ€ ํ•„์š”ํ•ฉ๋‹ˆ๋‹ค. ํ•˜์ง€๋งŒ Enum์˜ ๊ฒฝ์šฐ ๊ฐ case๊ฐ€ ์• ์ดˆ๋ถ€ํ„ฐ ๊ตฌ๋ณ„๋˜๋Š” rawValue๋ฅผ ๊ฐ€์ง€๋ฉฐ ์„ค์ •์ด ์•ˆ๋˜๋”๋ผ๋„ default๋กœ ์ •์ˆ˜๊ฐ’์ด ํ• ๋‹น๋˜๋ฏ€๋กœ ์ดˆ๊ธฐํ™”์˜ ํ•„์š”์„ฑ์ด ์—†์Šต๋‹ˆ๋‹ค.


  2. ์ƒ์†(Inheritance):

    Class์—์„œ๋Š” ์ƒ์†์ด ๊ฐ€๋Šฅํ•˜์ง€๋งŒ Struct๋‚˜ Enum์—์„œ๋Š” ๋ถˆ๊ฐ€๋Šฅํ•ฉ๋‹ˆ๋‹ค.


  3. ๊ฐ’ ํƒ€์ž…(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๋Š” ๋’ค์—์„œ ๋ฌด์Šจ ์ผ์ด ์ผ์–ด๋‚˜๊ณ  ์žˆ๋Š”์ง€ ๋ณด๊ณ  ์žˆ๋‹ค๊ฐ€ ์˜ค๋žซ๋™์•ˆ ํž™ ๋ฉ”๋ชจ๋ฆฌ์— ๋จธ๋ฌผ๊ณ  ์žˆ๋Š” ๊ฒƒ๋“ค์„ ํ•œ๊บผ๋ฒˆ์— ์ˆ˜์ง‘ํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.


  4. ํƒ€์ž… ์บ์ŠคํŒ…(Type Casting):

    ํด๋ž˜์Šค๋Š” ์‹คํ–‰ ์‹œ ์ปดํŒŒ์ผ๋Ÿฌ๊ฐ€ ํด๋ž˜์Šค ์ธ์Šคํ„ด์Šค์˜ ํƒ€์ž…์„ ๋ฏธ๋ฆฌ ํŒŒ์•…ํ•˜๊ณ  ๊ฒ€์‚ฌํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.


  5. ์†Œ๋ฉธํ™” ๊ตฌ๋ฌธ(deinit):

    ํด๋ž˜์Šค๋Š” ์ธ์Šคํ„ด์Šค๊ฐ€ ์†Œ๋ฉธ๋˜๊ธฐ ์ง์ „์— ์ฒ˜๋ฆฌํ•ด์•ผํ•  ๊ตฌ๋ฌธ๋“ค์„ ๋ฏธ๋ฆฌ ๋“ฑ๋กํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.


  6. ๋ฉค๋ฒ„์™€์ด์ฆˆ ์ดˆ๊ธฐํ™”(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:

๋ฐ˜์‘ํ˜•
๋Œ“๊ธ€
๋ฐ˜์‘ํ˜•
๊ณต์ง€์‚ฌํ•ญ
์ตœ๊ทผ์— ์˜ฌ๋ผ์˜จ ๊ธ€
์ตœ๊ทผ์— ๋‹ฌ๋ฆฐ ๋Œ“๊ธ€
Total
Today
Yesterday
๋งํฌ
TAG more
ยซ   2024/11   ยป
์ผ ์›” ํ™” ์ˆ˜ ๋ชฉ ๊ธˆ ํ† 
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
๊ธ€ ๋ณด๊ด€ํ•จ