Share
Welkom bij mijn serie over het leren omgaan met de geweldige taal die Objective-C is. In deze kleine reeks artikelen wil ik u van geen enkele ervaring met Objective-C ertoe brengen om het met vertrouwen in uw eigen toepassingen te gebruiken. Dit is geen haastig karwei - dus verwacht niet dat je gewoon door de basis snelt en weg bent - we zullen niet alleen de essentiële dingen doen, maar ook de beste praktijken die je kunt toepassen om ervoor te zorgen dat je code de beste is het kan zijn. Laten we meteen naar binnen springen!
Als je deze serie aan het lezen bent, maak ik een gok dat je het al weet, maar voor degenen onder jullie die dat niet doen, maak je geen zorgen want aan het einde van dit deel weet je wat het is. -front en inside-out.
Objective-C is een object-georiënteerde taal die bovenop de C-taal ligt (maar dat gokte ik!). Het is primair in modern computergebruik, is op Mac OS X als een desktoptaal en ook op iPhone OS (of zoals het nu heet: iOS). Het was oorspronkelijk de belangrijkste taal voor NeXTSTEP OS, ook bekend als het besturingssysteem dat Apple Mac OS X van Mac OS X kocht en afstapte, wat verklaart waarom zijn primaire huis van vandaag op de besturingssystemen van Apple ligt.
Omdat Objective-C een strikte superset van C is, zijn we vrij om C in een Objective-C-bestand te gebruiken en het zal prima compileren. Omdat elke compiler van Objective-C ook elke rechte C-code compileert die erin wordt doorgegeven, hebben we alle kracht van C en de kracht van objecten die door Objective-C worden geboden.
Als je op dit punt een beetje in de war bent, denk er dan zo over: alles wat C kan doen, kan Objective-C ook, maar niet andersom.
Gedurende deze reeks zullen we ons niet concentreren op het bouwen van applicaties voor de iPhone. In plaats daarvan zullen we ons meer concentreren op de taal zelf en om deze reden heeft u alleen een Mac met een compiler zoals GCC nodig. Als u de ontwikkelaarstools van Apple (Xcode, Interface Builder, enz.) Hebt geïnstalleerd, moet GCC al zijn geïnstalleerd. Als dat niet het geval is, ga dan naar de ontwikkelaarswebsite van Apple en ontvang een gratis exemplaar.
Voor zover de vereisten gaan, hoewel ik niet verwacht dat je een volledige achtergrond in de computerwetenschappen hebt, zou enige kennis van programmeren in het algemeen of van C in het bijzonder zeker een bonus zijn. Als u niet veel voorafgaande programmeerervaring hebt, hoeft u zich geen zorgen te maken; u haalt het snel op!
Als u Windows gebruikt (wat onwaarschijnlijk is omdat deze tutorial gericht is op iPhone-ontwikkelaars), kunt u nog steeds Objective-C compileren op uw systeem met behulp van een compiler zoals CygWin of MinGW. Deze tutorialserie is bedoeld voor Mac-gebruikers, maar als je Windows gebruikt en problemen tegenkomt, laat dan een reactie achter en ik zal kijken of ik kan helpen.
Voordat u uw code in actie kunt zien, moet u deze in een uitvoerbaar bestand kunnen compileren. Hopelijk heb je nu je exemplaar van GCC klaar. Compileren is heel eenvoudig, een eenvoudige opdracht met één regel.
NOTITIE:
Compileren is het proces waarbij een computertaal op hoog niveau, zoals Objectief-C of PHP, wordt "vertaald" naar een machinecode op laag niveau die door een computer kan worden verwerkt wanneer het programma wordt uitgevoerd.
Alle programma's die we zien draaien in ons fraaie Mac OS-besturingssysteem bestaan uit een reeks instructies die ons visueel worden getoond in een GUI of grafische gebruikersinterface. In tegenstelling tot de interactie van het GUI-programma met een muis die de meesten van ons kennen, is het mogelijk om opdrachten rechtstreeks aan het besturingssysteem te geven via een op tekst gebaseerde interface die een "terminal" of "commandoregel" wordt genoemd.
De opdrachtregeltoepassing in Mac OS wordt Terminal genoemd en is te vinden in Toepassingen -> Hulpprogramma's. Ga je gang en open Terminal nu (je kunt er ook naar zoeken in Spotlight). Terminal heeft verschillende basiscommando's waarvan u op de hoogte moet zijn om er op de juiste manier gebruik van te kunnen maken. Een van de belangrijkste commando's om te weten is CD, wat staat voor "wijzigingsdirectory". Met deze opdracht kunnen we wijzigen waar in het bestandssysteem de Terminal vandaan komt. We kunnen Terminal niet vertellen om ons bestand te compileren als we het niet laten zien waar het bestand het eerst staat! Om over te schakelen naar een gewenste map, kunt u een volledig pad gebruiken zoals:
cd / Gebruikers / MyName / Desktop / Test
U kunt ook relatieve paden gebruiken, zodat u in sommige gevallen slechts één mapnaam kunt typen. Als u zich bijvoorbeeld al in de map Desktop bevindt, typt u eenvoudigweg:
cd Test
om naar de map Test te gaan.
Wat als je wilt zien waar je momenteel bent? De naam van de onmiddellijke map wordt vóór de prompt weergegeven (het bit waar u typt). Bijvoorbeeld als uw prompt zegt Dan-Walkers-MacBook: Desktop iDemonix $ Ik kan aannemen dat ik in de map Desktop zit. Als u het niet zeker weet, kunt u ook typen pwd om het absolute bestandspad van de huidige locatie weer te geven.
Als u wilt weergeven welke bestanden en mappen zich in de huidige map bevinden, gebruikt u de opdracht list: ls. Als u tenslotte een map naar een bovenliggende map wilt gaan, typt u "CD… Dus als we in de testmap stonden, die zich in de map Desktop bevindt, maar in plaats daarvan naar de map Bureaublad wilden gaan, konden we typen CD… om naar de bovenliggende map te gaan, Desktop. Als we naar de homedirectory wilden gaan, zouden we typen cd ... / ... om twee niveaus omhoog te gaan. Als alternatief kun je gewoon typen om naar de homedirectory te gaan cd ~ van waar dan ook.
Bij het gebruik van de Terminal-applicatie ziet het compileren er als volgt uit:
gcc inputfile.m -o outputfile
Je hebt waarschijnlijk al geraden hoe het werkt: inputfile.m bevat onze code (.m is de extensie die wordt gebruikt voor Objective-C-bestanden) en -O vertelt gcc dat we willen dat ons uitvoerbare bestand wordt opgeroepen, wat we dan ook specificeren, wat in het bovenstaande voorbeeld is outputfile. Om onze creatie na het compileren uit te voeren, typen we eenvoudigweg:
./ outputfile
Eenvoudig.
Wanneer u compileert, genereert de compiler eventuele fouten, meldingen of waarschuwingen met betrekking tot de syntaxis van uw code. Fouten die tijdens het compileren ontstaan, worden begrijpelijkerwijs "compile-time" -fouten genoemd, en dit is vaak het meest stressvolle deel van het schrijven van een applicatie (vooral wanneer uw code niet compileert omdat u een enkel teken op de verkeerde plaats hebt gezet of bent vergeten eindig een lijn met een puntkomma). Compileren kan ook enige tijd duren wanneer je grote applicaties schrijft die uit meerdere bestanden bestaan, wat ook een reden is waarom compileren een saaie ervaring kan zijn. Dit feit heeft geleid tot een alomtegenwoordige programmeur-grap die vaak te zien is op de t-shirts van mannen met onverzorgde baarden: "Ik versla niet, mijn code is aan het compileren."
Objective-C zelf is niet zo moeilijk om te leren. Zodra je de basisprincipes onder de knie hebt, kun je de rest vrij gemakkelijk kiezen. Je moet wel een goed begrip hebben van de grondbeginselen van C-programmeren, en dat is wat de rest van deze tutorial zal behandelen.
Laten we naar een basisapplicatie in C kijken:
#includeint main () printf ("Hello World \ n"); retourneer 0;
Al deze applicatie zal doen als je het uitvoert, de string "Hallo wereld" in Terminal weergeven en afsluiten.
NOTITIE:
Benieuwd naar de 'return 0'-verklaring? Omdat we de compiler hebben verteld dat de functie main () een geheel getal zal retourneren, retourneren we de constante integerwaarde '0' aan het einde van de functie. Per conventie retourneren '0'-signalen aan het aanroepende programma dat ons programma zonder fouten is uitgevoerd.
Om dit voor jezelf te proberen, start je Xcode op en maak je een nieuwe Objective-C-klasse. Verwijder alle code die Xcode je standaard geeft en stop de bovenstaande code. Zodra je dat gedaan hebt, kun je het compileren met Terminal. Open Terminal en ga naar de locatie waar uw bestand zich bevindt, als u het op het bureaublad hebt opgeslagen, typt u gewoon cd-bureaublad zodat Terminal nu aan het lezen is vanaf je Desktop. Typ vervolgens deze opdracht:
gcc programma1.m -o programma1
Je programma moet compileren zonder fouten. Voer het volgende uit om het uit te voeren:
./ program1
Raak vervolgens terug.
Geweldig, dus wat is daar eigenlijk gebeurd? Nou, eerst importeerden we een bibliotheek genaamd stdio die de standaard i / o (input output) functies, zoals printf (), beheert. Vervolgens maken we een functie met de naam main die een int of integer zou moeten teruggeven, wat in feite een getal zonder decimale punt is. Vervolgens gebruiken we de functie printf () om 'Hallo Wereld' in terminal uit te voeren. De \ n die we gebruiken, vertelt Terminal om een nieuwe regel na de tekst te plaatsen. Tenslotte retourneren we 0 (onthoud dat we hebben gezegd dat main een integer getal moet retourneren), wat het besturingssysteem vertelt dat alles goed is gegaan. We gebruiken de hoofdnaam omdat deze automatisch wordt geactiveerd wanneer het programma wordt uitgevoerd.
Tot dusverre zou alles vrij eenvoudig moeten zijn: we wilden wat tekst naar Terminal schrijven, dus we importeerden een bibliotheek met een functie voor het schrijven van tekst, daarna gebruikten we een functie uit die bibliotheek om de tekst te schrijven. Stel je voor dat wat je importeert een fysieke bibliotheek is en printf () een van de beschikbare boeken is.
Soldaat vooruit, we zijn nu bezig met variabelen. Een van de fundamentele dingen die we in onze applicaties moeten kunnen doen, is het tijdelijk opslaan van gegevens. We doen dit met variabelen, dit zijn containers die verschillende soorten gegevens kunnen bevatten en op verschillende manieren kunnen worden gemanipuleerd. We gebruiken variabelen om alle soorten gegevens op te slaan, maar we moeten de compiler eerst vertellen wat we erin gaan opslaan. Hier zijn enkele van de belangrijkste variabelen die u voorlopig zou moeten kennen:
Wanneer we geen variabelen gebruiken, gebruiken we vaak constanten. Een constante zal nooit veranderen: we weten altijd wat de waarde zal zijn. Als we constanten combineren, krijgen we een constante uitdrukking, waarvan we altijd het resultaat zullen kennen. Bijvoorbeeld:
123 + 2 = 125
Dit is een constante expressie, 123 + 2 is altijd gelijk aan 125, wat er ook gebeurt. Als we een constante voor een variabele vervangen, ziet de nieuwe expressie er als volgt uit:
123 + i = ?
Omdat ik een dynamische variabele is, weten we niet zeker het resultaat van deze vergelijking. We kunnen i veranderen in wat we willen en een ander resultaat krijgen. Dit zou u een idee moeten geven van hoe variabelen werken.
Eén ding dat we nog moeten weten, is hoe we variabelen weergeven zoals we hierboven 'Hallo wereld' hebben weergegeven? We gebruiken nog steeds de functie printf (), behalve dat deze deze keer een beetje verandert:
#includeint main () int someNumber = 123; printf ("Mijn nummer is% i \ n", someNumber); retourneer 0;
Wat we hier hebben gedaan is de functie printf () waar we willen dat ons gehele getal verschijnt en waar het kan worden gevonden. Dit is anders dan veel andere talen, zoals PHP, waar je de variabele gewoon in de tekst zou kunnen plaatsen.
We zijn niet beperkt tot slechts één variabele in printf (). De functie kan meerdere parameters accepteren, gescheiden door komma's, dus we kunnen er in de tekst zoveel invoegen als we opmaakborden hebben. Hierboven gebruiken we% i als een opmaakteken omdat we een geheel getal hebben opgenomen. Andere variabelen hebben hun eigen indelingsspecificaties:
Een ding dat ik wil bespreken voordat we verder gaan, is het char-type. Een variabele van het type char kan maar één teken behandelen, als dat alles is wat we nodig hebben is dit geweldig, maar als we een reeks tekst nodig hebben, is het behoorlijk nutteloos. Om dit te omzeilen, gebruiken we iets dat een karakterarray wordt genoemd.
Stel je voor dat je een zin hebt die 11 tekens lang is (zoals 'Hallo Wereld' - vergeet niet om de spatie in te voegen), een karakterreeks is net zoiets als 11 tekens, maar allemaal aan elkaar gelijmd. Dit betekent dat de waarde van de tekenreeks in het algemeen 'Hallo Wereld' is, maar dat teken [0] 'H' is. Tussen haakjes staat de char die je zoekt, omdat we 0 hebben, krijgen we het eerste personage. Vergeet niet dat het tellen in arrays meestal begint bij 0, niet bij 1.
Wanneer een applicatie een beslissing moet nemen, gebruiken we een voorwaardelijke. Zonder conditionals zou het elke keer dat u uw applicatie draait hetzelfde zijn, zoals het kijken van een film. Door beslissingen te nemen op basis van variabelen, invoer of iets anders, kunnen we de toepassing wijzigen - dit kan net zo eenvoudig zijn als een gebruiker die een serienummer invoert of meer dan 10 keer op een knop drukt.
Er zijn een paar verschillende soorten conditionaliteit, maar voor nu gaan we kijken naar de meest gebruikelijke en basis: de als uitspraak. Een if-statement doet hoe het klinkt, het controleert of iets waar is en handelt dan hoe dan ook. Bijvoorbeeld:
#includeint main () if (1 == 1) // Dit is altijd waar // Doe hier wat dingen retourneer 0;
Als 1 gelijk is aan 1, dan wordt alles wat zich tussen de haakjes bevindt uitgevoerd. Je vraagt je misschien ook af waarom we twee gelijktekens hebben gebruikt in plaats van één. Het gebruik van twee gelijke tekens is een gelijkheidsoperator, die controleert of de twee gelijk zijn aan elkaar. Als we een enkel gelijkteken gebruiken, proberen we de eerste waarde toe te wijzen aan de tweede waarde.
Hierboven, omdat 1 altijd hetzelfde zal zijn als 1, wat dan ook tussen de haakjes zou worden uitgevoerd. Wat als we iets wilden doen als dit niet waar was? Dat is waar anders komt binnen. Door else te gebruiken, kunnen we code uitvoeren als de if conditional false retourneert, zoals zo:
int main () if (1 == 1) // Doe hier wat dingen. else // Het universum is gebroken! retourneer 0;
Natuurlijk zouden we in het echte leven niet controleren of 1 gelijk is aan 1, maar het punt is gemaakt. Overweeg een toepassing die wordt gesloten als u driemaal op de knop Sluiten drukt (vervelend maar relevant). Je zou tussen haakjes kunnen kijken om te zien hoe vaak het is gepusht. Als het lager is dan 3, kan uw else-blok code uitvoeren om de gebruiker te vertellen hoeveel keer de knop moet worden ingedrukt om te verlaten.
We zullen conditionals meer bekijken wanneer we ze later in de serie in onze toepassingen gaan gebruiken.
Laten we nu een programmeerlus onderzoeken. Loops laten we, zoals de naam al doet vermoeden, een stukje code doorlopen en het meerdere keren uitvoeren. Dit kan erg handig zijn in situaties zoals het invullen van een lijst of het herhalen van een stuk code totdat een voorwaarde waar retourneert.
Er zijn drie soorten lussen, in volgorde van meest gebruikelijk: voor, terwijl, en do. Elk wordt gebruikt om de uitvoering van een codeblok te herhalen, maar ze functioneren anders. Hier zijn voorbeelden van elk:
Accentsconagua
// if loop int main () int i = 9; int x = 0; voor (x = 0; x < i; x++) printf("Count is: %i\n", x); return 0; Dit ziet er in het begin misschien wat ingewikkeld uit, maar dat is het echt niet. Tussen de haakjes na is de initiator, een voorwaardelijke actie en de actie. Wanneer de for-lus start, wordt de initiator uitgevoerd, wat in ons geval hierboven x op 0 instelt. Telkens wanneer de lus wordt uitgevoerd (inclusief de allereerste keer), wordt de voorwaarde gecontroleerd, namelijk "is x kleiner dan i?" Uiteindelijk, na elke lus door de code, voert de lus de actie uit - welke hierboven x met één wordt verhoogd. Eenvoudig. Aangezien x telkens met één wordt verhoogd, zal x binnenkort niet meer minder zijn dan i en eindigt de lus en blijft het programma actief.
// while loop int main () int x = 0; terwijl (x < 10) printf("Count is: %i\n", x); //Watch OUT! Something is missing. return 0; Net als bij de for-lus zal de while-lus de code tussen de haakjes uitvoeren totdat de conditionele waarde false is. Omdat x 0 is en we het niet veranderen in het codeblok, zou het bovenstaande voor altijd werken, waardoor een "oneindige lus" wordt gecreëerd. Als je x wilt verhogen, dan zou je in het geval van onze while-lus dit tussen de haakjes moeten doen:
// while loop int main () int x = 0; terwijl (x < 10) x++; printf("Count is: %i\n", x); return 0; De do-lus is in wezen de while-lus, behalve de voorwaardelijke runs achter het codeblok. Wat dit betekent is dat wanneer u een do-lus gebruikt, de code gegarandeerd minstens één keer wordt uitgevoerd:
// do loop int main () int x = 0; doe x ++; printf ("Aantal is:% i \ n", x); while (x < 10); return 0; Wijzers kunnen veel verwarring veroorzaken bij nieuwkomers bij het programmeren of gewoon nieuwkomers bij C. Het is ook niet meteen duidelijk voor sommige mensen hoe nuttig ze zijn, maar je zult dit geleidelijk aan leren. Dus, wat is een aanwijzer?
Zoals de naam al aangeeft, wijzen pointers naar een locatie. Met name locaties in het computergeheugen. Zie het als volgt, wanneer we een variabele maken (laten we zeggen dat het een geheel getal is dat 'foo' heet, zoals zo populair is bij de programmeertheorie) en het een waarde geven van bijvoorbeeld 123, we hebben alleen dat - een variabele met een waarde van 123. Nu, als we een pointer naar foo instellen, dan hebben we een manier om er indirect toegang toe te hebben. Dat wil zeggen, we hebben een aanwijzer van het type int die naar foo verwijst die de waarde '123' bevat. Dit zou gedaan worden in de code zoals zo:
int foo = 123; // Dit is een integer-variabele int * ptr = &foo; // Dit is een aanwijzer naar een integer-variabele
Helder als modder? Zweet het niet. Pointers zijn moeilijk - vaak beschouwd als het moeilijkste om te leren bij het oppakken van de C-taal. Pointers zullen uiteindelijk echter een tweede natuur voor je worden, en er zullen meer aanwijzingen zijn in Objective-C verderop in deze serie.
U hebt zojuist een overzicht van de ongevallencursus van de C-taalbeginselen gekregen. Dit deel van de serie was bedoeld als een snelle inleiding op C om je klaar te maken en voorbereid op de rest van de serie, en had vooral handig moeten zijn geweest voor degenen die al bekend zijn met programmeren in een andere taal. Als je nieuw bent in programmeren in het algemeen of nog steeds twijfelt over een basis van C, lees het bovenstaande dan opnieuw en voel je vrij om vragen in de comments achter te laten.
Zorg ervoor dat je vóór de volgende keer probeert je eigen programma's te compileren met behulp van de bovenstaande code. Stel jezelf kleine uitdagingen, zoals het 10 keer uitvoeren van een lus en tel elke keer door de lus met behulp van printf. Het is niet schadelijk om te proberen en te experimenteren. Als het fout gaat, is het waarschijnlijk nog beter, omdat het je op het juiste spoor brengt om problemen met je eigen code op te lossen..
Voor deze week eindigen we met een eenvoudige uitdaging. U moet drie programma's maken die tellen tot 10 met behulp van elk type lus. Omdat we loops vaak in Objective-C gebruiken, is het goed dat je ze uit het hoofd leert maken. Dat zou vrij eenvoudig moeten zijn, dus probeer achteraf van 10 naar 1 te tellen (als ++ met één toeneemt, wat zou dan de code kunnen zijn om met 1 te verlagen?).
In de volgende aflevering van deze serie zal ik een overzicht geven van hoe Objective-C werkt. We zullen ook kijken naar objectgeoriënteerde programmering en het gebruik ervan, en ook echt inzoomen op klassen, instanties, methoden, overerving en meer.
Volgende week zou je echt moeten helpen begrijpen wat Objective-C zo'n geweldige taal maakt en waarom het de C-taal echt op zoveel handige manieren uitbreidt.
Als je vragen hebt, kun je een reactie achterlaten waar ik probeer het na te kijken of je kunt een bericht op Twitter (http://www.twitter.com/iDemonix) schieten, waar ik terug ga naar je zo snel mogelijk.
