Fotografický magazín "iZIN IDIF" každý týden ve Vašem e-mailu.
Co nového ve světě fotografie!
Zadejte Vaši e-mailovou adresu:
Kamarád fotí rád?
Přihlas ho k odběru fotomagazínu!
Zadejte e-mailovou adresu kamaráda:
Informace
Nastal čas na kakao - Kopírování objektů
3. června 2004, 00.00 | Na náš minulý rozbor toho, jak objekty vznikají a zanikají, je vhodné navázat popisem koncepce měnitelných a neměnných objektů. To proto, že kromě dosud popsaných postupů objekty mohou také vznikat jako kopie objektů dříve existujících – a způsob, jak jsou tyto kopie vytvářeny, je s koncepcí měnitelných a neměnných objektů úzce svázán.
Na náš minulý rozbor toho, jak objekty vznikají a zanikají, je vhodné navázat popisem koncepce měnitelných a neměnných objektů. To proto, že kromě dosud popsaných postupů objekty mohou také vznikat jako kopie objektů dříve existujících – a způsob, jak jsou tyto kopie vytvářeny, je s koncepcí měnitelných a neměnných objektů úzce svázán.
Vlastní kopírování
Ne všechny objekty prostředí Cocoa kopírování podporují: pro některé objekty by to totiž nemělo rozumný smysl – třeba taková instance třídy NSApplication, jež je v každé aplikaci jen jediná a zprostředkuje komunikaci kódu aplikace s operačním systémem: jaký by mělo smysl vytvářet její kopii?
Objective C proto pro kopírování využívá nám již známých protokolů: existuje protokol NSCopying, jemuž odpovídají právě ty třídy, jejichž instance lze kopírovat. Kromě toho existuje protokol NSMutableCopying, jemuž odpovídají právě ty třídy, od jejichž instancí lze vytvářet měnitelné kopie.
Kopii instance vytvoříme obecně tak, že jí pošleme zprávu copy:
NSString *novyString=[existujiciString copy];
Zpráva copy ovšem spolu s kombinací alloc/init patří mezi těch několik málo výjimek, jež sice vytvoří nový objekt, avšak nezařadí jej do správy paměti, takže garbage collector jej automaticky neuvolní.
To je proto, že v praxi zprávu copy daleko nejčastěji užíváme na místě zprávy retain v případech, kdy si chceme uchovat vlastní kopii daného objektu, nadále nezávislou na originálu:
@interface Foo:NSObject { NSString *title; ... } @end @implementation Foo ... -(void)setTitle:(NSString*)newTitle { [title autorelease]; title=[newTitle copy]; } ...
Pokud bychom zde použili – podobně jako v příkladu v minulém dílu – "title=[newTitle retain];", vystavovali bychom se nebezpečí, že po chvíli obsah předaného objektu někdo nějak změní; změnil by se tak tedy i náš titulek (neboť s využitím zprávy retain sdílíme týž objekt, který nám odesilatel zprávy předal v parametru newTitle). To patrně nechceme!
(V minulém dílu toto risiko nehrozilo prostě proto, že textový objekt jsme tam nedostali od někoho jiného, ale sami jsme si jej vytvořili. Nebyl tedy sdílený, takže nám jej nikdo jiný změnit nemohl.)
V ostatních případech – pokud vytváříme kopii, již nechceme držet po delší dobu, než po dobu trvání dané metody – ovšem musíme explicitně použít zprávu autorelease:
... NSArray *a=[[jinePole copy] autorelease]; // nějaké použití 'a' // dále již 'a' potřebovat nebudu ...
Analogicky jako zpráva copy funguje i zpráva mutableCopy; ta však vždy vytvoří kopii, jejíž obsah můžeme měnit:
... NSMutableArray *ma=[[pole mutableCopy] autorelease]; [ma addObject:jinyObjekt]; // nemění 'pole', jen mou kopii ...
Měnitelné a neměnné objekty
Základní myšlenkou koncepce měnitelných a neměnných objektů je dosažení vyšší efektivity (nejen, ale především) při kopírování objektů, aniž by se o to programátor musel vědomě starat.
Uvědomme si, že případů, kdy je zapotřebí vytvářet kopie objektů, je mnoho: služby "undo" v grafickém uživatelském rozhraní obvykle využívají kopií; naprosto klasickým případem je jeden z nejužívanějších objektů vůbec – hashovaná tabulka. Ukažme si právě tento případ: hashovaná tabulka v Cocoa samozřejmě je k dispozici, odpovídající třída se jmenuje NSDictionary. Základní dvě zprávy, jež nabízí, jsou
-(void)setObject:anObject forKey:aKey; -objectForKey:aKey;
První z nich uloží do tabulky dvojici <klíč, hodnota>, druhá vyhledá hodnotu k zadanému klíči (v čase nezávisejícím na počtu hodnot v tabulce). Je zřejmé, že má-li hashovaná tabulka být konsistentní, musí interně udržovat ne sdílené odkazy na klíče, ale jejich neměnné kopie — kdyby v tabulce byly jen odkazy na klíče, mohl by se objekt reprezentující klíč kdykoli změnit, aniž by se o tom tabulka vůbec dozvěděla; hashovaná tabulka by se v takovém případě stala samozřejmě nekorektní. Implementace metody setObject:forKey: tedy musí vypadat přibližně takto:
-(void)setObject:anObject forKey:aKey { id myKey=[aKey copy]; // potřebuji vlastní neměnnou kopii id myVal=[anObject retain]; // hodnota se může klidně měnit (ale nesmí zaniknout) zaradit_do_tabulky(myKey,myVal); // hashováním se zde zabývat nepotřebujeme }
Za těchto podmínek bude hashovaná tabulka pracovat korektně, ovšem zaplatíme za to zpomalením programu a větší spotřebou paměti: každý klíč vkládaný do tabulky se musí nejprve zkopírovat — to znamená, že potřebujeme dvakrát tolik paměti a navíc se program musí zdržovat kopírováním dat objektu. Přitom to v řadě případů není doopravdy zapotřebí: velmi často (v praxi téměř vždy, protože klíče obvykle bývají textové konstanty, tedy statické, neměnné objekty třídy NSString) se obsah klíčů stejně nikdy nebude měnit; hashovaná tabulka by si tedy ve skutečnosti vlastně mohla udržovat pouze odkazy na klíče — musela by ale 'vědět', které klíče se ještě mohou měnit a které ne.
Objektové prostředí se svým polymorfismem ovšem nabízí samozřejmé a velmi elegantní řešení: hashovaná tabulka samozřejmě nemůže vědět které objekty se budou měnit; mohou to ale vědět tyto objekty samy! Stačí zavést pro každý typ objektů pro který to dává rozumný smysl dvě třídy: třídu neměnných objektů a třídu objektů. které se mohou měnit — např. NSString (neměnné) a NSMutableString (měnitelné). Neměnné objekty pak nemusí nikdy vytvářet kopie; jejich metoda copy může být implementována nějak takto:
@implementation NSString // princip ... -copy { return [self retain]; } ... @end
Nyní funguje vše automaticky s nejvyšší možnou efektivitou: vkládáme-li do hashované tabulky klíč, který se nikdy nebude měnit, hashovaná tabulka bude udržovat pouze odkaz — žádná paměť navíc, žádná ztráta času, nic se nekopíruje. Pouze v případě že jako klíč využijeme měnitelný objekt — např. NSMutableString — kopie se vytvoří; v takovém případě se tomu ale stejně nemůžeme vyhnout. Navíc tentýž trik automaticky funguje nejen v hashované tabulce, ale kdekoli, kde potřebujeme okamžité kopie objektů: připravujeme např. program, který si pro funkci 'undo' musí zapamatovat momentální stav svých datových objektů? Nic jednoduššího — prostě vytvoříme kopie všech objektů reprezentujících data tak, že jim pošleme zprávu copy. Díky koncepci měnitelných a neměnných objektů nemusíme zkoumat, která data se mohou měnit, a která ne — fakticky se zkopírují jen ta, kterých se změny mohou týkat.
Cocoa proto v řadě případů nabízí dvojice tříd NSXXX a NSMutableXXX, kde objekty třídy NSXXX se nemohou měnit, zatímco objekty třídy NSMutableXXX ano (je tomu tak mimochodem i u třídy NSDictionary — metoda setObject:forKey: je tedy samozřejmě k dispozici pouze u objektů třídy NSMutableDictionary). Třída NSMutableXXX je vždy dědicem třídy NSXXX; měnitelné objekty tedy 'umějí' všechno, co neměnné, a navíc jsou schopny změn. Pošleme-li kterémukoli objektu třídy NSXXX zprávu copy, nevytvoří se žádná kopie; namísto toho získáme další sdílený odkaz na tentýž (neměnný) objekt. Pošleme-li však zprávu copy objektu třídy NSMutableXXX, dostaneme nový objekt třídy NSXXX, který bude obsahovat neměnnou kopii momentálního stavu původního objektu.
Složené objekty
Uvědomme si, že koncepce měnitelných a neměnných objektů zaručuje co nejefektivnější zkopírování i u složených objektů. Jako příklad vezměme objekt třídy NSMutableArray, který reprezentuje pole libovolných dalších objektů, do nějž můžeme přidávat nebo z něj odebírat (odpovídající neměnná třída NSArray reprezentuje pole, jehož obsah je při vytvoření pevně dán a nadále jej již nemůžeme měnit).
Obrázek ukazuje příklad objektu třídy NSMutableArray, obsahujícího (odkazy na) jak měnitelné, tak neměnné objekty. Vyžádáme-li si nyní zprávou copy neměnnou kopii momentálního stavu tohoto objektu, musí se vytvořit nový objekt třídy NSArray (protože existující objekt mutableArray je měnitelný) se stejným (a neměnným) obsahem. Nový objekt tedy může se starým sdílet odkazy na neměnné vnořené objekty, ale musí obsahovat vlastní (neměnné) kopie objektů, které byly měnitelné. Výsledek bude vypadat takto:
Čas od času bychom mohli potřebovat 'přece jenom' změnit neměnný objekt. Doslova to samozřejmě není možné — tím bychom celou koncepci měnitelných a neměnných objektů postavili na hlavu; můžeme si však pomocí zprávy mutableCopy vyžádat vytvoření vlastní měnitelné kopie objektu. Obsahuje-li původní objekt vnořené objekty, bude jeho měnitelná kopie obsahovat (odkazy na) tytéž objekty, a to i v případě, že tyto objekty samy jsou neměnné (chceme-li např. vytvořit měnitelnou kopii pole, je to proto, abychom do něj mohli přidávat nebo z něj odebírat další objekty; ne proto, abychom mohli měnit objekty v něm obsažené):
Koncepce měnitelných a neměnných objektů je velmi silným a šikovným mechanismem, který kromě výrazného zvýšení efektivity programů dokáže i omezit programátorské chyby: používáme-li neměnný objekt, nemůže se nám omylem stát, že jej některý úsek programu změní (z podobného důvodu byl např. v ANSI C zaveden modifikátor const). Rozdělení měnitelných a neměnných objektů na samostatné třídy NSXXX a NSMutableXXX navíc umožňuje některé takové chyby odchytit již při překladu — pokusíme-li se např. staticky typovanému objektu třídy NSArray poslat zprávu addObject: překladač vydá varování.
Obsah seriálu (více o seriálu):
- Nastal čas na kakao...
- Tak nejdřív kakao ochutnáme...
- Programovací jazyk C: velmi, velmi stručně
- Objective C: to si vysvětlíme podrobněji
- Co jsme si o Objective C ještě neřekli...
- Nastal čas na kakao - Vznik a zánik objektů
- Nastal čas na kakao - Kopírování objektů
- Nastal čas na kakao - Skryté podtřídy
- Nastal čas na kakao - Základní služby objektů
- Nastal čas na kakao - Jak správně psát v Objective C
- Nastal čas na kakao - Jak správně importovat
- Nastal čas na kakao - Podtřídy, delegáti, vkládání, jak se to rýmuje?
- Nastal čas na kakao - Využití kategorií namísto dědičnosti
- Nastal čas na kakao - Vkládání objektů a přesměrování zpráv
- Nastal čas na kakao - Inicializace a rušení objektů
- Nastal čas na kakao - Metody initWith... a designovaný inicializátor
- Nastal čas na kakao - Inicializace: tipy a triky
- Nastal čas na kakao - Accesory: přístup k proměnným instancí
- Nastal čas na kakao - Šedá je teorie, zelený je strom života...
- Nastal čas na kakao - Více o XCode: inspektory
- Nastal čas na kakao - Aplikace RSS2: datový model
- Nastal čas na kakao - Aplikace RSS: implementace datového modelu
- Nastal čas na kakao - Aplikace RSS: parsování XML
- Nastal čas na kakao - Interface Builder a uživatelské rozhraní
- Nastal čas na kakao - Interface Builder: atributy objektů
- Nastal čas na kakao - Interface Builder: atributy objektů
- Nastal čas na kakao - Druhý kontrolér a dokončení aplikace
- Nastal čas na kakao - Drobná vylepšení a zdokonalení...
- Nastal čas na kakao - Ladění
- Nastal čas na kakao - Třídy Foundation Kitu
- Nastal čas na kakao - Třídy Foundation Kitu (2)
- Nastal čas na kakao - Textové řetězce: NS(Mutable)String
- Nastal čas na kakao - Čísla, binární data a další...
- Nastal čas na kakao - Archivace objektů
- Nastal čas na kakao - Trocha magie, aneb distribuované objekty
- Nastal čas na kakao - Málem bychom zapomněli: NSAutoreleasePool
- Nastal čas na kakao - Zpracování výjimek: NSException
- Nastal čas na kakao - NSInvocation a černá magie
- Nastal čas na kakao - Kakao v Tygrovi
- Nastal čas na kakao - Notifikace: nepřímé předávání zpráv
- Nastal čas na kakao - NSUserDefaults
- Nastal čas na kakao - Co nového ve Foundation Kitu
- Nastal čas na kakao – s Intelem, s Intelem, jedeme do...
- Co nového v Xcode
- Začínáme s AppKitem
- Jak MVC v Kakau vypadá doopravdy?
- Jak MVC v Kakau vypadá doopravdy: dokončení
- Přehled tříd AppKitu
- Nastal čas na kakao - Přehled tříd AppKitu 2
- Přehled tříd AppKitu 3: zbývající třídy GUI
- Přehled tříd AppKitu 4: textový systém
- Nastal čas na kakao - Přehled tříd AppKitu 5: hlavně grafika
- Přehled tříd AppKitu 6: dokumentový systém
- Přehled tříd AppKitu 7: dokončení
- Pojmenované vlastnosti objektů
- Pojmenované vlastnosti objektů: implementace
- Pojmenované vlastnosti objektů: relace 1:N
- Pojmenované vlastnosti objektů: řazení jmen a agregační funkce
- Sledování změn objektů
- Sledování změn objektů – ukázka
- Sledování změn objektů – zdrojový kód
- Sledování změn objektů: kód modelu
- Sledování změn objektů: přímý přístup
- Kontroléry a vazby
- Vázání vazeb
- Další vazby s jednoduchým kontrolérem
- Implementace a použití převodu hodnot
- Validace hodnot
- Validace a chyby, a jedna hezká vazba...
- Práce s polem objektů
- Základní vazby NSArrayControlleru
- Převodníky, přepínače, placeholdery
- Mírná vylepšení v mezích zákona
- Objective C 2.0 - novinky z Leoparda
- NSTreeController
- Programování v Cocoa - Pár tipů a triků
- Programování v Cocoa - Základy kreslení
- Kterak nakreslit modrý obdélník...
- Další služby pro kreslení
- Obrázky a písmenka...
- Události a myš
- Lepší práce s myší
- Události klávesnice
- Input Management
- Příkazy a schránka
- Další události
- Táhni a padni
- Byli jsme na tahu; nyní padneme.
- Zvolme si, jak vhodit
- Drobnosti a chybičky
- Speciální případy tahání či házení
- Kterak táhnout něco, co neexistuje?
- Jak na sítě...
- NSURLConnection
- Safari za minutu
- Služby WebKitu
- Kakao v Leopardu
- Druhé Objective C
- Druhé Objective C: různé drobnosti
- Druhé Objective C: kategorie a protokoly
- Druhé Objective C: nový příkaz cyklu
- Druhé Objective C: atributy a accesory
- Druhé Objective C: atributy a accesory
- 64 je dvakrát 32
- Ubicumque dulce est, ibi et acidum invenies...
- Irbis: že prý žádné novinky?
- Blok sem, blok tam, nám už je to všechno jasné...
- Bloky jsou i v AppKitu
- Irbis a Foundation Kit
- Kde jsou má data?
- Kde jsou má data? V NSCache!
- Soubor, jméno, URL, jak se to rýmuje...
- Další podpora NSURL
- Zabíjení!
- A máme tady i...OS!
- Systémové prvky GUI
- Programování pro iOS 1. díl - Rozdíly mezi "i" a "Mac"
- Programování pro iOS - 2. Začínáme programovat
- Programování pro iOS - 3. základní ovladače a propojení GUI s kódem
- Programování pro iOS - 4. Varovná hlášení
- Programování pro iOS - 5. Rámce a jejich řídicí objekty
- Programování pro iOS - 6. Ukládání dat
- Programování pro iOS - 7. Správa paměti a starý restík
- Programování pro iOS - 8. Dokončení aplikace
- Programování pro iOS - 9. Jak dostat aplikaci do iPhone
- Programování pro iOS - 10. Instalace aplikace do cizího iPhone
- Programování pro iOS - 11. Jak dostat aplikaci do libovolného iPhone
- Programování pro iOS - 12. Touching!
- Programování pro iOS - 13. Kreslíme na iPhone
- Programování pro iOS - 14. Udělejme gesto
- Programování pro iOS - 15. Další gesta
- Programování pro iOS - 16. Více prstů, více zábavy
- Programování pro iOS - 17. Podpora standardních gest
- Programování pro iOS - 18. Recognizery v iOS
- Programování pro iOS - 19. Další standardní recognizery
- Programování pro iOS - 20. Co nového v iOSu
- Programování pro iOS - 21. "Multitasking"
- Programování pro iOS - 22. Nulla est honesta avaritia nisi temporis
- Programování pro iOS - 23. Jak se aktivovat, jsme-li v pozadí
- Programování pro iOS - 24. Zbývající drobnosti
- Programování pro iOS - 25. Řídicí objekty rámců
- Programování pro iOS - 26. Jak se dělá UIViewController
- Programování pro iOS - 27. Kde vzít rámce
- Programování pro iOS - 28. Základní služby
- Programování pro iOS - 29. Práce s rámci
- Programování pro iOS - 30. Rotace zařízení
- Programování pro iOS - 31. Správa paměti v rámcích
- Programování pro iOS - 32. Řídicí objekt pro tabulky
- Programování pro iOS - 33. Řídicí objekt pro strom
- Programování pro iOS - 33. Více o UINavigationControlleru
- Programování pro iOS - 35. Ještě jednou UINavigationController
- Programování pro iOS - 36. Po navigátoru taby
- Programování pro iOS - 37. Více o UITabBarControlleru
- Programování pro iOS - 38. Dokončení UITabBarControlleru
- Programování pro iOS - 39. UIPopoverController
- Programování pro iOS - 40. Další triky UIPopoverControlleru
- Programování pro iOS - 41. Zbývající služby UIPopoverControlleru
- Programování pro iOS - 42. UISplitViewController
- Programujeme v
iTunesXcode 4 - Programování pro iOS - 44. Předvolby Xcode 4
- Programování pro iOS - 45. Práce v Xcode 4
- Xcode 4: projekt a cíle
- Xcode 4: práce s cíli
- Xcode 4: Build Settings
- Xcode 4: Build Phases
- Xcode4: Build Phases podruhé
- Xcode 4: Co jsou to Build Rules?
- Xcode4: taje editoru
- Xcode4: automatické doplňování v editoru
- XIBy chyby
- Více o XIBech
- Editor XIBů
- Inspektory pro XIBy
- Vazby mezi objekty v XIBech
- Vazby mezi objekty v kódu
- Paletky Xcode pro XIBy
- Xcode 4: levý sloupec
- Xcode 4: okno Organizer
- Xcode 4: okno Organizer, část druhá
- Xcode 4: co je to Workspace?
- Xcode 4: základy schémat
- Xcode 4: akční schémata
Diskuse k článku
Vložit nový příspěvek Sbalit příspěvky
|
|
|
|
|
|
|
|
|
|