Share
Välkommen till min serie om att ta tag i det fantastiska språket som är Objective-C. Under hela denna lilla serie av artiklar är mitt mål att ta dig från ingen tidigare erfarenhet av Objective-C för att använda det säkert i dina egna applikationer. Det här är inte ett skyndsamt jobb - så förvänta dig inte att bara skumma igenom grunderna och vara borta - vi kommer att gå igenom inte bara de nödvändiga sakerna, men också de bästa metoderna du kan ansöka för att säkerställa att din kod är bäst det kan vara. Låt oss hoppa rakt in!
Om du läser den här serien kommer jag att riskera en gissning som du redan vet, men för de av er som inte gör det, oroa dig inte, eftersom i slutet av den här delen vet du vad det är tillbaka till -front och inuti.
Objective-C är ett objektorienterat språk som ligger ovanpå C-språket (men jag slår vad om att du gissat den delen!). Det är primärt bruk i modern databehandling är på Mac OS X som skrivbordsspråk och även på iPhone OS (eller som det kallas nu: iOS). Det var ursprungligen huvudspråket för NeXTSTEP OS, även känt som operativsystemet Apple köpte och descended Mac OS X från, vilket förklarar varför sitt primära hem idag ligger på Apples operativsystem.
Eftersom Objective-C är en strikt superset av C, är vi fria att använda C i en Objective-C-fil och den kommer att kompilera böter. Eftersom en kompilator av mål-C också kommer att sammanställa en rak C-kod som passerar in i den, har vi all kraft av C tillsammans med kraften i objekt som tillhandahålls av Objective-C.
Om du är lite förvirrad på den här tiden, tänk på det så här: allt C kan göra, mål-C kan också göra, men inte tvärtom.
Under hela serien kommer vi inte fokusera på att bygga applikationer för iPhone. I stället kommer vi att koncentrera oss mer på språket i sig och därför är allt du behöver en Mac med kompilator som GCC. Om du har installerat utvecklingsverktygen från Apple (Xcode, Interface Builder, etc), bör GCC redan installeras. Om inte, gå sedan till Apples utvecklarwebbplats och skaffa dig en gratis kopia.
När det gäller förutsättningar, medan jag inte förväntar dig att du har en fullständig bakgrund i datavetenskap, skulle viss kunskap om programmering i allmänhet eller av C definitivt vara en bonus. Om du inte har mycket tidigare programmeringserfarenhet, oroa dig inte-du hämtar det på nolltid!
Om du kör Windows (vilket är osannolikt eftersom denna handledning riktar sig till iPhone-utvecklare) kan du fortfarande kompilera Objective-C på ditt system med hjälp av en kompilator som CygWin eller MinGW. Denna tutorial-serie tillgodoses Mac-användare, men om du använder Windows och stöter på några problem så var noga med att lämna en kommentar och jag ska se om jag kan hjälpa till.
Innan du kan se din kod i åtgärd måste du kunna kompilera den till något körbar. Förhoppningsvis har du nu din kopia av GCC redo. Kompilering är väldigt enkelt, ett enkelt linjeskommando.
NOTERA:
Kompilering är processen att "översätta" ett högt datorspråk, som mål-C eller PHP, till en maskinskal på låg nivå som kan bearbetas av en dator när programmet körs.
Alla program som vi ser att köra i vårt fina Mac OS-operativsystem består av en serie instruktioner som visuellt visas för oss i en GUI eller ett grafiskt användargränssnitt. I motsats till GUI-programmet interaktion med en mus som de flesta av oss känner till, är det möjligt att utfärda kommandon direkt till operativsystemet via ett textbaserat gränssnitt som kallas "terminal" eller "kommandorad".
Kommandoraden i Mac OS kallas Terminal och finns i Program -> Verktyg. Gå vidare och öppna Terminal nu (du kan också söka efter det i Spotlight). Terminal har flera grundläggande kommandon som du borde vara medveten om för att kunna utnyttja den korrekt. En av de viktigaste kommandona att veta är CD, vilket står för "byta katalog". Med det här kommandot kan vi ändra var i filsystemet Terminal läser från. Vi kan inte bara berätta för Terminal att kompilera vår fil om vi inte visar var filen är först! För att växla till en önskad katalog kan du använda en fullständig sökväg, till exempel:
cd / användare / myName / skrivbord / test
Du kan också använda relativa sökvägar, så att du bara kan skriva ett enda mappnamn i vissa fall. Om du till exempel finns i skrivbordsmappen kan du helt enkelt skriva:
cd-test
för att komma till testmappen.
Vad händer om du vill se var du är för närvarande? Det omedelbara mappnamnet visas före prompten (den bit där du skriver). Till exempel, om din fråga säger Dan- Walkers-MacBook: Skrivbord iDemonix $ Jag kan anta att jag är i skrivbordet mappen. Om du inte är säker kan du också skriva pwd för att visa den absoluta filfilen för den aktuella platsen.
Om du vill lista vilka filer och mappar som finns i den aktuella mappen, använd listkommandot: ls. Slutligen, om du vill gå upp en katalog till en föräldermapp, skriv "CD… ". Så, om vi var i testmappen, som ligger inne i skrivbordsmappen, men vi ville gå till skrivbordsmappen i stället kunde vi skriva CD… att gå upp till moderkatalogen, skrivbordet. Om vi ville komma till hemkatalogen skulle vi skriva CD… /… att gå upp i två nivåer. Alternativt, för att komma till hemkatalogen kan du bara skriva cd ~ från varsomhelst.
När du använder Terminal-programmet ser kompilering ut så här:
gcc inputfile.m -o outputfile
Du har förmodligen redan gissat hur det fungerar: inputfile.m innehåller vår kod (.m är förlängningen som används för Objective-C-filer) och -o berättar gcc vi vill att vår körbar ska kallas vad vi än anger, vilket i exemplet ovan är utdatafil. För att köra vår skapelse efter sammanställning skriver vi helt enkelt:
./ utdatafil
Enkel.
När du sammanställer, kommer kompilatorn att generera eventuella fel, meddelanden eller varningar relaterade till din kods syntax. Fel som genereras vid sammanställningen är begripligt hänvisade till som "kompileringstid" -fel, och detta är ofta den mest stressfulla delen av att skriva en applikation (speciellt när din kod inte kompilerar eftersom du sätter en enda karaktär på fel ställe eller glömde att avsluta en linje med en halvkolon). Kompilering kan också ta tid när du skriver stora applikationer som består av flera filer, vilket också är en annan anledning till att kompilering kan vara en tråkig upplevelse. Detta faktum har lett till att en allestädes närvarande skådespelare skådas ofta på mänens t-shirts med oskaddade skägg: "Jag slår inte av. Min kod sammanställer."
Mål-C själv är inte så svårt att lära. När du väl fattar de grundläggande principerna kan du välja resten när du går ganska enkelt. Du behöver förstå grunden för C-programmeringen, och det är vad resten av denna handledning kommer att täcka.
Låt oss titta på en grundläggande applikation i C:
#inkluderaint main () printf ("Hello World \ n"); returnera 0;
All den här applikationen kommer att göra när du kör det visas strängen "Hello World" i Terminal och exit.
NOTERA:
Är du nyfiken på uttalandet "return 0"? Eftersom vi berättade för kompilatorn att funktionen main () kommer att returnera ett heltal returnerar vi det konstanta heltalet "0" i slutet av funktionen. Med konventionen returnerar '0' signaler till det anropande programmet som vårt program slutfördes utan några fel.
För att prova detta själv, skjut upp Xcode och skapa en ny mål-C-klass. Ta bort all kod Xcode ger dig som standard och klistra in ovanstående kod. När du har gjort det kan du kompilera det med Terminal. Öppna Terminal och ändra till den plats där din fil är, om du sparat på skrivbordet skriver du helt enkelt cd-skrivbordet så att Terminal nu läser från skrivbordet. Skriv sedan det här kommandot:
gcc program1.m -o program1
Ditt program borde kompilera utan några fel. För att köra den, skriv bara:
./ program1
Slå sedan tillbaka.
Awesome, så vad hände faktiskt där? Tja, först importerade vi ett bibliotek som heter stdio som hanterar standard i / o (input output) funktioner, som printf (). Vi skapar då en funktion som heter huvud som ska returnera ett int eller heltal som i grund och botten är ett tal utan decimal. Vi använder funktionen printf () för att mata ut 'Hello World' till terminalen. Den \ n vi använder berättar Terminal att lägga en ny linje efter texten. Slutligen returnerar vi 0 (kom ihåg att huvudet skulle returnera ett heltal) som berättar operativsystemet gick allt bra. Vi använder namnet huvud eftersom det här utlöses automatiskt när programmet körs.
Hittills borde allt vara ganska enkelt: vi ville skriva lite text till Terminal, så vi importerade ett bibliotek med en funktion för att skriva text, då använde vi en funktion från det biblioteket för att skriva texten. Tänk dig att det du importerar är ett fysiskt bibliotek och printf () är en av de tillgängliga böckerna.
Soldiering framåt, vi är nu på variabler. En av de grundläggande sakerna som vi behöver för att kunna göra i våra applikationer lagrar data tillfälligt. Vi gör detta med hjälp av variabler, som är behållare som kan hålla olika typer av data och manipuleras på olika sätt. Vi använder variabler för att lagra alla slags data, men vi måste först berätta för kompilatorn vad vi ska lagra i den. Här är några av de viktigaste variablerna som du borde veta om för nu:
När vi inte använder variabler använder vi ofta konstanter. En konstant kommer aldrig att förändras: vi vet alltid vad värdet kommer att bli. Om vi kombinerar konstanter får vi ett konstant uttryck, som vi alltid kommer att känna till resultatet av. Till exempel:
123 + 2 = 125
Detta är ett konstant uttryck, 123 + 2 kommer alltid att vara lika med 125, oavsett vad. Om vi ersatte en konstant för en variabel skulle det nya uttrycket se ut så här:
123 + i = ?
Eftersom jag är en dynamisk variabel vet vi inte säkert resultatet av denna ekvation. Vi kan ändra mig till vad vi vill och få ett annat resultat. Detta borde ge dig en uppfattning om hur variabler fungerar.
En sak som vi fortfarande behöver veta är hur vi visar variabler som vi visade "Hello World" ovan? Vi använder fortfarande funktionen printf (), förutom att den ändras lite den här gången:
#inkluderaint main () int someNumber = 123; printf ("Mitt nummer är% i \ n", någonNumber); returnera 0;
Vad vi har gjort här berättas funktionen printf () där vi vill att vårt heltal ska visas, var det kan hittas. Det här skiljer sig från många språk som PHP där du bara kan placera variabeln i texten.
Vi är inte bara begränsade till bara en variabel i printf (). Funktionen kan acceptera flera parametrar separerade med kommatecken, så vi kan skicka in så många som vi har formateringsskyltar för i texten. Ovan använder vi% i som en formateringsskylt eftersom vi inkluderade ett heltal. Andra variabler har egna formatspecifikatorer:
En sak jag vill ta på innan vi går vidare är char-typen. En variabel av typen char kan bara hantera enstaka tecken, när det är allt vi behöver är det bra, men om vi behöver en sträng text är det ganska meningslöst. För att komma runt detta använder vi något som kallas en teckenuppsättning.
Tänk dig att du har en mening som är 11 tecken lång (som "Hello World" - glöm inte att inkludera mellanslag), en teckenuppsättning är som att ha 11 karaktärer men alla limmade ihop. Det betyder att värdet av teckenuppsättningen övergripande är 'Hello World' men char [0] är'H '. I parentes är charmen du efter, eftersom vi sätter 0 får vi den första karaktären. Glöm inte att räkna i arrays börjar vanligtvis från 0, inte 1.
När en ansökan behöver fatta beslut använder vi en villkorlig. Utan conditionals, varje gång du körde din ansökan skulle det vara exakt detsamma, som att titta på en film. Genom att fatta beslut baserat på variabler, inmatning eller något annat kan vi göra ansökan ändras - det kan vara lika enkelt som en användare skriver in ett serienummer eller trycker på en knapp mer än 10 gånger.
Det finns några olika typer av conditionals, men för tillfället ska vi bara titta på de vanligaste och grundläggande: om påstående. Ett if-uttalande gör vad det låter som, det kontrollerar för att se om något är sant, då agerar det på något sätt. Till exempel:
#inkluderaint main () if (1 == 1) // Detta är alltid sant // Gör några saker här returnera 0;
Om 1 är lika med 1, exekveras vad som helst mellan parenteserna. Du kanske också undrar varför vi använde två lika tecken istället för en. Att använda två lika tecken är en likhetsoperatör som kontrollerar om de två är lika med varandra. Om vi använder ett enda lika tecken försöker vi att tilldela det första värdet till det andra värdet.
Ovan, eftersom 1 alltid kommer att vara densamma som 1, kommer vad som helst i parenteserna att utföras. Vad händer om vi ville göra något om detta inte var sant men? Det är där annan kommer in. Genom att använda annat kan vi köra kod när de villkorliga avkastningarna är falska, som så:
int main () if (1 == 1) // Gör några saker här. else // Universum är trasigt! returnera 0;
Naturligtvis, i det verkliga livet, skulle vi inte kontrollera att 1 är densamma som 1, men poängen är gjord. Tänk på en applikation som stängs om du trycker på stängningsknappen tre gånger (irriterande men relevant). Du kan kolla in parenteserna för att se hur många gånger det har blivit tryckt. Om det är lägre än 3, kan ditt annat block exekvera kod för att berätta för användaren hur många gånger gånger knappen måste tryckas för att avsluta.
Vi kommer att titta på conditionals mer när vi kommer att använda dem i våra applikationer längre fram i serien.
Låt oss nu undersöka en programmeringsslinga. Loops, som namnet antyder, låt oss gå igenom en bit kod och genomföra den flera gånger. Detta kan vara mycket användbart i situationer som att fylla i en lista eller upprepa ett stycke kod tills en villkorlig avkastning är sann.
Det finns tre typer av slingor, i de flesta fall: för, medan, och do. Var och en används för att upprepa utförandet av ett block av kod, men de fungerar annorlunda. Här är exempel på varje:
Accentsconagua
// om loop int main () int i = 9; int x = 0; för (x = 0; x < i; x++) printf("Count is: %i\n", x); return 0; Det kan först se lite komplex först, men det är det inte. I parenteserna efter för är initiativtagaren, en villkorlig och åtgärden. När startkroppen startar utförs initieraren, som i vårt fall ovan anger x till 0. Varje gång slingan körs (inklusive första gången) kontrollerar den villkoret, vilket är "är x mindre än jag?" Slutligen, efter varje slinga genom koden, körs slingan åtgärden - som över steg x för en. Enkel. Eftersom x ökar med en varje gång, kommer x snart inte längre att vara mindre än jag och slingan kommer att slutföras och programmet fortsätter att springa.
// medan loop int main () int x = 0; medan (x < 10) printf("Count is: %i\n", x); //Watch OUT! Something is missing. return 0; På samma sätt som för slingan, kommer slingan att köra koden mellan parentesen tills det villkorliga är falskt. Eftersom x är 0 och vi inte ändrar det i kodblocket skulle ovanstående springa för alltid, skapa en "oändlig loop". Om du vill öka x, då skulle vi göra det här mellan parentesen i samband med vårt ögonblick.
// medan loop int main () int x = 0; medan (x < 10) x++; printf("Count is: %i\n", x); return 0; Slingan är i huvudsak en slinga, förutom de villkorliga körningarna efter koden. Vad det här betyder är att när du använder en loop, är koden garanterad att köra minst en gång:
// gör loop int main () int x = 0; gör x ++; printf ("Count är:% i \ n", x); medan (x < 10); return 0; Pointers kan orsaka mycket förvirring med nykomlingar till programmering eller bara nykomlingar till C. Det är inte heller omedelbart tydligt för vissa människor hur de är användbara, men du lär dig gradvis det här med tiden. Så, vad är en pekare?
Som namnet antyder pekar pekare på en plats. Specifikt platser i datorns minne. Tänk på det här, när vi skapar en variabel (låt oss säga att det är ett heltal som heter "foo" som är så populärt med programmeringsteori) och ge det ett värde av, till exempel 123, har vi just det - en variabel med ett värde av 123. Om vi nu ställer in en pekare till foo så har vi ett sätt att indirekt komma åt det. Det vill säga, vi har en pekare av typen int som pekar på foo som håller värdet "123." Detta skulle göras i kod som så:
int foo = 123; // Detta är en heltal variabel int * ptr = &foo; // Detta är en pekare till en heltal variabel
Klar som lera? Svettas inte. Pointers är svåra - anses ofta det svåraste att lära sig när man tar upp C-språket. Pointers kommer i slutändan att bli andra naturen till dig, och det kommer att finnas mer på pekare inom Mål-C längre i denna serie.
Du har just fått en översyn av kollisionskursen av C-grundprinciperna. Denna del av serien var avsedd att vara en snabb primer på C för att få dig redo och förberedd för resten av serien och borde ha varit särskilt användbar för dem som redan är bekanta med programmering på ett annat språk. Om du är ny för att programmera i allmänhet eller fortfarande är i tvivel om någon grundläggande av C, läs om ovanstående och gärna lämna frågor i kommentarerna.
Innan nästa gång, var noga med att försöka kompilera dina egna program med koden ovan. Ställ dig själv små utmaningar, som att göra en slinga 10 gånger och räkna varje gång genom slingan med printf. Det är ingen skada när du försöker och experimenterar, om det går fel så är det nog bättre än det kommer att få dig på rätt spår för att felsöka din egen kod.
För den här veckan kommer vi att sluta på en enkel utmaning. Du ska skapa tre program som räknas till 10 med varje slinga. Eftersom vi kommer att använda slingor ofta i mål-C är det bra att du lär dig att skapa dem av hjärtat. Det ska vara ganska enkelt, så försök att räkna ner från 10 till 1 efteråt (om + + inkrement med en, vad kan koden minska med 1?).
I nästa del av denna serie ger jag en översikt över hur Objective-C fungerar. Vi kommer också att titta på objektorienterad programmering och dess användningsområden, samt verkligen borra ner i klasser, instanser, metoder, arv och mer.
Nästa vecka borde verkligen hjälpa dig att förstå vad som gör Objective-C så bra språk och varför det verkligen utökar C-språket på så många användbara sätt.
Om du har några frågor kan du antingen lämna en kommentar nedan där jag ska försöka fortsätta kontrollera eller du kan skjuta mig ett meddelande på Twitter (http://www.twitter.com/iDemonix) där jag kommer tillbaka till du ASAP.
