클래스(class)와 구조체(struct)의 속성(property)

썹스·2022년 10월 8일

Swift 문법 swift

Swift 문법

목록 보기

15/68

속성(property)

속성(property)은 클래스(class) 또는 구조체(struct) 안에서 사용된 변수(var)와 상수(let)를 의미합니다.

Swift에서 사용되는 속성(property)은 크게 5개가 존재하며, 사용 목적과 용도에 따라 다르게 사용되고 있습니다. (클래스와 구조체에서 사용되는 여러 가지 속성은 사용법과 구현법이 모두 동일)

속성은 "프로퍼티"라는 단어로도 많이 사용됩니다. (속성 == 프로퍼티)

속성(property)의 종류

📌 1. 저장 속성(Stored Properties)

저장 속성(Stored Properties)은 가장 기본적이고 단순한 방법이며, 클래스 또는 구조체로부터 만들어진 객체(인스턴스)의 프로퍼티 정보를 저장하는 프로퍼티입니다.
즉, 클래스 또는 구조체 내부에 선언하는 변수, 상수를 저장 속성이라 부릅니다.

struct Man{
    var name: String      //저장 속성(Stored Properties)
    var age: Int          //저장 속성(Stored Properties)


    //프로퍼티에 초깃값이 없으면, 생성자(init)를 사용하여 프로퍼티을 초기화해야 합니다.
    init(name: String, age: Int){
        self.name = name
        self.age = age
    }
   
    func introduce(){
        print("저의 이름은 \(name)입니다. 나이는 \(age)살 입니다.")
    }
}

var kim = Man(name: "김철수", age: 25)
kim.introduce()

📌 2. 지연 저장 속성(Lazy Stored Properties)

지연 저장 속성(Lazy Stored Properties)으로 만들어진 프로퍼티는 클래스나 구조체가 정의되어 인스턴스를 생성할 때 해당 프로퍼티의 데이터를 메모리에 할당하지 않고, 해당 프로퍼티에 접근할 때 메모리에 할당하는 특징을 가지고 있습니다.
지연 저장 속성은 변수(var) 앞에 특정 키워드인 "lazy"를 작성하여 사용하며, 상수(let)로 만들어진 프로퍼티는 지연 저장 속성으로 사용할 수 없습니다.
불필요한 메모리 공간 사용을 줄일 수 있다는 장점이 있기 때문에 지연 저장 속성은 프로퍼티는 종류가 많고 복잡한 클래스나 구조체에서 많이 사용됩니다.
지연 저장 속성을 만들 때는 프로퍼티의 초깃값을 꼭 작성해야 합니다.

struct Man{
    var name: String                      //저장 속성(Stored Properties)
    var age: Int                          //저장 속성(Stored Properties)
    lazy var address: String = "떡잎마을"   //지연 저장 속성(Lazy Stored Properties)
   
    init(name: String, age: Int){
        self.name = name
        self.age = age
    }
   
    func introduce(){
        print("저의 이름은 \(name)입니다. 나이는 \(age)살 입니다.")
    }
}


var kim = Man(name: "김철수", age: 25)
// 아직까지 address는 초기화 되지 않고 있다. (메모리에 공간 사용 X)
kim.address  // address가 초기화 되어 초깃값(떡잎마을)이 메모리에 할당
---------------------------------------------------------------------------------------
인스턴스가 lazy 키워드를 사용하여 만든 프로퍼티에 접근하려는 순간에 초기화됨(데이터가 메모리에 할당)

📌 3. 계산 속성(Computed Properties)

계산 속성(Computed Properties)은 데이터를 저장하는 프로퍼티가 아닌, 특정 데이터(값)를 계산하는 특징을 가지고 있는 프로퍼티입니다.
즉, 계산 속성은 함수처럼 연산이 가능한 특징을 가지고 있는 프로퍼티입니다. (실제로 계산 속성으로 만들어진 프로퍼티는 변수(상수)가 아닌 함수입니다.)
계산 속성은 코드와 계산에 사용되는 값에 따라 결과값이 달라지기 때문에 변수(var)로만 선언할 수 있습니다.
get{ } 키워드를 사용하여 계산된 값을 return 받을 수 있다. (필수 작성)
set(newValue){ } 키워드를 사용하여 새로운 값을 대입할 수도 있다. (선택 작성)

그렇다면 왜 함수(메서드)를 놔두고 계산 속성을 사용할까??🤔

프로퍼티 안에 get, set 함수를 한 번에 작성하여 사용할 수 있으며, 개발자가 코드를 읽을 때 쉽게 읽고 사용할 수 있다는 장점이 있기 때문에 계산 속성을 사용합니다. (즉, 코드의 가독성을 높이기 위해 사용된다.)

✅메서드(func)를 사용한 방식의 구조체

struct Conversion{
    var cm: Double = 10
    func inchConversion() -> Double{
        let inch = cm * 0.393701
        return inch
    }
}

var lengthCm = Conversion()
lengthCm.inchConversion()

✅계산 속성을 사용한 방식의 구조체(get만 사용)

struct Conversion{
    var cm: Double = 1
    var inchConversion: Double{
        get{
            return cm * 0.393701
        }
    }
}
var lengthCm = Conversion()
lengthCm.inchConversion

✅계산 속성을 사용한 방식의 구조체(get, set 사용)

struct Conversion{
    var cm: Double = 1
    var inchConversion: Double{
        get{
            return cm * 0.393701
        }
        set{
            cm = newValue
        }
    }
}
var lengthCm = Conversion()
print(lengthCm.inchConversion)

lengthCm.inchConversion = 100
print(lengthCm.cm)
print(lengthCm.inchConversion)

계산 속성은 구현방식에 따라 축약 표현이 가능합니다.

✅ get{ }만 사용할 때는 get{ } 키워드를 생략

var x: Int = 1
var DoubleX: Int{
    get{
        return x*2
    }
}

get{ }만 사용할 때는 아래와 같은 표현도 가능합니다.

var x: Int = 1
var DoubleX: Int{ return x*2 }

✅ set(새로운 값){ } 을 사용할 때 새로운 값은 애플에서 제공하는 키워드인 "newValue"를 사용하여 생략할 수 있습니다.

struct Conversion{
    var cm: Double = 1
    var inchConversion: Double{
        get{
            return cm * 0.393701
        }
        set(inchConversion){
            cm = inchConversion
        }
    }
}

struct Conversion{
    var cm: Double = 1
    var inchConversion: Double{
        get{
            return cm * 0.393701
        }
        set{
            cm = newValue
        }
    }
}

📌 4. 속성 감시자(Property Observers)

속성 감시자(Property Observers)는 프로퍼티의 값이 새로 할당받을 때마다 작동되는 특징을 가지고 있습니다.
속성 감시자의 종류는 willSet(newValue){ }과 didSet(oldValue){ }이 있습니다.

✅ willSet(newValue){ }

willSet은 새로 할당될 값이 메모리에 할당되기 직전에 작동하는 함수입니다.

아직 메모리 공간에 값이 할당되지 않았기 때문에 변경될 값은 새로운 값이기 때문에 애플에서 제공하는 newValue 키워드를 사용하여 축약 표현도 가능합니다.

struct Balance{
    var money: Int{
        willSet(newmoney){
            print("잔액이 \(money)에서 \(newmoney)으로 변경되었습니다.")
        }
    }
    init(money: Int){
        self.money = money
    }
}

var kim = Balance(money: 25000)
kim.money = 15000    //25000 -> 15000으로 새로운 값 할당

/*
 출력 결과
잔액이 25000에서 15000으로 변경되었습니다.
*/

newValue를 사용한 축약표현

struct Balance{
    var money: Int{
        willSet{
            print("잔액이 \(money)에서 \(newValue)으로 변경되었습니다.")
        }
    }
    init(money: Int){
        self.money = money
    }
}

var kim = Balance(money: 25000)
kim.money = 15000    //25000 -> 15000으로 새로운 값 할당

/*
 출력 결과
잔액이 25000에서 15000으로 변경되었습니다.
*/

✅ didSet(oldValue){ }

didSet은 새로 할당될 값이 메모리에 할당된 직후 작동하는 함수입니다.

메모리에 새로운 값이 이미 할당되었기 때문에 예전에 사용했던 값은 애플에서 제공하는 oldValue 키워드를 활용하여 사용할 수 있습니다. (oldValue 키워드를 사용하여 축약 표현이 가능)

struct Balance{
    var money: Int{
        didSet(newmoney){
            print("잔액이 \(newmoney)에서 \(money)으로 변경되었습니다.")
        }
    }
    init(money: Int){
        self.money = money
    }
}

var kim = Balance(money: 25000)
kim.money = 15000    //25000 -> 15000으로 새로운 값 할당

/*
 출력 결과
잔액이 25000에서 15000으로 변경되었습니다.
*/

oldValue를 사용한 축약표현

struct Balance{
    var money: Int{
        didSet{
            print("잔액이 \(oldValue)에서 \(money)으로 변경되었습니다.")
        }
    }
    init(money: Int){
        self.money = money
    }
}

var kim = Balance(money: 25000)
kim.money = 15000    //25000 -> 15000으로 새로운 값 할당

/*
 출력 결과
잔액이 25000에서 15000으로 변경되었습니다.
*/

📌 5. 타입 속성(Type Properties)

타입 속성(Type Properties)에 저장된 값을 인스턴스가 사용하는 것이 아닌, 타입 자체가 사용하는 프로퍼티입니다. (클래스, 구조체가 사용하는 프로퍼티)
(주로 인스턴스의 공통적인 특징 또는 고유 번호 등을 저장할 때 많이 사용)
선언하는 방법은 변수(상수) 앞에 "static" 키워드 또는 "class" 키워드를 작성하여 선언합니다.
static 키워드는 클래스/구조체 모두 사용 가능하지만, class키워드는 클래스에서만 사용 가능합니다. (class는 클래스에서 메서드를 상속할 때 주로 사용)
타입 속성으로 선언된 프로퍼티는 초깃값이 있어야 합니다. (필수)
타입 속성을 사용하지 않으면 메모리에 할당되지 않으며, 타입 속성에 접근할 때만 메모리에 할당됩니다. (지연 저장 속성의 특징을 가지고 있음)

struct Cat{
    static let breed = "고양이"
    var name: String
    init(name: String){
        self.name = name
    }
}

var cat1 = Cat(name: "나비")
var cat2 = Cat(name: "치즈")
cat1.name   //나비
cat2.name   //치즈

Cat.breed   //고양이