Kiiratás a képernyőre

BecomeAnXcoder – Kiiratás a képernyőre

Bevezető

Az eddigiekben szépen felépítettük a programunkat, de nem mondtuk semmit arról, hogyan lehet a képernyőn megjeleníteni az eredményeket. Az Objective C önmagában nem képes erre, de szerencsére vannak olyan háttérfüggvények, amelyek segítségünkre lesznek. Több lehetőség is létezik, mi most Az Apple Cocoa környezet által tartalmazott beépített függvényt fogjuk használni erre a célra, az NSLog() függvényt. Ez nagyon kényelmes és egyszerű lesz, még programozni sem kell hozzá semmit.

Tehát hogyan is működik ez az NSLog() függvény? Az Xcode rendelkezik egy Console ablakkal, ahol ki tudja írni a napló üzeneteket. A Console ablakot úgy tudjuk megnyitni, ha a Run menüből kiválasztjuk a Console sort (Cmd-shift-R). Egy program futtatása során a program összes NSLog() üzenete látható lesz ebben az ablakban.

Az NSLog() alapvetően arra lett tervezve, hogy a hibaüzeneteket írja ki és nem a program eredményeit. Azonban annyira egyszerű a használata, hogy ebben a könyvben a segítségével fogjuk megjeleníteni az eredményeket. Minél többet tudsz majd a Cocoa környezetről, annál kifinomultabb módszerek állnak majd a rendelkezésedre az eredmények kiíratására.

Az NSLog használata

Most megmutatjuk, hogyan kell használni az NSLog() függvényt. A main.m fájlba gépeld be a következő sorokat:

//[1] 
int main()
{
NSLog(@"Julia a kedvenc színésznőm."); return 0;
}

Az [1] programkód futtatásakor a “Julia a kedvenc színésznőm.” szövegnek kell megjelennie a képernyőn. A @” és ” jelek közötti részt stringnek nevezzük.

A szöveg kiíratása mellett az NSLog() függvény még további információkat is kiír a képernyőre, mint például az aktuális időpontot,vagy a program nevét. Egy lehetséges eredményre mutatunk most példát:

2005-12-22 17:39:23.084 test[399] Julia a kedvenc színésznőm.

A string hossza lehet nulla, vagy 1, vagy 1-nél több karakter.

Megjegyzés: A következő példákban, csak a main() főggvény törzsének megfelelő utasításait adjuk meg.

//[2] 
NSLog(@"");
NSLog(@" ");

A [2.1] utasítás egy üres stringet mutat be, ennek a hossza nulla karakter, amit úgy is szoktunk mondani, hogy nulla karaktert tartalmaz. A [2.2] utasítás viszont már nem egy üres string, annak ellenére, hogy nagyon úgy néz ki. Ez tartalmaz egy üres karaktert (space karaktert) és ezért a hossza 1.

Néhány karaktersorozat speciális jelentéssel bír egy stringben. Ezeket a speciális karaktereket vezérlő, vagy escape karaktereknek szokták nevezni.

Annak érdekében, hogy az utolsó szó a mondatunkból a következő sorba kerüljön, egy speciáls kódot kell beilleszteni a [3.1] utasítás belsejébe. Ez a kód a következő: \n, egy új sor kezdését jelöli.

//[3] 
NSLog(@"Julia a kedvenc \nszínésznőm.");

Most a nyomtatási kép így néz ki (csak a megfelelő részt mutatjuk):

Julia a kedvenc 
színésznőm.

A [3.1] utasításban a fordított törtvonal (visszafelé perjel) egy escape karakter, aminek hatásárára az NSLog() függvény tudni fogja, hogy az ezt követő karakter egy speciális karakter, amit nem kell kiíratni a képernyőre, hanem speciális jelentése van. Ebben az esetben az “n” azt jelenti, hogy “kezdj egy új sort” (new line).

Abban a ritka esetben, ha éppen egy fordított törtvonalat szeretnénk kiíratni a képernyőre, az bizony első pillanatban gondot okozhat. A megoldás azonban nagyon egyszerű. Írjunk egymás mellé két fordított törtvonalat. Az első megváltoztatja a második jelentését, azaz megszünteti annak escape karakter voltát. Ebből az NSLog()függvény tudni fogja, hogy a második fordított törtvonalat már ki kell nyomtatni és a speciális jelentését ignorálni kell. A következő példából minden világos lesz:

//[4]
NSLog(@"Julia a kedvenc színésznőm.\\n");

A [4.1] utasítás hatására a képernyőn a következőt fogjuk látni

Julia a kedvenc színésznőm.\n

 

Változók értékének kiíratása

Idáig csak stringeket írattunk ki a képernyőre. Írassuk ki most egy számítás eredményét.

//[5] 
int x, integerToDisplay;
x = 1;
integerToDisplay = 5 + x;
NSLog(@"Az integer típusú változó értéke %d.", integerToDisplay);

Figyeljük meg, hogy a zárójelek között van egy szöveg, egy vessző és egy változónév. A szöveg tartalmaz valami mulatságosat: %d. A fordított törtvonalhoz hasonlóan a százalékjelnek: % is speciális jelentése van. Ezt egy d betű követi (a tizedes szám – decimal number rövidítése ez). A futtatás során azon a helyen ahol a %d szerepel kiíratódik a vessző után szereplő változó értéke, tehát az integerToDisplay változó aktuális értéke. Az [5]-ös példa futási eredménye ez lesz:

Az integer típusú változó értéke 6.

Ha egy lebegőpontos változó értékét szeretnénk kiíratni, akkor a %f kódot kell használnunk a %d helyett.

//[6] 
float x, floatToDisplay;
x = 12345.09876;
floatToDisplay = x/3.1416;
NSLog(@"A float típusú változó értéke %f.", floatToDisplay);

Te tudod meghatározni, hogy hány darab tizedesjegyet írjon ki a program. Ahhoz, hogy két tizedesjegy kerüljön kiíratásra a .2 kódot kell írni a % és az f betűk közé, ahogy a következő példában láthatod:

//[7] 
float x, floatToDisplay;
x = 12345.09876;
floatToDisplay = x/3.1416;
NSLog(@"A float típusú változó értéke %.2f.", floatToDisplay);

Kicsit később megtanuljuk, hogyan lehet egyszerűen ismételni utasításokat. Képzeljünk el például egy konverziós táblázatot a Celsius és a Kelvin fokok között. Ha szépen szeretnéd elrendezni a táblázatot, akkor jó lenne, ha két oszlopban és rögzített karakter szélességgel lennének kiírva a számok. Ezt könnyű beállítani egy egész szám segítségével, amit a % és az f betű (vagy a % és a d betű) közé kell beírni. Abban az esetben, ha kisebb számot adunk meg, mint a szám karakterhosszúsága, akkor az utóbbi élvez perefernciát.

//[8] 
int x = 123456;
NSLog(@"%2d", x);
NSLog(@"%4d", x);
NSLog(@"%6d", x);
NSLog(@"%8d", x);

A [8]-as példa futtatási eredménye ilyen lesz:

123456 
123456
123456
123456

Az első két utasításban [8.2, 8.3] túl kevés helyet igényelünk a számok kiíratásához, ezért a számok aktuális hossza érvényesül. Csak a [8.5] utasításban határozunk meg a szám hosszánál nagyobb értéket, ezért itt a szám előtt megjelennek a kiegészítő üres karakterek, és azokkal együtt lesz a karakterszám az előírtnak megfelelő.

Természetesen kombinálni is lehet a kiíratandó szám szélességét és az elvárt tizedesjegyek számát.

//[9] 
float x=1234.5678;
NSLog(@"Lefoglalunk 10 karaktert a számnak és azt 2 tizedesjegy pontossággal írjuk ki.");
NSLog(@"%10.2f", x);

Több érték együttes kiíratása

Nincs akadálya annak sem, hogy egyszerre több változó értékét is kiírassuk, illetve annak, hogy keverjük a típusokat [10.3]. Figyelni kell arra, hogy helyesen válasszuk meg a típus meghatározást (int, float) a %d és az %f jelölések segítségével.

//[10] 
int x = 8;
float pi = 3.1416;
NSLog(@"Az egész típusú változó értéke %d, a lebegőpontosé pedig %f.", x, pi);

A jelöléseknek és az értékeknek egyezniük kell

Az egyik leggyakoribb hiba kezdő programozók esetében, hogy helytelenül adják meg az adat típusát az NSLog() és más függvényekben. Ha a kapott eredmény értelmetlen, vagy váratlanul lefagy a program futás közben, akkor érdemes azzal kezdeni a hibakeresést, hogy ellenőrizzük a típus beállításokat!

Ha sikerül elrontani már az elsőt, akkor jó eséllyel a második sem fog helyesen megjelenni. Lássunk egy példát:

//[10b] 
int x = 8;
float pi = 3.1416;
NSLog(@"Az egész típusú változó értéke %f, míg a lebegőpontosé %f.", x, pi);
// A helyes változat ez lenne: NSLog(@"Az egész típusú változó értéke %d, míg a lebegőpontosé %f.", x, pi);

Ez a hibás kód a következő eredményt produkálja:

Az egész típusú változó értéke 0.000000, míg a lebegőpontosé 0.000000.


A Foundation könyvtár belinkelése

Már csak egy kérdés és egy válasz maradt az első programmal kapcsolatban.

Ez pedig nem más, mint hogy honnan tud a programunk erről a hasznos NSLog() függvényről? Hát bizony egyáltalán nem tud róla, egészen addig amíg nem segítünk neki ebben. A következő utasítás segítségével tudjuk beimportálni azt a könyvtárt, amelyik tartalmazza az NSLog() függvényt. Szerencsére ez a könyvtár a Macintosh operációs rendszer ingyenes tartozéka:

#import <Foundation/Foundation.h>

Ennek az utasításnak kell a legelsőnek lenni a programkódban. Az alábbi programkódban összefoglaltuk fejezetünk tartalmát. A következő fejezetben azt is megmutatjuk, hogyan kell azt futtatni.

//[11] 
#import <Foundation/Foundation.h>
float circleArea(float theRadius);
float rectangleArea(float width, float height);
int main()
{
float pictureWidth, pictureHeight, pictureSurfaceArea,
circleRadius, circleSurfaceArea;
pictureWidth = 8.0;
pictureHeight = 4.5; circleRadius = 5.0;
pictureSurfaceArea = rectangleArea(pictureWidth, pictureHeight);
circleSurfaceArea = circleArea(circleRadius);
NSLog(@"A kör területe: %10.2f.", circleSurfaceArea);
NSLog(@"A kép területe: %f. ", pictureSurfaceArea);
return 0;
}
float circleArea(float theRadius)                // az első saját függvény 
{
float theArea;
theArea = 3.1416 * theRadius * theRadius;
return theArea;
}
float rectangleArea(float width, float height) // a második saját függvény
{
return width*height;
}

eredeti oldal