Több dimenziós tömbök

A C# is támogatja az egynél több dimenzióval rendelkező tömbök létrehozását. Programozásban a dimenzió fogalom alatt nem a fizikai tér dimenziói értendőek. A dimenzió méretet, kiterjedést jelent. Jelen esetben tömbök esetén azt, hogy hány független index kell a tömbön belül az elem egyértelmű beazonosításához.

Ezen logika alapján az egydimenziós tömb leginkább egy számegyenesként vagy listaként fogható fel, a kétdimenziós tömb egy táblázatként, a háromdimenziós pedig egy térbeli adatszerkezetként.

Itt meg is áll az emberi tudomány, mivel a három dimenzió feletti tömböket nem igen tudjuk vizuálisan elképzelni. Ez azonban nem jelenti azt, hogy nem lehetséges ilyen tömb elkészítése. Gyakorlatban azonban a legtöbbször programozás során két- vagy háromdimenziós tömbökkel fogunk találkozni.

A kétdimenziós tömb létrehozásának szintaxisa:

var tomb = new int[20,20];

Az egyes dimenziók kiterjedéseit vesszővel kell megadni. Az első kiterjedés a sorok számát határozza meg, a második pedig az oszlopok számát. Tehát jelen példában egy 20 sorból és 20 oszlopból álló táblázatunk van, amit matematikában szokás mátrixnak nevezni.

A több dimenziós tömbök esetén a tömb elemeinek bejárására két egymásba ágyazott for ciklust szokás alkalmazni, de az elemek bejárása megoldható foreach ciklus segítségével is. Az alábbi példa ezt mutatja be:

using System;

namespace Pelda2dtomb
{
    class Program
    {
        static void Main(string[] args)
        {
            //tömb elemeinek meghatározása
            //minden sor külön zárójelet igényel
            var tomb2d = new int[,]
            {
                { 1, 2, 3 },
                { 4, 5, 6 },
                { 7, 8, 9 }
            };

            Console.WriteLine("Bejárás for ciklusokkal");
            //A length tulajdonság itt nem használható
            //mivel a tömb 2d kiterjedésű. 
            for (int i=0; i<tomb2d.GetLength(0); i++)
            {
                for (int j=0; j<tomb2d.GetLength(1); j++)
                {
                    Console.Write("{0} ", tomb2d[i, j]);
                }
                Console.WriteLine();
            }
            Console.WriteLine("Bejárás foreach ciklusokkal");
            foreach (var elem in tomb2d)
            {
                Console.Write("{0} ", elem);
            }
            Console.ReadLine();
        }
    }
}

A program kimenete:

Bejárás for ciklusokkal
1 2 3 
4 5 6 
7 8 9 
Bejárás foreach ciklusokkal
1 2 3 4 5 6 7 8 9 

A példában látható, hogy több dimenziós tömbök esetén a Length tulajdonság nem használható, mivel a tömb nem csak egydimenziós kiterjedésű. Ilyen esetekben az egyes dimenziók lekérdezésére a GetLength metódus alkalmazható. A metódus paramétere a dimenzió számát jelöli. A dimenziók számozása 0-tól indul.

A kétdimenziós tömbök problémája, hogy kezelésük nagy méretek esetén a program lassulásához vezet. Ennek oka a memóriában való elhelyezkedésben keresendő.

A gyorsasági problémát orvosolhatjuk fűrészfogas tömb létrehozásával. A fűrészfogas tömb, idegen szóval Jagged Array lényege, hogy létrehozunk egy egydimenziós tömböt, ami további egydimenziós tömböket tárol. Ennek előnye, hogy az egyes elemek elérése ezáltal gyorsabb lesz, mivel a keretrendszer egydimenziós tömbök kezelésére van jól optimalizálva.

Hátránya viszont annyi, hogy több memóriát fog igényelni egy ilyen objektum, mivel tömbök tömbjét tároljuk és minden tömbnek vannak belső adattagjai.

A fűrészfogas név onnan jön, hogy ilyen tömbök esetén a tömb elemeinek száma soronként tetszőlegesen változhat. Az ilyen tömbök létrehozási szintaxisa:

var jagged = new int[3][];

Itt a definícióban csak a sorok számát kell megadni, mivel minden sor egy tömb lesz, amit külön példányosítani kell. Az eltérő sorokban pedig eltérő elemszám tárolása lehetséges. Természetesen itt is lehetséges előre megadni az elemek számát futásidőben és természetesen ugyanúgy lekérdezhetőek az elemek foreach, vagy for ciklussal is.

Azonban itt az egyes elemek bejárásához mindenképpen két foreach ciklust vagy két for ciklust kell alkalmaznunk. Az alábbi példa a fűrészfogas tömbök kezelését mutatja be:

using System;

namespace Pelda2djagged
{
    class Program
    {
        static void Main(string[] args)
        {
            //tömbök tömbje.
            //ha menet közben fogjuk feltölteni
            //akkor a szintaxis eltér:
            //var jagged = new int[3][];
            var jagged = new int[][]
            {
                new int[] { 1, 2, 3 },
                new int[] { 4, 5, 6 },
                new int[] { 7, 8, 9 }
            };

            foreach (var sor in jagged)
            {
                foreach (var oszlop in sor)
                {
                    Console.Write("{0} ", oszlop);
                }
                Console.WriteLine();
            }
            Console.ReadLine();
        }
    }
}

A program kimenete:

1 2 3 
4 5 6 
7 8 9