A InfoWiki wikiből

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ő!

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();
  }

Alprogramot nem csak a Main()-ből hívhatunk - nincs ilyen kitüntetett szerepköre, lehetősége a Main()-nek. Bármely alprogramból szabad más alprogramot meghívni. A hívás ez esetben ugyanúgy zajlik, mint fentebb leírtuk: le kell írni az indítandó alprogram nevét, és ki kell tenni a gömbölyű zárójelpárt.

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
	...
  }

Másik osztályba helyezés

Amennyiben a programunk tagoltsága megkívánja, az alprogramjainkat más osztályba is helyezhetjük, mint amiben az őt meghívó alprogram helyezkedik el (pl. a Main()). Ez esetben ezt külön engedélyezni kell. Ugyanis alapvetően az a szabály, hogy ugyanabban az osztályban lévő alprogramok egymással szoros kapcsolatban állnak (ezért vannak ugyanabban az osztályban), és egymást bármikor meghívhatják. Más osztályokban szereplő függvényeket azonban alapvetően nem hívhatják meg, csak ha azt megengedik nekik.

Saját lakásunkban abba a szobába megyünk be, amelyikbe csak akarunk. A szomszéd lakásába azonban csak akkor léphetünk be, ha ő azt megengedte. A postaládájába bármikor betehetünk lapot, azt ugyanis ő bárkinek megengedi, lehetővé tette.

A megengedést a public kulcsszó jelöli (publikus). Ezt a kulcsszót a static elé, és mögé is írhatjuk, a két jelző sorrendje lényegtelen. Szokás azonban a public-al kezdeni:

class Masik
{
  public static void kiiras() 
  {
   ...
  }
}
 
class Program
{
  static void Main()
  {
     Masik.kiiras();
  }
}

Amennyiben a meghívandó alprogram nem ebben, hanem egy másik osztályban helyezkedik el, akkor hívásakor ki kell írni a tartalmazó osztály a nevét is. Ha visszagondolunk, erre számtalan példát mondhatunk, melyet eddig is használtunk már (a nélkül hogy tudtuk volna mit is csinálunk). Ilyen a Console.WriteLine() alprogram hívása, vagy a Math.Sqrt(), stb. Ezen alprogramok (függvények) hívásakor azért kell kiírni az osztály nevét is (Console, Math), mert ahonnan mi hívtuk, annak az osztálynak a neve nem ez volt.

class Console
{
  public static void WriteLine() 
  {
   ...
  }
}
 
class Math
{
  public static double Sqrt(...) 
  {
   ...
  }
}