Pověz mi o mechanismu optimalizace kopírování v iOS…

Optimalizační mechanismus kopírování v iOS a macOS, často spojený s použitím struktury Copy-on-Write (CoW) nebo s významovou semantikou, umožňuje vyhnout se zbytečnému kopírování dat při předávání struktur nebo tříd s významovou semantikou, jako jsou pole, slovníky, řetězce a dokonce i vlastní struktury, pokud implementují protokol Equatable a Hashable (ne striktně, ale typický případ).

Podstata CoW:

Při vytváření kopie struktury (například při přiřazení jedné proměnné jiné nebo při předání do funkce hodnotou) nedojde k faktickému kopírování dat. Obě proměnné odkazují na stejná data v paměti. Čítač odkazů na data se zvýší.
Kopírování je odloženo, dokud jedna z kopií nepokusí změnit data.
Teprve při změně jsou data skutečně zkopírována a změněna nová kopie. Původní kopie nadále odkazuje na původní data (dokud má alespoň jednoho vlastníka).

Výhody:

Snížení režijních nákladů na operace kopírování, zejména u velkých objemů dat (pole, řetězce).
Snížení využití paměti, protože více entit může sdílet stejná data.
Zvýšení výkonu při předávání struktur s významovou semantikou.

Příklady, kde je CoW aktivně používáno:

NSArray, NSDictionary, NSString: V Objective-C tyto třídy používají CoW pro optimalizaci.
Array, Dictionary, String ve Swift: Tyto základní typy ve Swift mají významovou semantiku a používají CoW.

var array1 = [1, 2, 3]
var array2 = array1 // Nedochází k kopírování, obě proměnné odkazují na stejná data

array2.append(4) // Dochází k reálnému zkopírování dat pro array2, poté append
// Nyní array1 = [1, 2, 3] a array2 = [1, 2, 3, 4]

Nevýhody:

Malé režijní náklady na kontrolu nutnosti kopírování při každé změně.
Možnost skrytého kopírování, které může ovlivnit výkon na nečekaných místech.

Je důležité si uvědomit, že CoW funguje efektivně u struktur s významovou semantikou (struct, enum). Třídy mají referenční semantiku, a při přiřazení nebo předání instance třídy se kopíruje pouze odkaz, nikoli data objektu.

Ve Swift většina vestavěných kolekcí a řetězců funguje s významovou semantikou a používá CoW na pozadí. Při vytváření vlastních struktur obsahujících referenční typy (například třídu) bude CoW aplikováno na samotnou strukturu, nikoli na obsah referenčního typu. Změna vlastnosti, která je referenčním typem uvnitř struktury, nezpůsobí CoW pro celou strukturu, ale může vyžadovat CoW pro samotný referenční typ, pokud ho podporuje.

Pro ruční implementaci CoW ve vlastních datových typech v Swift lze použít kombinaci referenčního typu pro ukládání dat (například třída s vnitřní strukturou) a kontroly unikátnosti odkazu před změnou (například isKnownUniquelyReferenced).

class Container<T> {
    var value: T

    init(_ value: T) {
        self.value = value
    }
}

struct CustomStruct {
    private var _container: Container<[Int]>

    var data: [Int] {
        get { return _container.value }
        set {
            // Kontrola, zda je kontejner unikátně odkazován
            // Pokud ne, vytvoříme novou kopii kontejneru a dat
            if !isKnownUniquelyReferenced(&_container) {
                _container = Container(newValue)
            } else {
                // Pokud ano, měníme data přímo v aktuálním kontejneru
                _container.value = newValue
            }
        }
    }

    init(data: [Int]) {
        _container = Container(data)
    }
}

var s1 = CustomStruct(data: [1, 2, 3])
var s2 = s1 // CoW: _container v s1 a s2 nyní odkazují na stejný Container

s2.data.append(4) // Setter pro data.
                   // isKnownUniquelyReferenced pro _container v s2 bude false (protože na něj odkazuje i s1).
                   // Vytvoří se nový Container s kopií [1, 2, 3, 4], s2._container na něj odkazuje.
                   // s1._container stále odkazuje na starý Container s [1, 2, 3].

print(s1.data) // Výstup: [1, 2, 3]
print(s2.data) // Výstup: [1, 2, 3, 4]

Pověz mi o mechanismu optimalizace kopírování v iOS.