Share
Benvenuti nella mia serie su come affrontare il fantastico linguaggio che è Objective-C. Nel corso di questa piccola serie di articoli, il mio obiettivo è di portarti da nessuna precedente esperienza con Objective-C a utilizzarlo con sicurezza nelle tue applicazioni. Questo non è un lavoro urgente - quindi non aspettarti di sfogliare le basi e stare lontano - non passeremo solo attraverso l'essenziale, ma anche le migliori pratiche che puoi applicare per assicurarti che il tuo codice sia il migliore può essere. Andiamo direttamente!
Se stai leggendo questa serie, azzarderò un'ipotesi che già conosci, ma per quelli di voi che non lo fanno, non ti preoccupare perché alla fine di questa parte saprai di cosa si tratta -front e dentro-fuori.
Objective-C è un linguaggio orientato agli oggetti che si trova in cima al linguaggio C (ma scommetto che hai indovinato quella parte!). Il suo uso principale nel computing moderno è su Mac OS X come linguaggio desktop e anche su iPhone OS (o come ora viene chiamato: iOS). Originariamente era la lingua principale di NeXTSTEP OS, noto anche come sistema operativo Apple acquistato e disceso da Mac OS X, il che spiega perché la sua casa principale oggi risiede nei sistemi operativi Apple.
Poiché Objective-C è un superset di C rigido, siamo liberi di usare C in un file Objective-C e verrà compilato correttamente. Poiché ogni compilatore di Objective-C compilerà anche qualsiasi codice C dritto passato, abbiamo tutta la potenza di C insieme alla potenza degli oggetti forniti da Objective-C.
Se sei un po 'confuso a questo punto, pensa in questo modo: tutto ciò che C può fare, l'Objective-C può fare anche tu, ma non il contrario.
In questa serie, non ci concentreremo sulla creazione di applicazioni per l'iPhone. Invece, ci concentreremo di più sul linguaggio stesso e per questo motivo tutto ciò di cui avrete bisogno è un Mac con un compilatore come GCC. Se hai installato gli strumenti di sviluppo di Apple (Xcode, Interface Builder, ecc.), GCC dovrebbe essere già installato. In caso contrario, vai al sito Web degli sviluppatori di Apple e procurati una copia gratuita.
Per quanto riguarda i prerequisiti, mentre non mi aspetto che tu abbia una preparazione completa in informatica, una certa conoscenza della programmazione in generale o di C in particolare sarebbe sicuramente un vantaggio. Se non hai molta esperienza di programmazione precedente, non preoccuparti: lo raccoglierai in pochissimo tempo!
Se stai usando Windows (che è improbabile dato che questo tutorial è rivolto agli sviluppatori di iPhone) puoi ancora compilare Objective-C sul tuo sistema usando un compilatore come CygWin o MinGW. Questa serie di tutorial è adatta agli utenti Mac, ma se utilizzi Windows e riscontri problemi, assicurati di lasciare un commento e vedrò se posso aiutarti.
Prima di poter vedere il tuo codice in azione, devi essere in grado di compilarlo in qualcosa di eseguibile. Spero che tu abbia la tua copia del GCC pronta. Compilare è davvero facile, un semplice comando di una riga.
NOTA:
La compilazione è il processo di "traduzione" di un linguaggio di computer di alto livello, come Objective-C o PHP, in un codice macchina di basso livello che può essere elaborato da un computer quando il programma viene eseguito.
Tutti i programmi che vediamo in esecuzione nel nostro sistema operativo Mac OS sono costituiti da una serie di istruzioni visualizzate visivamente in una GUI o in un'interfaccia utente grafica. A differenza dell'interazione con un mouse del programma GUI con cui la maggior parte di noi ha familiarità, è possibile impartire comandi direttamente al sistema operativo attraverso un'interfaccia testuale nota come "terminale" o "riga di comando".
L'applicazione della riga di comando in Mac OS si chiama Terminale e può essere trovata in Applicazioni -> Utilità. Vai avanti e apri Terminale ora (puoi anche cercarlo in Spotlight). Terminal ha diversi comandi di base di cui dovresti essere a conoscenza per poterlo utilizzare correttamente. Uno dei comandi più importanti da sapere è CD, che sta per "cambia directory". Questo comando ci consente di cambiare la posizione del file system dal terminale. Non possiamo semplicemente dire a Terminal di compilare il nostro file se non lo mostriamo dove il file è il primo! Per passare a una directory desiderata, puoi utilizzare un percorso completo come:
cd / Utenti / MyName / Desktop / Test
Puoi anche utilizzare percorsi relativi, in alcuni casi puoi digitare solo un nome di cartella. Ad esempio, se sei già nella cartella Desktop, puoi semplicemente digitare:
cd test
per arrivare alla cartella Test.
Cosa succede se vuoi vedere dove sei attualmente? Il nome della cartella immediata viene visualizzato prima del prompt (il bit in cui si digita). Ad esempio, se il tuo prompt dice Dan-Walkers-MacBook: Desktop iDemonix $ Posso supporre che io sia nella cartella Desktop. Se non sei sicuro, puoi anche digitare pwd per visualizzare il percorso file assoluto della posizione corrente.
Se si desidera elencare quali file e cartelle si trovano nella cartella corrente, utilizzare il comando list: ls. Infine, se desideri andare su una directory in una cartella genitore, digita "CD… Quindi, se ci trovassimo nella cartella Test, che si trova all'interno della cartella Desktop, ma volessimo invece andare alla cartella Desktop, potremmo digitare CD… per andare alla directory superiore, Desktop. Se volessimo raggiungere la home directory, dovremmo digitare cd ... / ... salire di due livelli. In alternativa, per arrivare alla directory home puoi semplicemente digitare cd ~ da qualsiasi luogo.
Quando si utilizza l'applicazione Terminale, la compilazione ha il seguente aspetto:
gcc inputfile.m -o outputfile
Probabilmente hai già indovinato come funziona: inputfile.m contiene il nostro codice (.m è l'estensione utilizzata per i file Objective-C) e -o dice a gcc che vogliamo che il nostro eseguibile sia chiamato qualunque cosa specifichiamo successivamente, che nell'esempio sopra è file di uscita. Per eseguire la nostra creazione dopo la compilazione, digitiamo semplicemente:
./file di uscita
Semplice.
Quando compili, il compilatore genererà errori, notifiche o avvisi relativi alla sintassi del tuo codice. Gli errori generati durante la compilazione sono comprensibilmente definiti errori "in fase di compilazione" e questa è spesso la parte più stressante della scrittura di un'applicazione (specialmente quando il codice non viene compilato perché si inserisce un singolo carattere nel posto sbagliato o si dimentica di termina una riga con un punto e virgola). La compilazione può anche richiedere del tempo quando si scrivono applicazioni di grandi dimensioni costituite da più file, che è anche un'altra ragione per cui la compilazione può essere un'esperienza noiosa. Questo fatto ha portato a uno scherzo programmatore onnipresente visto spesso sulle t-shirt di uomini con la barba incolta: "Non sto rallentando, il mio codice è in fase di compilazione."
L'obiettivo C non è così difficile da imparare. Una volta che ti trovi in linea con i principi di base, puoi scegliere il resto mentre vai avanti abbastanza facilmente. È necessario avere una comprensione dei fondamenti della programmazione in C, e questo è ciò che il resto di questo tutorial coprirà.
Diamo un'occhiata a un'applicazione di base in C:
#includereint main () printf ("Hello World \ n"); ritorno 0;
Tutto ciò che questa applicazione farà quando lo si esegue è visualizzare la stringa "Hello World" nel terminale e uscire.
NOTA:
Curioso dell'istruzione "return 0"? Poiché abbiamo detto al compilatore che la funzione main () restituirà un intero, restituiremo il valore intero costante '0' alla fine della funzione. Per convenzione, restituendo "0" al programma chiamante che il nostro programma ha terminato l'esecuzione senza errori.
Per provare questo, lancia Xcode e crea una nuova classe Objective-C. Elimina tutto il codice che Xcode ti fornisce per impostazione predefinita e inserisci il codice sopra riportato. Una volta che lo hai fatto, puoi compilarlo usando Terminal. Apri Terminale e cambia nella posizione in cui si trova il tuo file, se hai salvato sul desktop digita semplicemente desktop cd in modo che Terminal stia leggendo dal tuo desktop. Quindi digitare questo comando:
gcc program1.m -o program1
Il tuo programma dovrebbe compilare senza errori. Per eseguirlo, digita semplicemente:
./ programma1
Quindi premi Invio.
Fantastico, quindi cosa è successo veramente lì? Bene, per prima cosa abbiamo importato una libreria chiamata stdio che gestisce le funzioni standard di i / o (input output), come printf (). Creiamo quindi una funzione chiamata main che dovrebbe restituire un intero o un intero che è fondamentalmente un numero senza punto decimale. Quindi usiamo la funzione printf () per produrre "Hello World" nel terminale. Il \ n che usiamo dice a Terminal di inserire una nuova riga dopo il testo. Infine, restituiamo 0 (ricordiamo che main dovrebbe restituire un intero) che indica al sistema operativo che tutto è andato bene. Usiamo il nome principale perché questo viene attivato automaticamente quando il programma viene eseguito.
Finora tutto dovrebbe essere piuttosto semplice: volevamo scrivere del testo su Terminale, quindi abbiamo importato una libreria con una funzione per scrivere del testo, quindi abbiamo usato una funzione da quella libreria per scrivere il testo. Immagina che ciò che importi sia una libreria fisica e printf () è uno dei libri disponibili.
Soldiering ahead, siamo ora alle variabili. Una delle cose fondamentali che dobbiamo essere in grado di fare nelle nostre applicazioni è memorizzare temporaneamente i dati. Lo facciamo usando le variabili, che sono contenitori che possono contenere vari tipi di dati ed essere manipolati in vari modi. Utilizziamo le variabili per archiviare tutti i tipi di dati, ma dobbiamo prima dire al compilatore cosa intendiamo archiviare al suo interno. Ecco alcune delle più importanti variabili che dovresti sapere per ora:
Quando non utilizziamo le variabili, spesso utilizziamo le costanti. Una costante non cambierà mai: sappiamo sempre quale sarà il valore. Se combiniamo le costanti otteniamo un'espressione costante, di cui sapremo sempre il risultato. Per esempio:
123 + 2 = 125
Questa è un'espressione costante, 123 + 2 sarà sempre uguale a 125, non importa quale. Se sostituissimo una costante per una variabile, la nuova espressione sarebbe simile a questa:
123 + i = ?
Poiché io sono una variabile dinamica, non conosciamo il risultato di questa equazione. Possiamo cambiare i con ciò che vogliamo e ottenere un risultato diverso. Questo dovrebbe darti un'idea di come funzionano le variabili.
Una cosa che dobbiamo ancora sapere è come visualizzare le variabili come abbiamo mostrato sopra "Hello World"? Usiamo ancora la funzione printf (), tranne che cambia leggermente questa volta:
#includereint main () int someNumber = 123; printf ("Il mio numero è% i \ n", someNumber); ritorno 0;
Quello che abbiamo fatto qui è detto alla funzione printf () dove vogliamo che il nostro intero appaia, quindi dove può essere trovato. Questo è diverso da molti linguaggi come PHP dove puoi semplicemente inserire la variabile nel testo.
Non siamo limitati a una sola variabile in printf (). La funzione può accettare più parametri separati da virgole, in modo tale che possiamo inserire tutti i segni di formattazione nel testo. Sopra usiamo% i come segno di formattazione perché includevamo un numero intero. Altre variabili hanno i loro specificatori di formato:
Una cosa che voglio toccare prima di andare avanti è il tipo di carattere. Una variabile di tipo char può gestire solo caratteri singoli, quando è tutto ciò di cui abbiamo bisogno è fantastico, ma se abbiamo bisogno di una stringa di testo è abbastanza inutile. Per aggirare questo, usiamo qualcosa chiamato un array di caratteri.
Immagina di avere una frase lunga 11 caratteri (come "Ciao mondo" - non dimenticare di includere lo spazio), un array di caratteri è come avere 11 caratteri ma tutti incollati insieme. Ciò significa che il valore dell'array di caratteri nel suo complesso è "Ciao mondo", ma char [0] è "H". Tra parentesi è il carattere che stai cercando, perché mettiamo 0 otteniamo il primo carattere. Non dimenticare che il conteggio negli array di solito inizia da 0, non 1.
Quando un'applicazione deve prendere una decisione, usiamo un condizionale. Senza condizionali, ogni volta che eseguivi la tua applicazione sarebbe esattamente la stessa, come guardare un film. Prendendo decisioni basate su variabili, input o qualsiasi altra cosa, possiamo fare in modo che l'applicazione cambi - questo potrebbe essere semplice come un utente che immette un numero seriale o che preme un pulsante più di 10 volte.
Esistono diversi tipi di condizionali, ma per ora guarderemo solo i più comuni e basilari: il Se dichiarazione. Un'istruzione if fa quello che sembra, controlla se qualcosa è vero, quindi agisce in entrambi i modi. Per esempio:
#includereint main () if (1 == 1) // Questo è sempre vero // Fai qualcosa qui return 0;
Se 1 è uguale a 1, allora viene eseguito qualsiasi elemento tra parentesi. Ci si potrebbe anche chiedere perché abbiamo usato due segni di uguale anziché uno. L'uso di due segni di uguale è un operatore di uguaglianza, che verifica se i due sono uguali tra loro. Se usiamo un singolo segno di uguale, stiamo cercando di assegnare il primo valore al secondo valore.
Sopra, poiché 1 sarà sempre uguale a 1, verrà eseguito qualsiasi elemento tra parentesi. E se volessimo fare qualcosa se questo non fosse vero? Ecco dove altro entra. Usando altro possiamo eseguire il codice quando il condizionale if restituisce false, in questo modo:
int main () if (1 == 1) // Fai qualcosa qui. else // L'universo è rotto! restituisce 0;
Certamente, nella vita reale, non verificheremo per assicurarci che 1 sia uguale a 1, ma il punto è fatto. Considera un'applicazione che si chiude se premi tre volte il pulsante di chiusura (fastidioso ma rilevante). Puoi controllare tra parentesi per vedere quante volte è stato spinto. Se è inferiore a 3, il tuo blocco else potrebbe eseguire codice per dire all'utente quante volte il pulsante deve essere premuto per uscire.
Guarderemo le condizioni più quando verremo a utilizzarle nelle nostre applicazioni più avanti nella serie.
Ora esaminiamo un ciclo di programmazione. I loop, come suggerisce il nome, passano attraverso un pezzo di codice e lo eseguono più volte. Questo può essere molto utile in situazioni come la compilazione di un elenco o la ripetizione di un pezzo di codice fino a quando un condizionale non restituisce true.
Esistono tre tipi di loop, nell'ordine del più comune: per, mentre, e fare. Ognuno viene utilizzato per ripetere l'esecuzione di un blocco di codice, ma funzionano in modo diverso. Ecco alcuni esempi di ciascuno:
Accentsconagua
// if loop int main () int i = 9; int x = 0; per (x = 0; x < i; x++) printf("Count is: %i\n", x); return 0; All'inizio potrebbe sembrare un po 'complesso, ma in realtà non lo è. Tra parentesi dopo per è l'iniziatore, un condizionale e l'azione. Quando inizia il ciclo for, esegue l'iniziatore, che nel nostro caso sopra imposta x a 0. Ogni volta che il ciclo viene eseguito (inclusa la prima volta) controlla il condizionale, che è "è x più piccolo di i?" Infine, dopo ogni ciclo attraverso il codice, il ciclo esegue l'azione - che sopra aumenta x di uno. Semplice. Dato che x aumenta di uno ogni volta, x presto non sarà più minore di me e il ciclo finirà e il programma continuerà a girare.
// while loop int main () int x = 0; mentre (x < 10) printf("Count is: %i\n", x); //Watch OUT! Something is missing. return 0; Simile al ciclo for, il ciclo while eseguirà il codice tra parentesi finché il condizionale non sarà falso. Poiché x è 0 e non lo cambiamo nel blocco di codice, il precedente funzionerebbe per sempre, creando un "ciclo infinito". Se desideri incrementare x, nel caso del nostro ciclo while lo farebbe tra parentesi:
// while loop int main () int x = 0; mentre (x < 10) x++; printf("Count is: %i\n", x); return 0; Il ciclo do è essenzialmente il ciclo while, tranne le esecuzioni condizionali dopo il blocco di codice. Ciò significa che quando si utilizza un ciclo do, il codice è garantito per essere eseguito almeno una volta:
// do loop int main () int x = 0; do x ++; printf ("Conteggio è:% i \ n", x); while (x < 10); return 0; I puntatori possono causare molta confusione con i nuovi arrivati alla programmazione o solo nuovi arrivati a C. Inoltre, non è immediatamente chiaro ad alcune persone come sono utili, ma lo imparerete gradualmente nel tempo. Quindi, che cos'è un puntatore?
Come suggerisce il nome, i puntatori indicano una posizione. In particolare, posizioni nella memoria del computer. Pensa in questo modo, quando creiamo una variabile (diciamo che è un intero chiamato'foo 'come è così popolare con la teoria della programmazione) e diamo un valore, ad esempio 123, abbiamo proprio questo: una variabile con un valore di 123. Ora, se impostiamo un puntatore su foo, allora abbiamo un modo per accedervi indirettamente. Cioè, abbiamo un puntatore di tipo int che punta a foo che contiene il valore '123.' Questo sarebbe fatto in codice in questo modo:
int foo = 123; // Questa è una variabile intera int * ptr = &foo; // Questo è un puntatore a una variabile intera
Chiaro come fango? Non sudare. I puntatori sono difficili - spesso considerati la cosa più difficile da imparare quando si prende in mano il linguaggio C. I puntatori alla fine diventeranno per voi una seconda natura, e in questa serie ci saranno altri suggerimenti all'interno di Objective-C.
Ti è appena stata fornita una panoramica del corso accelerato sui fondamentali del linguaggio C. Questa parte della serie doveva essere un veloce manuale su C per prepararti e prepararti per il resto della serie e avrebbe dovuto essere particolarmente utile a coloro che hanno già familiarità con la programmazione in un'altra lingua. Se sei nuovo alla programmazione in generale o se sei ancora in dubbio su qualsiasi base di C, rileggi la precedente e sentiti libero di lasciare domande nei commenti.
Prima della prossima volta, assicurati di provare e compilare i tuoi programmi utilizzando il codice sopra. Mettiti alla prova, come fare un ciclo eseguito 10 volte e contare ogni volta nel ciclo usando printf. Non c'è nulla di male nel provare e sperimentare, se va male allora probabilmente è ancora meglio perché ti porterà sulla giusta strada per risolvere il tuo codice.
Per questa settimana, termineremo con una semplice sfida. Devi creare tre programmi che contano fino a 10 usando ogni tipo di loop. Dato che useremo i loop spesso in Objective-C, è bene che impari a crearli a memoria. Dovrebbe essere abbastanza facile, quindi prova a contare da 10 a 1 in seguito (se ++ incrementa di uno, quale potrebbe essere il codice da decrementare di 1?).
Nella prossima puntata di questa serie, fornirò una panoramica di come funziona Objective-C. Analizzeremo anche la programmazione orientata agli oggetti e i suoi usi, oltre ad analizzare dettagliatamente classi, istanze, metodi, ereditarietà e altro ancora.
La prossima settimana dovrebbe davvero aiutarti a capire cosa rende Objective-C un linguaggio così fantastico e perché estende davvero il linguaggio C in così tanti modi utili.
Se hai qualche domanda, puoi lasciare un commento qui sotto dove cercherò di continuare a controllare o puoi mandarmi un messaggio su Twitter (http://www.twitter.com/iDemonix) dove tornerò a APPENA POSSIBILE.
