Lapforrás

<cim 
	cim3="Egyszerű alprogramok"
	cim2="Magasszintű Programozási Nyelvek I." 
	cim1="Imperatív, procedurális nyelvek alapjai" 
	prev="mp1/page470"
	next="mp1/page490"
	kep="hz_csik.png" 
	back="mp1/Nyitolap" 
	szerzo="hz|Hernyák Zoltán"
/>
<path p1="Kezdolap|Kezdőlap" p2="EBooks|Jegyzetek" p3="mp1/Nyitolap|Tartalomjegyzék" 
      xx="-" 
      w1="mp2/Nyitolap|Gyakorlatok" w2="mp1/Tematika|Vizsgatematika" w3="cs/Blog|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).

<code lang="csharp">
class Program
{
  static void atlagszamitas()
  {
   ...
  }

  static void Main()
  {
    ...
  }
  
  static void adatbekeres()
  {
    ...
  }
}
</code>

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

<code lang="csharp">
  static void Main()
  {
    adatbekeres();
	atlagszamitas();
	kiiras();
  }
</code>

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


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



<alairas>Hernyák Zoltán</alairas>
__NOTOC__