A InfoWiki wikiből
Hello World!
Ez a program igen elhíresült programozói és oktatói körökben. Először Brian Kernighan írta meg 1972-ben a Tutorial Introduction to the Language B (Oktatóbevezetés a B nyelvbe), más hivatkozásokban a Brian Kernighan és Dennis Ritchie által írt The C Programming Language (A C programozási nyelv) könyvben bukkant fel először. Első változatában ez a hello world programként szerepelt, a nagy kezdőbetűs és felkiáltójellel zárt változata később alakul ki.
A program feladata, hogy egy egysoros szöveget írjon ki a képernyőre (ez az üzenet a "hello world", helló világ). Ez egyike a legegyszerűbb programozási feladatoknak, egyike a legrövidebb megírható programoknak. Általában annak gyors tesztelésére készült, hogy az adott fordítóprogram és futtató rendszer alapvetően működik-e.
Eredeti változata:
#include <stdio.h> main() { printf("hello, world"); }
Ezt a programot szokták a programozók új programozási nyelv tanulásakor legelősször megírni, lefordítani, futtatni. Ennek ma már kultusza van: hello world programok bármely nyelven.
Hello World! C# nyelven
class Sajat { static void Main() { System.Console.WriteLine("Hello Világ"); } }
A fenti példaprogramot készítsük el egy tetszőleges editor programmal (akár a jegyzettömb is megfelel) HelloVilag.CS néven, majd command prompt-ból fordítsuk le a kis programunkat: csc HelloVilag.cs parancs kiadása segítségével.
A csc.exe – a C-Sharp compiler - a merevlemezen a Windows rendszerkönyv-tárában, a C:\WINDOWS\Microsoft.NET\Framework\<version> alkönyvtárban talál-ható, ahol a <version> helyében a dotNET Framework verziószámát kell behelyettesíteni (például: v1.1.4322). Amennyiben a számítógép nem ismeri fel a csc programnevet, úgy vagy írjuk ki a teljes nevet, vagy vegyük fel a PATH-ba a fenti alkönyvtárat.
A fenti parancs kiadása után ugyanazon alkönyvtárban, ahova a program szövegét is lementettük, elkészül egy HelloVilag.exe futtatható program is. Elindítva a programot, az kiírja a képernyőre a kívánt üdvözlő szöveget.
Nos, ezen módja a programkészítésnek nagyon kőkorszaki. Nézzük, milyen módon kell ezt csinálni a 21. században.
Hello World! a Visual Studio-ban
Első lépésként indítsuk el a Microsoft Visual Studio.NET 2008 fejlesztői környezetet, majd a File/New/Project menüpontot válasszuk ki:
A felbukkanó párbeszédablak arra kíváncsi, milyen típusú program írását kívánjuk elkezdeni:
A fenti párbeszédablak minden pontja roppant fontos! Első lépésként a bal felső részen határozzuk meg, milyen nyelven kívánunk programozni (ez C#).
Második lépésként adjuk meg, milyen típusú programot akarunk fejleszteni ezen a nyelven. Itt a sok lehetőség közül egyelőre a Console Application-t, a legegyszerűbb működési rendszerű programtípust választjuk ki.
Harmadik lépésként a Location részben adjuk meg egy (már létező) alkönyvtár nevét. Negyedik lépésben válasszuk ki a készülő program nevét a Name részben. Mivel e program több forrásszövegből fog majd állni, ezért a Studio külön alkönyvtárat fog neki készíteni. Ezen alkönyvtár neve a Location és a Name részből tevődik össze, és a „Project will be created…” részben ki is van írva, jelen példában ez a C:\programok\HelloWorld alkönyvtár lesz!
Az OK nyomógombra kattintva rövid időn belül nagyon sok minden történik a háttérben. Ezt egy Windows Intéző indításával azonnal tapasztalhatjuk, ha megtekintjük a fenti alkönyvtár tartalmát. Több file is generálódott ebben az alkönyvtárban. De térjünk vissza a Studio-hoz!
A kód megírása
using System; using System.Collections.Generic; using System.Text; namespace HelloWorld { class Program { static void Main(string[] args) { } } }
Mire figyeljünk? A programunk utasításokból áll. Egyelőre jegyezzük meg a következő fontos szabályt: minden programutasítást a Main függvény belsejébe kell írni! Sehova máshova! A Main függvény belsejét a Main utáni kezdő kapcsos zárójel és a záró kapcsos zárójel jelzi!
using System; using System.Collections.Generic; using System.Text; namespace HelloWorld { class Program { static void Main(string[] args) { // ... // ide kell írnunk a program sorait // ... } } }
Koncentráljunk most a valódi problémára: a programnak ki kell írnia a képernyőre a Helló Világ szöveget! Vigyük a kurzort a Main függvény belsejébe, és a hiányzó sort (System.Console.WriteLine("Hello Világ");) gépeljük be.
static void Main(string[] args) { System.Console.WriteLine("Hello Világ"); }
A kiíró utasítás neve WriteLine, mely az angol Write=írni, Line=sor szavakból tevődik össze. A szöveget a konzolra kell írni (Console=karakteres képernyő). Ez egy, a rendszer (angol: System=rendszer) által eleve tartalmazott utasítás, ezért a parancs teljes neve System.Console.WriteLine. A kiírandó szöveget a parancs után gömbölyű zárójelbe kell írni, és dupla idézőjelek közé kell tenni. Az utasítás végét pontosvesszővel kell lezárni (mint a ’pont’ a mondat végén).
Mentés és indítás
Az elkészült programot a File/Save All menüponttal mentsük le, majd indítsuk el. Ennek több módja is van. Az első: Debug/Start menüpont. Második: üssük le az F5 billentyűt. A harmadik: kattintsunk az indítás gombra, amelyet egy kis háromszög szimbolizál:
Mivel a programindítás igen fontos, és sűrűn használt funkció, ezért javasoljuk, hogy jegyezzük meg az F5 billentyűt!
Máris van egy problémánk: a program elindul, rövid időre felvillan egy fekete színű kis ablak, esetleg elolvashatjuk a kiírást, de csak ha elég gyorsak vagyunk, mert az ablak azonnal be is csukódik! Miért? A válasz: a program egyetlen utasítást tartalmaz: a szöveg kiírását. Mivel a program ezt már megtette, más dolga nincsen, ezért így a futása be is fejeződik. És ha a program már nem fut, akkor bezáródik az ablak!
Azonnali bezárás megakadályozása
A megoldás is erre fog épülni: adjunk még dolgot a programnak, hogy ne fejeződjön be azonnal! Első módszer: utasítsuk arra, hogy várjon valamennyi idő elteltére. A szóban forgó utasítás a Sleep():
System.Threading.Thread.Sleep(1000);
Ezen utasításnak zárójelben (paraméterként) ezredmásodpercben kell megadni a várakozás idejét. A megadott érték (1000) éppen 1 másodpercnyi várakozást jelent. A Sleep=aludni jelentése konkrétan annyi, hogy a program jelen esetben 1 másodpercre elalszik, e közben nem történik semmi (még csak nem is álmodik), de a következő utasítást majd csak egy másodperc letelte után fogja végrehajtani a számítógép!
Lényeges, hogy hova írjuk ezt a sort! A szabály értelmében a Main függvény belsejébe kell írni. De milyen sorrendben?
A programozás tanulás legjobb módszere a próbálkozás! Próbáljuk meg a kiírás elé beírni!
System.Threading.Thread.Sleep(1000); System.Console.WriteLine("Hello Világ");
Indítsuk el a programot, és gondolkozzunk el a látottakon: a kis ablak előbukkan, kis ideig nem történik semmi, majd felvillan a kiírás, és azonnal bezáródik az ablak.
Próbáljuk meg fordított sorrendben:
System.Console.WriteLine("Hello Világ"); System.Threading.Thread.Sleep(1000);
A kiírt szöveg megjelenik, eltelik egy kis idő (1 másodperc), majd bezáródik az ablak. Miért?
Sorrendi kérdések
A számítógép a program sorait nem akármilyen sorrendben hajtja végre. Van egy nagyon fontos szabály: az utasításokat ugyanabban a sorrendben kell végrehajtani, amilyen sorrendben a programozó leírta azokat. Ezt azt elvet később pontosítjuk, és elnevezzük szekvencia-elvnek.
Bezárás megakadályozása
Persze felmerül a kérdés, hogy 1 mp elég-e? Növelhetjük az időt persze az érték átállításával. De mennyire? Ez a megoldás nem elég rugalmas. Néha több időt kellene várni, néha kevesebbet. Keressünk más megoldást:
System.Console.ReadLine();
A Sleep-es sort cseréljük le a fenti sorra. Próbáljuk elindítani a programot. Mit tapasztalunk? Hogy az ablak nem akar bezáródni! Üssük le az Enter billentyűt – és ekkor az ablak bezáródik.
Mi történt? Az ablak akkor záródik be, amikor a program futása befejeződik. Ezek szerint a program még futott, azért nem záródott be! Mivel most összesen két utasításunk van (a WriteLine, és a ReadLine), melyik utasítás miatt nem fejeződött be a program? Az nem lehet a WriteLine, mert a szöveg már kiíródott a képernyőre, ez az utasítás végrehajtása tehát már befejeződött! Ekkor csak a ReadLine utasítás maradt. Nos, a ReadLine utasítást alapvetően akkor használjuk majd, ha adatot kérünk be a billentyűzetről. Az adatbevitelt az Enter leütésével jelezzük, ezért a ReadLine mindaddig nem fejeződik be, amíg le nem ütjük az Enter-t.
Megjegyzés: a megoldás azért nem tökéletes, mert bár a ReadLine ellátja a feladatát, de sajnos az Enter leütése előtt lehetőségünk van bármilyen szöveget begépelni, s ez elrontja a dolog szépségét. De egyelőre ez a módszer lesz az, amit használni fogunk.
Lépésenkénti programvégrehajtás
Kerüljünk közelebbi kapcsolatba a programmal, és a programozással! Figyeljük meg lépésről lépésre a működést! Ehhez ne az F5 billentyűvel indítsuk el a programot, hanem az F11 billentyűvel (vagy a Debug/Step into menüponttal):
A sötétebb sárga kiemelés (és a sor eleji kis sárga nyíl) a következő végrehajtandó utasítást jelöli. Közben láthatjuk, hogy a program ablaka létrejött, de még egyelőre üres. Üssük le újra az F11 billentyűt! A sárga kiemelő csík átlépett a Sleep sorára. Ezt azt jelenti, hogy a WriteLine végrehajtásra került? Ellenőrizzük! A programablakra kattintva láthatjuk, hogy kiíródott a szöveg a képernyőre. Üssük le újra az F11 billentyűt. Egy másodpercig nem történik semmi (a program ’elalszik’), majd újra felbukkan a sárga kiemelés a Main függvény blokkjának záró kapcsos zárójelén. Ez az utolsó pillanat, amikor még ellenőrizhetjük a program kiírásait a fekete hátterű ablakban. Újabb F11 leütésére a program végképp befejeződik, az ablak bezáródik.
Futás közbeni programmódosítás
Nagyon ügyeljünk arra, hogy ha már elkezdtük a programot futtatni lépésenként, akkor ne módosítsuk a program szövegét (ez főként akkor fordul elő, ha véletlenül leütünk valamilyen billentyűt). Ha ez mégis előfordulna, a Studio (korábbi változataiban) nem fogja tudni, mit is akarunk tőle:
A szöveg fordítása: A forráskód megváltozása nem fog jelentkezni a program futásában, amíg azt újra nem indítja. Ha folytatja a futtatást, a forráskód és a futó program nem fog megegyezni. Ez azt jelenti, hogy ha pl. átírjuk a szöveget Helló Világ!-ról Helló Mindenki-re, és folytatjuk a program futtatását, akkor is még az eredeti Helló Világ fog kiíródni. Ennek oka az, hogy amikor elkezdtük a programot futtatni (az első F11 leütésével), a Studio rögzítette az állapotot (a forráskód akkori tartamát), és a közben bekövetkezett változásokat nem fogja figyelembe venni. Ez azért nagy gond, mert mi a forráskódban a már megváltozott szöveget látjuk, és esetleg nem értjük, hogy miért nem az történik, amit látunk, ha végrehajtjuk a következő lépést!
A Restart lenyomásával leállíthatjuk a program futtatását, vagy a Continue lenyomásával dönthetünk úgy is, hogy a változás ellenére folytatjuk az eredeti program futtatását.
Jegyezzük meg, hogy a Visual Studio 2008 már képes arra, hogy ha futás közben megváltoztatjuk a forráskódot, akkor a nyomkövetés újraindítása nélkül alkalmazza a módosításokat. Ezt onnan vesszük észre, hogy bár módosítunk a kódon, de a fentihez hasonló párbeszédablak nem jelenik meg, mégis léptethetjük a programot a következő utasításra.
A VS 2008-ban is előfordulhat azonban a fentihez hasonló szituáció (elsősorban akkor, ha a végzett módosítások szintaktikai hibát okoztak). Ő ezt a párbeszédablakkal jelzi:
A Módosítások voltak végezve amelyeket nem lehet lefordítani. A futtatás nem folytatható amíg a fordítási hibák nem lettek javítva. Az Edit gombra kattintva folytathatjuk a forráskód javítását, a Stop-ra leállíthatjuk a jelenlegi programváltozat futtatását.
A program futtatását egyébként bármikor megszakíthatjuk a Debug/Stop debugging menüponttal, vagy a Shift-F5 leütésével.
A fenti módszert főként akkor használjuk, ha a program nem úgy működik, ahogyan azt szeretnénk, vagy csak nem értjük annak működését teljes mértékben. E módszert nyomkövetésnek hívjuk (angolul debugging), jelen esetben lépésenkénti programvégrehajtást végzünk. Később újabb módszerekkel és technikákkal bővíthetjük ez irányú tudásunkat.
