В чем различия между типами диспетчеризации?

Различия между типами диспетчеризации (Dynamic vs Static)

Диспетчеризация — это механизм, который определяет, какой метод вызывается в runtime. В Swift существует два основных типа: статическая и динамическая диспетчеризация. Это критически важно для производительности и дизайна.

1. Static Dispatch (Статическая диспетчеризация)

Определяется в compile-time:

struct User {
    func getName() -> String {
        return "John"
    }
}

let user = User()
user.getName()  // Компилятор ТОЧНО ЗНАЕТ, какой метод вызвать

Характеристики:

• Адрес функции известен во время компиляции
• Компилятор может в inline код функции (встраивает в вызывающий код)
• Максимальная производительность
• Меньше overhead
• Используется для struct, final class, глобальных функций

Пример с structs:

struct Point {
    var x: Int
    var y: Int
    
    func distance() -> Double {
        return sqrt(Double(x * x + y * y))
    }
}

let p = Point(x: 3, y: 4)
p.distance()  // Static dispatch — нет overhead

2. Dynamic Dispatch (Динамическая диспетчеризация)

Определяется в runtime:

class Animal {
    func speak() {
        print("Some sound")
    }
}

class Dog: Animal {
    override func speak() {
        print("Woof")
    }
}

let animal: Animal = Dog()
animal.speak()  // Runtime: КАКОЙ класс? Dog или Animal?

Как это работает:

• Каждый объект имеет указатель на Virtual Method Table (VMT)
• При вызове метода ищется в таблице нужная реализация
• Это добавляет overhead (extra lookup)
• Компилятор не может inlining

Пример с иерархией:

class Vehicle {
    func drive() {
        print("Driving vehicle")
    }
}

class Car: Vehicle {
    override func drive() {
        print("Driving car")
    }
}

class Truck: Vehicle {
    override func drive() {
        print("Driving truck")
    }
}

func startTrip(vehicle: Vehicle) {
    vehicle.drive()  // Dynamic dispatch: какой класс вызова?
}

startTrip(vehicle: Car())    // Вызовет Car.drive()
startTrip(vehicle: Truck())  // Вызовет Truck.drive()

3. Protocol Dispatch (Диспетчеризация через протоколы)

Наиболее сложный случай:

protocol Drawable {
    func draw()
}

struct Circle: Drawable {
    func draw() {
        print("Drawing circle")
    }
}

struct Square: Drawable {
    func draw() {
        print("Drawing square")
    }
}

func render(drawable: Drawable) {
    drawable.draw()  // Какая реализация? Зависит от runtime типа
}

Механизм:

• Использует Protocol Witness Table (PWT)
• Ищет нужную реализацию в таблице
• Если struct — может быть оптимизирована (inline)
• Если class — как классическая динамическая диспетчеризация

4. Сравнительная таблица

5. Практический пример: производительность

import Foundation

struct StaticPoint {
    var x: Double
    var y: Double
    
    func distanceToOrigin() -> Double {
        return sqrt(x * x + y * y)
    }
}

class DynamicPoint {
    var x: Double
    var y: Double
    
    init(x: Double, y: Double) {
        self.x = x
        self.y = y
    }
    
    func distanceToOrigin() -> Double {
        return sqrt(x * x + y * y)
    }
}

// Benchmark
let iterations = 1_000_000

var start = Date()
for i in 0..<iterations {
    let p = StaticPoint(x: Double(i), y: Double(i))
    _ = p.distanceToOrigin()  // Static dispatch — очень быстро
}
print("Struct: \(Date().timeIntervalSince(start))s")

start = Date()
for i in 0..<iterations {
    let p = DynamicPoint(x: Double(i), y: Double(i))
    _ = p.distanceToOrigin()  // Dynamic dispatch — медленнее
}
print("Class: \(Date().timeIntervalSince(start))s")

Результат: Struct примерно в 2-3 раза быстрее для простых операций.

6. Когда использовать что

Используй Static (struct, final class): ✅ Простые типы данных (Point, Color, Size) ✅ Когда не нужно наследование ✅ Когда важна производительность ✅ Value semantics (копирование при присвоении)

Используй Dynamic (class с наследованием): ✅ Полиморфные иерархии (Vehicle → Car → SportsCar) ✅ Когда нужна reference semantics ✅ Когда нужна идентичность объекта ✅ UIViewController, NSObject и его подклассы

Используй Protocol Dispatch: ✅ Когда нужна абстракция без наследования ✅ Когда разные типы реализуют один интерфейс ✅ Dependency injection через протоколы

7. Оптимизация диспетчеризации

Final keyword:

class DataManager {
    final func fetchData() {  // Компилятор знает: это не переопределится
        // Может быть inlined
    }
}

Whole Module Optimization:

• В Build Settings: Optimization Level → Whole Module Optimization
• Компилятор видит весь модуль и может применить агрессивные оптимизации

Понимание диспетчеризации — это ключ к написанию эффективного Swift кода. Правильный выбор влияет и на производительность, и на архитектуру приложения.