Bevezetés a C tömbökbe

A tömb objektumok halmaza. A tömbben lévő elemek azonos adattípusúak. Lehet, hogy int, float, char, stb. A tömbök fogalma a C # -ben létezik, hogy elkerüljék a nehézséget a különböző értékek tárolásakor, különféle változók létrehozásával.

235632541
01234

A tömb indexe 0-tól kezdődik, és a tömb indexét a tömb konkrét mérete alapján növelik. Ha van egy 5 hosszúságú tömbünk, akkor a tömb a 0-tól kezdődik, és a 4-es indexnél fejeződik be. Tehát a tömb hossza határozza meg az adott tömbben lévő elemek számát.

Hogyan működik az Array a C # -ben?

A C #-ban a tömb hossza fix vagy dinamikus lehet. Rögzített hosszúságú tömbben rögzített számú elem tárolható. A dinamikus tömb mérete növekszik, amikor új elemek érkeznek a tömbbe, mivel a tömb memóriaelosztása dinamikus. A tömbökben a veremmemória a tömb változóját tárolja, míg a kezelt halom az elemeket tárolja. A C #-ban a tömb a System-ből származik. Tömb osztály. Ha egész számú tömbünk van, akkor az összes elemnek megvan a megfelelő értéke és mivel a C # tömbje referencia típus, akkor az elemek hivatkozni fognak a tényleges objektumokra.

Hogyan hozzunk létre tömböt a C # -ben?

Egy tömb szintaxisa: data_type () name_of_array

1. Egy tömb nyilatkozata

Kód:

class Name
(
static void Main(string()args)
(
Int32() intarray; //array declaration
)
)

Kód magyarázat: A tömb deklarációban az első rész adattípus, amely meghatározza a tömb objektumainak típusát. A második rész () határozza meg a tömb objektumának számát, majd a következő tömb nevét adja meg, amely ebben az esetben int tömb

2. Tömb inicializálása

Kód:

class Name
(
static void Main(string()args)
(
Int32() Intarray; //array declaration
Intarray = new Int32(4); // array initialization
Intarray(0)= 23; // assigning values to the elements
Intarray(1)=5;
Intarray(2)=88;
Intarray(3)=6;
)
)

Kód magyarázat: A tömb inicializálásakor szögletes zárójelekkel meg kell határoznia a tömbben lévő értékek számát, és ezeket az értékeket a tömb minden eleméhez hozzá kell rendelni. Tehát itt az intarray (0) azt jelenti, hogy az első pozícióban értéket rendelünk, az intarray (1) pedig azt jelenti, hogy a második pozícióban értékeket rendelünk, és így tovább.

3. A tömb értékeinek megjelenítése

Kód:

class Name
(
static void Main(string()args)
(
Int32() Intarray; //array declaration
Intarray = new Int32(4); //array initialization
Intarray(0)= 23; //assigning values to array
Intarray(1)=5;
Intarray(2)=88;
Intarray(3)=6;
Console.WriteLine(Intarray(0));
Console.WriteLine(Intarray(1));
Console.WriteLine(Intarray(2));
Console.WriteLine(Intarray(3));
Console.ReadKey();
)
)

Kód magyarázat: A Console.WriteLine egy módszer a tömb minden értékének megjelenítéséhez a konzolon.

Példák tömbökre

A példák és a C # eredményei az alábbiakban találhatók

1. példa

Kód:

using System;
namespace ArrayDemo
(
class Name
(
static void Main(string() args)
(
Int32() Intarray; // array declaration
Intarray = new Int32(4); // array initialization
Intarray(0) = 23; // assigning values to the array element
Intarray(1) = 5;
Intarray(2) = 88;
Intarray(3) = 6;
Console.WriteLine(Intarray(0));
Console.WriteLine(Intarray(1));
Console.WriteLine(Intarray(2));
Console.WriteLine(Intarray(3));
Console.ReadKey();
)
)
)

A fenti kódban a tömb deklarálódik és négy elemmel inicializálódik, és a Console.WriteLine megjeleníti az összes értéket.

Kimenet:

2. példa

Kód:

using System;
namespace Demo
(
class Array
(
static void Main(string() args)
(
int() arr = new int(4) ( 10, 20, 30, 40 );
for (int i = 0; i < arr.Length; i++) // Traverse array elements
(
Console.WriteLine(arr(i));
)
)
)
)

A fenti kódban a tömb négy elemmel inicializálódik és deklarálódik, majd hurkot használnak a tömb elemeinek eléréséhez.

Kimenet:

3. példa

Használhatjuk az foreach felhasználásával a tömb elemeit is

Kód:

using System;
namespace Demo
(
class Array
(
static void Main(string() args)
(
int() arr = new int(4) ( 10, 20, 30, 40 );
foreach (int i in arr)
(
Console.WriteLine(i);
)
)
)
)

Kimenet:

A C # tömb típusai

A C # esetében többféle tömb van:

  1. Egydimenziós tömb.
  2. Többdimenziós tömb.
  3. Egyenetlen tömb.

A fenti példák egydimenziós tömböt tartalmaznak.

Többdimenziós tömb

Téglalap alakú vagy többdimenziós tömbökben az adatokat táblázatos formában tárolják

Int(, ) intArray = new int(4, 3)

Ebben a sorban négy sor és három oszlop megadásával határoztuk meg a tömb méretét.

1. A többdimenziós tömbök deklarálása

int(, ) array = new int(3, 3); //declaration of 2D array
int(,, ) array=new int(3, 3, 3); //declaration of 3D array

2. A többdimenziós tömb inicializálása

int(, ) array = new int(3, 3); //declaration of 2D array
array(0, 1)=10; //initialization
array(1, 2)=20;
array(2, 0)=30;

Példa a többdimenziós tömbre

Kód:

using System;
namespace Demo
(
class Array
(
public static void Main()
(
int(, ) intArray = new int(3, 2)(
(1, 2),
(2, 4),
(4, 8)
);
Console.WriteLine(intArray(0, 0));
Console.WriteLine(intArray(0, 1));
Console.WriteLine(intArray(1, 0));
Console.WriteLine(intArray(1, 1));
Console.WriteLine(intArray(2, 0));
Console.WriteLine(intArray(2, 1));
)
)
)

Kód magyarázat: A fenti kódban a sorok és oszlopok három sorral és négy oszloppal vannak megadva, és a Console.WriteLine megjeleníti az összes értéket.

Kimenet:

Jagged Array

Az egyenetlen tömbök elemei „tömb”, mert közvetlenül tárolják a tömböt.

1. Az egyenetlen tömb deklarálása

int()() array = new int(3)();

Az első zárójel a méretét, a második zárójel a tömb méreteit mutatja.

2. Inicializálja és rendeljen értékeket az egyenetlen tömbökhöz

array(0) = new int(4) ( 1, 2, 3, 4 );
array(1) = new int(5) ( 1, 2, 3, 4, 5 );

Az elemek mérete eltérő lehet.

Az alábbiakban bemutatjuk az egyenetlen tömb példáit:

1. példa

Kód:

using System;
namespace Demo
(
class Array
(
public static void Main()
(
int()() array = new int(2)();// Declare the array
array(0) = new int() ( 1, 2, 6, 8 );// Initialize the array
array(1) = new int() ( 72, 51, 47, 23, 54, 13 );
// Traverse array elements
for (int i = 0; i < array.Length; i++)
(
for (int j = 0; j < array(i).Length; j++)
(
System.Console.Write(array(i)(j) + " ");
)
System.Console.WriteLine();
)
)
)
)

Kimenet:

2. példa

Kód:

using System;
namespace Demo
(
class Array
(
public static void Main()
(
int()() array = new int(3)()(
new int() ( 51, 22, 43, 87 ),
new int() ( 2, 3, 4, 56, 94, 23 ),
new int() ( 4, 5 )
);
// Traverse array elements
for (int i = 0; i < array.Length; i++)
(
for (int j = 0; j < array(i).Length; j++)
(
System.Console.Write(array(i)(j) + " ");
)
System.Console.WriteLine();
)
)
)
)

Teljesítmény :

Tömb módszer C # -ben

A következő pontok a következők:

  1. Törlés (tömb, Int32, Int32) : Ezt a módszert az elemtartomány alapértelmezettre állításához használja az elem típusa alapján.
  2. Klón (): Ezt a módszert az elem másolatának létrehozására használják.
  3. Másolás (tömb, tömb, Int32): Ezt a módszert az egyik tömb elemének másolására használják.
  4. Egyenlő (objektum): Ez a módszer alapvetően ellenőrzi, hogy az említett objektum megegyezik-e az aktuális objektummal.
  5. Rendezés (tömb): Ez a módszer a tömb rendezéséhez használható.
  6. CreateInstance (Type, Int32): Ezt a módszert egy adott típusú, hosszúságú és méretű tömb létrehozására használják.
  7. ToString (): A karakterlánc-ábrázolás megjelenítésére szolgál.
  8. GetType (): Ez a módszer az objektum típusának visszaadására szolgál.
  9. IndexOf (tömb, objektum): Ez a módszer az adott objektum keresésére és az 1D tömb első előfordulásának indexének visszatérítésére szolgál.
  10. Fordított (tömb): Ezt a módszert az elemek sorrendjének megfordítására használják.
  11. SetValue (Object, Int32): Az 1D tömbben ezt a módszert használják az elem értékének beállításához.

Példa

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ArrayMethod
(
class Program
(
static void Main(string() args)
(
int() arr = new int(6) ( 5, 8, 9, 25, 0, 7 );
// Creating an empty array
int() arr2 = new int(6);
Console.WriteLine("length of first array: " + arr.Length); // length of array
Array.Sort(arr); //sorting array elements
Console.Write("Sorted array elements: ");
PrintArray(arr);
Array.Copy(arr, arr2, arr.Length); // copy elements of one array to other
Console.Write("Second array elements: ");
PrintArray(arr2);
Console.WriteLine("Get Index:\t(0)", Array.IndexOf(arr, 9)); // index of value
Array.Reverse(arr);
Console.Write("\nFirst Array elements in reverse order: "); // reverse the elements of array
PrintArray(arr);
Array.Clear(arr, 0, 6); //set default value of elements
PrintArray(arr);
)
static void PrintArray(int() arr)
(
foreach (int i in arr)
(
Console.Write("\t(0)", i);
)
Console.WriteLine("\n");
)
)
)

Kód magyarázat: A fenti kód azon tömb több módszerét mutatja be, amelyben az arr. A hosszúságot arra használjuk, hogy a hosszúság egyenlő legyen, Array. A Sort a rendezett formában adja meg az értékeket. Sor. A Másolás másolja az értékeket az első tömbből a második tömbbe. Sor. A fordított sorban a tömb fordított sorrendben jelenik meg, míg a Törlés az elemek alapértelmezett értékeit.

Kimenet:

Következtetés

Ezért jobb egy tömbváltozót deklarálni, ahelyett, hogy túl sok különféle változót deklarálna, mivel a memória elemei egymás után vannak tárolva, ami gyorsabbá teszi. Ezenkívül tömbökkel is könnyű megkeresni, manipulálni és rendezni az adatokat.

Ajánlott cikkek

Ez egy útmutató a C # tömbjeihez. Itt tárgyaljuk, hogyan hozhatók létre tömbök a c # -ben, a tömb típusai, a módszerek és a példák. Megnézheti más kapcsolódó cikkeinket, hogy többet megtudjon-

  1. C # parancsok
  2. C # Funkciók
  3. C # lista vs tömb
  4. Tömbök C ++-ban
  5. Többdimenziós tömb C-ben
  6. Többdimenziós tömb Pythonban
  7. Tömbök a PHP-ben
  8. Többdimenziós tömbök C ++-ban példákkal

Kategória:

Szoftverfejlesztés