Függvények

Függvények használatával összetett programot részekre lehet tagolni, átláthatóbb kódot lehet írni. Egy függvényt egyszer le kell írni, azaz megadni, hogy milyen típusú értéket ad vissza, milyen paramétereket használ, milyen típusú saját változói vannak, milyen utasításokat hajt végre. Ennek módja:

  visszaadott_érték_típusa függvénynév(argumentumok_ha_vannak)
{
változók deklarációja;
utasítások;
}

Függvénynek paraméterként kétféle módon adhatunk adatokat: érték szerint illetve cím (más elnevezéssel referencia) szerint. Érték szerinti paraméterátadás esetén a függvény az adat értékének másolatával dolgozik, cím szerinti paraméterátadás esetén a függvény az adat címét kapja meg. Ha érték szerint átadott adatot változtatunk egy függvényben, a függvényből kilépve az adaton nem látszik a változás, ha cím szerint átadott adatot változtatunk egy függvényben, akkor a változás a függvényből kilépve is megmarad. Érték szerinti paraméternek nincs külön jelzése, cím szerint átadni kívánt paraméter elé a ref szócskát kell beszúrni. A ref szócskát híváskor is ki kell írni. a kerek zárójeleket akkor is ki kell tenni a függvénynév után, ha nincsenek paraméterei.
A függvénynév előtti típusjelzés a függvény visszatérési értékének típusát határozza meg. A visszatérési értéket a return utasítás után írt kifejezés értéke adja. Ha nincs szükség visszatérési értékre, akkor a void jelzést használjuk és a return utasítást nem követi kifejezés.
Példáinkban szerepel még a típusjelzés előtt a static jelölés, ez a függvények statikus voltát jelzi. Egyszerű, egyetlen osztályból álló programokban csak statikus függvényeket lehet használni.

1. példa - érték szerinti paraméterátadás:

class Program
{
static void változtat(int a) // Itt kezdődik a függvényleírás, itt TILOS a ; { ... a = 100; return; // Itt ér véget a függvényleírás } static void Main(string[] args) { int x = 5; változtat(x); // Az előző sor hívja meg a függvényt, azaz hajtja végre a függvény utasításait a megadott x paraméter értékével Console.WriteLine(x); // 5 lesz a kiírás eredménye
Console.ReadKey();
}
}
2. példa - referencia szerinti paraméterátadás
class Program
{
static void változtat(ref int a)
{
...
a = 100;
return;
}
static void Main(string[] args)
{
int x = 5;
változtat(ref x);
Console.WriteLine(x); // 100 lesz a kiírás eredménye
Console.ReadKey();
}
}

Ha egy függvénynek több eredményt kell adnia, akkor eredményváltozókat használhatunk, ezeket az eléjük írt out szócska jelzi. Az out jelzőt híváskor is ki kell írni. Az eredmény paramétereknek a függvényből történő kilépéskor értékkel kell rendelkezni.
3. példa: A leírt hányados_maradék függvény két pozitív egészet vár paraméterül, ha mindkét paraméter pozitív akkor 1-et ad visszatérési értékül, különben -1-et. Pozitív paraméterek esetén kiszámolja a két szám egészosztással képzett hányadosát és maradékát és ezt két eredmény paraméterben adja vissza.

class Program
{
static void Main(string[] args)
{
int x = 13, y = 3, z, v;
if (hányados_maradék(x,y, out z, out v) == 1)
Console.WriteLine("{0} és {1} egész hányadosa: {2}, a maradék: {3}", x, y, z, v);
else
Console.WriteLine("A hányados_maradék függvény pozitív paraméterekkel működik!");
Console.ReadKey();
}
static int hányados_maradék(int a, int b, out int h, out int m)
{
h = 0;
m = 0;
if ((a <= 0) || (b <= 0))
return -1;
h = a / b;
m = a % b;
return 1;
}
}

Tömbök paraméterként természetesen cím szerint kerülnek átadásra.
4. példa: A tömb_összeg függvény egy paraméterként megkapott egész számokból álló tömb elemeinek összegét számolja ki.

class Program
{
static void Main(string[] args)
{
int[] sorozat ={ 1, 5, -7, 10 };
Console.WriteLine(tömb_összeg(sorozat)); // 9 lesz a kiírt szám Console.ReadKey(); } } static int tömb_összeg(int[] tömb) { int összeg = 0; foreach (int x in tömb) összeg += x; return összeg; } }

Függvényleírásokat nem ágyazhatunk egymásba, de egy függvény meghívhatja önmagát. Az ilyen függvényeket rekurzív függvényeknek nevezik.
5. példa: Pozitív egész kitevőjű hatványozás megvalósítása rekurzív függvénnyel. (Feltételezzük, hogy a felhasználó olyan paramétereket ad meg, hogy a hatványozás során nem lép ki a függvény az dupla pontossággal ábrázolható számok köréből, és a megadott kitevő nem negatív.)

class Program
{
static void Main(string[] args)
{
Console.WriteLine(hatvány(2.5, 4)); // 39,0625 Console.ReadKey(); } static double hatvány(double alap, int kitevő) { if (kitevő > 0) return alap*hatvány(alap, kitevő - 1); // az előző sorban hívja a függvény önmagát ugyanazzal az alappal és eggyel kisebb kitevővel
else
return 1;
}
}

A main függvény paramétere egy arg nevű szövegtömb. Ritkán használjuk, a programnév után szóközökkel elválasztott adatok lesznek az arg elemei szövegként értelmezve.
6. példa: Egy olyan programot írunk, amely a program neve után írt számokat kilistázza a képernyőre és kiszámítja az összegüket. Ha az előállított program neve összead, a könyvtárában kiadott összead 2,3 4,5 6,6 parancs kilistázza soronként a beírt három számot, és a következő sorba kiírja az összegüket, ami 13,4. (Érdemes megjegyezni, hogy ha a program kódjába írunk tizedes törtet, akkor a pont a tizedes elválasztó jel, egyébként beolvasott vagy kiírt adatoknál a vessző.)
static void Main(string[] args)
{
double osszeg=0;
foreach (string x in args)
{
Console.WriteLine(x);
osszeg += Convert.ToDouble(x);
}
Console.WriteLine("A beírt számok összege: " + osszeg+
"\n\nA kilépéshez nyomjon le egy billentyűt!");
Console.ReadKey();
}

Vissza a tartalomjegyzékhez