Static Dispatch vs Dynamic Dispatch

Static Dispatch ,  Dynamic Dispatch

Static Dispatch

컴파일시 호출될 함수를 결정하기에 성능상 이득

Dynamic Dispatch

런타임에 호출될 함수를 결정하기에 성능상 손해

 

Class ->  Dynamic Dispatch 

이유 ovveride 를 통해 함수가 변경 될 수 있기 때문에

 

Struct -> Static Dispatch

이유 ovveride 를 통해 함수가 변경 될 수 없기에 항상 동일한 함수가 호출

 

Protocol -> Dynamic Dispatch

이유 해당 프로토콜을 선언을 해주는곳에서 각각 다른 함수로 동작하기에 알 수 없음

 

자세한 예제들은 아래의 코드를 보면서 하나씩 진행해보면 좋습니다!

 

import Foundation

protocol commomProtocol {
    func A()
}


extension commomProtocol{
    func A(){
        print("AAAA")
    }
}
//Static Dispatch
//struct 는 상속 X ovveride 가 안되기때문
struct StructTestA {
    var a : Int = 0
    var b : Int = 0
    
    func A(){
        
    }
}
//Static Dispatch
extension StructTestA{
    func B(){
        
    }
}
//Dynamic Dispatch
class Human {
    func sayHello() {
        print("Hello Human!")
    }
}
//Static Dispatch
extension Human {
    func sayHo() {
        print("Ho~~")
    }
}

//Value Type에서의 Dispatch
//protocl
//Dynamic Dispatch
struct StructTestB : commomProtocol {
   
}
//struct는 상속을 받을 수 없음
//struct StructTestC : StructTestA {
//
//}

//Dynamic Dispatch
//항상이 불린다는 보장이없기에
// func sayHello() {
//print("Hello Human!")
//}

protocol HumanB {
    func sayHello()
}
 
extension HumanB {
    func sayHello() {
        print("Hello Human!")
    }
}
 
class Student: HumanB { }

class Teacher: HumanB {
    func sayHello() {
        print("Hello Teacher!")
    }
}


protocol HumanC { }
 
extension HumanC {
    func sayHello() {
        print("Hello Human!")
    }
}
 
class StudentC: HumanC { }

class TeacherC: HumanC {
    var a : Int = 0
    
    func sayHello() {
        print("Hello Teacher!")
    }
}
//항상 확장시켜적용한
//func sayHello() {
//    print("Hello Human!")
//}
//함수가 호출되기에 static dispatch
//var sodeul: Human = Student.init()
//sodeul.sayHello()       // Hello Human!
//
//sodeul = Teacher.init()
//sodeul.sayHello()       // Hello Human!