Mire jó a return?

"Ez az amit nem értek. Minek ad vissza értéket? meg miért."

A függvényeket arra használjuk, hogy valamit csináljanak, pl. adjanak össze két számot.

Akkor a függvény paraméterei lesznek azok a számok, amelyeket összegét keressük és a függv. visszatérési értéke lesz a két paraméter összege.

C# kódodban ha van main nevű függvény, ami publikus és statikus, akkor a programod futtatásakor ez a függvény hívódik.

Lehet több függvény is egy programban definiálva, de csak a main-ed fut le. A main-edben tudsz hívni függvényeket, mint a Console.WriteLine(), de saját függvényt is lehet definiálni és akkor azokat is meghívhatod. Írhatsz olyan függvényt, aminek beadsz két számot és visszaadja a kettő különbségét(tehát nem kiírja, hanem visszaadja a főprogramnak).

Ennek így igazából valóban nincs sok értelme. Általában ehhez valamiféle paraméter kell a függvénybe, pl:

public double PitagoraszTetel(double a, double b) {

return Math.Sqrt(a*a + b*b);

}

Ha van egy ilyen függvényed például, akkor nem kell mindig beírogatni a függvényben levő dolgokat, hanem elég csak PitagoraszTetel(szam1, szam2), és kiszámolja.

Máshol alkalmazhatod ezt értékadásként pl:

Random random = new Random();

int a = random.Next(0, 50);

int b = random.Next(0, 50);

int c = Pitagorasz(a, b);

Vagy akár alkalmazhatod if-ben is:

if(PitagoraszTetel(a, b) >= 50)

Console.WriteLine("A derékszögű háromszög átfogója nagyobb vagy egyenlő, mint 50);

else

Console.WriteLine("A derékszögű háromszög átfogója kisebb, mint 50);

A függvény egy alprogram.

A programok szerkezete olyan, hogy van egy főprogram (main), amelybe szekvenciálisan beleírják magát a programot.

Azonban előfordulhat olyan, hogy egy-egy programrészt nem kell végrehajtani, meg olyan is, hogy egy-egy programrészt többször is végre kell hajtani.

Erre jó, ha ezen programrészeket subrutinokba, függvényekbe, alprogramokba írját és csak szükség esetén híják meg őket. Ezek a főprogramon kívül vannak, ezért kell őket meghívni, ami a főprogramból való kilépést, végrehajtást és a főprogramba való visszatérést jelenti. A visszatéréskor a meghívott függvény visszaadja a főprogram számára azt az eredményt, amit az vár (hiszen ezért hívta meg a függvényt). Nos, ezért visszatérési érték a neve a return-nak (pontosabban az értékének), de nem minden nyelven, mert a return jelenthet más nyelven egészen mást.

Amit te feszegetsz, azok talán a lokális, globális változók, illetve ezek különbsége.

A második példád nem hiba, hanem bűn. Ilyet soha nem csinálunk!

Amúgy is, a globális változók már elég régen kimentek a divatból.

A void függvény implicit visszaadja a futást a hívójának, úgyhogy nem gond, ha nincs benne return, és a fordító nem is kér ilyet.

Olyankor viszont jól jön, ha bizonyos feltételek esetén nem kell a teljes függvénynek lefutnia, hanem korábban visszatér. Helyettesítheti a breaket vagy a gotot például.

Na kezdjük a legelején. Van a nagy programozási elméletben egy olyan dolog, hogy alprogram (szeretik még szubrutinnak is nevezni, főleg a sci-fi filmekben). Ilyeneket azért írunk, hogy rövidebbé és átláthatóbbá tegyük a programunkat. Nem kell messzire menni példáért, nézzük a napirendedet:

felkelsz

megmosakszol

felöltözöl

előveszel egy szelet kenyeret

megkened vajjal

teszel rá szalámit

megeszed

csinálod a napi teendőidet

előveszel egy szelet kenyeret

megkened májkrémmel

teszel rá hagymát

megeszed

lefekszel

alszol

Ez már így ránézésre is furcsa érzéseket vált ki az emberből. Feltűnhet, hogy van egy ismétlődő részlet, amelyben bár apróbb eltérések lehetnek, de egy adott feladatot látnak el - kaját csinálsz. De:

- ha egy harmadik helyen is fel kell használnod, megint copy-paste-elheted

- mivel emberek vagyunk, az előbbi lépést minden további nélkül elcsesszük

- ha rájövünk, hogy ebben vannak hibák (ugye nem nézzük meg, hogy jók-e még azok a cuccok, amiből a szendvicset csináljuk), vagy egyszerűen csak valamit másképp akarunk csinálni, rögtön száz helyen írhatjuk át

- mellesleg hosszabb is tőle a kód (mondjuk ez nem hátrány akkor, ha csak annyi a lényeg, hogy meglegyen a napi sorszám-kvóta)

Az esetleges apróbb eltérések lesznek a függvény és eljárás paraméterei. Szóval ha értelmes ember módjára akarjuk ezt elkövetni, az így néz ki:

szendvicskészítés (kenőanyag, feltét):

.. előveszel egy szelet kenyeret

.. megkened kenőanyaggal

.. teszel rá feltétet

.. megeszed

felkelsz

megmosakszol

felöltözöl

szendvicskészíté s(vaj, szalámi)

csinálod a napi teendőidet

szendvicskészítés(májkrém, hagyma)

lefekszel

alszol

A lényeg itt az volna, hogy amikor megírjuk a függvényünket és eljárásunkat, nem tudjuk, hogy milyen értékei lesznek a paramétereknek. Így nemes egyszerűséggel adunk neki valamilyen nevet, és az majd szépen be fog helyettesítődni. Hogy hol adsz a paramétereknek értéket? Ott, ahol meghívod. Ugye fontos a sorrend, elvégre a hagymát és a szalámit nem nagyon tudjuk kenni...

Nos, akkor hogy mi is az a függvény és az eljárás.

Az eljárással egy összetettebb cselekvést tudsz leírni. Ennek a cselekvésnek lehet valamilyen hatása - pl. kiír a programod valamit a képernyőre, megnyit egy fájlt, átállít valamilyen tulajdonságot stb. Ellenben a függvénnyel összetettebb műveleteket tudsz leírni. Minden egyes műveletnek pontosan egy eredménye van (nem több, nem kevesebb - jó, nyilván lehet trükközni, de a kőbe vésett szabály ez). Ezt hívjuk szakkifejezéssel visszatérési értéknek. És ha eredménye van, fontos kérdés lesz az, hogy milyen típusú eredménye lesz. Ezt leszámítva persze egy függvénynek is lehet valamilyen hatása, az eljáráshoz hasonlóan.

C-szerű nyelvek (C, C++, C#, Java például) a függvényeket és eljárásokat egy kalap alá veszik. A kezdők ezért szokták úgy rendesen besz_pni. Mivel egy eljárásnak csak hatása lehet (=nincs neki eredménye), így azt void kulcsszóval jelöljük:

void osszead_es_kiir(int a, int b) {

printf("%d", a+b);

}

Ellenben a függvénnyel, az ugye képez eredményt - onnan tudjuk, hogy függvénnyel állunk szemben, hogy az eredményének típusa jelölve van. Tegyük fel, összeadsz két int típusú adatot, annak az eredménye egy int típusú adat:

int osszead(int a, int b) {

return a+b; //na ez aztán nagyon összetett művelet volt...

}

Szóval feltűnhet, hogy van ez a return. Ennek két alakja van:

return;

return [kifejezés];

Előbbi csak eljárásokban szerepelhet, utóbbi csak függvényekben. A kettő közt az a különbség, hogy utóbbival jelezzük, ha a függvény futása során eredmény áll elő. A közös dolog bennük, hogy amikor return utasítás meghívódik, ott azon a ponton megszakad a függvény vagy eljárás futása.

void valami() {

return;

puts("Ezt már nem fogod látni");

}

int valami() {

return 5;

puts("Ezt se nagyon...");

}

És akkor beszéljünk ezeknek a meghívásáról. Egy függvény meghívása minden olyan helyen szerepelhet, ahol kifejezésnek vagy utasításnak kell állnia (ez utóbbi azért lehetséges, mert egy függvénynek lehet hatása, mint azt már korábban említettem). Ellenben egy eljárás csak olyan helyen szerepelhet, ahol utasításnak kell állnia (elvégre annak nincs eredménye, csak hatása).

Fontos kérdés lesz itt a paraméterátadási módok, de ebbe nem megyek most bele.

"Értéket ad vissza az összead függvénynek.

Ez az amit nem értek. Minek ad vissza értéket? meg miért."

Nem a függvénynek ad vissza értéket, hanem a függvény adja vissza azt az értéket a hívónak.

Nézzünk egy hasonlatot:

Mondjuk egy munkahelyen van egy ember (András), aki jól tud számolni, de a hatványozást egy másik ember végzi (Béla), mert ő azt keni-vágja nagyon. András ezen dolgozik:

10 + 5^2

Amikor odaér, hogy 5^2, akkor ezt átadja Bélának. Béla kiszámolja és visszaadja(!) Andrásnak, hogy 25. Andrást nem érdekli, hogy az hogy jött ki, neki csak az eredmény kell.

Tehát: András a hívó, ő hívja meg a Béla nevű függvényt, pl. így:

10 + Béla(5,2)

A Béla(int a,int b) függvény kódjának végén pl. az fog szerepelni, hogy:

return a^b;

ami ebben esetben return 5^2; vagyis ez lesz az eredmény, ez jelenik meg a hívónál:

10 + 25

>"a return c sora egyenlő lesz hárommal."

Nem a sor lesz egyenlő bármivel is, hanem az egész függvénynek lesz az a visszatérési értéke, tehát ahol meghívták a függvényt, ott az az érték fog megjelenni.

>"Viszont ha ugyan ezt megcsinálom voiddal akkor már kiiratom."

Ha void típusú a függvény, akkor nem ad vissza értéket, és pl. bele lehet tenni a kiiratást, de nem biztos, hogy az értéket mindig ki kell iratni, lehet hogy előtte vagy helyette mást akarunk csinálni vele, szóval általánosabban használható megoldás, ha visszaadja a hívónak, és ott majd eldől, hogy ki mire akarja használni az eredményt.

>"és az oop része jött"

Ennek így nincs sok köze az OOP-hez, esetleg a poliformizmus, reuse fogalmakhoz, de valójában ezek még procedurális alapok. Túl gyorsan haladsz, és közben átugrasz fontos alapfogalmakat.