C# tömb oktatóanyaga: létrehozás, deklarálás, inicializálás

Mi az a tömb a C#-ban?

Egy tömb egy gyűjtemény vagy elemsorozat tárolására szolgál. Ezek az elemek azonos típusúak lesznek.

Így például, ha egész értékekből álló tömbje van, a tömb lehet értékek gyűjteménye, például [1, 2, 3, 4]. Itt a tömb elemeinek száma 4.

A tömbök akkor hasznosak, ha azonos típusú értékek gyűjteményét szeretnénk tárolni. Tehát ahelyett, hogy deklarálná a változó minden elemhez csak egy változót deklarálhat.

Ez a változó egy tömbre vagy elemlistára mutat, amely a tömb elemeinek tárolásáért felelős.

Nézzük meg, hogyan dolgozhatunk tömbökkel C#-ban. Példánkban egész számok tömbjét deklaráljuk, és ennek megfelelően dolgozunk velük.

Vegye figyelembe, hogy az alábbi kódok mindegyike a Program.cs fájlba készül.

Step 1) Tömb deklarálása – Az első lépés egy tömb deklarálása. Nézzük meg, hogyan érhetjük el ezt az alábbi kódpéldával.

Code Magyarázat:-

1. Az első rész a adattípus. Meghatározza a tömbben használt elemek típusát. Tehát a mi esetünkben egész számokból álló tömböt hozunk létre.
2. A második rész [ ], amely a tömb rangját határozza meg. (A rang egy helyőrző, amely megadja, hogy a tömb hány elemet tartalmazzon)
3. A következő a tömb neve, ami esetünkben "értékek". Vegye figyelembe, hogy zöld, kancsal aláhúzást lát, emiatt ne aggódjon. Ez csak a .Net azt mondja, hogy deklarált egy tömböt, de nem használja sehol.

Step 2) A következő lépés a tömb inicializálása. Itt fogjuk megadni, hogy a tömb hány értéket fog tartalmazni. A tömb minden eleméhez értékeket is rendelünk.

Code Magyarázat:-

1. Először is beállítjuk a tömbben lévő elemek számát 3-ra. Tehát a szögletes zárójelben azt mondjuk, hogy a tömb 3 elemet tartalmaz.
2. Ezután a tömb minden eleméhez értéket rendelünk. Ezt úgy tehetjük meg, hogy megadjuk a változó nevét + a tömbben lévő index pozícióját. Tehát a values[0] azt jelenti, hogy a tömb első pozíciójában tárolunk egy értéket. Hasonlóképpen a második pozíció eléréséhez a values[1] jelölést használjuk, és így tovább, és így tovább.

Megjegyzések: – A tömbökben az index pozíciója 0-tól kezdődik.

Step 3) Most jelenítsük meg a tömb egyes elemeit a konzolban. Adjuk hozzá az alábbi kódot ennek eléréséhez.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DemoApplication
{
 class Program
 {
  static void Main(string[] args) 
  {
   Int32[] value;
   value=new Int32[3];
   
   value[0]=1;
   value[1]=2;
   value[2]=3;
   
   Console.WriteLine(value[0]);
   Console.WriteLine(value[1]);
   Console.WriteLine(value[2]);
    
   Console.ReadKey(); 
  }
 }
}

Code Magyarázat:-

Ez az az egyszerű rész, ahol csak a Console.WriteLine metódust használjuk, hogy az elem minden értékét elküldjük a konzolnak.

Megjegyezzük, hogy ismét minden elemhez a tömbváltozónév és az indexpozíció segítségével érünk el.

Ha a fenti kódot megfelelően beírta és a program lefut, a következő kimenet jelenik meg.

output:

A kimenetből láthatja, hogy a tömb összes értéke megjelenik a konzolban.

Hogyan cikluson keresztül haladjunk egy C# tömbön foreach használatával

Az egyes elemek index szerinti olvasása működik, de unalmassá válik, ha egy tömb sok értéket tartalmaz. A foreach ciklus letisztultabb módot kínál arra, hogy egy tömb minden elemét sorban bejárjuk anélkül, hogy... tracKirályold magadnak az indexváltozót.

A foreach utasítás egyesével veszi ki a tömb minden elemét, és egy ciklusváltozóba másolja azokat. Ezután ezt a változót használjuk a ciklus törzsében. Mivel a ciklus automatikusan megáll az utolsó elemnél, a foreach kiküszöböli a tömb vége utáni olvasás kockázatát.

using System;
namespace DemoApplication
{
 class Program
 {
  static void Main(string[] args)
  {
   Int32[] values = new Int32[3] {1, 2, 3};
   foreach (Int32 item in values)
   {
    Console.WriteLine(item);
   }
   Console.ReadKey();
  }
 }
}

A fenti példa deklarál és inicializál egy három egész számból álló tömböt, majd foreach paranccsal végigmegy rajta. Minden menetben a változó tétel fogadja a következő értéket, és a Console.WriteLine kiírja azt. A kimenet az 1, 2 és 3 számok külön sorokban.

Fontos szempontok a foreach függvénnyel kapcsolatban tömbök esetén:

• A ciklusváltozó csak olvasható, így a foreach a legjobb az értékek olvasására, nem pedig a helyben történő módosítására.
• Elemek módosítása loo közbenping, használjon inkább egy for ciklust indexszel.
• A foreach egydimenziós tömbökkel, többdimenziós tömbökkel és bármilyen iterációt támogató gyűjteménnyel működik.

C# többdimenziós tömbök

Az eddig bemutatott tömbök egydimenziósak, ami azt jelenti, hogy egyszerű értéklistákat tárolnak. A C# támogatja a többdimenziós tömböket is, amelyek sorokból és oszlopokból álló rácsban rendezik el az elemeket. A kétdimenziós tömb a leggyakoribb forma, és olyan adatokhoz illik, mint a mátrixok, játéktáblák és táblázatok.

Egy kétdimenziós tömböt úgy deklarálunk, hogy vesszőt teszünk a szögletes zárójelek közé. Minden további vessző egy újabb dimenziót ad hozzá, tehát az int[,] kétdimenziós, az int[,,] pedig háromdimenziós. Az elemek ezután dimenziónként egy indexszel érhetők el.

using System;
namespace DemoApplication
{
 class Program
 {
  static void Main(string[] args)
  {
   int[,] matrix = new int[2, 2] { {1, 2}, {3, 4} };
   Console.WriteLine(matrix[0, 0]);
   Console.WriteLine(matrix[1, 1]);
   Console.ReadKey();
  }
 }
}

Itt a tömbmátrix két sort és két oszlopot tartalmaz. A matrix[0, 0] elem 1-et ad vissza, a matrix[1, 1] pedig 4-et. A dimenziók száma a tömb deklarálásakor rögzített, míg az egyes dimenziók mérete a tömb létrehozásakor van beállítva.

C# Jagged tömbök

A szaggatott tömb olyan tömb, amelynek elemei maguk is tömbök. Egy téglalap alakú, többdimenziós tömbbel ellentétben minden belső tömb eltérő hosszúságú lehet, ezért a szaggatott tömböt gyakran tömbök tömbjeinek tömbjeinek nevezik. Ez a rugalmasság akkor hasznos, ha a sorok természetes módon különböző számú értéket tartalmaznak.

Egy szaggatott tömböt deklarálsz két szögletes zárójelkészlettel, majd a belső tömböket külön-külön hozod létre. A következő példa egy szaggatott tömböt hoz létre, ahol az első sor három, a második sor pedig kettő értéket tartalmaz.

using System;
namespace DemoApplication
{
 class Program
 {
  static void Main(string[] args)
  {
   int[][] jagged = new int[2][];
   jagged[0] = new int[] {1, 2, 3};
   jagged[1] = new int[] {4, 5};
   Console.WriteLine(jagged[0][2]);
   Console.WriteLine(jagged[1][1]);
   Console.ReadKey();
  }
 }
}

A jagged[0][2] kifejezés az első sor harmadik elemét olvassa be, ami 3, a jagged[1][1] kifejezés pedig a második sor második elemét, ami 5. Mivel minden sor egy külön tömb, a jagged tömbök hatékonyan használják a memóriát, ha a sorok hossza változó, bár egy plusz lépésre van szükségük minden belső tömb inicializálásához.

GYIK