C# - C# nyelv

C# nyelv 5. rész

forráskód letöltése
Sorozatunk mostani részében a változókról, azok típusairól és használatukról lesz szó.
A C# hét különböző típusú változót különböztet meg. Ezekre példát láthatunk az alábbi Teszt nevű osztályban.
  class Teszt
  {
      public static int a;
      int b; 
    ...
    public void Function(int[] c, int d, ref int e, out int f) 
    {
      int g = 1;        
      f = a;
    }
    ...
Ezek alapján a fenti Teszt osztályban lévő változók a következők:
  • a – statikus változó
  • b – példány változó
  • c – tömb változó
  • d – érték paraméter
  • e – referencia paraméter
  • f – kimenő paraméter
Statikus változók
Ahhoz, hogy változó statikus legyen a static kulcsszó megadására van szükségünk. Ez előtt még rendelkezhetünk annak láthatóságáról is, mely jelen esetben publikus. Ha egy változó statikus, akkor arról azt kell tudnunk, hogy a változó nem az adott példánytól függ, hanem az adott osztálytól. Ez azt jelenti, hogy a Teszt osztály „a” változóját akkor is használhatjuk, ha a Teszt osztályból még nem hoztunk létre változót. Másrészről, ha hozunk létre változót a Teszt osztályból, akkor ezekben az „a” változó csupán egyszer van jelen, tehát minden létrehozott példányra nézve globális, valamint a példányokon keresztül nem érhetjük el a statikus változókat.
Tekintsük át mindezt a gyakorlatban is:
A Teszt osztály „a” változójának tehát bármikor adhatunk értéket.
      protected void button1_Click (object sender, System.EventArgs e)
      {
        Teszt.a = 4;
Ha ezek után létrehozunk két példányt a Teszt osztályból, akkor láthatjuk, hogy az a változóból csak egy darab lesz.
        Teszt x = new Teszt();
        Teszt y = new Teszt();
        int[] cc = new int[5];
        int dd = 10, ee = 20, ff;
Mivel a Teszt osztály Funciton függvényének ff paraméterébe visszakapjuk az a változó értékét, így e függvényt hívjuk meg az x változón keresztül. Ebben az esetben tehát az ff megkapja a Teszt osztály a változójának értékét.
        x.Function(cc, dd, ref ee, out ff);
        Text = ff.ToString();
Ugyanezt tesszük a másik példánynál is az y változónál. Itt ff ismét értéket kap és ha futtatjuk a programot, akkor látható, hogy ugyanaz lesz most is az értéke, pedig két egymástól független példányát hoztuk létre a Teszt osztálynak.
        y.Function(cc, dd, ref ee, out ff);
        Text += " - " + ff.ToString();
      }
Statikus változóknál azt is tudnunk kell, hogy az osztályból létrehozott példányon keresztül nem érhetjük el azt. Fenti példánál maradva tehát a következő sor hibás:
  x.a = 11;
Példány változó
Ha egy osztályon, vagy struktúrán belül deklarálunk egy változót a static kulcsszó nélkül, akkor az példány változó lesz. Mellékelt példában a b változó ilyen. Ha láthatóságát nem szabályozzuk külön, akkor a változónk csak az adott osztály példányában és azon belül is csak belülről lesz elérhető, viszont ott globális változóként tekintendő. Így tehát a b változónak tudunk például értéket adni az osztályunk konstruktorában és a Function2-ben is felhasználhatjuk annak értékét.
      public Teszt()
      {
        b = 10; 
      }
      public int Function2() 
      {        
        return b * 2;        
      }
      protected void button2_Click (object sender, System.EventArgs e)
      {
        Teszt x = new Teszt();
        Text = x.Function2().ToString();
      }
Tömb változó
A tömb változó olyan speciális változó, mely egy referenciát tárol egy adott memória területről, ahol a tényleges adatok helyet kapnak. A tömb minden egyes eleme egy tetszőleges típus lehet és az elem száma szintén tetszőleges.
Tömb változó deklarációjánál a [] operátort kell használnunk, épp úgy, mint annak elérésekor.
      public string Function3(int[] c) 
      {   
        string s = "";
        foreach (int i in c)
        {
          s += i.ToString() + " ";
        }
        return s;
      }
      protected void button3_Click (object sender, System.EventArgs e)
      {
        Random r = new Random();
        int[] cc = new int[5];
        for (int i = 0; i<5; i++)
        {
          cc[i] = r.Next(10);
        }        
        Teszt x = new Teszt();
        Text = x.Function3(cc);
      }
Érték paraméter
Ha egy függvény paramétert csak egyszerűen megadunk és nem használjuk a ref, vagy out módosítókat, akkor abból egy érték típusú paraméter lesz. Ennek legfőbb tulajdonsága, hogy csak az érték kerül átadásra, így ha azt egy függvényen belül meg is változtatjuk, annak nincs hatása az eredeti értékre.
      public int Function4(int d)
      {
        d *= 2;
        return d;
      } 
      protected void button4_Click (object sender, System.EventArgs e)
      {
        int dd = 15;
        Text = new Teszt().Function4(dd).ToString() + " " + dd.ToString();
      }
Referencia paraméter
Az érték paraméternél láthattuk, hogy az átadott változó értékét bár módosítottuk, a módosítás nem volt hatással a hívó oldalon lévő változó értékére. Van, amikor pont erre van szükségünk, de lehet, hogy pont nem. Ha azt szeretnénk, hogy ilyen esetben a hívó oldalon lévő változó értéke is megváltozzon, akkor használjunk a referencia paramétert. Az ilyen paramétereket a ref szóval kell jelölnünk, mind a függvényünk, mind a hívó oldalon. Ebben az esetben nem az adott változó értéke kerül átadásra, hanem csak egy arra utaló referencia.
Mellékelt példában létrehozunk egy ee változót, melynek értéke 15. Meghívjuk a Teszt osztály Function5 függvényét paraméterként átadva az ee referenciáját. Ekkor ez a függvény e paramétere az ee változó memória területére fog mutatni. Ha az e változónak értéket adunk, akkor ezzel valójában azt tesszük, hogy az e-ben tárolt memória területnek, vagyis az ee-nek adunk értéket.
     public int Function5(ref int e)
      {
        e *= 2;
        return e;
      }
      protected void button5_Click (object sender, System.EventArgs e)
      {
        int ee = 15;
        Text = new Teszt().Function5(ref ee).ToString() + " " + ee.ToString();
      }
Kimenő paraméter
A függvénynek egy visszatérési értéke lehet. Abban az esetben, ha olyan függvényre van szükségünk, mely egynél több értéket szolgáltat vissza, akkor lesz szükségünk kimenő paraméterek létrehozására. Ekkor a függvény paramétereit az out szóval kell megjelölnünk. Ebben az esetben, ha függvényen belül értéket adunk ezeknek a változóknak, akkor azok értéke visszakerül a hívó oldalra.
      public void Function6(out int f)
      {
        f = 75;
      }
      protected void button6_Click (object sender, System.EventArgs e)
      {
        int ff = 0;
        Teszt x = new Teszt();
        x.Function6(out ff);
        Text = ff.ToString();
      }

C# nyelv cikksorozat