- Andrea Picchi - Objective-C 2 · Programmare con Objective-C per iOS e OS X è nato con...

Objective-C 2.0per iOS e OS X

BESTSELLERBESTSELLER

2a EDIZIONE

2a EDIZIONE

Sintassi, principi e concetti della programmazione basata sull'Objective-C >>

Polimorfismo e binding dinamico, categorie e protocolli >>

Preprocessore e compilatore >>

Programmazione concorrente e blocchi >>

- Andrea Picchi -

Objective-C 2.0per iOS e OS X

Seconda edizione

Andrea Picchi

Programmare con Objective-C 2.0 | per iOS e OS X2a edizione

Autore: Andrea Picchi

Collana:

Editor in Chief: Marco AleottiProgetto grafico: Roberta Venturieri

ISBN: 978-88-6895-075-0

Copyright © 2015 LSWR SrlVia Spadolini, 7 - 20141 Milano (MI) - www.edizionilswr.it

Finito di stampare nel mese di gennaio 2015 presso “Rotolito Lombarda” spa, Pioltello (MI)

Nessuna parte del presente libro può essere riprodotta, memorizzata in un sistema che ne permetta l’elaborazione, né trasmessa in qualsivoglia forma e con qualsivoglia mezzo elettronico o meccanico, né può essere fotocopiata, riprodotta o registrata al-trimenti, senza previo consenso scritto dell’editore, tranne nel caso di brevi citazioni contenute in articoli di critica o recensioni.

La presente pubblicazione contiene le opinioni dell’autore e ha lo scopo di fornire informazioni precise e accurate. L’elaborazione dei testi, anche se curata con scrupolosa attenzione, non può comportare specifiche responsabilità in capo all’autore e/o all’edi-tore per eventuali errori o inesattezze.

Nomi e marchi citati nel testo sono generalmente depositati o registrati dalle rispettive aziende. L’autore detiene i diritti per tutte le fotografie, i testi e le illustrazioni che compongono questo libro, salvo quando diversamente indicato.

PrimePagine_ObjectiveC.indd 4 28/01/15 14:05

5

Sommario

INTRODUZIONE ......................................................................................................13

Parte 1 - Concetti fondamentali

1. OBJECTIVE-C 2.0 ...........................................................................................23Storia dell’Objective-C .............................................................................................................24Programmazione orientata agli oggetti ...............................................................................27Che cos’è l’Objective-C .......................................................................................................... 30Tempo di compilazione e tempo di esecuzione .................................................................33Le tre fasi del codice .................................................................................................................33OS X ..............................................................................................................................................35iOS .................................................................................................................................................37Ambienti di sviluppo iOS e OS X ...........................................................................................38Scrivere il primo programma Objective-C .......................................................................... 41Stampare a video valori di variabili ...................................................................................... 46Utilizzare input da tastiera ..................................................................................................... 49Riepilogo ..................................................................................................................................... 50Domande ......................................................................................................................................51Esercizi ..........................................................................................................................................51

2. CLASSI, ISTANZE E MESSAGGI ..................................................................53La relazione tra oggetto, classe e istanza ............................................................................54Creare una classe ......................................................................................................................59Regole e convenzioni sui nomi ...............................................................................................62La sezione @interface ..............................................................................................................65La sezione @implementation .................................................................................................72Metodi con argomenti multipli ..............................................................................................78Estendere la definizione e la dichiarazione di una classe ............................................... 80Il campo di visibilità di una variabile ....................................................................................82Metodi accessori ...................................................................................................................... 89Proprietà e metodi accessori ..................................................................................................93Accedere alle proprietà con la notazione puntata ..........................................................102Accedere alle proprietà con un puntatore ........................................................................103Variabili locali ...........................................................................................................................105La parola chiave static ............................................................................................................109La parola chiave self ................................................................................................................ 112La parola chiave super ............................................................................................................ 115

6

Programmare con Objective-C 2.0 per iOS e OS X

Metodi che dichiarano e ritornano oggetti ........................................................................116La sezione program .................................................................................................................. 121Dichiarazione di un’istanza ................................................................................................... 122Allocazione di un’istanza....................................................................................................... 123Inizializzazione di un’istanza ................................................................................................ 124Inizializzazione personalizzata di un oggetto ................................................................... 125Separare dichiarazione e implementazione ..................................................................... 129Sommario .................................................................................................................................. 135Domande ................................................................................................................................... 135Esercizi ....................................................................................................................................... 135

3. TIPI DI DATO ................................................................................................. 137Numeri a rappresentazione finita ....................................................................................... 138Il sistema numerico binario ..................................................................................................140Algebra di Boole ...................................................................................................................... 143Tipo di dato primitivi e composti ........................................................................................ 147Tipo di dato int .........................................................................................................................148Tipo di dato float .....................................................................................................................149Tipo di dato char ...................................................................................................................... 152Tipo di dato BOOL................................................................................................................... 156Qualificatori .............................................................................................................................. 157Tipo di dato puntatore ........................................................................................................... 158Tipo di dato id .......................................................................................................................... 159Tipo di dato costante ...............................................................................................................161Espressioni Aritmetiche ........................................................................................................ 165Operatori binari ....................................................................................................................... 167Operatore unario .....................................................................................................................169Operatore a bit .........................................................................................................................169Operatore di modulo .............................................................................................................. 172Operatore di assegnamento composto ............................................................................. 174Operatore di cast ..................................................................................................................... 175Tipo di dato enum ...................................................................................................................180Dichiarazione typedef .............................................................................................................181Riepilogo ....................................................................................................................................184Domande ...................................................................................................................................184Esercizi .......................................................................................................................................184

4. CONTROLLO DEL FLUSSO ......................................................................... 185Operatori logici e relazionali.................................................................................................186Costrutto for ............................................................................................................................. 187Costrutto for-in ........................................................................................................................ 195Costrutto while ........................................................................................................................196Costrutto do ............................................................................................................................200Costrutto break .......................................................................................................................202

7

Sommario

Costrutto continue .................................................................................................................203Costrutto if ...............................................................................................................................203Costrutto switch .......................................................................................................................211Costrutto Condizionale ..........................................................................................................216Istruzione goto .........................................................................................................................219Variabili booleane ....................................................................................................................219Sommario .................................................................................................................................. 221Domande .................................................................................................................................. 222Esercizi ...................................................................................................................................... 222

Parte 2 - Concetti avanzati

5. EREDITARIETÀ ..............................................................................................225La radice dell’Objective-C .................................................................................................... 225Relazione superclasse-sottoclasse .................................................................................... 227Ereditare variabili di istanza attraverso l’ereditarietà .................................................... 227Aggiungere variabili di istanza attraverso l’ereditarietà ................................................ 231Aggiungere metodi attraverso l’ereditarietà ................................................................... 233Processo di invocazione di metodi ereditati .................................................................... 234Estendere metodi attraverso l’ereditarietà ...................................................................... 238Sovrascrivere metodi attraverso l’ereditarietà ................................................................ 243La Direttiva @class ................................................................................................................ 245Meta-classi .............................................................................................................................. 249Classi astratte .......................................................................................................................... 251Cluster di classi ....................................................................................................................... 253Sommario ................................................................................................................................. 254Domande .................................................................................................................................. 255Esercizi ...................................................................................................................................... 255

6. CATEGORIE, PROTOCOLLI, ESTENSIONI E RIFERIMENTI ASSOCIATIVI ...................................................................257

Categorie .................................................................................................................................. 258Estensioni ................................................................................................................................. 263Protocolli ................................................................................................................................... 265Adottare e implementare un protocollo ........................................................................... 270Protocolli con protocolli .........................................................................................................275Protocolli come tipo di dato ..................................................................................................275Determinare la conformità a un protocollo ..................................................................... 276Evitare dipendenze circolari di protocolli ......................................................................... 277Riferimenti associativi ........................................................................................................... 278Importazione e collegamento debole di classi ............................................................... 282Sommario .................................................................................................................................284Domande .................................................................................................................................. 285Esercizi ...................................................................................................................................... 285

8


7. PREPROCESSORE E COMPILATORE ...................................................... 287Compilatore .............................................................................................................................288Preprocessore ..........................................................................................................................294La direttiva #import ...............................................................................................................296Direttiva #include ..................................................................................................................298Direttiva #define ....................................................................................................................299Direttiva #undef ......................................................................................................................301Direttiva #line ......................................................................................................................... 302Direttiva #pragma .................................................................................................................. 302Direttiva #error ....................................................................................................................... 303Definizioni avanzate .............................................................................................................. 303Operatori di preprocessore ..................................................................................................305Definizioni condizionali.........................................................................................................305Sommario .................................................................................................................................308Domande ..................................................................................................................................309Esercitazione ...........................................................................................................................309

8. OBJECTIVE-C È ANCHE C .......................................................................... 311Array ........................................................................................................................................... 312Blocchi ........................................................................................................................................ 319Strutture....................................................................................................................................320Unioni ........................................................................................................................................ 322Campi di bit ............................................................................................................................. 325Funzioni ..................................................................................................................................... 328Puntatori ...................................................................................................................................350Operatore sizeof ......................................................................................................................375Relazione tra C e Objective-C ..............................................................................................376Sommario ................................................................................................................................. 378Domande .................................................................................................................................. 379Esercizi ...................................................................................................................................... 379

9. IL SISTEMA A TEMPO DI ESECUZIONE ................................................ 381Comportamento statico ....................................................................................................... 382Comportamento dinamico ...................................................................................................384Typing dinamico ...................................................................................................................... 387Binding dinamico ....................................................................................................................390Polimorfismo .......................................................................................................................... 400Sommario ................................................................................................................................ 400Domande ...................................................................................................................................401Esercitazione ............................................................................................................................401

Parte 3 - Foundation Framework

10. INTRODUZIONE AL FOUNDATION FRAMEWORK ..........................405Che cosa è un Framework? ..................................................................................................405

9

Obiettivi del Foundation Framework .................................................................................406Struttura del Foundation Framework.................................................................................406Cluster di classi .......................................................................................................................407Documentazione del Foundation Framework .................................................................409Sommario ...................................................................................................................................411Domande ...................................................................................................................................412

11. NUMERI, STRINGHE E COLLEZIONI ....................................................... 413Contenere valori: NSValue ....................................................................................................413Stringhe: NSString e NSMutableString ..............................................................................419Insiemi chiave-valore: NSDictionary .................................................................................447Insiemi non ordinati: NSSet e NSMutableSet ................................................................. 455Memorizzare indici: NSIndexSet e NSMutableIndexSet ...............................................461Sommario .................................................................................................................................465Domande ..................................................................................................................................465Esercizi ......................................................................................................................................465

12. FILE E DIRECTORY ....................................................................................... 467Path: NSPathUtilities ............................................................................................................. 467Directory: NSFileManager.....................................................................................................471File: NSFileManager, NSData, NSMutableData e NSFileHandle ........................................................................................................................ 476URL: NSURL .............................................................................................................................487Applicazione: NSBundle .......................................................................................................489Sommario .................................................................................................................................490Domande ..................................................................................................................................490Esercizi ......................................................................................................................................490

13. GESTIONE DELLA MEMORIA ...................................................................491Modello a processi cooperanti............................................................................................ 492Compilazione ed esecuzione ............................................................................................... 493Allocazione della memoria ..................................................................................................494Creazione istanze e gestione della memoria ..................................................................505Manual Reference Counting (MRC) ..................................................................................508Manual Reference Counting (MRC) e Pool Autorelease ............................................. 545Automatic Reference Counting (ARC) ............................................................................. 552Automatic Reference Counting (ARC) e blocco autorelease .....................................590Automatic Garbage Collection (AGC) ..............................................................................591Sommario ................................................................................................................................ 600Domande ................................................................................................................................. 600Esercitazione .......................................................................................................................... 600

14. COPIARE OGGETTI ......................................................................................601Copia superficiale ....................................................................................................................601Copia profonda .......................................................................................................................602

Sommario

10


Implementare il protocollo <NScopying> ........................................................................605Copia superficiale vs copia profonda ................................................................................607Sommario .................................................................................................................................607Domande ..................................................................................................................................608Esercitazione ...........................................................................................................................608

15. ARCHIVIARE DATI ......................................................................................609Lista di proprietà in XML ......................................................................................................609Archivi basati su chiave ......................................................................................................... 612Metodi di codifica e decodifica ............................................................................................614Archivi personalizzati con NSData .....................................................................................619Archivi e copia degli oggetti ................................................................................................ 624Serializzare dati con JSON ................................................................................................... 627Sommario ................................................................................................................................. 633Domande .................................................................................................................................. 633Esercitazione ........................................................................................................................... 633

16. GESTIONE DEGLI ERRORI ED ECCEZIONI ........................................... 635Gestione delle eccezioni ....................................................................................................... 636Gestione degli errori ..............................................................................................................647Sommario .................................................................................................................................650Domande ..................................................................................................................................650Esercitazione ...........................................................................................................................650

17. DESIGN PATTERN ........................................................................................ 651Anatomia di un design pattern ........................................................................................... 652Target-Action...........................................................................................................................666Composite ................................................................................................................................ 667Key-Value Coding ...................................................................................................................669Key-Value Observing ............................................................................................................. 687Thread Pool ..............................................................................................................................696Sommario ................................................................................................................................. 697Domande .................................................................................................................................. 697Esercitazione ........................................................................................................................... 697

Parte 4 - Programmazione concorrente

18. BLOCCHI .........................................................................................................701Puntatori a funzioni ................................................................................................................ 702Blocchi .......................................................................................................................................704Blocchi e variabili .....................................................................................................................716Blocchi e allocazione della memoria ................................................................................. 722Blocchi e gestione della memoria ...................................................................................... 733Riflessioni sui blocchi ............................................................................................................ 750Sommario .................................................................................................................................. 751

11

Domande ................................................................................................................................... 751Esercitazione ........................................................................................................................... 752

19. PROGRAMMAZIONE MULTITHREADING E GRAND CENTRAL DISPATCH ...............................................................753

Programmazione multithreading ....................................................................................... 753Grand Central Dispatch ........................................................................................................ 756Dispatch queue asincrone ................................................................................................... 759Controllo di una dispatch queue ........................................................................................ 769Dispatch Queue sincrone ..................................................................................................... 783Grand Central Dispatch, blocchi e design pattern asincroni ....................................... 787Sommario ................................................................................................................................. 789Domande ..................................................................................................................................790Esercitazione ...........................................................................................................................790

Parte 5 - Framework Cocoa e Cocoa Touch

20. INTRODUZIONE A COCOA E COCOA TOUCH ................................. 793Cocoa e Cocoa Touch ............................................................................................................ 793Apple Developer Center .......................................................................................................796Apple Developer Library ....................................................................................................... 797Seguire un corso per iOS su iTunesU ................................................................................ 797Scegliere un libro di testo per iOS ......................................................................................798Sommario .................................................................................................................................799Domande ..................................................................................................................................799

APPENDICE A - SHORTCUT XCODE ................................................................801Application ................................................................................................................................801File ...............................................................................................................................................801Edit .............................................................................................................................................802View ...........................................................................................................................................802Navigate ....................................................................................................................................803Navigate Source Code ...........................................................................................................803Edit Menu Data Model..........................................................................................................803Edit Menu Hex ........................................................................................................................803Edit Menu Interface Builder .................................................................................................804Edit Menu Scripting Definition ...........................................................................................804Edit Menu Source Code ........................................................................................................804Window Menu ........................................................................................................................804Help Menu ...............................................................................................................................804Product Menu..........................................................................................................................805Code Completion ...................................................................................................................805

GLOSSARIO ........................................................................................................... 807

INDICE ANALITICO ............................................................................................ 823

Sommario

13

Complimenti, e così vuoi iniziare a programmare in Objective-C! Ottima scelta, come biasimarti, i dispositivi iOS sono un gioiello di tecnologia e il sistema operativo OS X è dieci anni avanti rispetto agli altri.Ti chiederai perché ti ho fatto i complimenti, in fin dei conti pensi di non aver fatto ancora niente, ma ti sbagli: hai appena preso in mano questo libro. Forse sei in una libreria e stai sfogliando libri di programmazione, forse lo hai già acquistato e lo stai leggendo con calma nel tuo posto preferito, ma quello che conta è che hai appena fatto il passo più importante: il primo!Un viaggio di mille chilometri inizia con un passo, diceva Lao Tze, e aveva ragione. Il tuo viaggio nel mondo della programmazione inizia qui e ora. Un viaggio faticoso, ma che ti permetterà di raggiungere importanti obiettivi per la tua formazione e, con mol-ta probabilità, il lavoro dei tuoi sogni. Buona fortuna!

Non servono prerequisiti, solo perseveranzaIniziamo con una buona notizia per chi vuole imparare per la prima volta un linguaggio di programmazione: per questo libro non servono prerequisiti. Una certa formazione mentale scientifica aiuterà a superare più agilmente il primo approccio, ma il libro è strutturato anche e soprattutto in modo che tale formazione venga creata, sviluppata e stimolata man mano che il lettore avanza nello studio dei capitoli e nello svolgimento degli esercizi proposti.

A chi è rivolto questo libro?Programmare con Objective-C per iOS e OS X è nato con l’intento preciso di creare un manuale per tutti coloro che sono intenzionati a imparare a programmare in Objecti-ve-C per iOS e OS X, siano essi studenti di un corso universitario piuttosto che liberi professionisti o, semplicemente, appassionati di informatica. In quest’ottica il libro è

Introduzione

14


stato suddiviso in cinque sezioni che abbracciano 20 capitoli, in modo tale che aspi-ranti programmatori, programmatori junior e programmatori senior possano deci-dere da quale livello iniziare.Dove è stato possibile senza andare fuori tema, abbiamo approfondito determinate tematiche che fanno parte del background di un informatico, ma che, generalmente, non vengono trattate in un testo o in un manuale di programmazione (ad esempio, l’allocazione della memoria, la struttura di un compilatore ecc.). Con tale approccio gli studenti universitari potranno trovare conferme e collegamenti con argomenti in-contrati in altri corsi (ad esempio, sistemi operativi), mentre gli altri potranno avere un’idea più chiara di quello che fanno e di ciò che accade “dietro la tastiera”.

Che cosa imparerai con questo libroIl libro è diviso in cinque parti fondamentali organizzate in 20 capitoli più due appen-dici che racchiudono il glossario dell’Objective-C e le combinazioni rapide di tasti, dette anche shortcut, di Xcode. A seconda del livello informatico di partenza, il lettore può cominciare il libro da un capitolo piuttosto che da un altro.La prima parte di questo libro è pensata per chi inizia a programmare da zero ed è scritta in maniera più discorsiva, in modo da permettere agli aspiranti programmatori di iniziare l’apprendimento del linguaggio Objective-C senza le difficoltà aggiuntive dovute al tipico linguaggio informatico. In questa parte, inoltre, i programmi fanno uso delle linee di codice per facilitare la localizzazione dei commenti che accompagnano ogni esempio. La prima parte introduce i concetti fondamentali della programmazione a oggetti e comprende i Capitoli 1-4.La seconda parte, che include i Capitoli 5-9, è pensata per i programmatori junior che provengono da altri linguaggi orientati agli oggetti. In essa vengono introdotti i concet-ti avanzati tipici dell’Objective-C. La terza parte è pensata per i programmatori senior che provengono da altri linguaggi orientati agli oggetti. Questa parte introduce le classi del Foundation Framework e include i Capitoli 10-17.La quarta parte affronta un argomento molto avanzato, ovvero la programmazione concorrente multithreading; essa include i Capitoli 18 e 19.La quinta parte, costituita dal Capitolo 20, conclude il libro introducendo i framework Cocoa e Cocoa touch e indirizzando il lettore verso le risorse per continuare il suo studio degli ambienti iOS e OS X. Di seguito possiamo vedere una piccola introduzione ai singoli capitoli che compongo-no questo libro e ad alcuni degli argomenti da essi trattati.

15

Ambiente di vviluppoQuesto testo è stato scritto e basato sull’ambiente di sviluppo Apple definito da Xcode 6, OS X 10.10 Yosemite e iOS 8. Se necessario, si consiglia il lettore di aggiornare il proprio ambiente di sviluppo prima di iniziare lo studio del testo.

Capitolo 1: Objective-CPresenta la storia del linguaggio Objective-C e i principi fondamentali della pro-grammazione orientata agli oggetti. Introduce gli ambienti di sviluppo Objective-C e il processo di sviluppo che porta dalla scrittura del codice sorgente alla sua com-pilazione ed esecuzione.

Capitolo 2: Classi, istanze e messaggiAffronta la natura di oggetto, di classe e di istanza in Objective-C e introduce il concet-to di messaggio. Introduce le regole e le convenzioni sui nomi e sui campi di visibilità delle variabili; tratta il processo di allocazione e inizializzazione degli oggetti e i pattern per accedere alle risorse.

Capitolo 3: Tipi di datoIntroduce la rappresentazione finita dei numeri, il sistema binario e l’algebra di Boole. Presenta i tipi di dato in Objective-C e gli operatori che possono essere loro applicati.

Capitolo 4: Controllo del flussoPresenta gli operatori logici e relazionali e i costrutti attraverso i quali è possibile modi-ficare il flusso di esecuzione di un programma; introduce, inoltre, le variabili booleane e alcune istruzioni a basso livello.

Capitolo 5: EreditarietàAffronta la relazione tra superclasse e sottoclasse e introduce il concetto di classe ra-dice. Presenta i vari pattern con i quali è possibile estendere una classe e/o un metodo e alcuni concetti teorici, come le classi astratte e le meta-classi.

Capitolo 6: Categorie, protocolli, estensioni e riferimenti associativiIntroduce le categorie, i protocolli, le categorie e i riferimenti associativi, mostrando come tali costrutti possano essere utilizzati per estendere una determinata classe a seconda delle necessità; tratta, inoltre, l’importazione e il collegamento debole di classi.

Introduzione

16


Capitolo 7: Preprocessore e compilatoreIntroduce l’anatomia di un compilatore e il funzionamento dei vecchi e nuovi compila-tori implementati all’interno di Xcode. Presenta il preprocessore e le istruzioni a esso indirizzate sottolineandone il contesto di utilizzo e la sintassi.

Capitolo 8: Objective-C è anche CIntroduce tutti i costrutti e le regole del linguaggio C che un programmatore Objec-tive-C deve conoscere. Presenta, inoltre, la relazione tra linguaggio C e linguaggio Objective-C, evidenziando come il linguaggio C implementi tutti i costrutti orientati agli oggetti dell’Objective-C.

Capitolo 9: Il sistema a tempo di esecuzioneIntroduce il supporto a tempo di esecuzione e analizza il comportamento statico e di-namico del linguaggio Objective-C. Presenta alcuni concetti orientati agli oggetti che si ritrovano in Objective-C come il typing dinamico, il binding dinamico e il polimorfismo.

Capitolo 10: Introduzione al Foundation FrameworkIntroduce il Foundation Framework, le classi che implementa e le varie versioni delle documentazioni ufficiali offerte dalla Apple in versione online e offline.

Capitolo 11: Numeri, stringhe e collezioniIntroduce le classi del Foundation Framework che permettono allo sviluppatore di cre-are e manipolare numeri, stringhe e vari tipi di collezioni.

Capitolo 12: File e directoryIntroduce le classi del Foundation Framework che permettono allo sviluppatore di cre-are e manipolare file e directory.

Capitolo 13: Ambiente iOS e OS X e gestione della memoriaAffronta la gestione della memoria nei sistemi iOS e OS X e introduce i sistemi di gestione della memoria manuale (MRC), automatico (ARC) e basato sul garbage collection (AGC).

Capitolo 14: Copiare oggettiIntroduce le classi del Foundation Framework che permettono allo sviluppatore di co-piare gli oggetti presentando i diversi tipi di copia possibili e i protocolli che ne imple-mentano il processo.

17

Capitolo 15: Copiare oggettiIntroduce le classi del Foundation Framework che permettono allo sviluppatore di ar-chiviare e manipolare dati attraverso standard come XML e JSON. Presenta gli archivi personalizzati e i metodi di codifica e decodifica.

Capitolo 16: Gestione degli errori ed eccezioniIntroduce le classi del Foundation Framework che permettono allo sviluppatore di ge-stire gli errori e le eccezioni presentandone i relativi costrutti e la logica implementativa.

Capitolo 17: Design PatternIntroduce i principali pattern che possono essere ritrovati in ambiente iOS e OS X, da quello che ne definisce le fondazioni, conosciuto col nome di Model View Controller (MVC), a quelli che implementano tecniche di manipolazione e osservazione dei valo-ri delle variabili, come Key-Value Coding (KVC) e Key-Value Observer (KVO).

Capitolo 18: BlocchiIntroduce i blocchi come estensione al linguaggio C e Objective-C, illustrandone la sin-tassi, le interazioni con le variabili e le implicazioni a livello di gestione della memoria.

Capitolo 19: Programmazione Multithreading e Grand Central DispatchIntroduce la programmazione multithreading e la sua implementazione offerta da Grand Central Dispatch (GCD). Presenta le code e i pattern sincroni e asincroni con i quali tali code possono essere utilizzate in ambiente iOS e OS X per schedulare task concorrenti e ottimizzare le performance.

Capitolo 20: Introduzione a Cocoa e Cocoa TouchIntroduce la struttura dei framework Cocoa e Cocoa Touch indirizzando il lettore verso il prosieguo del suo cammino nello studio degli ambienti iOS e OS X.

Programmi, Esempi ed EserciziAl fine di illustrare e comprendere i principi e gli argomenti trattati, in questo testo vengono proposte, a scopo didattico, tre forme di assegnamenti didattici: i Program-mi, gli Esempi e gli Esercizi.I Programmi possono essere copiati e incollati in Xcode al fine di compilarli e provare ad eseguirli. Alcuni di essi possono essere eseguiti senza nessuna modifica mentre

Introduzione

18


altri contengono “sviste o errori” che devono essere corretti prima di procedere all’e-secuzione ed alla conseguente visualizzazione dell’output.Gli Esempi rappresentano invece una finestra su un ipotetico programma al fine di illu-strarne solo la parte rilevante per l’argomento correntemente trattato; in questo caso il lettore è invitato a ricostruirne il corpo integrando in esso l’esempio fornito.La terza forma didattica proposta è rappresentata dagli Esercizi, nei quali viene chiesto al lettore di scrivere un programma completo basato sul tema trattato nel capitolo corrente.Prima di passare al capitolo successivo si consiglia di completare tutti gli esercizi pra-tici. Le soluzioni degli esercizi non vengono volutamente riportate in questo testo per due motivi didatticamente molto importanti. Il primo perché, salvo casi a bassissima complessità, un programma non ha mai un’unica soluzione corretta e fornirne una si-gnifica indirettamente limitare la creatività e la crescita del programmatore. Il secondo motivo invece risiede nella volontà di evitare al lettore di consultare la soluzione prima di aver speso il tempo soggettivamente richiesto per la risoluzione del problema. In caso si trovi difficolta a completare gli esercizi si consiglia di rileggere il capitolo chia-mato in causa dall’esercizio.

NO

TA

Dal Capitolo 4 in poi, alcuni dei Programmi (quindi non gli Esempi e/o gli Esercizi) proposti presentano volontariamente alcune imperfezioni che il lettore è invitato ad individuare e correggere prima di poter essere in grado di eseguire il tale programma e visualizzare l’output atteso. Questo approccio vuole rappresentare un ulteriore livello di auto verifica proposto al lettore nel suo cammino di consolidamento delle conoscenze presentate in questo testo.

Ogni esercizio richiede uno specifico output da ottenere, se il lettore riesce ad ottene-re quel dato output l’esercizio può ritenersi risolto; senza (per il momento) preoccu-parsi troppo di soluzioni ottime o sub-ottime.

La tua roadmap da sviluppatore iOS e OS XDiventare uno sviluppatore iOS e/o OS X ha un grande valore nel mercato informa-tico moderno, sempre più orientato ai dispositivi mobili. Purtroppo (o per fortuna), come avviene per tutte le cose di grande valore nella vita, viene richiesto un gran-de impegno per conquistarle.

19

Sviluppare un’applicazione può sembrare facile, ma le abilità richieste sono molteplici. Nonostante ciò, difficile non vuol dire impossibile, e anche questo percorso, per quan-to irto possa sembrare, può essere compiuto brillantemente se affrontato con metodo, dedizione e perseveranza.Questo libro fornirà un metodo e strutturerà un cammino verso il nostro obiettivo fortemente orientato all’apprendimento; ai lettori, invece, il compito di seguire tale cammino con dedizione e perseveranza fino al raggiungimento dell’obiettivo finale: diventare uno sviluppatore iOS e OS X.Divideremo la nostra strada per diventare uno sviluppatore iOS e/o OS X in quattro passi, come mostrato in Figura I.1. Questo testo coprirà completamente i primi due passi e fornirà un’introduzione al terzo passo, orientato allo studio dei framework Co-coa e Cocoa Touch. Il quarto step rappresenterà il perfezionamento finale.

Figura I.1 - La roadmap di un aspirante sviluppatore iOS e/o OS X.

Con questo testo affronteremo la parte iniziale e più impegnativa del cammino, che ci permetterà di comprendere a fondo i principi di programmazione (primo step) e di apprendere in maniera approfondita il linguaggio di programmazione Objective-C (secondo step) attraverso lo studio dei suoi costrutti, delle classi che costituiscono il Foundation Framework e della programmazione multithreading. Dopo aver costruito delle solide fondamenta con questo testo, il futuro studio dei framework Cocoa e Co-coa Touch e la fase di perfezionamento risulteranno molto agevolati.Una volta terminato questo testo, il lettore avrà acquisito tutte le conoscenze e la pra-tica necessarie per iniziare lo studio degli ambienti iOS e OS X (terzo step) e affrontare la successiva fase di perfezionamento (quarto step), che gli permetterà di divenire un vero esperto degli ambienti di casa Apple.

Introduzione

20


Il linguaggio e i termini usati nel libro Questo libro è completamente scritto in italiano, ma in alcuni casi, dove il termine inglese rappresentava il termine comunemente accettato nella comunità iOS e OS X, abbiamo fatto uso della sua versione in lingua inglese. Nella maggior parte dei casi sono stati presentati sia il termine in lingua italiana sia l’originale in lingua inglese; in altri, invece, dove la traduzione risultava fuorviante, sono stati usati i soli termini in lingua inglese. In ogni caso, il significato di molti dei termini utilizzati in questo libro possono essere ricercati nel glossario.

Contattare l’autoreIl tuo feedback è importante! Se hai suggerimenti e/o feedback da segnalare, puoi contattarmi direttamente via email a: [email protected] avere, invece, informazioni aggiornate sul testo puoi visitare il sito web ufficiale del libro, raggiungibile all’indirizzo www.objective-c.it, oppure visitare la pagina dedicata al libro sul mio sito personale: www.andreapicchi.it.

21

Parte 1

Concetti fondamentali

23

Introduzione ai principi dei linguaggi orientati agli og-getti, al linguaggio Objective-C, a Xcode e agli am-bienti di sviluppo per le applicazioni iOS e OS X dispo-

nibili in ambiente Mac e Windows.

In questo capitolo cominceremo a prendere confidenza con i concetti tipici dei lin-guaggi orientati agli oggetti e con l’Objective-C, i suoi principi, le sue caratteristiche e le sue regole. Per chi, con questo testo, si trovasse a studiare un linguaggio di program-mazione per la prima volta, in un primo momento molti concetti potranno sembrare astratti. Tuttavia, a mano a mano che avanzeremo e ne illustreremo l’implementazio-ne, cominceranno ad assumere una connotazione molto più concreta.Ogni programmatore Objective-C dovrebbe conoscere le origini del linguaggio di pro-grammazione che usa quotidianamente. Inizieremo quindi questo capitolo presentan-do la nascita e l’affermazione del linguaggio Objective-C in ambiente Apple.Dopo la storia dell’Objective-C illustreremo i principi fondamentali sucui si basa tutta la programmazione orientata agli oggetti e introdurremo un concetto molto importan-te: la differenza tra tempo di compilazione e tempo di esecuzione, andando a vedere le differenti fasi di tali processi.Introdurremo il concetto di framework e vedremo l’architettura dei framework usati in ambiente iOS e OS X. Presenteremo l’ambiente di sviluppo iOS e OS X offerto da Apple e un’alternativa Open Source compatibile con Windows e Linux.

Objective-C 2.0

1

24


Nella parte finale di questo capitolo scriveremo il nostro primo programma Objective-C e ne vedremo alcune varianti, per rendere più ampio ed esaustivo il nostro primo approccio al linguaggio.

Storia dell’Objective-CLa storia dell’Objective-C inizia indirettamente nel 1972, quando nei laboratori dell’AT&T Dennis Ritchie sviluppa il linguaggio C come evoluzione del precedente lin-guaggio B per sistemi Unix. Il C è un linguaggio procedurale, detto anche imperativo, non orientato agli oggetti.Nel 1980 nei laboratori della Xerox PARC nasce un nuovo linguaggio chiamato Small-talk. Al contrario del C, Smalltalk è un linguaggio orientato agli oggetti. Esso quindi su-pera l’approccio procedurale basato sul paradigma di John von Neumann, che prevede la separazione tra dati e programmi, per basarsi sul nuovo concetto di oggetto, che per la prima volta include in modo inscindibile sia i dati sia i programmi.Nel 1983 i fondatori della Stepstone, Brad Cox e Tom Love, sviluppano un nuovo lin-guaggio partendo dal C, aggiungendovi un preprocessore capace di supportare le nuo-ve capacita introdotte da Smalltalk.

NO

TA Nel Capitolo 12 vedremo in dettaglio come funziona la componente pre-

processore, mentre nel Capitolo 13 impareremo a usare il linguaggio C in ambiente Objective-C.

Questo nuovo linguaggio, che assume appunto il nome di Objective-C, prende forma come un’implementazione a oggetti del C. Ciononostante, al contrario di altri linguag-gi che hanno modificato il C per ottenere una sua versione a oggetti (per esempio, C++ o C#), Objective-C lascia intatta tutta la parte sul C, mantenendo una retrocompatibi-lità totale, e prende la parte orientata agli oggetti da Smalltalk.Il coinvolgimento di Apple inizia in maniera indiretta nel 1985 quando Steve Jobs, dopo essere stato licenziato dall’azienda che aveva creato, riparte con un nuovo progetto fondando la NeXT. NeXT nel 1988 acquista la licenza dell’Objective-C dalla Stepstone, realizzando un proprio compilatore Objective-C e nuove librerie per sviluppare l’in-terfaccia utente di quello che sarebbe stato il NeXT Operating System. Le vendite dei computer NeXT non hanno grande impatto sul mercato per la scarsa disponibilità di software dedicato. Degno di nota, però, è il fatto che nel 1990 il primo Web server della storia, progettato e costruito da Tim Berners-Lee al CERN di Ginevra, giri proprio su un computer NeXT.

25

Objective-C 2.0 Parte 1 - Capitolo 1

Figura 1.1 - L’edificio dove negli anni ’80 risiedeva la sede della Stepstone (Wikipedia).

Figura 1.2 - Il computer NeXT Cube usato da Tim Berners-Lee come primo Web server della storia (Wikipedia).

Nel 1996 Apple acquista NeXT assieme alla licenza dell’Objective-C e al suo sistema di sviluppo Project Builder (in seguito rinominato Xcode), e con questi nuovi strumen-ti comincia a sviluppare quello che nel 2002 sarebbe stato presentato come OS X. OS X combina le caratteristiche del vecchio Mac OS 9 con l’architettura del sistema operativo Unix BSD. Il nuovo OS X è un sistema operativo di tipo Unix certificato IEEE, pienamente compatibile con lo standard POSIX.Nel 2007 Apple presenta Objective-C 2.0, aggiungendo molte nuove proprietà alla prima versione del linguaggio, e lo utilizza per creare il primo iPhone OS. L’iPhone OS,

26


presentato il 9 gennaio 2007 al Macworld Conference & Expo, entra in commercio il 29 giugno dello stesso anno con il primo modello di iPhone. Nel 2008, per la prima volta, Apple apre le porte a sviluppatori di terze parti rilasciando l’iPhone SDK e ag-giornando l’iPhone OS alla versione 2.0. Nel 2009 viene rilasciato iPhone OS 3.0 e nel 2010, dopo la presentazione del primo iPad, Apple rilascia iPhone OS 4.0, rinominato iOS 4 per riunire concettualmente sia lo smartphone sia il suo nuovo tablet sotto la stessa immagine. Con iOS 4 e OS X 10.6 viene aggiunta la libreria che implementa Grand Central Dispatch (GCD), un nuovo paradigma di programmazione concorrente basato sulle gestione indiretta dei thread.

Figura 1.3 - Dal linguaggio C, passando per l’Objective-C 2.0 fino al sistema operativo iOS.

Nel 2011 Apple aggiunge un’altra importante funzionalità a livello del compilatore LLVM. Si chiama ARC (Automatic Reference Counting) e semplifica la gestione della memoria specialmente in ambiente iOS, gestendo automaticamente l’inserimento del-le chiamate ai metodi deputati alla ritenzione e al rilascio della memoria; allo sviluppa-tore viene lasciato il solo onere di esplicitare il possesso di un determinato oggetto; nel-lo stesso anno Apple presenta anche iOS 5 e l’anno seguente nel 2012 iOS 6. Nel 2013 Jonathan Ive diventa Head of Human Interface Design ed Apple rilascia iOS 7 con un nuovo design flat e minimalista tipico di tutti i progetti guidati dal designer britannico segnando così la fine dello stile scheumorfico in casa Apple. Nel 2014 viene rilasciato iOS 8 che rappresenta l’ennesimo step evolutivo del precursore di tutti i sistemi opera-tivi per dispositivi mobile. A oggi con Objective-C 2.0 possiamo sviluppare applicazioni sia per iOS sia per OS X e venderle rispettivamente nell’App Store e nel Mac App Store.

27


Programmazione orientata agli oggettiIl paradigma della programmazione orientata agli oggetti (spesso abbreviata con OOP - Object Oriented Programming) si fonda sul concetto di oggetto. In tale paradigma il programma è organizzato in una collezione di oggetti che interagiscono tra loro. Un oggetto è un’entità contenitore per un insieme di attributi, che modellano un deter-minato spazio del problema, e di azioni, che rappresentano le interazioni che l’oggetto può compiere con lo spazio della soluzione.

Classi, istanze e messaggiLe classi sono le specifiche che definiscono le istanze, stabilendo i loro attributi o membri (variabili) e le loro azioni possibili (metodi). In linea generale possiamo dire che ogni istanza appartiene a una classe specifica, ovvero si dice che è un’istanza di quella data classe. Volendo fare un esempio pratico, le specifiche e le informazioni contenute nel progetto di una Ferrari rappresentano una classe, mentre la Ferrari che noi tutti abbiamo in garage rappresenta un’istanza della classe Ferrari. In Figura 1.4 possiamo vedere una classe e un’istanza rappresentate graficamente.

Figura 1.4 - Vista di una classe (a sinistra) e di una sua istanza (a destra), composta da variabili e metodi.

Nella Figura 1.4 vediamo rappresentata un’istanza della classe gto599. In questo sem-plice modello abbiamo quattro attributi o membri (variabili): Andrea e Picchi sono rispettivamente il nome e il cognome del proprietario, 670 sono i cavalli del motore e 001 è il numero di serie dell’esemplare (ne sono stati costruiti solo 599). Vedremo più avanti che possiamo avere più istanze di una stessa classe e infatti, molto proba-bilmente, tutti noi abbiamo più di una Ferrari nel nostro garage. Le diverse istanze di una classe saranno memorizzate in aree separate della memoria come oggetti diversi.

28


In Objective-C esiste il concetto di messaggio che, inviato a un dato oggetto, gli chiede di compiere una data azione invocando un dato metodo. In Figura 1.5 possiamo vedere l’invio di un messaggio rappresentato graficamente.

Figura 1.5 - Vista di una generica interazione tra istanza (oggetto), messaggio e metodo.

Una volta che un messaggio viene ricevuto da una data istanza, tale oggetto si preoc-cuperà di invocare il relativo metodo per eseguire l’azione.

Information hidingIl principio teorico dell’information hiding si basa su una tecnica conosciuta come in-capsulamento dei dati (data encapsulation) e rappresenta un approccio volto a ridurre il livello di complessità dei programmi. Il concetto alla base dell’information hiding è nascondere la reale implementazione di un oggetto allo sviluppatore fornendogli un’interfaccia con cui interagire; in altre parole, un insieme di azioni (metodi) possibili per poterlo usare in un determinato modo.

Figura 1.6 - Il principio dell’incapsulamento: lo sviluppatore interagisce solo con l’interfaccia dell’oggetto.

29


Possiamo quindi vedere una classe come una scatola nera che cela il suo contenuto e funzionamento all’esterno, ma che presenta un’interfaccia per comunicare con essa e quindi per utilizzarla. Tornando al nostro esempio precedente possiamo dire che l’unica cosa che interessa a uno sviluppatore è sapere che, quando la sua istanza della Ferrari riceve un messaggio engineOn, il bolide di Maranello avvia il suo potente motore.

EreditarietàIl concetto di ereditarietà è definito molto bene dalla parola stessa. Nel Capitolo 5 ve-dremo un approccio più rigoroso al tema dell’ereditarietà, ma per adesso immaginia-moci che, esattamente come nella vita reale una persona può ereditare qualcosa da un familiare, in un linguaggio a oggetti una data ClasseB può ereditare delle proprietà da una data ClasseA. Al contrario della vita reale, dove la cosa ereditata passa fisicamente da una persona all’altra (e il defunto non possiede più la cosa), nel mondo binario dei computer ciò che viene ereditato è la possibilità di usare una certa proprietà. Abbiamo scritto ClasseB eredita da ClasseA e non il contrario per introdurre un con-cetto fondamentale, ovvero quello di sottoclasse. La ClasseB è sottoclasse della ClasseA, detta superclasse o padre, dalla quale eredita attributi e operazioni, ovvero variabili e metodi.

Figura 1.7 - Vista UML di una generica relazione (super)classe - sottoclasse.

Le relazioni tra (super)classi e sottoclassi sono di tipo generalizzazione/specificazione. Vedremo in dettaglio questi concetti nel Capitolo 2. Per adesso possiamo immaginarci una classe AutoSportiva che ha due sottoclassi, una chiamata Ferrari e una Porsche.

PolimorfismoIl polimorfismo è la capacità tipicamente di un metodo di appartenere a classi diffe-renti e di rispondere allo stesso messaggio. Immaginiamoci un metodo disegna definito

30


in tre classi, chiamate Cerchio, Quadrato e Rettangolo. Trattandosi di tre figure geome-triche diverse il metodo disegna sarà definito in maniera differente nelle tre classi, in modo da poter disegnare tre diversi oggetti geometrici.

Figura 1.8 - Il polimorfismo: Il metodo disegna, che risponde allo stesso messaggio ma implementando tre diversi comportamenti.

A questo punto immaginiamo di inviare un messaggio disegna a tutti e tre gli oggetti. Il risultato sarà che lo stesso messaggio porterà a tre diversi output nella nostra in-terfaccia grafica. Potremmo riassumere il polimorfismo con lo slogan: stesso nome e implementazione diversa in classi diverse.

Che cos’è l’Objective-CCome abbiamo potuto intuire leggendo la storia di questo linguaggio, Objective-C nasce con lo scopo specifico di aggiungere il supporto agli oggetti al linguaggio C. Objective-C è infatti un linguaggio di programmazione procedurale compilato orien-tato agli oggetti, definibile come un sovrainsieme del linguaggio C. Ciò significa che Objective-C supporta la sintassi del C aggiungendo il supporto per gli oggetti prove-niente originariamente da Smalltalk. Perciò in questo libro ci troveremo a usare sintas-si tipiche del linguaggio di casa Apple, ma anche altre che possono essere incontrate in un tipico programma scritto in C.Al contrario del C, che ha un processo di linking o collegamento di tipo statico (con-testualizzeremo il processo di linking nel prossimo paragrafo), Objective-C ha un lin-

31


king di tipo dinamico. Ciò significa, per esempio, che il metodo da invocare o alcune delle informazioni sulle proprietà di un oggetto sono conosciute e collegate a tempo di esecuzione anziché a tempo di compilazione. Questa proprietà, riferita agli oggetti, è conosciuta come tipizzazione dinamica (o weak typing). Durante la fase di linking (dinamico) viene anche caricato e scaricato codice dalla memoria.Le proprietà dinamiche di Objective-C sono basate su un sistema chiamato run-time o a tempo di esecuzione, che supporta, tra le altre cose, la gestione degli oggetti, delle eccezioni, del threading e della messaggistica remota. Questo sistema, che si aggiun-ge a quello ereditato dal C, verrà analizzato nel Capitolo 9. Per alcuni casi particolari Objective-C offre anche la possibilità di specificare il tipo di un oggetto a tempo di compilazione; tale proprietà prende il nome di tipizzazione statica (o strong typing).Come tutti i linguaggi orientati agli oggetti Objective-C supporta l’eredita, ma a dif-ferenza di altri linguaggi (come Java o C#), che adottano una forma particolare di eredità multipla, in Objective-C è supportata solo l’eredità singola, dove una classe può ereditare in modo diretto da una e da una sola classe padre.Objective-C supporta l’overriding, ovvero la ridefinizione dei metodi, e implementa una gestione degli oggetti di tipo dinamico, decidendo a tempo di esecuzione (a run-time) gli oggetti e i metodi da richiamare e di cui caricare e scaricare il codice dalla memoria.Al pari di altri linguaggi orientati agli oggetti Objective-C gestisce particolari eventi chiamati eccezioni. Con le eccezioni è possibile memorizzare informazioni relative a un errore verificatosi in un oggetto. La gestione particolare di tale oggetto evita che il programma vada in crash o che generi comportamenti aleatori a causa dell’errore. Vedremo le eccezioni e il loro ruolo atipico nel linguaggio Objective-C nel Capitolo 16.Objective-C implementa tre modi di gestire la memoria, che vedremo in dettaglio nel Capitolo 13.Uno è dinamico e completamente automatico, basato su un sistema chiamato Au-tomatic Garbage Collection (AGC). Tipico di molti linguaggi orientati agli oggetti, libera automaticamente le risorse occupate da un oggetto secondo una data politi-ca. Il metodo AGC non è mai stato disponibile per l’ambiente iOS e veniva utilizzato solo in ambiente OS X; è stato considerato deprecato a partire dalla versione 10.8 dello stesso OS X.Diametralmente opposto a quello dinamico e completamente automatico vi è il siste-ma manuale che si basa sulla gestione del Manual Reference Counting (MRC), che di fatto conta il numero di volte che un oggetto è riferito; quando il numero dei riferimenti è uguale a zero l’oggetto viene rimosso dalla memoria.A partire da OS X 10.6 e iOS 5 è stato introdotto l’Automatic Reference Counting (ARC), che mantiene il paradigma del Reference Counting ma a livello di compilatore

32


aggiunge funzionalità che gestiscono le dinamiche legate a tale processo che, di fatto, facilitano e alleggeriscono il lavoro da parte dello sviluppatore.Una caratteristica peculiare di Objective-C è invece il concetto di direttiva. Una diret-tiva è caratterizzata dal simbolo @, che marca in modo esplicito determinati elementi sintattici del linguaggio in modo che il preprocessore li possa riconoscere e trattare durante la sua (pre)analisi del codice sorgente precedente il processo di compilazione. Vedremo le direttive di preprocessore nel Capitolo 7.

Figura 1.9 - L’Apple developer program offre il download gratuito dei tool necessari allo sviluppo di applicazioni per iOS ed OS X.

Per permettere la comunicazione tra oggetti distribuiti su processi diversi, sia operanti sulla stessa macchina sia su macchine diverse, Objective-C supporta il remoting, ov-vero la comunicazione tra tali oggetti remoti attraverso l’invio di messaggi.Oltre al remoting il linguaggio supporta anche il multithreading, ovvero l’esecuzione di più processi su più core del processore all’interno di una stessa applicazione mediante l’uso di una API chiamata GCD (Grand Central Dispatch), disponibile a partire da OS X 10.6 e iOS 4. Tratteremo il Grand Central Dispatch e la programmazione multithre-ading nel Capitolo 17.Objective-C offre uno dei più avanzati paradigmi di programmazione a oggetti, ma l’arma vincente di ogni sviluppatore iOS e OS X sono i framework. Un framework è una raccolta di classi (è detto anche class cluster, dal nome del pattern che lo implementa) e molte altre risorse importabili all’interno di un progetto. Due tra i più conosciuti framework in ambiente Apple sono Cocoa (per OS X) e Cocoa Touch (per iOS), che permettono di rendere il processo di sviluppo più rapido, preciso e qualitativamente migliore. Sia Cocoa sia Cocoa Touch si avvalgono di un framework chiamato Foundation Framework, che fornisce le fondazioni di tutte le operazioni basilari per ogni applicazione. Vedremo il Foundation Framework a partire dal Capitolo 10.

33


I molti concetti introdotti finora saranno ritrovati e contestualizzati uno dopo l’altro nei capitoli seguenti, permettendo al lettore di sviscerare ogni singolo argomento nel modo migliore.

Tempo di compilazione e tempo di esecuzioneObjective-C è un linguaggio di programmazione compilato con un sistema a tempo di esecuzione (RTS) che lavora a run-time in maniera dinamica. Questo significa che Objec-tive-C è compilato e collegato mediante un approccio di compilazione statica, ma che in seguito viene eseguito attraverso una fase che prevede la gestione dinamica dei metodi. Tale caratteristica permette agli sviluppatori Objective-C di usare tecniche tipicamente disponibili solo in linguaggi di scripting, come il duck typing o l’introspezione sui tipi.

Duck typingIl duck typing, in informatica, è il principio in base al quale se un oggetto somiglia a una papera e fa quack come una papera, allora deve per forza essere una papera. Il duck typing è un principio che si oppone diametralmente al concetto di static typing, dove un oggetto deve essere di tipo concorde a quello definito nella sua dichiarazione.

IntrospezioneL’introspezione sui tipi di oggetto prevede invece che si possa determinare il tipo di un oggetto a run-time attraverso il supporto del sistema a run-time (RTS). Vedremo il sistema a tempo di esecuzione nel Capitolo 9.

Le tre fasi del codicePrima ancora di iniziare a scrivere una singola riga è importante introdurre le tre fasi fondamentali del percorso che porta il codice sorgente Objective-C a essere scritto, compilato ed eseguito su un dispositivo iOS o OS X.

Scrivere il codiceScrivere il codice significa scrivere istruzioni, coerenti col linguaggio di program-mazione usato, dentro un editor di testi più o meno evoluto (per esempio Xcode) prima della compilazione. I linguaggi come Objective-C separano la dichiarazione dell’interfaccia dalla reale im-plementazione (la definizione) dell’interfaccia stessa. Nel paradigma a oggetti un’in-terfaccia è tipicamente un insieme di operazioni che vengono esportate per permette-re lo scambio di informazioni.

34


La dichiarazione dell’interfaccia risiede in un file interface, che descrive general-mente le operazioni (metodi), mentre la sua implementazione (definizione) risiede in un file implementation, dove tali operazioni vengono implementate specificando quello che fanno e come lo fanno. Nel file implementation vengono inoltre dichiarati gli attributi (variabili). Possiamo avere uno o, molto più spesso, più file di questo tipo, che insieme al file che comprende la routine main del programma, tipicamente, sono riferiti come codice sorgente.I file di tipo interface hanno estensione .h, mentre quelli di tipo implementation e main hanno estensione .m. Inizieremo a vedere in dettaglio le classi nel Capitolo 2.

Compilare il codiceIl codice sorgente è un tipo di codice più user-friendly che processor-friendly. Tale affermazione implica che, una volta scritto il codice sorgente, dovremo trasformarlo in “qualcosa” di comprensibile per il processore che lo dovrà in seguito eseguire. Quando compiliamo un progetto in ambiente Xcode tutto si riduce a cliccare su un pulsante che riporta la dicitura Run (⌘+R), ma in realtà il processo è complesso e lo vedremo in dettaglio nel Capitolo 7.

Il compilatore LLVM, sviluppato anche da Apple, adottato come compilatore di default dalla versione 4.2 di Xcode e a partire da OS X 10.6, oltre a compilare co-dice Objective-C e C, offre anche la possibilità di utilizzare codice C++ all’interno

Figura 1.10 - I tre tipi di file che compongono il codice sorgente in Objective-C.

Figura 1.11 - Il processo di compilazione in Objective-C.

35


di progetti per OS X e iOS. Questa importante caratteristica consente di ottenere porzioni di codice riutilizzabili e un sistema altamente modulare, indirizzato agli sviluppatori che hanno la necessita di riferire anche altri ambienti mobile (e non solo) come quelli dei dispositivi basati su Windows Phone o Symbian OS. Oltre al supporto C++, per motivi di compatibilità Xcode integra il compilatore LLVM-GCC, definito legacy, in grado di compilare quasi tutto il linguaggio C compilabile con il compilatore standard GNU GCC.Se ci sono errori di sintassi o semantici in questa fase vengono mostrati a video sia messaggi di warning, che volendo possono essere ignorati (cosa da non fare quasi mai), sia messaggi di veri e propri errori, detti errori a tempo di compilazione perché vengono rilevati in questa particolare fase del processo. Una volta che il codice risulta privo di errori o warning è pronto per essere eseguito.

Eseguire il codiceLa fase di esecuzione prende in input il file eseguibile e lo esegue. La fase di esecuzione, o run-time, può presentare errori in grado di portare alla terminazione del programma.

Esiste un sottoinsieme di errori che molto spesso non possono essere rilevati a tempo di compilazione, ma che una volta processati a tempo di esecuzione portano a malfun-zionamenti. Essi prendono il nome di errori a tempo di esecuzione.

OS XIl sistema operativo OS X è stato sviluppato a partire dalla distribuzione BSD (Berkeley Software Distribution) di Unix ed è basato sul sistema operativo NeXTSTEP, sviluppa-to da NeXT a partire dalla meta degli anni ‘80. Esiste anche una versione server che prende il nome di OS X Server. Lo stesso sistema operativo iOS deriva da OS X ed è alla base degli applicativi dei dispositivi mobili di casa Apple e dell’Apple TV. Nella Tabella 1.1 possiamo vedere l’evoluzione delle versioni di OS X aggiornate all’anno 2014.

Figura 1.12 - La fase di esecuzione del codice in Objective-C.

36


Tabella 1.1 - Timeline del sistema operativo OS X.

Versione Nome in codice Data di rilascio

Public Beta Kodiac 13 settembre 200010.0 Cheetah 24 marzo 200110.1 Puma 25 settembre 200110.2 Jaguar 23 agosto 200210.3 Panther 24 ottobre 200310.4 Tiger 29 aprile 200510.5 Leopard 26 ottobre 200610.6 Snow Leopard 28 agosto 200910.7 Lion 20 luglio 201110.8 Mountain Lion 25 luglio 201210.9 Mavericks 22 Ottobre 201310.10 Yosemite 22 Ottobre 2014

Partendo dallo strato più basso, il sistema operativo OS X presenta i componenti har-dware e il firmware EFI (Extensible Firmware Interface). Il livello superiore è lo spazio kernel rappresentato dal DarwinOS, composto principalmente dal kernel XNU e strut-turato dal componente BSD, da quello denominato Mach e dalle componenti di I/O. Andare oltre tale livello di dettaglio esula dalla trattazione di questo testo. In Figura 1.13 possiamo vedere la struttura del kernel XNU con le sue singole componenti.

Figura 1.13 - Architettura del kernel XNU.

Sopra lo spazio kernel troviamo lo spazio utente. Esso è composto dai servizi fonda-mentali, da quelli applicativi e, sopra di loro, da un insieme di API denominate BSD,

37


Carbon, Cocoa e Java (deprecato a partire da OS X 10.7). Sopra questo blocco trovia-mo l’interfaccia grafica Aqua e sopra ancora le applicazioni vere e proprie. Nella Figura 1.14 possiamo vedere l’intera architettura del sistema OS X.

Figura 1.14 - Architettura del sistema OS X.

Il core del sistema operativo OS X è conforme allo standard definito dalla librerie PO-SIX e, dalla versione 10.6, è compilato con la certificazione Unix 03. Il core del sistema DarwinOS è rilasciato con licenza Open Source dalla stessa Apple. DarwinOS, al con-trario di OS X, non include l’interfaccia grafica Aqua e inizialmente supportava solo i processori Power-PC fino a quando, nel 2005, Apple non aggiunse il supporto per i processori Intel a 32 bit e 64 bit e migrò totalmente verso tali architetture.

iOSIntrodotto nel giugno 2007, il sistema che ormai tutti conoscono come iOS, basandosi su OS X, presentava una rivoluzionaria interfaccia grafica basata su un insieme di API denominate Cocoa Touch, derivate in parte da quelle di OS X denominate Cocoa e ot-

38


timizzate per il nuovo hardware del telefono di casa Apple. Al contrario di DarwinOS, nessun componente di iOS è stato rilasciato da parte di Apple, originando voci discor-danti all’interno della comunità degli sviluppatori. Se da un lato una politica con tali regole limita l’azione degli sviluppatori in alcuni contesti, dall’altro offre loro un livello di affidabilità, consistenza e sicurezza che altri sistemi operativi mobili non potranno mai avere per via della loro natura. Nella Tabella 1.2 possiamo vedere la timeline del sistema operativo iOS aggiornata all’anno 2014.

Tabella 1.2 - Timeline del sistema operativo iOS.

Versione Nome in Codice Data di Rilascio

1 iPhone OS 1 29 giugno 20072 iPhone OS 2 11 luglio 20083 iPhone OS 3 17 giugno 20094 iOS 4 21 giugno 20105 iOS 5 6 giugno 20116 iOS 6 11 giugno 20127 iOS 7 18 settembre 20138 iOS 8 18 settembre 2014

Al momento del lancio l’iPhone non supportava applicazioni di terze parti; fu in quel periodo che le cosiddette WebApp iniziarono a essere spinte ufficialmente da Apple e piano piano a comparire in rete per la prima volta. Nel 2008 Apple rilasciò la prima SDK ufficiale per sviluppare applicazioni native per iPhone, che previa approvazione Apple venivano distribuite attraverso il nuovo negozio chiamato App Store.

Ambienti di sviluppo iOS e OS XImmagino che essendo interessato alla programmazione in Objective-C tu abbia va-lutato l’acquisto di un computer Apple. Forse ne hai già uno sulla tua scrivania mentre stai leggendo queste righe o hai pianificato di prenderne uno più avanti.La buona notizia è che, se non hai un computer Apple, puoi iniziare a programma-re in Objective-C senza alcun problema perché esiste una versione del compilatore Objective-C per Windows e Unix che si chiama GNUStep.La notizia meno bella è che quando avrai imparato perfettamente l’Objective-C e sarai pronto per passare allo studio dell’SDK Apple per sviluppare applicazioni iOS e OS X dovrai avere giocoforza un computer Apple in grado di far girare l’SDK (Software Development Kit).

39


In un contesto object oriented un ambiente di sviluppo come quello con cui interagire-mo è composto tipicamente dai seguenti elementi:

• un linguaggio di programmazione orientato agli oggetti (come Objective-C);• uno o più framework (per esempio, Foundation Framework, Cocoa o Co-

coa Touch);• un kit di sviluppo software (Apple SDK);• un ambiente di simulazione run-time (come iOS Simulator).

L’ambiente di sviluppo usato e sottinteso in questo testo e nei suoi esempi grafici sarà Apple SDK, scaricabile gratuitamente raggiungendo la pagina: https://developer.apple.com/xcode/.

Apple SDKDi seguito sono elencati e descritti i componenti dell’Apple SDK che lo sviluppatore si trova di fronte una volta eseguito il download:

• Xcode - Ambiente di sviluppo integrato che permette di gestire un progetto in modo diretto o indiretto attraverso i vari tool incorporati;

• Instruments - Tool per l’analisi delle performance a tempo di esecuzione tipica-mente utilizzato per ottimizzare le prestazioni di un’applicazione;

• iOS Simulator - Tool che simula lo stack di iOS permettendo allo sviluppatore di testare le proprie applicazioni, raccogliendo importanti informazioni in locale;

• iOS e OS X framework - insieme di framework che permettono lo sviluppo delle applicazioni per iOS e OS X;

• iOS Developer Library - Documentazione ufficiale Apple delle classi che co-stituiscono i vari framework. Essa rappresenta una versione offline della docu-mentazione reperibile online ed è perciò da considerarsi aggiornata alla data di download dell’SDK Apple.

Nel prossimo breve paragrafo amplieremo la nostra conoscenza di Xcode, che adope-reremo in ogni programma di esempio proposto in questo testo.

Apple XcodeUtilizzando Xcode possiamo avere tutti gli strumenti necessari per scrivere il nostro codice, compilarlo, eseguirlo applicare procedure di debug. Xcode è quello che si de-finisce un IDE (Integrated Development Environment), ovvero un software con un’in-terfaccia “facile” da usare per utilizzare i framework di sviluppo e i vari tool (integrati) che facilitano e ottimizzano le operazioni di sviluppo del codice sorgente.

40


Figura 1.15 - La finestra di startup di Xcode.

Xcode comprende inoltre il simulatore iOS per testare le proprie applicazioni senza essere costretti a ricorrere al device fisico. Nonostante il simulatore rappresenti un’u-tile risorsa non può essere considerato sostitutivo del test effettuabile sul device reale, che in ultima istanza deve essere sempre effettuato prima di rilasciare un’applicazio-ne. Come precedentemente segnalato Xcode è disponibile per il download all’indi-rizzo https://developer.apple.com/xcode/. Per conoscere le novità introdotte in ogni versione di Xcode si può cercare la pagina web “What’s New in Xcode” mantenuta all’interno della documentazione ufficiale Apple accessibile online.

Il progetto GNUstepGNUstep propone una versione open e free delle API Cocoa (NeXTSTEP/OpenStep in passato) e dei tool di sviluppo necessari. GNUstep implementa le librerie AppKit e Foundation di Cocoa e include Gorm (Interface Builder) e Project Center (Xcode).GNUStep è disponibile per Windows e Unix (GNU-Linux e GNU/HURD, Solaris, NetBSD, OpenBSD, FreeBSD, Darwin) a partire dall’indirizzo: http://wwwmain.gnustep.org/.Per installare la versione Windows occorre prima installare, nell’ordine, due pacchetti:

1. GNUstep MSYS System;2. GNUstep Core.

Il primo pacchetto, GNUstep MSYS System, contiene tutti i package necessari per eseguire GNUstep (shell, librerie grafiche e altro), mentre GNUstep Core, come si in-tuisce dal nome, contiene le librerie GNUstep del core.

41


Figura 1.16 - La homepage del progetto GNUstep.

Scrivere il primo programma Objective-CConcludiamo questo capitolo introduttivo su Objective-C scrivendo il nostro primo programma. Apriamo Xcode e:

1. dal menu File scegliamo la voce New > Project (⇧+⌘+N);2. si apre un box titolato Choose a template for your new project;3. sotto la dicitura Mac OS X selezioniamo Application > Command Line Tool;4. si apre un box intitolato Choose options for your new project;5. inserire HelloWorld come Product Name, ossia il nome del progetto;6. inserire come Company Identifier una stringa che ci identifichi; tipicamente si

usa una sintassi di tipo reversed domain, per esempio it.andreapicchi;7. scegliere come Type il tipo di progetto Foundation;8. controllare che sia selezionato Use Automatic Reference Counting.

A questo punto si sarà aperta una finestra di Xcode. Andiamo sul menu a tendina Xco-de, scegliamo la voce Preferences (⌘+,) e dal tab Text Editing selezioniamo l’opzione Show: line numbers, poi clicchiamo su OK e chiudiamo. Abbiamo abilitato il conteggio delle righe di codice. Questa funzione ci tornerà utile per identificare linee di codice precise durante le spiegazioni dettagliate.

42


Figura 1.17 - L’opzione di Xcode per visualizzare il numero delle linee di codice.

In Xcode, nella colonna di sinistra che definisce la Navigator Area, abbiamo i nostri file e alcune risorse che vedremo più avanti. Per adesso, sotto la voce che rappresenta il nome del progetto, possiamo appunto selezionare il nome del progetto e vedere alcuni file, tra cui main.m. Clicchiamo su questo file e nella barra sottostante apparirà il suo contenuto, ovvero il seguente codice Objective-C:

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[]){ @autoreleasepool {

// insert code here... NSLog(@"Hello, World!");

} return 0;}

Il codice dopo il doppio slash (//) rappresenta un commento; editiamolo insieme alla riga sottostante come mostrato di seguito:

Programma 1.1 - HelloWorld: codice

01 //02 // PROJECT: HelloWorld03 // FILE: HelloWorld.m04 //05 // CREATO DA: Andrea Picchi06 //07 08 #import <Foundation/Foundation.h>09 10 int main (int argc, const char * argv[]) {11 @autoreleasepool {

43


12 13 // il mio primo programma objective-c14 NSLog(@"Hello, World! Si Comincia!");15 16 }17 return 0;18 }

Ora che abbiamo scritto il codice dobbiamo compilarlo, scegliendo dal menu Product la voce Build (⌘+B). Nella parte inferiore di Xcode, se non abbiamo commesso errori, la console di debug mostrerà un’icona con la dicitura Build succeeded per aggiornarci sull’avvenuta compilazione. In Figura 1.18 possiamo vedere lo spazio di lavoro di Xcode.

Figura 1.18 - Le aree che definiscono lo spazio di lavoro di Xcode.

Una volta compilato il nostro codice sorgente (che viene trasformato in un file detto anche file oggetto) possiamo eseguire il nostro programma. Per eseguire tale ope-razione dobbiamo andare sul menu Run e selezionare Run (⌥+⌘+R). La console di debug riporterà il seguente output:

Programma 1.1 - HelloWorld: output

2014-10-20 15:30:10.270 HelloWorld[1523:303] Hello, World! Si Comincia!Program ended with exit code: 0.

44


Ogni volta che il debugger ritorna uno stato di valore 0 significa che non ci sono stati errori a run-time, ovvero a tempo di esecuzione.

Spiegazione del programma HelloWorldLe prime sei linee di codice sono commenti. Ora potranno sembrare superflui, ma all’interno di un progetto complesso possono fornire preziose informazioni sul tipo di codice, sul progetto cui appartiene, su chi lo ha scritto e molto altro. I commenti possono essere di tipo mono riga, se sono preceduti dal doppio slash (//), oppure multi riga, se sono racchiusi dalla combinazione di slash e asterisco (/* */). I seguenti commenti sono egualmente ammissibili in Objective-C:

//// PROJECT: HelloWorld// FILE: HelloWorld.m//// CREATO DA: Andrea Picchi//

/*PROJECT: HelloWorldFILE: HelloWorld.m

CREATO DA: Andrea Picchi*/

La linea 8 riporta l’importazione del framework Foundation e, nella fattispecie, del file Foundation.h, che contiene informazioni sulle classi e funzioni necessarie per eseguire le operazioni, come nel nostro caso la stampa a video della frase "Hello, World! Si Comincia!".


Il Foundation Framework è un file di sistema, non è codice che abbiamo scritto noi. Noi lo importiamo per usarlo e, una volta importato, è come se fosse scritto nel nostro programma.

int main (int argc, const char * argv[])

La linea 10 rappresenta quello che viene chiamato il main del programma. La parola chiave main serve a indicare precisamente dove il programma inizia la sua esecuzione. La parola riservata int specifica che il tipo di valore che il main ritornerà sarà un intero (analizzeremo tale caratteristica nel Capitolo 2). Per adesso ignoriamo la sintassi tra

45


parentesi tonde, perché si riferisce ad argomenti che tratteremo più avanti, quando avremo acquisito le conoscenze necessarie per comprenderli.

@autoreleasepool

La linea 11 rappresenta il primo vero statement, o istruzione, del main. Essa riserva uno spazio in memoria per un autoreleasepool. Per adesso sorvoliamo anche su questa istruzione, poiché tratteremo in dettaglio la gestione della memoria nel Capitolo 13.

NSLog(@"Hello, World! Si Comincia!");

Nella linea 14 viene chiamata la routine NSLog, cui viene passato come parametro la stringa "Hello, World! Si Comincia". Il carattere speciale @ precede la stringa, che viene racchiusa dai doppi apici (""). La routine NSLog è una funzione che fa parte della libreria Objective-C e ha il compito di stampare a video il proprio argomento. Ogni statement deve terminare con un punto e virgola (;).La fine del nostro main, o funzione main, per convenzione, riporta sempre lo statement che possiamo vedere alla linea 17. Il main ritorna un valore 0 ogni volta che termina la sua esecuzione. Per convenzione il ritorno del valore 0 significa che il programma (il main) è terminato con successo senza riportare errori. Ogni valore diverso da 0 indica generalmente che qualche problema è occorso durante l’esecuzione.L’output completo che possiamo vedere nella console di debug riporta sia l’output vero e proprio del programma sia l’esito dello stesso, rappresentato dal valore ri-tornato dal main:

2014-10-20 15:30:10.270 HelloWorld[1523:303] Hello, World! Si Comincia!Program ended with exit code: 0.

Variante al primo programma Objective-CDopo avere analizzato il primo programma vediamo se siamo in grado di intuire l’ou-tput del seguente codice sorgente.

Programma 1.2 - HelloWorld2: codice


int main (int argc, const char * argv[]) { @autoreleasepool {

// il mio primo programma objective-c NSLog(@"Hello, World! Si Comincia!"); NSLog(@"..e non pensavo fosse tanto facile!");

46


} return 0;}

Programma 1.2 - HelloWorld2: output

2014-10-20 15:30:10.270 HelloWorld[1624:303] Hello, World! Si Comincia!2014-10-20 15:30:10.270 HelloWorld[1624:303] ..e non pensavo fosse tanto facile!Program ended with exit code: 0

Possiamo usare più volte la routine NSLog per creare messaggi a video su più righe di-verse. Se vogliamo ottenere lo stesso risultato, ma senza essere costretti a chiamare due volte la routine NSLog, possiamo usare una combinazione speciale di due caratteri, il backslash e la lettera n (\n). Questa combinazione è conosciuta come carattere new-line e proviene direttamente dal linguaggio C (vedremo in dettaglio i caratteri speciali in uno dei prossimi capitoli). Lo stesso programma con l’uso della sequenza newline ha il codice seguente:

Programma 1.3 - HelloWorld3: codice


int main (int argc, const char * argv[]) { @autoreleasepool { // il mio primo programma objective-c NSLog(@"Hello, World! Si Comincia!\n..e non pensavo fosse tanto facile!"); } return 0;}

Programma 1.3 - HelloWorld3: output

2014-10-20 15:30:10.270 HelloWorld[1642:303] Hello, World! Si Comincia! ..e non pensavo fosse tanto facile!Program ended with exit code: 0

Stampare a video valori di variabiliLa routine NSLog non solo può essere usata per stampare a video stringhe alfanumeri-che, ma anche valori di variabili. Nella Tabella 1.3 possiamo vedere alcuni dei simboli che tale routine può stampare a video e i simboli usati per farlo (vedremo tutti i tipi di dati e i relativi simboli in Objective-C nel Capitolo 3).

47


Tabella 1.3 - Tipi di dato stampabili tramite la routine NSLog.

Tipo di dato Caratteri di conversione NSLog

intero %i

float %f

double %d

char %c

id %p

Nel seguente programma, chiamato Somma, stamperemo a video il risultato di un’ope-razione di somma.

Programma 1.4 - Somma: codice

01 #import <Foundation/Foundation.h>02 03 int main (int argc, const char * argv[]) {04 @autoreleasepool {05 06 int somma;07 08 somma = 10 + 15;09 NSLog(@"La somma tra 10 e 15 vale %i", somma);10 11 }12 return 0;13 }

Nel nostro primo programma abbiamo prima compilato con il comando Build e in se-guito eseguito con il comando Run.

Figura 1.19 - Il Pulsante Build & Run di Xcode, per eseguire compilazione ed esecuzione in un solo clic.

48


L’interfaccia di Xcode mette a disposizione un pulsante per lanciare la compilazione e l’esecuzione con un singolo clic: il pulsante Build & Run (⌥+⌘+⏎). Se non abbiamo commesso errori l’output sarà il seguente:

Programma 1.4 - Somma: output

2014-10-20 15:30:10.270 HelloWorld[1658:303] La somma tra 10 e 15 vale 25Program ended with exit code: 0

Spiegazione del programma SommaLe prime quattro linee di codice sono identiche al programma HelloWorld su cui ab-biamo lavorato precedentemente:


int main (int argc, const char * argv[]) { @autoreleasepool { ...

La linea 6 è occupata dalla dichiarazione di una variabile. In un programma, prima di usare una variabile bisogna dichiararla, perché il compilatore deve avere queste infor-mazioni per generare le istruzioni necessarie a memorizzarla e recuperarla.La parola riservata int dice che la variabile memorizzerà un valore intero (ovvero sen-za valori decimali), mentre somma specifica il suo nome. Anche in questo caso la dichia-razione deve terminare con un punto e virgola (;):

int somma;

La linea 8 è quella in cui, attraverso l’operatore di assegnazione uguale (=), alla varia-bile somma viene assegnato un valore derivato dall’applicazione dell’operatore somma a due valori interi, nella fattispecie 10 e 15:

NSLog(@"La somma tra 10 e 15 vale %i", somma);

La routine NSLog alla linea 9 questa volta ha due argomenti anziché uno, come abbiamo visto nei programmi 1.1 e 1.2. Questi due argomenti sono separati da una virgola (,) e sono rispettivamente la stringa da stampare a video, racchiusa tra una coppia di doppi apici (""), e la variabile somma, o meglio il suo valore.Il carattere speciale percentuale (%) precede il tipo di valore che dovrà essere vi-sualizzato. La posizione in cui questa coppia di caratteri %i sarà inserita all’interno della stringa è la stessa in cui verrà visualizzato il valore memorizzato. Possiamo vedere la coppia di caratteri %i anche come un segnaposto all’interno della stringa da visualizzare a video. Ogni volta che una routine NSLog trova la coppia di caratteri

49


%i in una stringa inserisce in quel punto il valore dell’argomento successivo della routine stessa.

return 0;

La linea 12 è identica ai programmi che abbiamo visto in precedenza: ritorna il valore 0 a fine esecuzione.

Utilizzare input da tastieraMolto spesso in un programma determinati valori di variabili devono per qualche mo-tivo provenire dal cosiddetto mondo reale. Tali valori possono essere introdotti nel mondo binario della macchina attraverso varie periferiche più o meno complesse (un esempio molto attuale sono i sensori), tra cui anche la tastiera.Tale requisito può essere soddisfatto mediante l’uso della routine scanf. Il concetto alla base della routine scanf è simile a quello della routine NSLog. La routine NSLog porta un valore nel mondo reale stampandolo a video, mentre scanf introduce un valore nell’u-niverso della macchina memorizzando una sequenza da tastiera.Quando inizieremo a lavorare sulle interfacce grafiche non useremo né la routine scanf né la NSLog, ma ora i nostri scopi sono ancora puramente didattici. Vediamo come potremmo modificare il programma 1.3 per essere in grado di usare un input da tastiera:

Programma 1.5 - Input: codice

01 #import <Foundation/Foundation.h>02 03 int main (int argc, const char * argv[]) {04…..@autoreleasepool {05 06 int somma;07 int addendo1;08 int addendo2;09 10 NSLog(@"Inserisci il primo addendo");11 scanf ("%i", &addendo1);12 13 NSLog(@"Inserisci il secondo addendo");14 scanf ("%i", &addendo2);15 16 somma = addendo1 + addendo2;17 NSLog(@"La somma tra %i e %i vale %i", addendo1, addendo2, somma);18 19 }20 return 0;21 }

50


Programma 1.5 - Input: output

2014-10-20 15:30:10.270 HelloWorld[1705:303] Inserisci il primo addendo102014-10-20 15:30:10.270 HelloWorld[1705:303] Inserisci il secondo addendo152014-10-20 15:30:10.270 HelloWorld[1705:303] La somma tra 10 e 15 vale 25Program ended with exit code: 0.

Spiegazione del programma InputTralasciando le parti comuni agli esempi precedenti, passiamo direttamente ad analiz-zare la routine scanf e la sua sintassi. Prima, però, notiamo come in questo programma vi sia la necessità di utilizzare tre variabili e come tali variabili debbano essere dichia-rate prima di essere usate nel programma:

scanf ("%i", &addendo1);

Dopo che la routine NSLog ci ha invitati a inserire il valore del primo addendo alla linea seguente, alla linea 11 troviamo la prima chiamata alla routine scanf. Il primo argomento della scanf è il formato della stringa da memorizzare. Nella routine NSLog, che usa il carattere speciale @ per il suo primo argomento, tale primo argomento è sempre un oggetto di tipo NSString. Nella scanf il primo argomento è invece in stile linguaggio C e non è preceduto dal carattere speciale @, bensì da quello di percen-tuale (%). Come nella routine NSLog, nella scanf la coppia di caratteri %i viene usata per indicare un valore intero.Il secondo argomento della routine scanf specifica dove il valore digitato da tastiera verrà memorizzato. Il valore digitato da tastiera sarà memorizzato quando l’utente premerà il tasto Invio sulla tastiera; il tasto Invio, di fatto, segnala che la sequenza da memorizzare è terminata.Il secondo argomento è preceduto dal nome della variabile dove verrà memorizzato l’input preceduto dal carattere speciale &. Il carattere & è in realtà un operatore vero e proprio, ma per adesso non occorre sapere come funziona in dettaglio. Ne parleremo approfonditamente nel Capitolo 14, dove affronteremo il linguaggio C.

RiepilogoIn questo primo capitolo abbiamo introdotto il linguaggio Objective-C, illustrando al-cune delle sue caratteristiche principali. Abbiamo introdotto la differenza tra tempo di compilazione e tempo di esecuzione, ripercorrendo le fasi che portano dalla scrittura e all’esecuzione di un codice sorgente.

51


Abbiamo presentato i due sistemi operativi OS X e iOS introducendo due ambienti di sviluppo, quello proprietario di Apple e quello Open Source GNUStep, compatibile con i sistemi Windows e Linux.Nella parte finale del capitolo abbiamo scritto il primo programma Objective-C con due varianti, capaci di accettare input da tastiera. Nel prossimo capitolo inizieremo a vedere in dettaglio le classi, le istanze e i messaggi.

Domande• Da quale linguaggio di programmazione deriva il linguaggio Objective-C?• Quali sono i principi fondamentali della programmazione orientata agli oggetti?• Che differenza esiste tra “tempo di compilazione” e “tempo di esecuzione”?• Quale routine viene utilizzata per stampare a video dei valori?• Quale funzione viene utilizzata per memorizzare un input da tastiera?

Esercizi• Scrivere un programma che stampi a video in colonna i titoli dei capitoli di que-

sto libro.• Scrivere un programma che prenda in input un numero e stampi il suo quadrato.• Scrivere un programma che prenda in input il numero di tessera universitaria,

il numero di matricola e l’anno accademico e ne stampi la scheda riassuntiva.• Scrivere un programma che prenda in input una sequenza di sei numeri (5+1) e

stampi tale sequenza specificando qual è il numero jolly.• Scrivere un programma che prenda in input il lato maggiore e il lato minore di un

rettangolo e ne stampi area e perimetro.

- Andrea Picchi - Objective-C 2 · Programmare con Objective-C per iOS e OS X è nato con...

Documents

Transcript of - Andrea Picchi - Objective-C 2 · Programmare con Objective-C per iOS e OS X è nato con...