fel
le

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:

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önyvtárában, a C:\WINDOWS\Microsoft.NET\Framework\<version> alkönyvtárban található, 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:

1. ábra: File/New project párbeszédablak

A felbukkanó párbeszédablak arra kíváncsi, milyen típusú program írását kívánjuk elkezdeni:

2. ábra: File/New project párbeszédablak

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:

3. ábra: Program indítása

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ó függvény a Sleep():

System.Threading.Thread.Sleep(1000);
 

Ezen függvénynek 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.

4. ábra: A történések lépései

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.

Hasonló megoldást kapunk, ha nem a Console.ReadLine()-t használjuk (amelynek igazából ennél fontosabb feladata lesz hamarosan), hanem a Console.ReadKey()-t.

System.Console.ReadKey();
 

A ReadKey() ráadásul nem csak Enter leütésére, hanem bármely billentyű leütésére befejezi a várakozást, így akár a Space billentyű is alkalmas lehet a program befejezésére.

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 is megfelel.

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):

5. ábra: Lépésenkénti programvégrehajtás

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:

6. ábra: Ha megváltozik a kód futás közben

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:

7. ábra: VS 2008 amikor nem tudja futás közben fordítani a kódot

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.

Hernyák Zoltán
2013-01-23 21:41:56