Átmenő paraméterek
Amennyiben egy alaptípusú paraméter-változón keresztül szeretnénk értéket visszaadni, úgy azt jelölni kell:
static void ParosElemek(int[] tomb, ref int db, ref int osszeg)
{
db=0;
osszeg=0;
for(int i=0;i<tomb.Length;i++)
if (tomb[i] % 2 == 0)
{
db++;
osszeg = osszeg + tomb[i];
}
}
{
db=0;
osszeg=0;
for(int i=0;i<tomb.Length;i++)
if (tomb[i] % 2 == 0)
{
db++;
osszeg = osszeg + tomb[i];
}
}
A fenti eljárás két értéket is előállít – a páros tömbelemek számát, és összegét. Mivel ez már kettő darab érték, ezért nem írhatjuk meg függvényként. Egy függvény csak egy értéket adhat vissza.
Az ilyen jellegű paraméterátadást cím szerinti paraméterátadásnak nevezzük. Ekkor a hívás helyén is jelölni kell, hogy az átadott változóban kimenő adatokat várunk:
int x=0,y=0;
ParosElemek(tomb, ref x, ref y);
Console.WriteLine("A paros elemek db={0}, osszeguk={1}",x,y);
ParosElemek(tomb, ref x, ref y);
Console.WriteLine("A paros elemek db={0}, osszeguk={1}",x,y);
A ref kulcsszóval kell jelölni, hogy az adott paraméterben értéket is vissza szeretnénk adni. Ugyanakkor a ’ref’ kulcsszó ennél többet jelent – a ’ref’ paraméterben értéket is adhatunk át az eljárás számára. Ez a paraméter klasszikus átmenő paraméter.
Az átmenő paraméterek egyidőben bemenő és kimenő paraméterek. Az eljárásban ezen paraméter értékét felhasználhatjuk, és meg is változtathatjuk.
int x,y;
ParosElemek(tomb, ref x, ref y);
Console.WriteLine("A paros elemek db={0}, osszeguk={1}",x,y);
ParosElemek(tomb, ref x, ref y);
Console.WriteLine("A paros elemek db={0}, osszeguk={1}",x,y);
Amennyiben a paraméterként átadott változók nem rendelkeznének értékkel a hívás pillanatában (definiálatlan változó), úgy a C# fordító szintaktikai hibát jelez (ilyen a fenti példa is!).
A fenti függvény esetén szükségtelen, hogy a db és osszeg paraméterváltozóinak kezdőértéke legyen. Az ilyen paramétereket nem a ’ref’, hanem az ’out’ kulcsszóval kell megjelölni!
static void ParosElemek(int[] tomb, out int db, out int osszeg)
{
db=0;
osszeg=0;
for(int i=0;i<tomb.Length;i++)
if (tomb[i] % 2 == 0)
{
db++;
osszeg = osszeg + tomb[i];
}
}
{
db=0;
osszeg=0;
for(int i=0;i<tomb.Length;i++)
if (tomb[i] % 2 == 0)
{
db++;
osszeg = osszeg + tomb[i];
}
}
A hívás helyén is:
int dbszam,summa;
ParosElemek(tomb, out dbszam, out summa);
ParosElemek(tomb, out dbszam, out summa);
A ’ref’ és az ’out’ módosítók közötti különbség, hogy a hívás helyén (aktuális paraméterlistában) szereplő változóknak ’out’ esetén nem kötelező értékkel rendelkezniük. E miatt egy ’out’ paraméterváltozót a függvény törzsében is kezdőérték nélkülinek tekint a fordító. A függvényben kötelező értéket adni ezeknek a paraméterváltozóknak a függvény visszatérési pontja (return) előtt.
A ’ref’ esetén a függvényhívás előtt a változóknak kötelező értéket felvenni, és a függvényben nem kötelező azt megváltoztatni.
Aki esetleg keresné, ’in’ módosító nincs a C#-ban, ugyanis a paraméterek alapértelmezésben bemenő adatok, vagyis az ’in’ módosítót ki sem kell írni.
static void Csere(ref int a, ref int b)
{
int c;
c=a;
a=b;
b=c;
}
{
int c;
c=a;
a=b;
b=c;
}
A fenti eljárás a paramétereként megkapott két változó tartalmát cseréli fel. Mivel ilyenkor érdekes a paraméterek aktuális értéke is, ezért a ’ref’ kulcsszót kell használni.
A fenti eljárás kitűnően felhasználható egy rendező eljárásban:
static void Rendezes(int[] tomb)
{
for(int i=0;i<tomb.Length-1;i++)
{
for(int j=i+1;j<tomb.Length;j++)
{
if (tomb[i]>tomb[j])
Csere(ref tomb[i],ref tomb[j]);
}
}
}
{
for(int i=0;i<tomb.Length-1;i++)
{
for(int j=i+1;j<tomb.Length;j++)
{
if (tomb[i]>tomb[j])
Csere(ref tomb[i],ref tomb[j]);
}
}
}