A InfoWiki wikiből

A lap 2009. november 14., 11:56-kori változata

Egyszerű alprogramok

Magasszintű Programozási Nyelvek I.

Imperatív, procedurális nyelvek alapjai

Hernyák Zoltán

Kezdőlap

Jegyzetek

Tartalomjegyzék

Gyakorlatok

Vizsgatematika

Programok C# nyelven

Egyszerű alprogramok

Amikor a programunk mérete már elér egy kritikus határt, akkor célszerűenk látszik a végrehajtást modulokra bontani. A modulok alatt most a program egy olyan részletét értjük, amely valamilyen részeredményt képez, számol ki, hajt végre.

A modulok képzése átgondolt tevékenység. A program indulásakor általában be kell kérni valamilyen bemenő adatokat (ez egyszerű esetben is lehet önálló modul, de ha az adatbekérés bonyolult, akkor ez a rész is felépülhet több modulból). Az adatbekérés után valamilyen számítási lépéssorozatot kell végrehajtani, mely jellemzően sok modulból áll. Az eredmények kiírása önálló modul szokott lenni.

Minden ilyen modul függ az előző modulok által kiszámolt részeredményektől, azok minőségétől. Egy modul által generált részeredményt gyakran egy if ellenőrzi, és annak minőségétől függően újabb modulokat indít vagy tilt le. Ha pl. a bekért adatok darabszáma nulla, akkor nem indítja el a számoljuk meg hány páros szám van benne modult, hiszen nincs is szám.

A modulokat a főprogramban is megírhatjuk, egymás mögé helyezve, de gyakoribb eset,hogy a modulokat alprogramokba - függvények és eljárások - készítjük el. Ennek több előnye is van.

Az eljárások és függvények közötti különbséget később tárgyaljuk, jelen fázisban eljárásokat fogunk készíteni.

Alprogramok készítése

Az alprogramok névvel (azonosító) rendelkező prorgamrészek. Az általunk fejlesztett alprogramok egyszerű esetben ugyanabba az osztályba (class) kerülnek, ahol a Main() is van, de nem a Main() belsejébe, hanem a Main() elé, vagy mögé (mindegy hova).

class Program
{
  static void atlagszamitas()
  {
   ...
  }
 
  static void Main()
  {
    ...
  }
 
  static void adatbekeres()
  {
    ...
  }
}

Az alprogramok készítésénél vegyük észre, hogy felépítése nagyon hasonlít a Main() alprogram felépítéséhez. A static void szavakkal kezdődnek, egy azonosítóval (névvel) folytatódnak, majd gömbölyű zárójelpárral. Az alprogram fejrésze ezzel véget is ér, következik a törzse. A törzsét (utasításblokk) a szokásos módon kapcsos zárójelpár fogja közre. A törzs rész a fejrésszel szoros kapcsolatban áll, közöttük nincs pontosvessző!

<note type="warn">Az alprogram fejrésze után nem teszünk pontosvesszőt! Következő félévben tanulunk majd ilyen esetet, de akkor a pontosvessző a törzs hiányát fogja jelölni (absztrakt metódus). Ezért ha kitesszük pontosvesszőt, akkor törzset nem írhatnánk, így a C# fordító hibásnak fogja találni a kapcsos záróljelpárt mint folytatást.</note>

A Main() alprogram

A Main() ugyanolyan alprogram, mint a saját fejlesztésűek, csak nevében speciális. Amennyiben több mint egy alprogramunk van, problémás lenne, melyikkel induljon el a program. Ezt a problémát úgy kezeli a C#, hogy a Main nevű alprogrammal kezdődik minden esetben a programunk végrehajtása. Ilyen nevű alprogramnak léteznie kell. Az mindegy, melyik osztályba (class) kerül be a Main, de egy ilyen nevűnek léteznie kell.

Alprogramok hívása

Ha elkészítünk valamely alprogramot, indítani tudjuk a törzsében szereplő utasításokat az alprogram nevének leírásával (és a két gömbölyű zárójelpárral):

static void Main()
  {
    adatbekeres();
	atlagszamitas();
	kiiras();
  }

A static kulcsszó

A Main() alprogramnál is megfigyelhető egy static kulcsszó a void előtt. Ennek a pontos jelentését következő (OOP) félévben tárgyaljuk, de ebben a félévben annyit is elég tudni, hogy az alprogramok készítésénel ki kell tenni.

A következő félévben világossá válik majd a pontos szerepe, és ki fog derülni, hogy olyan alprogramokat is lehet készíteni, amelyek nem static jellemzőjűek. Ezért ha nem tesszük ki a static kulcsszót, azt a fordító még nem tekinti azonnal hibának. Viszont az ilyen jellemzőjű (static hiányú) alprogramok hívása egyéb technikával zajlik, ezért meghívása közvetlenül nem lehetséges:

class Program
{
  void kiiras() // <- elfelejtettük a static-t
  {
   ...
  }
 
  static void Main()
  {
    ...
    kiiras();  // <- ez itt nem fog működni
	...
  }