13. Structure and Class

Structures and Classes

Structure

Struct StructName {
property
method
initializer
subscript
}

// 커스텀 타입 = Enum, Structure, Class

// Class = 추상화, 설계도

// Structure = 작은 데이터

struct Person {
    var name: String
    var age: Int
    
    func speek(){
        print("Hello")
    }
}

let p = Person(name: "Steve", age: 50)

let name = "Paul"
name

// 구조체 접근 방식
p.name
p.age

// 메소드 접근
p.speek()

// 함수는 이름만으로 호출
// 메소드는 인스턴스 이름으로 호출

Class

Class ClassName {
property
method
initializer
deinitializer
subscript
}

class Person {
    var name = "John Don"
    var age = 0
    
    func speek() {
        print("Hello")
    }
}

let p = Person()

p.name
p.age

p.speek()

// 구조체는 가평식(복사되어 전달)
// 클래스는 참조

Initializer Syntax

init(parameters) {
statements
}

let str = "123"
let num = Int(str)

// 생성자 - init 초기화

class Position {
    var x: Double
    var y: Double
    
    init() {
        // 초기화
        x = 0.0
        y = 0.0
    }
    
    init(value: Double) {
        x = value
        y = value
    }
}


let a = Position.init()
a.x
a.y

let b = Position.init(value: 100)
b.x
b.y

// 열거형, 구조체, 클래스는 모두 설계도이다
// 설계도를 따라서 인스턴스(객체)를 만들기 위해서는 초기화 과정이 반드시 필요하다.
// 생성자를 호출하면 초기화가 시작되고, 생성자가 완료하면 모든 속성이 초기화된다.
// 에러없이 초기화가 완료되면 인스턴스가 생성된다.

Value Types vs Reference Types

Value Type

• Structure
• Enumeration
• Tuple

Reference Type

• Class
• Closure

• 가평식과 참조형식 차이
• Value Type = 값 복사
• Reference Type = 원본 값 전달
• 개발할 때 대부분 class로 함
• 상대적으로 적은 데이터를 전달하고 상속이 필요하지 않다면 가평식으로 구현
• 연관된 상수 그룹으로 구현할 때는 열거형으로 구현하고
• 코드내에서 한 번만 사용하는 것은 튜플로 구현

struct PositionValue {
    var x = 0.0
    var y = 0.0
    
}

class PositionObject {
    var x = 0.0
    var y = 0.0
    
}

// 기본 생성자
var v = PositionValue()
var o = PositionObject()

var v2 = v
var o2 = o

v2.x = 12
v2.y = 34

v
v2

o2.x = 12
o2.y = 34

o
o2

Nested Types

하나의 형식 내부에 다른 형식을 선언하고 새로운 인스턴스를 생성하는 방법

// 형식 내부에 선언된 형식

// 모두 Nested Types타입을 가질 수 있음
class One {
    struct Two {
        enum Three {        // 열거형에 클래스 추가도 가능
            case a
            
            class Four {
                
            }
        }
    }
    var a = One.Two()      // One 생략해도 상관없음
}

let two: One.Two = One.Two()