Érdekes programozási útmutató a tervező számára-Programfolyamat-vezérlés-Loop Statement: 8 lépés

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:44

Programfolyamat-vezérlés- Loop Statement

Ebből a fejezetből egy fontos és erőteljes tudáspont-kijelentéssel fog kapcsolatba lépni.

E fejezet elolvasása előtt, ha 10 000 kört szeretne rajzolni a programba, akkor csak egy szörnyű módszerrel teheti meg. Ez azt jelenti, hogy 10 000 sor ellipszis kódot kell írni. Azok a lusta kódtervezők, akik mindenképpen javítani akarják a hatékonyságot, biztosan nem engednék, hogy ez megtörténjen. Létrejön tehát a ciklus utasítás. Ezzel a kijelentéssel intuitív módon érezheti a számítógépes automatizálás erejét.

1. lépés: Loop esetén

Sok ciklus utasítás áll rendelkezésre, amelyek közül a leggyakrabban használt For Loop. Mindannyian tudjuk, hogy a függvényhúzás folyamatosan működik a forgalomban. Kezdje az első mondattal az elején, fentről lefelé hajtja végre az utolsó mondatig. Miután befejezte a műveletet, az első mondatból újra elindul. Az utasítás egy kicsit hasonlít a draw függvényhez. Az utasításban lévő kód többször is végrehajtható.

Íme a nyelvtani szerkezete:

A (kifejezés 1; kifejezés 2; kifejezés 3) {

Hurok test

}

Nyilvánvaló, hogy a cikketesten belüli mondatokat vártuk ismételt végrehajtásra. Az 1. kifejezés az első érték inicializálására és hozzárendelésére szolgál a ciklusváltozóhoz. A 2. kifejezés ciklusfeltételre vonatkozik. A 3. kifejezés frissíti a ciklusváltozó értékét.

Mi a hurok változó? Valójában egyenértékű egy helyi változóval. Nézzünk egy teljes írást.

for (int i = 0; i <10; i ++) {

Hurok test

}

A ciklusfunkció megvalósítása érdekében az utasítás főként egy helyi változóra támaszkodik, amelyet a ciklus befejezésekor használnak. A fenti példában szereplő helyi változó az i. Az 1. kifejezés befejezte a helyi változó inicializálását. Később minden alkalommal, amikor a ciklus egyszer működik, ezt a változót frissíteni kell. A fenti példa közül az i ++ kifejezést használjuk a 3. kifejezésben a frissítési funkció megvalósításához. Ezen keresztül a változó minden frissítéskor 1 -gyel nő. Végül a cikktörzsben lévő kód nem ciklusozhat a végtelenségig, ellenkező esetben az utóbbi utasítások nem hajthatók végre. Tehát szükségünk van egy terminális feltételre. Az Express 2 csak erre való. Itt a program meg fogja ítélni, hogy i kevesebb, mint 10. Ha igen, akkor folytassa a műveletet. Ha nem, ugorjon ki a körből.

Ezért a utasítás műveletsorozata éppen ilyen.

1. kifejezés (helyi változó inicializálása)

2. kifejezés (elégedett, majd továbbra is működik)

Hurok test (első kör)

3. kifejezés (frissítés)

2. kifejezés (elégedett, majd továbbra is működik)

Hurok test (második körforgás)

3. kifejezés (frissítés)

2. kifejezés (elégedett, majd továbbra is működik)

Hurok test (harmadik kör)

3. kifejezés (frissítés)

2. kifejezés (nem elégedett, majd ugorjon ki a körből)

Ezt a végrehajtási sorozatot többször is szimulálhatja a fejében. De lehetetlen megérteni a kódot anélkül, hogy egyszer kézzel beírná. Ha egy furcsa fogalmat szeretnénk megtudni, akkor a println utasítással kinyomtathatjuk az értéket a konzolon.

Kódpélda (5-1): void setup () {

for (int i = 0; i <10; i ++) {

println ("futtatás");

}

}

Megszámolhatja a konzolon a futás kimenetét. Itt pontosan 10. Ez azt jelzi, hogy hányszor hajtották végre a ciklus törzsében található kódot. Azonban még mindig nem tudjuk észlelni, hogy milyen változások történtek valójában a ciklusban. Tehát megpróbálhatjuk megváltoztatni a karaktert, és be kell futni az "i" változóba, és meglátjuk, mi fog történni.

Kódpélda (5-2): void setup () {

for (int i = 0; i <10; i ++) {

println (i);

}

}

Most láthatjuk, hogy a hurok törzsében az i érték folyamatosan növekszik. Később ezt az értéket használhatjuk a ciklus aktuális folyamatának megértéséhez.

Az (5-2) kódpéldában az i értéke 0-ról 9-re változik. A tényleges ciklusidőkhöz képest úgy tűnik, hogy mindig 1-gyel kevesebb. Ha nem szokta meg, a for utasítás zárójelben lévő kifejezés a következőre írható:

for (int i = 1; i <＝ 10; i ++)

Így i pontosan megfelel a ciklusidőknek. A "<＝" jelentése kisebb és egyenlő. Tehát amikor i egyenlő 10 -el, akkor is teljesíti a feltételt. Ezért még egyszer fog működni ahhoz képest, hogy i <10 -be íródott. Bár 1 -től kezdődik, a ciklusidők továbbra is 10. Természetesen, ha semmi különösre nincs szükség, javaslom, hogy alkalmazza az írási módszert a példa az elején. Később bemutatjuk Önnek a vektort vagy tömböt, mindkettő az elemét az index alapján nyeri el. Az alapértelmezett előfizetések pedig 0 -tól kezdődnek. A kezdeti érték 0 -ra történő meghatározása az összehasonlító gyakorlat.

A fenti példában, ha azt írjuk, hogy i túl van a 0 -n, a pogram összeomlik. Mivel a változó folyamatosan növekszik, soha nem felel meg ennek a feltételnek. Ez olyan, mintha soha nem lehetne leállítani úgy, hogy a program végtelen ciklusba fog futni.

A for utasítás helyi változói nemcsak a műanyag típusokat, hanem a lebegőpontos típusok változóit is deklarálhatják. Például felírható (úszó i = 0; i <10; i + = 0,02).

2. lépés: Használja a hurkot matematikai problémák megoldásához

Emlékszel még Gauss matematikus gyerekkori történetére? Ekkor Guass 10 éves volt. Tanára feladatot akart adni az osztályban, és a kérdés az volt

1＋2＋3＋4……＋97＋98＋99+100＝？

Ha a kezével számol, sok időt vesz igénybe. De úgy tűnik, Guass már rájött a számtani sorozat összegzésének módszerére. Így csak a kérdés elhangzása után könnyedén kimondta a választ, ami nagyon meglepte tanárát.

Most talán még nem emlékszünk arra, hogy mi az aritmetikai sorozat összegzése, de primitív és erőszakos módon megkaphatjuk a választ. És ez a hurokra vonatkozik. Mivel a számítógépek csak egy kis tortát számítanak, a kérdést olyan nyelven kell leírnunk, amelyet a számítógép felismer, és akkor könnyen megkaphatjuk a választ.

Kód példa (5-3):

void setup () {

int válasz = 0;

for (int i = 1; i <= 100; i ++) {

válasz += i;

}

println (válasz);

}

Úgy gondolom, hogy az eredmény ugyanaz, mint Guass jelentése: 5050!

Tippek: A ciklus helyi változóinak neve tetszés szerint megváltoztatható, feltéve, hogy megfelel a változók elnevezési szabályainak. Írhatod (int k = 1; k <= 100; k ++). Ha nem történt speciális feltétel, akkor alapértelmezés szerint az i a változó neve.

3. lépés: Hurok rajzoláshoz

Egy sor unalmasnak tűnő ágynemű után végre egy érdekesebb részhez juthatunk. Ez a képek rajzolásához használt hurok. Most félre tudjuk tenni ezeket az unalmas matematikai számításokat. Mi, tervezők érzékenyebbek vagyunk a grafikára.

Használja a hurok körkörös rajzolásához

Ha azt szeretnénk használni, hogy a ciklus az ismétlődő elemek egy csoportját ábrázolja, akkor előzetesen meg kell győződnünk ezen elemek számviszonyáról, majd használhatjuk a hurkot, hogy kényelmesen megvalósítsuk, ahelyett, hogy masszív ismétlést végeznénk. Tegyük fel, ha egy körsort szeretnénk rajzolni vízszintes irányban egyenlően. Virtuális koordinátája változatlan, míg vízszintes koordinátája megváltozik. Balról jobbra pedig a vízszintes koordináta folyamatosan növekszik, és a növekvő távolság ugyanaz. Jelenleg az i in for ciklus segítségével használhatjuk az egyes körök vízszintes koordinátáit.

Kódpélda (5-4): void setup () {

méret (700, 700);

háttér (83, 51, 194);

noStroke ();

}

void draw () {

for (int i = 0; i <7; i ++) {

ellipszis (50,0 + i * 100,0, magasság/2,0, 80,0, 80,0);

}

}

Az 50 a bal első kör kezdőpozícióját jelenti. 100 az i * 100 -ban a növekvő távolságot jelöli.

4. lépés: Használja a hurkot egy véletlenszerű kerek pont rajzolásához

A fenti grafikus pozíció előre látható. Ez minimalizálja a sok érdeklődést. Használhatjuk az előző fejezetben hivatkozott véletlenszerű függvényt, és megpróbálhatjuk rajzfunkcióba írni.

Kódpélda (5-5):

void setup () {

méret (700, 700);

háttér (0);

noStroke ();

}

void draw () {

háttér (0);

for (int i = 0; i <10; i ++) {

float randomWidth = random (60,0);

ellipszis (random (szélesség), random (magasság), randomWidth, randomWidth);

}

}

Itt az oka annak, hogy a kör pozíciója folyamatosan villog, mert minden véletlenszerű funkció egyszer működik, az eredmény véletlen. Mivel a függvény rajzolása alapértelmezés szerint 60 képkocka / másodperc fut, így minden másodpercben húzott 10 kör 60 -szor megváltoztatja pozícióját. Ezzel a gyors villanással a kép több, mint 10 körből áll. Egy egyszerű érték megváltoztatása a programban teljesen más hatást eredményez. A terminál állapotának felülvizsgálatával megváltoztathatjuk a ciklusidőket. Az alábbi képen a terminál állapota i <100

1. Íme a hatás, ha a terminál állapota i <1000:
2. RandomSeed
3. Ha nem akarom, hogy a kör helyzete és a villanása véletlenszerűen generálódjon, mit tehetek? Az egyik módszer az, hogy minden körhöz független változókat hoz létre és tárol, majd inicializálja ezeket a változókat a beállításban. Rendeljen ezekhez a változókhoz egy véletlen értéket. Így a rajzolás rajzolási funkciójának használatakor a változókban tárolt értékre hivatkoztunk. Nem fog változni. Ezt a módszert csak 10 kör rajzolásához használhatjuk. De mi van akkor, ha 1000 kört vagy 10 000 kört szeretnénk rajzolni? Elég nehézkes lesz, ha ezt a hagyományos módszert használjuk ezen változók felépítéséhez és elnevezéséhez. Nem kell új változóépítési módszert tanulnunk. Íme egy rugalmas módszer, amely segíthet elérni ezt a célt. Vagyis a randomSeed használatát. Most nézzük meg a hatását használat után. Kódpélda (5-6): [cceN_cpp theme = "dawn"] void setup () {size (700, 700); háttér (0); noStroke ();}

4. void draw () {

   háttér (0);

   randomSeed (1);

   for (int i = 0; i <10; i ++) {

   float randomWidth = random (20,0, 60,0);

   ellipszis (random (szélesség), random (magasság), randomWidth, randomWidth);

   }

   } [/cceN_cpp]

   A korábbi kóddal összehasonlítva nincsenek módosítások, kivéve, ha a kör sugarának tartománya 10 -ről 30 -ra változik, csak az OfSeedRandom mondatával. E mondat hozzáadása után a grafika statikussá válik.

   Meghívási formátum:

   randomSeed (a);

   Ebben a formátumban az a beállítása mag. Egész számot kell kitöltenie (lebegőpontos értéket írjon a P5 -be, nem lesz baj, hanem egészként kell kezelnie). A randomSeed funkciója az, hogy a magot véletlenszerű értékre állítsa be. Ekkor különböző véletlen tömböket generál különböző magok szerint. Ezután véletlenszerű függvényt hívunk meg, így a visszatérés eredménye határozott. Itt a határozott nem az eredmény határozott értéke, hanem a generált tömb. Vagyis a visszatérés eredménye határozott a hivatkozási időkhöz képest.

   Kódpélda (5-7): [cceN_cpp theme = "dawn"] void setup () {

   randomSeed (0);

   for (int i = 0; i <5; i ++) {

   println (véletlenszerű (10));

   }

   } [/cceN_cpp]

   Most folytatjuk a println használatával egy kísérletet. A randomSeed használata után minden alkalommal, amikor bezárja a programot, és újraindítja a programot, visszatér ugyanahhoz az eredményhez. Az érték egyenként megfelel a sorozatnak. Ha törli, akkor minden alkalommal más értékre tér vissza. Miért van ez a beállítás? Ez azért van, mert maga a véletlen érték a programban pszeudo -véletlen. Az eredmény véletlenszerűnek tűnik, de valójában egy fix és megismételhető számítási módszerrel generálódik. Ez megegyezik a randomSeed primitív értékének kijelölésével, akkor a következő eredményt ennek a magnak megfelelően kell kiszámítani. Ha azonban nem jelöljük ki a magot, a program alapértelmezés szerint a rendszer jelenlegi idejét használja a vetőmag előállításához. Ezért minden művelet eredménye más. Az alábbi példa segíthet a randomSeed jobb megértésében.

   Példakód (5-8): [cceN_cpp theme = "dawn"] void setup () {

   méret (700, 700);

   háttér (0);

   noStroke ();

   }

   void draw () {

   randomSeed (1);

   for (int i = 0; i <10; i ++) {

   float randomWidth01 = random (10, 60);

   ellipszis (random (szélesség), random (magasság), randomWidth01, randomWidth01);

   println (randomWidth01);

   }

   randomSeed (1);

   for (int i = 0; i <10; i ++) {

   float randomWidth02 = random (10, 60);

   ellipszis (random (szélesség), random (magasság), randomWidth02, randomWidth02);

   println (randomWidth02);

   }

   } [/cceN_cpp]

   Próbálja átdolgozni a második randomSeed (1) értéket randomSeed (0) értékre, és hasonlítsa össze a végeredményt.

   Tippek: A P5 -ben csak a sorsolás végén kell meghívnunk a noLoop függvényt, hogy ugyanazt a hatást érhessük el. Feladata a program leállítása. Teljesen eltér a fenti működési elvektől.

5. lépés: Használja a hurkot a vonal megrajzolásához

Miután elsajátítottuk a randomSeed használatát, megpróbálhatjuk megváltoztatni a rajzolási funkciót. Például változtassa meg a körrajzot vonalrajzzá. Csak ha a sor végére tervezünk néhány változó szabályozást, akkor sok, egymással összefonódó sort használhatunk egyedi minta létrehozásához.

Kód példa (5-9):

[cceN_cpp theme = "dawn"] érvénytelen beállítás () {

méret (700, 700);

háttér (0);

}

void draw () {

randomSeed (0);

for (int i = 0; i <2000; i ++) {

úszó x1 = szélesség/2,0;

úszó x2 = véletlenszerű (50,0, 650,0);

ütés (255, 20);

vonal (x1, 50, x2, 650);

}

} [/cceN_cpp]

Készítsen egyszerű ecsetet

Vissza a ciklushoz. A fenti példák nem interaktívak. Ha érdekesebbé akarjuk tenni az eredményt, nem felejthetjük el, hogy az mouseX -t és az mouseY -t kombináljuk a kódunkkal.

Kód példa (5-10):

[cceN_cpp theme = "dawn"] érvénytelen beállítás () {

méret (700, 700);

háttér (255);

noStroke ();

}

void draw () {

for (int i = 0; i <1000; i ++) {

kitöltés (0, 30);

float x = egérX + véletlen (-50, 50);

float y = egérY + véletlenszerű (-50, 50);

ellipszis (x, y, 2, 2);

}

} [/cceN_cpp]

Létrejön egy "szórási pontok" ecset. Mivel minden intenzív mini kerek pont az egér helyzetén alapul, korlátozott irányokat mozgathat a bal, jobb, fel és le négy irányából. Tehát az ecset végső alakterjedése hasonló a négyzethez.

Kód példa (5-11):

[cceN_cpp theme = "dawn"] érvénytelen beállítás () {

méret (700, 700);

háttér (255);

noStroke ();

}

void draw () {

for (int i = 0; i <1000; i ++) {

float ratio = mouseX/(float) szélesség;

float x = egérX + véletlen (-50, 50);

float y = egérY + véletlenszerű (-50, 50);

kitöltés (0, arány * 255, 255 * (1 - arány), 30);

ellipszis (x, y, 2, 2);

}

}

[/cceN_cpp]

Ha az mouseX értékét használjuk a töltési szín befolyásolására, akkor sokkal varázslatosabb színátmenetet kapunk.

6. lépés: Hurokba ágyazva

A hurok beágyazható. A for ciklusba újra írhat egy for cikket. Ha kétdimenziós pontmátrixot kell rajzolni, akkor ezt a módszert választhatja.

Kód példa (5-12):

[cceN_cpp theme = "dawn"] érvénytelen beállítás () {

méret (700, 700, P2D);

háttér (202, 240, 107);

}

void draw () {

kitöltés (0);

for (int i = 0; i <5; i ++) {

mert (int j = 0; j <5; j ++) {

úszó x = 150 + i * 100;

úszó y = 150 + j * 100;

ellipszis (x, y, 60, 60);

println (i + ":" + j);

}

}

}

[/cceN_cpp]

A beágyazott hurok első használatához ki kell találni a logikai összefüggéseit. A programban a kód megvalósítása mindig fentről lefelé halad. Ezért az első megvalósított mindenképpen a legkülső ciklus. Minden alkalommal, amikor a külső hurok egyszer működik, a belső hurok folyamatosan működik, amíg már nem tudja kielégíteni a feltételt. Ezt követően elindítja a második külső hurok műveletet. A második művelet megkezdése után a belső hurok addig megy a munkagépen, amíg nem tudja kielégíteni a feltételt. Ez az ismétlés addig történik, amíg minden feltétel nem teljesül, és ki nem ugrik a ciklusból.

A fenti kódban a külső hurok hurkteste összesen 5 -ször működött, míg a belső hurokban lévő hurkotest 25 -ször. 25 -ször, az i, j érték különbsége szerint, külön biztosíthatjuk a kör vízszintes és függőleges koordinátáját. Beágyaztam egy nyomtatott részt, megfigyelheti az adatkimenetet, és elgondolkodhat annak változásán. Csak két egymásba ágyazott hurokkal tapasztalhatjuk az i, j adatok összes kombinációját.

Tippek

A hurok a második rétegben általában lecsapódik a Tab az elején. Ez egyértelműbbé teheti a kódszerkezetet. A ciklus két rétegében meg kell neveznie a helyi változókat különböző nevekkel. Közülük az "i", "j", "k" a leggyakrabban használt.

Rugalmas használat "i", "j"

Az "i", "j" két változó neve a ciklus két rétegének helyi változóit jelenti. Az alábbi példa elmélyíti az "i" "j" fogalmának megértését. Az "i", "j" eltérő értéke szerint paramétereket írhatunk be az elemek csoportosítására.

Kódpélda (5-13): [cceN_cpp theme = "dawn"] void setup () {

méret (700, 700);

háttér (0);

noStroke ();

}

void draw () {

háttér (0);

kitöltés (250, 233, 77);

for (int i = 0; i <7; i ++) {

mert (int j = 0; j <7; j ++) {

pushMatrix ();

fordítás (50 + i * 100, 50 + j * 100);

// 1. beállítás

// lebegési szög = sin (millis ()/1000,0) * PI/2;

// 2. beállítás

// lebegési arány = i/7,0;

// lebegési szög = sin (millis ()/1000,0 + arány * (PI/2)) * PI/2;

// 3. beállítás

lebegési arány = (i * 7 + j)/49,0;

lebegési szög = sin (millis ()/1000,0 + arány * (PI/2)) * PI/2;

forgatás (szög);

rectMode (CENTER);

// Rajzolja le az 1. képet

egyenes (0, 0, 80, 80);

// Rajzolja le a 2. képet

// rect (0, 0, 100, 20);

// Rajzolja le a 3. képet

// rect (0, 0, arány * 50);

popMatrix ();

}

}

} [/cceN_cpp]

Kódmagyarázat

A rectMode (CENTER) megváltoztathatja a négyzet rajzolási módszerét. A rect orinális két korábbi paraméterét használjuk a sqaure bal felső sarkának koordinátájának meghatározására. Miután elindítottuk ezt a parancsot, ezt a két paramétert használjuk a négyzet középpontjának koordinátájának beállításához. Mivel itt az elforgatást a forgatáson keresztül működtetjük, ezért ezt a módszert kell használnunk, hogy a középpontot a koordináta eredeti pontjához rajzoljuk.

A millis () megszerzi a program kezdetétől a jelenig eltelt időt. Az egység ms. Ez az érték befolyásolja a sin kimeneti érték változó sebességét. Ha közvetlenül millisokat írunk, a változó skála túl nagy. Így el kell osztanunk 1000.0 -val.

A kód ezen szakaszában a "//" megjegyzés szimbólumot használjuk számos beállítás elrejtésére. Az effektusokat indítással vagy bezárással változtathatja. Például, ha mondatokat kezdünk a "3. beállítás" mögött, akkor a megjegyzés szimbólummal kell lezárnunk az "1. beállítás" és a "2. beállítás" kódblokkokat. Ami a hasonló programszerkezet példáit illeti, különböző helyi változókkal, ebben a formátumban írhatunk. Így nem kell több mérnöki dokumentumot külön tárolni. Ezt a készséget gyakran használhatjuk a gyakorlat és a létrehozás során, és megőrizhetünk néhány kielégítő paraméterbeállítást.

Közülük az i, j értéknek a programra gyakorolt hatását főként az "1. beállítás (2. beállítás) (3. beállítás)" eltolása jelzi. Az alábbiakban összehasonlíthatja a kimeneti eredményeket.

1. ábra rajzolása: 1. beállítás

1. ábra rajzolása: 2. beállítás

1. ábra rajzolása: 3. beállítás

2. ábra rajzolása: 1. beállítás

2. ábra rajzolása: 2. beállítás

2. ábra rajzolása: 3. beállítás

Az 1. beállításban nem használtuk az i és a j elemet az egyes elemek elforgatási szögének befolyásolására. Így láthatjuk, hogy minden elem mozgása azonos. Míg a 2. beállításban az i értéket használtuk, és az i és a j értéket a 3. beállításban. Végül befolyásolták a sin függvény paraméterbevitelét az arányon keresztül. Ez megváltoztatta a szög időszakos változását. Mivel a 2. és a 3. beállítás tényleges hatása nem annyira nyilvánvaló az animált grafikában, ezt a következő képernyőképen figyelhetjük meg.

2. kép rajzolása (balra: 2. beállítás; jobbra: 3. beállítás)

Rajzolja le a 3. képet (balra: 2. beállítás; jobbra: 3. beállítás)

Az első képen az arányt használják a négyzetes elforgatási szög befolyásolására. A második képen a kör sugarát közvetlenül lehet szabályozni. Láthatjuk, hogy i value mondatot használt:

lebegési arány = i/7,0;

Függőleges elemváltozása következetes. Mivel a kép vezérléséhez szükséges vízszintes koordináták csak az i értékétől függenek, így az azonos vízszintes koordinátákkal rendelkező minták azonosak lesznek. És az arány, a forgatási szög és a kör sugara is ugyanaz.

Ugyanakkor i, j mondatot használunk:

lebegési arány = (i * 7 + j)/49,0;

"Gradienst" írhat le. Itt a tényező szorzásának módszerével egyesítette a sorok és oszlopok hatását. Tehát minden elem más.

7. lépés: Loop közben

Van egy testvére a huroknak. Ez a ciklus. Mit tehet a hurok, míg a hurok is. De a while ciklus gyakorisága a kreatív kódolásban nem olyan magas, mint a ciklus esetében.

Kódpélda (5-14): [cceN_cpp theme = "dawn"] void setup () {

int a = 0;

míg (a <10) {

println (a);

a ++;

}

} [/cceN_cpp]

A while nyelvtani szerkezetét könnyebb megérteni, mint érteni. Az utasítás előtt változókat hozhatunk létre. Ezután töltsön ki egy kifejezést szögletes zárójelben. Ha teljesül, akkor működtesse a mondatokat a hurktesten belül. Végül egy kifejezést teszünk a ciklus törzsébe a változók frissítéséhez, majd amíg a ciklus befejeződik. Ami a biztos ciklusidőt illeti, gyakran használjuk a ciklushoz. Ami a végtelen változó értékét illeti, azt javasoljuk, hogy ciklus közben használja.

Gondol:

Próbáljon meg mindenféle alapvető elemet használni a rajzelemek helyett a hurokban, hogy különböző ecseteket hozzon létre.

Kombinálja az utolsó fejezetben hivatkozott trigonometrikus függvénnyel, próbálja átdolgozni a "szórási pontok" kefét kerek formájú ecsetre.

Próbáljon kétdimenziós pontmátrixot készíteni, csak for ciklus esetén.

Következő fejezet Előnézet A program egy pandora doboz. Minden, amit csak el tud képzelni, meg tudja tenni érted. Tehát nincs okunk arra, hogy ne tanuljuk meg ezt a nyelvet, amely képes kommunikálni a számítógéppel. Következő fejezetünkben bemutatunk egy másik folyamatvezérlő nyilatkozatot. Szabályozhatja a folyamatok folyamatát, és bonyolultabb és változékonyabb eredményeket hozhat. Az if állítással könnyedén hozhat létre saját szöveges kalandjátékokat! Ez a cikk Wenzy tervezőtől származik. Relatív olvasmányok: Érdekes programozási útmutató tervezőnek-Kezdeti érintés feldolgozása Érdekes programozási útmutató tervezőnek-Hozza létre első feldolgozó programját - Készítse el a képfuttatást (első rész) Érdekes programozási útmutató tervezőnek - Futtassa a képet (második rész)

8. lépés: Forrás

Ez a cikk innen származik:

Ha bármilyen kérdése van, vegye fel a kapcsolatot a ： [email protected] címen.