C#-ban költségesebb listát használni, mint tömböt int típusú adatok eltárolására? (List<int>, int[])

Igen költségesebb.

A beépített tömbök sokkal gyorsabbak más nem beépített tömböknél.

Nem vagyok annyira otthon még programozásban de szerintem azért mert a beépített tömbök nem képesek túl sok mindenre.

Azokba csak belerakod,kiolvasod az értékeket míg egy Lis egy csomó mindenre képes pl törölheted az elemeit és ezen kívül egy csomó plusz funkcióra képes.

És szerintem ehhez elengedhetetlen,hogy a List úgy legyen létrehozva,hogy annak a szerkezete lassabb de biztosabb szebben szervezettebb adattárolásra képes és ez mindenképp teljesítmény csökkenéssel jár.De egyébként a List az nagyon gyors szerintem.

Használj beépített tömböket ha a tömbben lévő adat manipulációra nincs szükség csak be és kiolvasásra.

Ha pedig többféleképpen manipulálni szeretnéd a tömbben levő adatokat,akkor pedig használj List et.

Ezt úgy írtam,hogy nem vagyok pró!

Az előző nagyon jól mondja, de azért van még mit hozzátenni:

1. "költséges" sokféle módon lehet valami: például a láncolt listához kellenek plusz pointerek, amik int esetén gyakorlatilag megháromszorozzák a MÉRETet; vagy például a tömbben gyorsan el tudod érni a középső adatot, egy listában ez elég sok ugrás (CPU time)

2. Teljesen másra való a kettő, ha tudsz angolul itt nagyon szépen le van írva:

[link]

gondolom nem láttál még listet belülről, mert c sharp-ban kezdtél

ha így van, nagy kár

A C#-ban eleve minden költséges, szóval optimalizálással csak akkor érdemes foglalkozni, ha már van egy működő programot, de nem fut elég gyorsan.

A C#-ban minden változóhoz szükséges egy class pointer, ami tulajdonképpen azt jelenti, hogy egy 64 bites processzoron egy 2 byte-os integert 6-byton lehet letárolni. C/C++-ban ez természetesen 2 byte.

A tömbök esetében viszont elég 1 class pointer, vagyis egy n elemű 2 byteos tömb esetén n*2+4 byte szükséges. Persze, nem számolva a class-ok memóriafoglalását... :)

A List ezzel szemben még több pointert használ, mint egy sima int változó, ugyanis láncolt listát valósít meg.

Tehát, memóriakezelés szempontjából a tömb a legoptimálisabb.

C#-ban a List<T> nem láncolt listát hoz létre, tehát az N. elem keresése nem lassú (Nem igaz, amit a 3. válaszoló írt)

A List<T> mögött egy tömb van, aminek kezdezben a mérete (ha nem adod meg) 0, az első elem berakásakor 4, utána mindig kétszereződik.

Tehát azért költségesebb, mert menet közben újra kell foglalni a tömböt, és átmásolni az adatokat az új tömbbe.

Ha tudod az elem számát kezdetben, akkor érdemes megadni, így hozd létre a listát:

var list = new List<int>(elemszam);

Nyílván így is lesz egy pici overhead a közvetlen tömbhasználathoz képest, mivel a lista indexerének a getterén keresztül van lekérbe a belső tömb adott eleme, de ez az overhead minimális.

A 4. válaszoló elég fura dolgokat ír. Mért kéne 6 byte egy 2 byteos integerhez (shorthoz)? Az int (short) value type. Javaban lehet igaz amit mondasz. C++-van is ugyanúgy van pointer a listához, semmiben nem különbözik a C++-hoz képest egy lista memóriahasználata. A sebességben van lényeges különbség, mivel a .NET minden elem kiolvasásakor* ellenőrzi, hogy az adott index valóban létezik-e (>=0 és <elemszám)

*Néha (triviális esetekben) a JIT kioptimalizálja ezt, azaz ha pl. egy for ciklust csinálsz 0-tol elemszám-1-ig, akkor az gyors lesz.

Nem vagyok annyira nagy .NET szakértő, de a fentieket megnézheted te is reflectorral vagy ilspy-jal.

na jó hát azt tényleg nem tudtam, hogy a c# list az egy vector..

akkor tulajdonképpen ugyanaz mint a tömb, a kérdés az, hogy tudod-e előre az elemszámot vagy nem

ma 21:01

ha a c++ vektorra gondolsz, az pontosan ugyanígy van megvalósítva ;) Dettó ugyanígy. Van benne egy rejtett tömb. Még a méretezési taktika is ugyanez.