TFeri.hu

A C++ nyelv alapjai 5. rész PDF Nyomtatás E-mail
  
Tartalomjegyzék
A C++ nyelv alapjai 5. rész
Rekurzív függvény
Gyakorlati feladatok és matematika
Minden oldal

9.fejezet: Függvények és külső eljárások

 

Úgy érzem, éppen itt az ideje, hogy összeszedjünk mindent, amit az eljárásokról, illetve a függvényekről tudni kell és rendszerezzük!Nos, az alapvető eljárás ugye a main(), ami alapesetben nem ad végeredményt, mivel return 0-val tér vissza. Először is lássunk egy általános függvény-leírást!

típus név ( paraméter1, paraméter2, ...) { törzs }

 

Itt a következők szerepelnek:
típus: ezt a fajta adatot adja vissza a függvény meghívásakor.
név: ez a függvény elnevezése lesz, azaz így lehet meghívni.
paraméter1, paraméret2, ... (amennyi csak szükséges): minden paraméter tartalmaz egy alapvető típust, mint egy helyi változó deklarációjánál (például: int x); továbbá ezek a változók azonnal használhatók a függvényen belül. Segítségükkel lehet a függvény paraméterek segítségével meghívni. A különböző paramétereket vesszőkkel kell elválasztani.
törzs: ezt kell mindenképpen végrehajtani.

 

Lássunk erre egy gyakorlati példát!

---------------------------------------------
// függvény-minta
#include <iostream>
using namespace std;


int osszeadas (int a, int b) // ez lesz a függvény neve és ezek a paraméterek
{
int r; // belső változó deklarálása
r=a+b;
return (r); // visszatérési érték megadása
}

int main () // Itt kezdődik a fő-ág.
{
int z; // deklaráció
z = osszeadas (5,3); //Függvény meghívása
cout << "Eredmeny: " << z; // Végeredmény kiírása
return 0;
}

---------------------------------------------

Ezt az összeadást simán meg lehet valósítani a hagyományos "+" jellel is, de így legalább könnyebben meg lehet érteni a C++ függvényeinek működési elvét!
Második példánkban lássunk egy hatványozást, nevezetesen 2-nek a 10-dik hatványát.

Itt magát a külső függvényt 10-szer fogjuk meghívni.

---------------------------------------------

// 2. függvény-minta
#include <iostream>
using namespace std;

float szorzas (float a, float b) // ez lesz a függvény neve és ezek a paraméterek
{
float r; // belső változó deklarálása
r=a*b;
return (r); // visszatérési érték megadása
}

int main () // Itt kezdődik a fő-ág. Ennek muszáj int-nek lennie!
{
float z=1; // deklaráció

for (int n=1; n<11;n++)

{
z = szorzas (z,2); //Függvény meghívása
}
cout << "2^10 = " << z; // Végeredmény kiírása
return 0;
}

---------------------------------------------

Nagyon fontos megérteni, hogy a z változó a main() körében érvényesül, míg az r változó csak a szorzas() körében.
Vannak különleges függvények, amelyek nem adnak vissza értéket. Ezt eljárásnak hívjuk. Neve: void(). Persze ezeknek is lehet paramétere, de nem kötelező!

---------------------------------------------

// Eljárás-minta
#include <iostream>
using namespace std;
void kiiras ()
{
cout << "Eljaras vagyok!";
}

int main ()
{
kiiras();
return 0;
}

---------------------------------------------

Még valami: első látásra furcsának tűnhet, hogy miért kell kirakni a függvény neve után az üres zárójelet, de a C++ lelkivilága ezt megköveteli...
Ebben például nincsen paraméter. Szeretném felhívni a figyelmet arra a tényre, hogy a kiiras(); szabályos, de a kiiras; nem.
Következő példánkban újabb minta jön a C++ végtelen rugalmasságára!

---------------------------------------------

// Paraméterek érték szerinti átadása
#include <iostream>
using namespace std;
void duplaz (int& a, int& b, int& c) // Így a paraméterek értékei megváltoztathatók lesznek!
{
a*=2; // Egyszerű duplázás
b*=2;
c*=2;
}

int main ()
{
int x=1, y=3, z=7;
duplaz (x, y, z);
cout << "x=" << x << ", y=" << y << ", z=" << z;
return 0;
}

---------------------------------------------

Itt, mivel eljárást hívtunk és nem függvényt, így nem lesz egyetlen visszaadott érték.
Ennek ellenére a paraméterek értékét meg tudjuk változtatni, mivel a paraméterek meghívásakor az int után "&" jel került.
A két eljárás-hívást természetesen keverhetjük is! Az alábbi példában egy tetszőleges egész szám szomszédait adjuk vissza (változtatható értékként), míg maga a szám nem változik!

---------------------------------------------

// Számszomszédok
#include <iostream>
using namespace std;

void szamelkov (int szam, int& elozo, int& kovetkezo)
{
elozo = szam-1;
kovetkezo = szam+1;
}

int main ()
{
int x=10, y, z;
cout <<" A szam: " << x;
szamelkov (x, y, z);
cout << ", Elo:zo:=" << y << ", Ko:vetkezo:=" << z;
return 0;
}

---------------------------------------------

Persze lehet olyan kérés is, hogy egy függvény paramétereiben egy vagy több eleve adott értékű legyen. Ez kicsit több mozgásteret tesz lehetővé, mivel így variálhatunk például a paraméterek számával (is). Lássuk a következő példát!

---------------------------------------------

// Alapértelmezett paraméter
#include <iostream>
using namespace std;
int szorzas (int a, int b=2) // b=2 alapértelmezett, ha nem jön meg paraméterként!

{
int r;
r=a*b;
return (r);
}

int main ()
{
cout << szorzas (12); // Nincs megadva a szorzó
cout << endl;
cout << szorzas (20,4); // Itt viszont megadtuk!
return 0;
}

---------------------------------------------

Itt a szorzas() függvény paramétere a szorzandó, amit mindenképpen meg kell adni, valamint a szorzó, amit ha nem adunk meg, akkor a függvény 2-nek veszi.
Többször is láthattuk, hogy a C++ rettenetesen rugalmas - jöjjön hát most egy újabb példa!

---------------------------------------------

// Többszörös elnevezésű függvények
#include <iostream>
using namespace std;

int operate (int a, int b) // Ez egészként lesz végrehajtva.
{
return (a*b);
}

float operate (float a, float b) // Ez pedig valósként.
{
return (a/b);
}

int main ()
{
int x=5,y=2;
float n=5.0,m=2.0;
cout << operate (x,y);
cout << "\n";
cout << operate (n,m);
cout << "\n";
return 0;
}

---------------------------------------------

Itt két különböző függvényt definiáltunk azonos névvel, ám az egyikük csak egész értékeket fogad, míg a másik csak valóst. A fordító a paramétereket áttekintve tudja, hogy melyiket mikor kell hívnia, így nem lesz zavar a meghívásukban. Szeretném mindazonáltal megjegyezni, hogy a függvények ilyen típusú többszörös elnevezésével csínján kell bánni, mivel a visszatérési érték különbözősége mellett legalább egy paraméternek különbözőnek kell lennie!



 
Ulti Clocks content

Hirdetés