Mi a különbség a for és a foreach között?

A foreach lényege kb annyi, hogy egyszerűbb használni, nincs olyan dolog, amit forral ne tudnál megoldani.

De pl ha van egy 10 dimenziós tömböd, aminek az elemein végig kell menned és mondjuk összeadni (lehet van rá beépített parancs, de ezt most hagyjuk), akkor a foreach használata praktikusabb.

Egy jó tanács: bár meg lehet oldani, tömböt listát NE PRÓBÁLJ FELTÖLTENI foreachel csak forral.

Ugyanis mondjuk itt ez a parancs (c#)

foreach(int x in tomb)

{

x = 1;

}

Azt hiheted, hogy ezzel a tomb minden elemét 1re állítottad, de nem!

Ugyanis az xbe csak belemásolódik a tomb aktuális elemének az értéke, azzal max számolhatsz, de ha megváltoztatod, akkor nem a tömb eleme változik, csak az x.

"Kapsz egy mattot, erre felrúgod a táblát és őrjöngsz, hogy Te nyertél? :D"

Először is: Tanulj meg sakkozni.

"A számlálós ciklus soha nem feltételes."

"Itt tehát olyannak, hogy feltétel, helye nincs. A FOR ciklus magja n-szer fog lefutni és kész. Az iteráció darabszámát futásidőben már semmivel NEM LEHET befolyásolni."

Akkor kérlek magyarázd el, hogy itt mi történik:

[link]

És azt is, hogy pontosan hányszor fog lefutni, ha már nem lehet befolyásolni futásidőben, vagyis a darabszám már fordításkor pontosan ismert.

A C sharp az a nyelv, amihez nem csak nem értek, de nem is kivánok érteni. Ettől függetlenül, megpróbálom kisilabizálni az ominózus kódrészt. De mielőtt ez megtörténne:

Én soha nem állítottam olyat, hogy a ciklusmag futásának darabszáma már fordításkor ismert lenne. Már csak azért sem, mert én magam is nap mint nap írok úgy számlálós ciklust, hogy nem tudom, annak magja hányszor fog lefutni.

Azt írtam - vagy legalábbis, azt akartam írni -, hogy a ciklus lefutásának pillanatától kezdve pontosan ismert, hogy a mag hányszor fog lefutni /incl. zero/ valamint azt, hogy ezt a számot befolyásolni nem lehet. Idézem magamat:

"Az iteráció darabszámát futásidőben már semmivel NEM LEHET befolyásolni."

Tehát, a ciklus futása idején.

Azt megelőzően még bármi lehet, mert miért ne*, de ahogy végrehajtásra - vagy kikerülésre - kerül a ciklusmag, onnan már nem.

*For N = 1 to RANDOM(20)

PRINT N

NEXT N

A számlálós ciklusban nincs semmiféle feltétel.

A programozó, bármit is bűvészkedik, csak egy nullát vagy egy pozitív egészet /integert/ ad át /elvárt esetben/ feldolgozásra, hogy ő ennyiszer kivánja lefuttatni a ciklus magját.

A feltétel, amin ti megütköztök, amit furcsa mód hiányoltok, nem egyéb mint a for ciklus implementációs szintű megvalósításának alkatrésze. A végrehajtás ellenőrzi, hogy a ciklusmag elérte-e már az elkivánt darabszámot és inkrementálja vagy dekrementálja a ciklusváltozót, ami nem több mint egy számláló.

--------------------

LiList<int> liList = new

LiList<int(Enumerable.Range(1,10));

for (LiListNode<int> node = liList.First; node != null; node = node.Next)

Help me, fix me, pls:

Tíz elemű láncolt listán kellene végigmenni, ahol a fejelem az első és addig iterál amíg a köv. elem ???

#25 a probléma az, hogy vannak olyan nyelvek (C, C++, Java, C#, JS mindenképp), ahol a for(;condition;) alak egyenértékű ezzel: while(condition). C/C++-ban u.az az assembly generálódik.

Ezekben a nyelvekben változtathatod futás közben az iterációk számát:

for(int i = 0; i < n; ++i) { --i; }

"ciklus lefutásának pillanatától kezdve pontosan ismert, hogy a mag hányszor fog lefutni /incl. zero/ valamint azt, hogy ezt a számot befolyásolni nem lehet."

Ez egyáltalán nem igaz,ezernyi módon lehet befolyásolni, néhány példa:

-fent belinkelt kódban

" if (node.Value % rnd.Next(1,linkedList.Count) == 0) linkedList.AddAfter(node, -node.Value);"

pl módosulhat a kollekció mérete mindenegyes iterációkor és addig járja be, amíg a végére nem ér.

-exceptionoknél idő előtt véget érhet ciklus.

-ciklustörzsön belül hozzá lehet férni a ciklusváltozókhoz és módosítani is lehet őket közvetve vagy közvetlenül.

-kívülről is lehet befolyásolni, ha ciklusváltozók nem helyi változók és valamelyik programrészlet másik szálról hozzányúl.

-break, return-nal ki lehet belőlük ugrani.

stb...

És ez szerintem nem csak csharp sajátosság.

"Tíz elemű láncolt listán kellene végigmenni, ahol a fejelem az első és !addig iterál amíg a köv. elem ???"

Ciklus változó kezdő értéke az első node és ameddig nem null, a következő node referenciáját kapja értékül. Van itt bárhol integer(a generikus paramétert leszámítva), inkrementáció vagy dekrementáció? Szerintem nincs.

"-exceptionoknél idő előtt véget érhet ciklus."

Az nem számít. Exceptiön bárhol lehet a kódban.

Akkor azt is írhatnád, hogy break vagy goto. Ezek a ciklusváltozóra nincsenek befolyással.

" Van itt bárhol integer(a generikus paramétert leszámítva), inkrementáció vagy dekrementáció? Szerintem nincs."

Hát van. Amiben igazad, igazatok van az, hogy a ciklusok száma valóban nem ismert a futásidő bizonyos - jelentős - részében.

Nem tudom más nyelvekben hogy van de c# ban a foreach ciklussal végig lehet iterálni, lépkedni olyan kollekciók, adatszerkezetek elemein melyek megvalósítják az ienumerator, innumerable interfrészeket valamint a foreach ciklus egész blokkjára kiterjedően nem engedélyezi a kollekció módosítását, csak olvasni lehet vele a egy kollekció elemeinek értékeit.

Szóval ha végig kell menned valaminek az elemein az összesen( mert ezzel az összesen végig iterálsz ha akarod ha nem hacsak megnem szakítod a folyamatot a break utasítással) és nem akarod módosítani a kollekciót(c# foreach ja ezt nem engedi) akkor használd a foreach ot mert minnél szigorúbb módon kódolsz annál gyorsabb és könnyebben karbantarthatóbb kódot írsz.