fel
le

Függvények

A függvény rokon fogalom az eljárással – egy apró különbséggel. A függvény egy olyan eljárás, amely olyan részfeladatot old meg, melynek pontosan egy végeredménye is van – egy érték.

Amennyiben az a részfeladat, hogy egy értékekkel már feltöltött tömb eleminek összegét kell kiszámítani, a végeredmény egyetlen számérték. Amennyiben ezt eljárás segítségével oldjuk meg, úgy a végeredményt egy megosztott változóba kell elhelyezni. Ez nem túl szerencsés megoldás, mert a függvény kötődik ezen megosztott változó nevéhez. Amennyiben egy másik programba szeretnénk ezt függvényt áthelyezni, úgy vele együtt kell mozgatni a megosztott változót is.

Az ilyen jellegű feladatokat megoldó alprogramokat függvények formájában írjuk meg.

Amennyiben függvényt akarunk írni, két fontos dolgot kell szem előtt tartanunk:

  • A függvényeknél rögzíteni kell, hogy milyen típusú értéket adnak vissza. Ezt a függvény neve előtt kell feltüntetni (a ’void’ helyett).
  • A függvények ezek után kötelesek minden esetben egy ilyen típusú értéket vissza is adni! A függvény visszatérési értékét a return kulcsszó után írt kifejezésben kell feltüntetni.

Pl:

static int OsszegSzamitas()
{
        int sum=0;
        for(int i=0;i<tomb.Length;i++)
                sum = sum + tomb[i];
        return sum;
}
 

A fenti részben e függvény egy egész számot fog visszaadni, ezt jelöljük a típusnévvel: int. A függvény saját változót használ fel segédváltozóként (sum) a számítás során, return sum–al jelöli, hogy a sum változóban szereplő értéket (ami int típusú) adja vissza, mint visszatérési értéket.

A függvények meghívása hasonlóan történik, mint az eljárások hívása. Csak mivel a függvény vissza is ad egy értéket, ezért gondoskodni kell róla, hogy ezen értéket a függvényt meghívó programrész fogadja, feldolgozza.

static void Main(string[] args)
{
        Feltoltes();
        Kiiras();
        int osszesen=OsszegSzamitas();
        Console.WriteLine("A tomb elemek osszege={0}",osszesen);
}
 

Itt a meghívó ponton az OsszegSzamitas() függvény által visszaadott értéket a meghívó rögtön eltárolja egy ’osszesen’ nevű változóba, melyből később ki tudja írni a képernyőre ezen értéket.

Ebben a formában a program már nem kell, hogy megosszon ’osszeg’ változót, hiszen az ’OsszegSzamitas()’ már nem ilyen módon közli az eredményt a Main() függvénnyel, hanem egyszerűen visszaadja azt.

class PeldaProgram
{
        static int[] tomb=new int[10];
        //................................................................
        static void Main(string[] args)
        {
                Feltoltes();
                Kiiras();
                int osszesen=OsszegSzamitas();
                Console.WriteLine("A tomb elemek osszege={0}",osszesen);
        }
        //................................................................
        static int OsszegSzamitas()
        {
                int sum=0;
                for(int i=0;i<tomb.Length;i++)
                        sum = sum + tomb[i];
                return sum;
        }
        //................................................................
}
 

A korábban vizsgált eljárások legnagyobb részét át lehet írni függvényekre. Vegyük például a maximális elem értékének meghatározását. A feladat: határozzuk meg a megosztott tomb vektorban lévő elemek közötti legnagyobb értéket.

static int MaximalisElemErteke()
{
        int max=tomb[0];
        for(int i=1;i<tomb.Length;i++)
                if (tomb[i]>max) max=tomb[i];
        return max;
}
 

Ezen függvény meghívása az alábbi módon történhet:

int maxElemErteke = MaximalisElemErteke();
        Console.WriteLine("A tomb legnagyobb elemének értéke={0}", maxElemErteke);
 

Amennyiben azt szeretnénk ellenőrízni, hogy egy adott érték szerepel-e egy – értékekkel már feltöltött – tömb elemei között, akkor az alábbi függvényt írhatnánk meg:

static bool Szerepel_E()
{
        for(int i=0;i<tomb.Length;i++)
                if (tomb[i]==keresett_elem) return true;
        return false;
}
 

A fenti függvényben kihasználjuk azt, hogy a ’return’ kulcsszó hatására a függvény azonnal megszakítja a futását, és visszatér a hívás helyére. Amennyiben az egyenlőség teljesül, úgy a keresett érték szerepel a tömbben, ezért a ciklus további futtatása már felesleges – megvan a keresett válasz. A ’return false’ utasításra már csak akkor jut el a függvény, ha az egyenlőség egyszer sem teljesült. Ekkor a kérdésre a válasz a false érték.

A fenti függvény meghívása a következő módon történhet:

bool valasz = Szerepel_E();
 if (valasz) Console.WriteLine("Szerepel a tömbben");
 else        Console.WriteLine("Nem szerepel a tömbben");
 

A függvény használatának másik módja, hogy a függvény visszatérési értékét rögtön az ’if’ feltételében használjuk fel:

if (Szerepel_E())  Console.WriteLine("Szerepel a tömbben");
else               Console.WriteLine("Nem szerepel a tömbben");
 

A függvények ennél bonyolultabb értékeket is visszaadhatnak:

static int[] Feltoltes()
{
        int[] t = new int[10];
        for(int i=0;i<t.Length;i++)
        {
                Console.Write("A tomb {0}. eleme=",i);
                string strErtek=Console.ReadLine();
                t[i] = Int32.Parse( strErtek );
        }
        return t;
}
 

A fenti függvény létrehoz egy int-ekből álló, 10 elemű tömböt a memóriában, feltölti elemekkel a billentyűzetről, majd visszaadja a feltöltött tömböt az őt meghívónak:

int tomb[] = Feltoltes();
 

Amennyiben a feltöltött tömböt egy megosztott változóba szeretnénk tárolni, akkor azt az alábbi módon kell megoldani:

class PeldaProgram
{
  static int[] tomb;
  //................................................................
  static void Main(string[] args)
  {
    tomb = Feltoltes();
    Kiiras();
    ...
  }
  ...
}
 

Ekkor a ’tomb’ változót először csak deklaráltuk, megadtuk a típusát. Majd a Main() függvény belsejében, a megfelelő időpontban meghívjuk a Feltoltes() függvényt, és az általa elkészített és feltöltött tömböt betesszük a megosztott változóba.

Hernyák Zoltán
2013-03-14 16:53:12