A hurkok lehetővé teszik egy vagy több kódsor többszöri végrehajtását. A VBA a következő hurkokat támogatja:
For...Következő Mindegyik...Következő Do... Loop
A For konstrukció. . . következő. Ha az ismétlések száma előre ismert, a For ciklus használatos. . . következő. A For ciklus egy ciklusváltozónak vagy hurokszámlálónak nevezett változót használ, amely a ciklus minden ismétlődésekor egy adott mennyiséggel növeli vagy csökkenti. Ennek a konstrukciónak a szintaxisa a következő:
Számláló esetén = elejétől végéig Következő utasítások
A számláló (számláló), start (ciklus kezdete), vége (ciklus vége) és inkrementum (növekmény) paraméterek numerikusak.
Jegyzet. A növekmény paramétere lehet pozitív vagy negatív. Ha pozitív, akkor a start paraméternek kisebbnek vagy egyenlőnek kell lennie, mint a végparaméter, különben a ciklus nem fog végrehajtani. Ha a növekmény paraméter negatív, akkor a start paraméternek nagyobbnak vagy egyenlőnek kell lennie a záró paraméter értékével ahhoz, hogy végrehajthassa a hurok törzsét. Ha a Step paraméter nincs beállítva, akkor a növekmény paraméter alapértelmezett értéke 1.
A VBA a For ciklust a következő sorrendben hajtja végre:
1. Beállítja a hurokváltozó számlálóját.
2. Összehasonlítja a hurokváltozó számláló értékét a végparaméter értékével. Ha a számlálóváltozó nagyobb, a VBA befejezi a hurkot. (Ha a növekmény paraméter értéke negatív, akkor a VBA leállítja a hurkot, ha a hurokváltozó számlálójának értéke kisebb, mint a végparaméter értéke.)
3. Végrehajtja a ciklustörzs utasításainak utasításait.
4. Növeli a hurokváltozó számláló értékét 1-gyel, vagy az inkrement paraméter értékével, ha adott.
5. Ismételje meg a 2–4. lépéseket.
Vegyünk egy példát: Számítsuk ki az f(t) függvény értékét
adott a, b, n, ha t a-ról b-re változik Dt=(b-a)/(n-1) lépésekben.
Sub example3() Dim f() As Single Dim a As Single, b As Single, t As Single, dt As Single Dim i As Integer, n As Integer Call read("a1", a) : Call read("b1" , b) : Hívás read("c1", n) ReDim f(1 To n - 1) dt = (b - a) / (n - 1) : t = a Call out("a2", "i") : Call out("b2", "t") : Call out("c2", "f(t)") For i = 1 To n - 1 t = t + dt Ha t<= -1 Then f(i) = -1 ElseIf t >1 Akkor f(i) = 1 Else f(i) = t End If Call out("a" & (2 + i), i) : Call out("b" & (2 + i), t) : Hívás out("c" & (2 + i), f(i)) Következő i End Sub
A Minden konstrukcióhoz. . . Következő
Minden hurokhoz. . . A következő olyan, mint egy For hurok. . . Következő, de megismétli az utasítások egy csoportját minden elemhez egy objektumkészletből vagy egy tömbből, ahelyett, hogy adott számú alkalommal ismételné meg az utasításokat. Különösen akkor hasznos, ha nem tudja, hány elem van a készletben.
A For Every loop konstrukció szintaxisa. . . Következő:
Minden elemhez A csoport utasításaiban Következő elem
Ügyeljen a következő korlátozásokra, amikor a For Every ciklust használja. . . Következő:
Halmazok esetén az elem paraméter csak típusváltozatú változó, általános objektum típusú változó vagy az Objektumböngészőben felsorolt objektum lehet.
Tömbök esetén az elem paraméter csak Variant típusú változó lehet
Nem használhat minden egyes hurkot. . . Következő egy felhasználó által definiált típusú tömb, mert a változó típusú változó nem tartalmazhat felhasználó által meghatározott típusú értéket
Csinálj...Hurkos kialakítást
A Do ciklus egy utasításblokk korlátlan számú végrehajtására szolgál. A Do konstrukciónak számos változata létezik. . . Hurok, de mindegyik kiértékel egy feltételes kifejezést, hogy meghatározza, mikor kell kilépni a ciklusból. Mint az If konstrukció esetében. . . Ekkor a feltételnek olyan értéknek vagy kifejezésnek kell lennie, amely hamis (nulla) vagy igaz (nem nulla) értékre számít.
A következő konstrukcióban a Do . . . A hurokutasítások mindaddig végrehajtásra kerülnek, amíg a feltétel értéke True (True):
Do While Condition Loop utasításokat
A ciklus végrehajtásakor a VBA először ellenőrzi a feltételt. Ha a feltétel False, akkor az összes ciklusutasítást kihagyja. Ha igaz, a VBA végrehajtja a hurokutasításokat, ismét visszatér a Do While utasításhoz, és újra teszteli a feltételt.
Ezért a konstrukció által képviselt hurok tetszőleges számú alkalommal végrehajtható, amíg a feltétel értéke nem nulla vagy igaz. Vegye figyelembe, hogy a ciklustörzs utasításai soha nem hajtódnak végre, ha a feltétel első ellenőrzésekor hamisnak (False) bizonyul.
Vegyünk egy példát: Számítsuk ki egy sorozat összegét
adott pontossággal.
Alpélda4() Dim e As Single, x As Single, s As Single Dim m As Single, p As Single, i As Single Hívás read("a1", x) : Call read("b1", e) s = 0 : i = 1: m = 1: p = -1 Call out("a2", "i") : Call out("b2", "m") : Call out("c2", "s") Do While Abs(m) >= e p = -p * x m = p / i s = s + m Call out("a" & (2 + i), i) : Call out("b" & (2 + i), Abs (m)) : Kihívás ("c" & (2 + i), s) i = i + 1 hurokvég
A Do konstrukció egy másik változata. . . A Loop először végrehajtja a ciklus törzsének utasításait, majd minden végrehajtás után ellenőrzi a feltételt. Ez a változat biztosítja, hogy a ciklustörzsben lévő utasítások legalább egyszer végrehajtásra kerüljenek:
Do utasítások Loop While feltétel
A hurokkonstrukció másik két változata hasonló az előzőekhez, azzal a különbséggel, hogy a ciklus akkor hajtódik végre, ha a feltétel hamis (False):
A ciklus egyáltalán nem, vagy többször is végrehajtódik:
Tedd a feltételekig
Loop kijelentések
A ciklus legalább egyszer végrehajtásra kerül:
operátorok
Hurok állapotig
7.2 Beágyazott hurkok.
Vezérlési struktúrákat helyezhet el más vezérlőstruktúrákba (például egy Ha... Majd blokk egy For... Következő hurkon belül). Egy másik vezérlőstruktúra belsejében elhelyezett vezérlőszerkezetről azt mondjuk, hogy beágyazott.
A vezérlőstruktúrák egymásba ágyazásának mélysége a VBA-ban nincs korlátozva. A kód olvashatóságának javítása érdekében beágyazott vezérlőstruktúrák használatakor bevett gyakorlat a döntési konstrukció vagy ciklus törzsének eltolása a programban.
Ha egy hurokba egy vagy több másik hurkot ágyazunk be, akkor beágyazott hurokról beszélünk, amelyek különbséget tesznek a külső (befogó) és a belső (beágyazott) hurok között.
Tekintsünk egy példát az A(n,m) mátrix Aij elemeinek soronkénti összegzésére.
Alpélda5() Dim a() As Single, s() As Single Dim n As Integer, m As Integer Dim i As Integer, j As Integer Call read("a1", n): Call read("b1", m ) ReDim a(1-től n-ig, 1-ig m-ig), s(1-től n-ig) "Mátrix olvasása i = 1-től n-ig j = 1-től m-ig Readcell(i + 1, j, a(i, j)) hívása Következő j Következő i "Számítás i = 1-hez n s(i) = 0-hoz j = 1-hez m s(i) = s(i) + a(i, j) Következő j Outcell(i + 1, m + 1) hívása , s(i)) Következő i Vége Sub
Vegye figyelembe, hogy az első Next bezárja a belső For ciklust, az utolsó Next pedig a külső For ciklust. Hasonlóképpen, a beágyazott If utasítások esetén az End If utasítások automatikusan a legközelebbi If utasítás bezárásához kerülnek alkalmazásra. Beágyazott szerkezetek Do . . . A ciklusok hasonló módon működnek: a legtávolabbi Loop utasítás a legtávolabbi Do utasításnak felel meg.
Amikor egy kétdimenziós tömb elemeinek bevitelét/kiadását végzi el egy Microsoft Excel munkalapon, célszerű egyéni beviteli/kimeneti eljárásokat használni:
Sub readcell(i As Integer, j As Integer, val As Variant) val = Leaf1.Cells(i, j).Érték vége Sub Outcell(i As Integer, j As Integer, val As Variant) Leaf1.Cells(i, j).Érték = val End Sub
ahol I a sor száma, j a munkalap oszlopának száma.
Az irányítási struktúrák elhagyása
Az Exit utasítás lehetővé teszi, hogy közvetlenül kilépjen egy For ciklusból, egy Do ciklusból, egy Sub eljárásból vagy egy Function eljárásból. Az Exit utasítás szintaxisa egyszerű:
Számláló esetén = eleje Befejezéséig [kimutatás blokk] [kimutatás blokk] Következő teendő [(Míg | Amíg) feltétel] [kimutatás blokk] [kimutatás blokk] Hurok
Az Exit For a For cikluson belül és az Exit Do a Do cikluson belül tetszőleges számú alkalommal megjelenhet.
Az Exit Do utasítás a Do ciklus szintaxisának összes változatával működik.
Az Exit For és az Exit Do utasításokat akkor használjuk, ha azonnal le kell zárni a ciklust anélkül, hogy további iterációkat kellene folytatni, vagy meg kell várnunk egy utasításblokk végrehajtását a ciklustörzsben.
Amikor az Exit utasítást használja a ciklusból való kilépéshez, a ciklusváltozó értéke attól függ, hogy a ciklus hogyan végződik:
Amikor a hurok normálisan végződik, a ciklusváltozó értéke eggyel több, mint a hurkok számának felső korlátja
Ha a ciklus idő előtt véget ér, a ciklusváltozó megtartja értékét, amit kapott, figyelembe véve a szokásos szabályokat.
Amikor a ciklus a halmaz végén véget ér, a ciklusváltozó Nothing, ha objektumváltozó, vagy Üres, ha változat
Utolsó frissítés: 2015.10.30
A vezérlőszerkezetek másik típusa a hurkok. A VB.NET többféle hurkot használ.
A...Next Loop számára
Ez a ciklus bizonyos számú alkalommal lefut, és ezt a számot a számláló állítja be:
For i As Integer = 1-től 9-ig Console.WriteLine("A (0) négyzete (1)", i, i * i) Következő
Itt az i változó számláló szerepét tölti be. A szó után Nak nek feltesszük a számláló maximális értékét. Minden ciklusnál a számláló értéke eggyel nő. És ezt az értéket összehasonlítja a következő értékkel Nak nek. Ha ez a két érték egyenlő, akkor a hurok véget ér.
Ha hurokkal dolgozunk, minden lépésnél növelhetjük a számláló értékét, nem csak eggyel, hanem általában tetszőleges számmal. Ehhez vagy a kulcsszót kell használnia lépésés utána adja meg a ciklus lépését, amellyel a számláló értéke növekedni fog, vagy közvetlenül a ciklusban növelheti a számlálót:
For i As Integer = 1-től -9-ig Lépés -1 For j As Integer = 1-től 9-ig Console.WriteLine("I és j szorzata (0)", i * j) j += 1 Következő Következő
Vegye figyelembe, hogy az első ciklus lépéseként negatív értéket választunk, és a számláló értéke minden lépéssel eggyel csökken. A belső ciklusban a j számláló minden lépésnél 2-vel növekszik, mert alapértelmezés szerint eggyel nő, mi pedig kifejezetten eggyel növeljük a ciklusban. Ennek eredményeként a belső hurok ötször működik, a külső pedig kilenc, azaz valójában 45 ciklust kapunk.
Mindegyikhez...Next Loop
A For Every ciklus egy adott csoport, például egy tömb vagy egy gyűjtemény elemei felett iterál. Tegyük fel, hogy van egy Integer típusú tömbünk, és ezt a tömböt véletlenszerű értékekkel kell inicializálnunk, majd minden elemét meg kell jelenítenünk a képernyőn:
"Hozzon létre egy öt számból álló tömböt Dim nums(4) As Integer Dim r As New Random() "inicializálja a tömböt For i As Integer = 0 To nums.Length - 1 nums(i) = r.Next(100) Next " Elemek tömbjének megjelenítése Minden i-hez Integer In nums Console.Write("(0) ", i) Következő
Az For Every utasításban először megadunk egy változót, amely a tömbelemek értékeit veszi fel. És a kulcsszó után Ban ben Adja meg azt a csoportot, amelyben az összes elemet rendezni szeretné.
míg hurok
A While ciklusban addig fut, amíg egy bizonyos, a While szó után megadott feltétel teljesül:
Dim j As Integer = 10 Míg j > 0 Konzol.WriteLine(j) j -= 1 End While
Csinálj hurkot
A Do ciklus, akárcsak a While ciklus, addig fut, amíg egy bizonyos feltétel teljesül. Ennek azonban különböző formái vannak. Tehát a következő példában először a feltételt ellenőrizzük, majd a ciklusban meghatározott kódblokkot hajtjuk végre:
Dim j As Integer = 10 Do Míg j > 0 Konzol.WriteLine(j) j -= 1 ciklus
Ebben az esetben a ciklus akkor kerül végrehajtásra, amikor j értéke nagyobb, mint nulla. De van egy másik bejegyzés, ahol a While szót használják a szó helyett Amíg, és a ciklus addig fut, amíg egy bizonyos feltétel nem teljesül, azaz amíg j értéke nullánál kisebb lesz:
Dim j As Integer = 10 Csinál j-ig< 0 Console.WriteLine(j) j -= 1 Loop
Ha a ciklusban megadott feltétel kezdetben hamis, akkor a ciklus nem fog működni. De definiálhatunk egy ellenőrzést a ciklus végén, és így a ciklusunk legalább egyszer lefut:
Dim j As Integer = -1 Do Console.WriteLine(j) j -= 1 ciklus j-ig< 0 "либо Do Console.WriteLine(j) j -= 1 Loop While j > 0
Folytatás és kilépési nyilatkozatok
Gyakran nem kell megvárni a ciklus végét, hanem azonnal ki kell lépni a ciklusból, ha egy bizonyos feltétel teljesül. Ehhez használja az operátort kijárat, majd a kilépéshez használt hurok típusa, például Exit Do (Exit While) :
Dim r As New Random() Dim num As Integer = r.Next(100) For i As Integer = 0-tól 100-ig num -= 1 If num< 50 Then Exit For Next Console.WriteLine(num)
Van egy másik feladat - kilépni nem a ciklusból, hanem az aktuális lépésből vagy iterációból, és menni a következőre. Ehhez használja a Continue utasítást, amely után jelzi a ciklus típusát, amelyből a kilépés történik, például Continue While:
Dim r As New Random() Dim num As Integer = r.Next(100) For i As Integer = 0-tól 10-ig num -= 7 If num< 50 AndAlso num >25 Akkor Continue For End If Console.WriteLine(num) Next
Ebben az esetben a hurok minden egyes lépésében kivonjuk a 7-es számot a num-ból, majd megnézzük, hogy a num szám a 25-től 50-ig terjedő intervallumhoz tartozik-e. És ha igen, akkor a ciklus új iterációjára lépünk, és ha nem, akkor megjelenítjük a képernyőn.
Laboratóriumi munka a programozás alapjairól
2.1. Az analitikusan ábrázolt függvények táblázata
és a közelben összefolyva
Célkitűzés
· Elméleti ismeretek megszilárdítása az elágazó és ciklikus struktúrák szerveződésének alapjairól.
· Gyakorlati programozási ismeretek elsajátítása elágazó és ciklikus struktúrák segítségével a Visual Basic rendszerben.
Háromféle ciklusutasítás létezik a VB-ben:
számláló ciklus: A…To…Továbbra
Cikkek előfeltételekkel: Do While...Loop, Do Until...Loop, While...WEend
Hurok utófeltételekkel: Do...Loop While, Do...Loop Amíg.
Számláló ciklus – lehetővé teszi, hogy meghatározott számú alkalommal végigfusson egy utasításkészleten. A szintaxisa a következő:
Mert számláló = Rajt Nak nek vége
[operátorok]
[operátorok]
Következő[ számláló]
Paraméter számláló egy numerikus változó (egész, valós vagy dátum, változat, pénznem), amely minden iteráció után automatikusan növekszik. Kezdő érték számláló egyenlő a paraméterrel Rajt,és a végső paraméter az vége. Ha nincs megadva, akkor a lépés egyenlőnek számít 1-gyel, a lépésérték módosítható. Ez lehet pozitív vagy negatív szám.
A Do….Loop négy szintaktikai konstrukciója létezik:
A Do...Loop kulcsszavak közötti utasítások a feltételtől függően meghatározott számú alkalommal kerülnek végrehajtásra. Például a következő programrészletben, amikor C = 100, a feltétel teljesül, és a ciklus belép. A cikluson belül az eljárás meghívódik, és a C értéke 1-gyel csökken. Ezután a feltételt újra ellenőrizzük (C > 0), és ismételten végrehajtjuk a ciklusutasításokat (összesen 100-szor lesznek végrehajtva), egészen C = 0. Amikor a C > 0 feltétel hamis lesz, és a ciklus leáll.
Csináld, amíg C > 0
Ugyanez a programrészlet a 2. szintaxis előfeltételes ciklusával végrehajtva:
Ebben az esetben a ciklus akkor hajtódik végre, ha a feltétel hamis, ellentétben az előző esettel, azaz folytatódik előtt a C = 0 feltétel teljesülése.
A 3. és 4. szintaxis ciklusutasításai nagyon hasonlóak az első kettőhöz, kivéve a feltételt nem mindaddig kiértékelődik, amíg a ciklus legalább egyszer le nem fut.
Ezeknek a ciklusoknak a szintaxisában használhatjuk a ciklusból való feltétel nélküli kilépés Exit For és Exit Do operátorait, amelyek lehetővé teszik a vezérlés átadását a ciklus mögötti operátornak. Például a következő programrészletben, ha a C kezdeti értéke >50, akkor a ciklus azonnal leáll.
C-ig csináld<= 0
MsgBox "Start. érték nagyobb a megengedettnél”, „Beviteli hiba”
A While...Wend hurkot a Visual Basic korai verzióiban használták. A szintaxisa a következő:
Míg<условие>
<Операторы>
A Do..Looptól eltérően a While ..Wend ciklusnak nincs második opciója, amelyben a feltételteszt a ciklus végén kerül végrehajtásra. Ezenkívül nincs benne cikluskilépési utasítás, mint az Exit Do.
VBA. Ciklusok szervezése.
A hurokutasítások egy művelet vagy műveletcsoport végrehajtásának adott számú ismétlésére szolgálnak. Az ismétlések (hurokiterációk) száma előre meghatározható vagy kiszámítható.
A VBA kétféle hurkolt konstrukciót támogat:
- Rögzített ismétlésszámú hurkok ( ciklusok számlálóval).
- Hurok határozatlan számú ismétléssel ( feltételes hurkok).
Minden típusú ciklus esetében ezt a koncepciót használják huroktest A, amely a ciklus kezdő és záró utasításai közé zárt utasítások blokkját határozza meg. A ciklustörzsben szereplő utasítások minden ismétlődése hívásra kerül iteráció .
Fix ciklusok
A VBA két vezérlőstruktúrát biztosít a rögzített hurok szervezéséhez: For ... Next (egy hurok számlálóval) és For Every ... Next (egy hurok felsorolással).
Mert… Következő nyilatkozat ez egy tipikus ciklus számlálóval, amely adott számú iterációt hajt végre. A For … Next utasítás szintaxisa a következő:
Mert<счетчик> = <начЗначение>Hogy<конЗначение>
<блок операторов>
Következő[<счетчик>]
Példa a For … Next utasítás használatára.
Felsorolás 1. A … következő nyilatkozathoz
CÉL: Írjunk programot, amely két számot kap a felhasználótól.
‘ Összeadja az összes számot a két szám által megadott tartományban, majd
‘ Megjeleníti a kapott összeget.
Alminta7()
Dim i As Integer ‘hurokszámláló
Dim sStart ’számláló indítási értéke
Dim sEnd ' a számláló végértéke
Dim sSum As Long ‘eredményes összeg
sStart = InputBox("Írja be az első számot:")
sEnd = InputBox("Írja be a második számot:")
sSum = 0
i esetén = CInt(sStart) - CInt(sEnd)
sSum = sSum + i
Következő i
MsgBox "A " & sStart & " és a " & sEnd & " közötti számok összege: " & sSum
vége al
Minden egyes … Következő ciklus-kimutatáshozobjektum típusú operátorok kategóriájába tartozik, azaz. elsősorban a gyűjteményekre vonatkozik objektumok, valamint tömbök . A ciklus törzse meghatározott számú alkalommal kerül végrehajtásra, a tömb vagy gyűjtemény elemeinek számának megfelelően. A For Every… Következő utasítás formátuma a következő:
Az egyes<элемент>Ban ben<группа> <блок операторов>Következő[<элемент>]
Feltételes hurkok (határozatlan ciklusok)
Feltételes hurkok akkor használatosak, ha ismételt műveleteket csak bizonyos feltételek mellett kell végrehajtani. Az iterációk száma nincs meghatározva, és általában nulla lehet (különösen az előfeltételes hurkok esetében). A VBA számos vezérlőstruktúrát kínál a fejlesztőknek a feltételes hurkok szervezéséhez:
- Négy típusú Do..Loop hurok, amelyek különböznek az ellenőrzött feltétel típusától és az ellenőrzés végrehajtásának időpontjától.
- Megszakítás nélküli While… Wend hurok.
Do While... Loop – Tipikus hurok előfeltétellel. A feltételt a ciklus törzsének végrehajtása előtt ellenőrizzük. A ciklus addig folytatja munkáját<условие>végrehajtásra kerül (azaz igaz). Mivel az ellenőrzést az elején hajtják végre, előfordulhat, hogy a ciklus törzse soha nem kerül végrehajtásra. A Do While… ciklus formátuma:
Csinálni, miközben<условие>
<блок операторов>
hurok
Listing 2. Do While … Loop
CÉLKITŰZÉS: Írjunk olyan programot, amely elfogadja a felhasználói bevitelt
‘ tetszőleges számsorozat. A belépést meg kell szüntetni
‘ csak akkor, ha a beírt páratlan számok összege meghaladja a 100-at.
Alminta8()
Dim OddSum As Integer
Dim OddStr As String 'karakterlánc páratlan számokkal
Dim Num 'bemeneti számok elfogadásához
OddStr = "" 'a kimeneti karakterlánc inicializálása
OddSum = 0 ‘OddSum összeg inicializálása
Do While OddSum< 100 ‘начало цикла
Num = InputBox("Írja be a számot: ")
Ha (Num Mod 2)<>0 Aztán ’páros paritás
OddSum = OddSum + Num ‘páratlan számok összegének halmozódása
OddStr = OddStr & Num & ”
Vége Ha
hurok
‘adjon ki egy karakterláncot páratlan számokkal
MsgBox prompt:=”Páratlan számok: ” & OddStr
vége al
Do...Loop While utasításszervezésre szántákhurok utófeltétellel. A feltétel ellenőrzése a ciklustörzs legalább egyszeri végrehajtása után történik. A ciklus addig tart<условие>igaz marad. Do...Loop While formátum:
Tedd<блок операторов>hurok közben<условие>
Listázás 3. Hurok utófeltétellel
CÉL: Készítsen programot a „Guess the Number” játékhoz. A programnak véletlenszerűnek kell lennie
A felhasználónak egy 1 és 1000 közötti szám létrehozásához szükséges
– Találd ki ezt a számot. A program minden beírt számhoz utalást jelenít meg.
' "többé-kevésbé".
Alminta8()
Randomize Timer ‘ a véletlenszám-generátor inicializálása
Dim msg As String ‘ üzenetkarakterlánc
Dim SecretNumber As Long, UserNumber As Variant
Kezdés: SecretNumber = Round(Rnd * 1000) ‘ számítógép által generált szám
UserNumber = Üres ‘ a felhasználó által beírt szám
Csinálj játékot
Válassza az Igaz kis- és nagybetű lehetőséget
Case IsEmpty(UserNumber): msg = "Kérjük, adjon meg egy számot"
Case UserNumber > SecretNumber: msg = "Túl sok!"
Felhasználói szám eset< SecretNumber: msg = “Слишком мало!”
Vége kijelölés
UserNumber = InputBox(prompt:=msg, Title:="Találd ki a számot")
Loop While UserNumber<>titkos szám
' vizsgálat
Ha MsgBox("Akarsz újra játszani?", vbYesNo + vbQuestion, "Jól tippeltél!") = vbYes Akkor
Ugrás az elejére
Vége Ha
vége al
Csináld, amíg… Hurok és csináld… Loop Until Loop a korábban tekintett feltételes hurkok inverziói. Általában hasonlóan működnek, kivéve, hogy a huroktörzs hamis feltétel mellett fut (pl.<условие>=Hamis). A Do Until ... ciklus formátuma:
Tedd Amíg<условие> <блок операторов>hurok
A Do … Loop Until ciklus formátuma:
<блок операторов>
Loop Amíg<условие>
Gyakorlati feladat:Írja át a 10-es és 11-es listában szereplő programokat fordított ciklusú utasításokkal.
Míg Loop ... Wend feltételes ciklusokra is vonatkozik. Ez az állítás teljes mértékben megfelel a Do While … Loop struktúrának. A While … Wend hurok formátuma:
Míg<условие>
<блок операторов>
Irányít
Ennek az utasításnak a megkülönböztető jellemzője, hogy lehetetlen a huroktörzs kényszerű befejezése (megszakítása) (az Exit Do utasítás nem működik a While ... Wend ciklusban).
Hurok megszakítása
Az Exit utasítás az iteráció befejezésére és a ciklusból való kilépésre szolgál. Ez az állítás minden ciklikus szerkezetre alkalmazható, kivéve a While ... Wend. Az Exit ciklus megszakítására használatos általános szintaxisa a következő:
<начало_цикла>
[<блок операторов1>]
Kilépés (For | Csinál)
[<блок операторов2>]
<конец_цикла>
Az Exit utasítás végrehajtásakor a ciklus megszakad, és a vezérlés átkerül az utasítást követő utasításra<конец_цикла>. A ciklustörzs több kilépési utasítást is tartalmazhat.
Felsorolás 4. Kényszerített hurokkilépés
Alminta9()
Ha i = 1 - 10000000
Ha i = 10, akkor Exit For ' lépjen ki a ciklusból, amikor a számláló eléri a 10-et
Következő
Operátori szintaxis:
MertSzámláló= Rajt ToVége[lépésLépés]
Nyilatkozat_Block
KövetkezőSzámláló
Itt van jelölve:
Mert – számára (kötelező VB kulcsszó);
Nak nek – előtt (kötelező VB kulcsszó);
Nyilatkozat_Block egy vagy több operátor hívott ciklus test;
Számláló - egy egész változó, amely számolja a végrehajtandó ciklusok számát;
Kezdete, vége - a számláló kezdeti és végső értékei;
lépés – lépés (VB kulcsszó);
lépés - számlálóváltási lépés; negatív lehet; a paraméter nem kötelező, mert ha a lépés 1, akkor Step Lépés Alsó;
Next - next (kötelező VB kulcsszó, ciklusvégi utasítás rekord).
Számláló érték (Kezdet, Vége) lehet numerikus állandók vagy egész vagy valós típusú változók lehetnek negatív vagy pozitív számok. Ahhoz, hogy a hurok törzsét legalább egyszer végre lehessen hajtani, ennek meg kell lennie Kezdés ≤ vége, ha Lépés> 0, és Kezdés ≥ vége, ha Lépés< 0. Amint kiderül, hogy Számláló>vége ( ha Rajt< Конец), ciklusvégrehajtás véget ér. Ha egy Start =vége, a ciklus egyszer végrehajtásra kerül;
9.1. példa .FunkcióértékelésY = 2 – 1.5 sinxha az X-et 0,2-es lépésekben változtatja a tartományban.
Az Y kiszámítására és az X argumentum és az Y függvény kiadására szolgáló program töredéke:
X = 0 - 2,4 esetén 0,2 lépés
Y = 2-1,5*Sin(X)
A ciklus működésének megértéséhez itt van egy program egy hasonló ciklushoz, amelyet a segítségével hoztak létre operátormenj, címkék, operátorHa… Akkor.
M1:X=X+0,2
Ha X<= 2.4 Then
Y = 2-1,5*Sin(X)
Elemezzük, hogyan működik ez a program. Az első számítás Y nem szabványos, úgymond kiesik a hurokból. A ciklus a GoToM1 vezérlés első átadása után kezdődik az M1 címkére. Az M1 feliratú sorban az X argumentumot 0,2-es lépéssel növeljük, és azonnal ellenőrizzük, hogy az X új értéke nem haladja-e meg a 2,4-es végső értéket. Ha nem haladja meg, akkor az Y számítása megismétlődik ezzel az új X-szel. Ezután a GoToM1 operátor újra végrehajtásra kerül, átadva a vezérlést az M1 feliratú sorra. Az Y kiszámításának ezen ismétlődései (ciklusai) véget érnek, amint X meghaladja a 2,4-et.
Most az If program összehasonlítható a For…Next ciklussal.
X = 0 - 2,4 esetén 0,2 lépés
két sort helyettesít
M1:X=X+0,2
Ha X<= 2.4 Then
Ez az utolsó két kódsor, amely a For ciklusban fut le, de ezt nem látjuk. Ezeket a cFor karakterlánccal kódoltuk... A GoTo M1 kódsor a Next X (szó szerint: next X) szóval van kódolva. Ez kompakt kialakítást eredményez.
A For…Next ciklus használatakor meg kell tanulnia a hurokszámláló használatát különféle problémák megoldása során. Ahhoz, hogy kitalálja, hogyan használhatja a számlálót a probléma megoldására, meg kell tennie a problémafelvetés elemzésére, a probléma egyes paramétereinek változási mintáinak megtalálására.
Példa 9.2 . Egy sorozat elemeinek összegének meghatározása: .
Programrészlet:
S = 0 ‘S a sorozat összege
Ha i = 1-től 16-ig, akkor az i számláló a tört nevezője
S = S + 1/i ‘ felhalmozási összeg
"S="; S ‘az S összeg kimenete a formára
Az i számláló minden értékére az 1/i kifejezés 1-től kezdődően egymás után képezi a sorozat elemeit.
9.3. példa
.
Elemsorozat összegének kiszámítása 
.
Programrészlet:
S = 0 ‘S a sorozat összege
Ha i = 1-től 18’-ig számláló i - számláló
S = S + i/(i + 1) ‘ a nevező 1-gyel nagyobb, mint a számláló
"S="; S ‘az S összeg kimenete a formára
9.4. példa . Összeg számítás: 5 + 8 + 11 + ... + 32 + 35
Programrészlet:
S = 0 ‘S a sorozat összege
Ha i = 5-től 35-ig, 3. lépés ‘ aritmetika _
progresszió 3-as nevezővel
"S="; S
9.5. példa. Adott x összegének kiszámítása:
A probléma elemzése azt mutatja, hogy a fok X-nél 1-ről 10-re változik. Ebben az esetben az együttható számlálója X-nél 1-gyel nagyobb, mint a fokszám, a nevező pedig 2-vel. A fokozat értéke alakul ki. a számláló segítségével i. Ezután megírhatja a következő programot (töredéket):
S = 1 ‘S a sorozat összege
Ha i = 1-től 10’-ig i számláló, a fok X-nél változik
S = S + (-1)^i*(i + 1)*x^i / (i + 2)
"S="; S
CiklusokMert… Következőhasználtbemenet kimenet éstömb feldolgozás .
9.6. példa. A tömbelemek értékeinek bevitele és kiadása B(N).
Programrészlet:
‘ Hagyja el az N érték hozzárendelését a változóhoz, _
beírva az űrlapon a txtN szövegmezőbe:
B(i) = InputBox("Írja be a B(" & i & ") elemet", _
"B bemeneti tömb(" & N & ")))
nyomtatás " "; Kettős);
Funkció InputBox() párbeszédpanelt jelenít meg egy bezárás gombbal, egy adott üzenettel, egy beviteli mezővel, gombokkal rendben,Megszünteti, fejléc (vagy anélkül). Ha a 12-es számot adjuk meg - az N tömb mérete, akkor példánkban az első megjelenéskor ez az ablak így fog kinézni:
Amint látja, az üzenet Írja be a B(1) elemet kéri, hogy írja be az 1. elem értékét a szövegmezőbe. Ez az ablak 12 alkalommal jelenik meg, mivel a tömb 12 elemet tartalmaz. Ez az űrlap fejlécéből következik. A B(i) elem indexe a promptban 1 és 12 között változik.
Ha csak a B(N) tömb elemeinek értékét kell megjeleníteni az űrlapon, akkor a ciklustörzs egy utasításból áll:
Egy tömb elemeinek megtekintése a rajtuk végrehajtandó műveletek végrehajtása érdekében a For…Next ciklus operátor használatával is megtörténik.
hozzuk példák egydimenziós tömbök feldolgozására.
9.7. példa . A maximális elem meghatározása a tömbben B(M).
A kezdeti adatok bevitelét és az eredmények kimenetét kivéve, röviden ismertetjük az algoritmust:
Deklaráljuk a Bmax változót, melybe beírjuk a tömb első elemének értékét, és az Imax változót, amelyhez 1-et rendelünk - a tömb első elemének indexét.
A ciklusban a For…Next operátor segítségével végignézzük a tömb összes elemét, a 2.-tól kezdve. Az If…Then operátor segítségével összehasonlítjuk azok értékét a Bmax változóban tárolt értékkel.
Ha kiderül, hogy egy tömbelem értéke nagyobb, mint a Bmax, akkor Bmax-hoz rendeljük ennek az elemnek az értékét, az Imax értéke pedig ennek a tömbelemnek az indexe.
A ciklus vége után a Bmax változó a maximális elem értékét, az Imax pedig az indexét (számát) tartalmazza.
Az algoritmus ezen részének programja.
Bmax = B(1): Imax = 1
Ha B(i) > Bmax, akkor Bmax = B(i): Imax = i
9.8. példa. A pozitív tömbelemek összegének, szorzatának és számának meghatározásaD(M).
Változók: S, P, K a pozitív elemek összege, szorzata és száma.
Algoritmus ez a meghatározás:
Az S és K változóhoz nullát, a P változóhoz 1-et rendelünk. Általában azokat a változókat, amelyekben az összeg halmozódik, itt S és k, nullára állítjuk a ciklus előtt, és azokat a változókat, amelyekben a a kiszámított termék az 1.
A For…Next ciklus segítségével végigmegyünk a tömb összes elemén, és ellenőrizzük, hogy pozitívak-e (D(i) > 0).
Ha kiderül, hogy az elem pozitív, akkor az értékét hozzáadjuk az S összeg értékéhez, és az új összeget ugyanabban a változóban tároljuk. A P változót megszorozzuk az elem pozitív értékével és tároljuk a P változóban is. És hozzáadunk 1-et a K változóhoz, és az új értéket ugyanabban a változóban tároljuk
Program az algoritmusnak ez a része így néz ki:
S=0: P=1: K=0
Ha D(i) > 0 Akkor
S = S + D(i) ‘ így halmozódik fel az összeg _
tömbelemek pozitív értékei D(i)
P = P*D(i) ‘ pozitív szorzatának meghatározása
‘ tömbelemek
K = K + 1 ‘ ezt az operátort COUNTER-nek hívják, itt van
’ határozza meg a pozitív tömbelemek számát
Példa 9.9. A páratlan tömbelemek összegének, szorzatának, számának és átlagának meghatározásaD(M).
Egy ilyen meghatározás programjának egy töredékét mutatjuk be.
S=0: P=1: K=0
Ha D(i) Mod 2<>0 Akkor
Ssr = S/k ‘ páratlan elemek átlagának kiszámítása
Hasonlítsa össze ezt a programrészletet a 9.8. példa programjával. Ez a program szinte teljesen megismétli az előzőt. Csak az If utasításban szereplő feltétel módosult. D(i) feltétel, 2. mód<>A 0 azt jelenti, hogy a D(i) tömb 2-vel még nem osztható elemeit, azaz páratlan elemeit keressük. Ha bejelöljük a D(i) Mod 2 = 0 feltételt, akkor a tömb páros elemeit választjuk ki.
Mint tudod, megosztottság Mod az osztás maradékát egész számokban adja meg. Például a d= 34Mod4 operátor végrehajtása után a d változó 2 lesz. Ezért a 4 többszöröseinek megfelelő tömbelemek kiválasztásához ellenőrizni kell a D(i) Mod 4 = 0 feltételt. legyen hasonló, ha olyan elemeket keresünk, amelyek más számok többszörösei. 4 helyett ezeket a többi számot írjuk le.
9.10. példa. Tömbelemek írásaR(N) osztható 5-tel egy másik tömbbe, és megjeleníti az új tömböt az űrlapon.
A másik tömböt például R5(N) jelöljük. Ennek az új tömbnek a méretét az eredetivel azonosnak kell tekinteni, mivel határesetben minden elem 5 többszöröse lehet.
Feladat algoritmus:
A számlálót nullázzuk k. A For…Next ciklus operátor segítségével végignézzük az R(N) tömb összes elemét.
Az If…Then operátor segítségével ellenőrizzük az egyes elemek 5-ös többszörösét, és a tömbelemet elosztjuk a Mod-dal.
Ha az elem többszöröse 5-nek, akkor egy k=k+ 1 számláló segítségével 1-től kezdve képezzük az R5(N) tömb indexeit, és írjuk a másik –R5(N) tömbbe.
Ha k értéke nem nulla, adja ki az arrayR5()-et az űrlapba.
Ha k egyenlő nullával, akkor a következőt adjuk ki: "Nincsenek olyan elemek, amelyek 5 többszörösei".
Programrészlet:
Ha R(i) Mod 5 Akkor k = k + 1: R5(k) = R(i)
Ha k<>0 Akkor
Nyomtassa ki a „Nincs 5-tel osztható elem”
A hurkok beágyazhatók más hurkokba.
Mutatjuk a munkát beágyazott hurkok . Az alábbiakban a program megszervezi az i, j és k ciklusszámlálók értékeinek kimenetét. Az i,j,k kimenetéből világossá válik, hogyan hajtják végre a beágyazott ciklusokat.
Privát Sub frmCycle_DblClick()
ScaleMode = 4 egység – szimbólumok
Ha i = 1–3 ’külső hurok
"i =" nyomtatása; én;
j = 1-től 4-ig ’1. beágyazott hurok
AktuálisX = TextWidth("i = 1") + 5
"j="; j;
AktuálisX = TextWidth("i = 1 j = 1") + 7
Ha k = 1 – 5 ‘2. beágyazott hurok
A megjelenített űrlap (1. ábra) mindhárom hurok számlálóinak megjelenítésének eredményét mutatja: a külső hurok - i számláló, az első beágyazott ciklus - counterj és a második, legbelső ciklus - counterk. Amint látjuk, a külső hurok "leglassabb" számlálója(poi), és a „leggyorsabb” a legbelső hurok számlálója (eszerintk).
A program az frmCicli űrlapra való dupla kattintás után fut le a bal egérgombbal.
CurrentX, CurrentY - űrlaptulajdonságok, amelyek megadják a Print metódussal történő információkiadás kezdőpontjának X, Y koordinátáit (lásd az X és Y tengelyek helyét az űrlapon az 1. ábrán).
A TextWidth() egy olyan függvény, amely a függvényben megadott szöveg szélességét adja vissza idézőjelben argumentumként.
A beágyazott hurkok kétdimenziós tömbök (mátrixok) feldolgozásakor használatosak. Egyes feladatokban azonban, kivéve a kétdimenziós tömb elemeinek be- és kimenetét, egy ciklusra korlátozhatja magát. Vegyünk néhány példát a mátrix programozásra.
9.11. példa. Egész számokból álló mátrix (kétdimenziós tömb) be- és kimeneteintA(N).
Beírhat egy mátrixot sorok és oszlopok szerint . Egyszerűbb - soronként, ha a tömbelemek kimenete az űrlapra közvetlenül a bevitel után kerül programozásra.
Mátrix bemenet és kimenetVonalról vonalra - 1. töredék.
Dim M As Integer, N Mint Integer, i As Integer, j As Integer
Dim intA() Egész számként deklarál egy dinamikus tömböt
M = Val(txtN.Text) ‘ M a sorok száma
N = Val(txtN.Text) ‘ N az oszlopok száma
ReDim intA(M, N) As Integer ‘ újradefiniálja a tömböt
Ha i = 1 - M ' i értékét megőrzi egészen addig
A j beágyazott ciklus nem hajtódik végre
nyomtatás " "; intA(i, j); ‘ sorról sorra kimenet
Print ‘ ugrás egy új sor elejére
A mátrix oszlopok szerinti beviteléhez a külső hurkot j-re kell tenni (az oszlopszámokat beállítja), a belsőt pedig az i-re (beállítja a sorszámokat).
Mátrix bemenet és kimenetoszlopok szerint – 2. töredék.
PrY = 2500: CurrentY = PrY ‘ A PrY beállítja az indítás Y koordinátáját
‘ minden oszlop első elemét adja ki az űrlapon
Ha j = 1 - N ' j megőrzi értékét egészen a teljességig
'beágyazott hurok az i-en nem kerül végrehajtásra
intA (i, j) = InputBox("Írja be az elemet: intA(" & i & "," & j & ")", _
"Matrix input intA(" & M & "," & N & ")")
Nyomtatás Tab(6 * j); intA(i, j) ‘ megjelenítés oszloponként
CurrentY = PrY ' az első elem megjelenítéséhez
' következő oszlop
Ez a második programrészlet nem ismétli meg az első részlet első 5 sorát. A Tab(6 * j) függvény beállítja a kimenet kezdetét egy soron (karakterben), amely az űrlap bal szélétől indul. A PrY koordináta itt 2500 twips, de választhat más értéket is.
Példa 9.12 . A tömbelemek értékeinek rendezéseV(N) Növekvő.
Számos algoritmus létezik a tömbök rendezésére. Íme az egyik közülük: beágyazott hurkok használatávalMert… Következőválasszon elemeket az elsőtől az utolsó előttiig, és hasonlítsa össze mindegyiket a következő elemekkel; ha kiderül, hogy a következő elem kisebb, mint a kiválasztott, cserélje ki őket.
Az algoritmust megvalósító program töredéke:
Ha i = 1 - N - 1
Ha j = i + 1 - N
Ha V(j)< V(i) Then P = V(i): V(i) = V(j): V(j) = P
Magyarázzuk meg ezt a programrészletet.
Egy i számlálóval ellátott külső hurok segítségével kiválasztjuk a V (i) elemet a következő elemekkel való összehasonlításhoz. A j számlálóval ellátott belső hurok a V(j) következő elemeit választja ki összehasonlításra. A j kezdeti értéke i + 1. Ez az első eleme a következőknek.
A V(i) és V(j) elemek értékeinek cseréjéhez bevezetünk néhány P változót, amelybe ideiglenesen „elrejtjük” az egyik tömbelem értékét (a programban ez V(i) )). Ekkor a V(i) elemhez a V(j) elem értékét, a V(j) elemhez pedig a V(i) értéket, amelyet a P változóban tárolunk. Ha V(j) értékét „elrejtjük” P-ben, akkor az értékcsere kódja a következő lesz: P = V(j): V(j) = V(i): V(i) = P. az eredmény nem fog változni.
Nak nek rendezze a tömböt csökkenő sorrendbe, elég az igazolási feltételt V(j) > V(i) alakban felírni, azaz az egyenlőtlenség jelét másikra cserélni.
Ha a tömb nem numerikus, hanem karakterlánc, és a tömb elemei vezetéknevekkel vannak kitöltve, akkor a 9.12. példa programja segítségével ábécé sorrendbe rendezhetjük a vezetéknevek listáját. A tény az, hogy a számítógépben használt ábécé betűire igazak az egyenlőtlenségek: A< Б < В < Г….< Я и т. д., поскольку числовые коды букв алфавита последовательно увеличиваются, начиная с А и до конца алфавита. Это же справедливо и для букв английского алфавита.
9.13. példa . Pozitív elemek összegének kiszámítása egy mátrix páratlan oszlopairaF(M, N) és az összegek megjelenítése az űrlapon.
Program algoritmus:
Egy 2-es lépéses külső hurok segítségével képezzük a mátrix páratlan oszlopainak indexét, az első oszloptól kezdve.
Visszaállítjuk az S összeget, amelyben a pozitív elemek összege halmozódik fel.
A belső ciklusban ellenőrizzük a tömbelem előjelét.
Ha a tömbelem pozitív (> 0), számítsa ki az S összeget.
A belső ciklus vége után adja ki az S összeget az űrlapra.
Töredék programokat:
j = 1 - N esetén 2. lépés
Ha F(i, j) > 0, akkor S = S + F(i, j)
Nyomtassa ki az „Oszlop összegét”; j; ":"; S 'j az oszlop száma!
A beágyazott hurkok lehetővé teszik a rendszerezést opciók felsorolása és olyan problémákat old meg, amelyeket analitikusan nem lehet megoldani. A felsorolás eredményeként megoldások születnek, amelyek közül egyet vagy többet választanak ki, amelyek megfelelnek a probléma feltételének.
9.14. példa. 1801 rubel van. Hány csokit lehet venni 31 rubelért. és egy tekercs 18 rubelért, hogy teljes mértékben elköltse az összes pénzt.
Program:
Összeg = 1801
AllCsokoládé = Összeg \ 31: Minden zsemle = Összeg \ 18
Ha i = 1 Minden csokoládéhoz
j = 1 esetén az AllBulkihoz
Ár = i * 31 + j * 18 ‘teljes vételár
Ha Ár = 1801 Akkor
Nyomtatás "Csokoládé:"; én; Tab(19); "Bulok: "; j
Magyarázzuk el azt a programot, amelyben oroszul elnevezett változókat használunk.
Először is meghatározzuk, hogy a teljes összegért legfeljebb hány csokoládé vagy csak zsemle vásárolható meg. A VseChocolate és VseBulki kapott értékeit arra használjuk, hogy korlátozzuk a keresések számát a csokoládé és a tekercsek számával. A csokoládék darabszámának (i) és a tekercsszámnak (j) minden egyes értékéhez meghatározzuk a vásárlás teljes árát. Ha a számított ár 1801, akkor a kiválasztott opció a probléma egyik megoldása.
A Tab() függvény megadja, hogy az űrlap szélétől melyik helyen jelenjenek meg a függvényt követő információk. Ha Tab(19), akkor a 19. pozícióból.
A program 3 lehetséges vásárlási lehetőséget jelenít meg:
Csokoládé 7, zsemle 88
Csokoládé 25, zsemle 57
Csokoládé 43, zsemle 26
Ha egyértelmű választ szeretne adni, további feltételt kell megfogalmaznia. Például „kevesebb zsemlét vettek, mint csokoládét”. Akkor az egyetlen megoldás a 3. lehetőség lenne.
Sok olyan matematikai probléma van, amelyet egyszerűen a beágyazott hurok programozáson keresztül történő iterációval lehet megoldani.
