Interessante programmeergeleiding vir ontwerper-programprosesbeheer- lusverklaring: 8 stappe

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:28

Programprosesbeheer- lusverklaring

Uit hierdie hoofstuk kom u in aanraking met 'n belangrike en kragtige kennispunt-lusverklaring.

As u 10 000 sirkels in die program wil teken voordat u hierdie hoofstuk lees, kan u dit net met 'n vreeslike metode doen. Dit is om 10 000 reëls ellipskode te skryf. Die lui kode -ontwerpers wat die doeltreffendheid met alle middele wil verbeter, sal beslis nie toelaat dat dit gebeur nie. Die lusverklaring word dus geskep. Met hierdie stelling kan u intuïtief die krag van rekenaarautomatisering voel.

Stap 1: Vir lus

Daar is baie lusstellings, waaronder For Loop die mees gebruikte is. Ons weet almal dat funksie -teken voortdurend in omloop is. Begin van die eerste sin aan die begin, dit word van bo na onder geïmplementeer tot die laaste sin. Nadat die operasie voltooi is, begin dit weer vanaf die eerste sin. Want verklaring is 'n bietjie soortgelyk aan funksie teken. Kode binne vir verklaring kan herhaaldelik uitgevoer word.

Hier is die grammatika -struktuur daarvan:

Vir (uitdrukking 1; uitdrukking 2; uitdrukking 3) {

Lus liggaam

}

Uiteraard het ons verwag dat die sinne binne die lusliggaam herhaaldelik geïmplementeer sal word. Uitdrukking 1 word gebruik om die eerste waarde aan die lusveranderlike te initialiseer en toe te ken. Uitdrukking 2 is vir lustoestand. Uitdrukking 3 sal die veranderlike waarde van die lus opdateer.

Wat is lus veranderlike? Dit is eintlik gelykstaande aan 'n plaaslike veranderlike. Kom ons kyk na die volledige skryfwerk.

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

Lus lyf

}

Om die lusfunksie te verwesenlik, berus die verklaring hoofsaaklik op 'n plaaslike veranderlike, wat gebruik sal word by die lusbeëindiging. Die plaaslike veranderlike in die voorbeeld hierbo is i. Uitdrukking 1 het die inisialisering van die plaaslike veranderlike voltooi. Elke keer dat die lus vir een keer werk, moet hierdie veranderlike bygewerk word. Onder die voorbeeld hierbo word i ++ in uitdrukking 3 gebruik om die opdateringsfunksie te realiseer. Daardeur verhoog die veranderlike 1 elke keer as dit opgedateer word. Uiteindelik kan die kode in die lusliggaam nie onbepaald loop nie, anders kan laasgenoemde stellings nie uitgevoer word nie. Ons benodig dus 'n terminale toestand. Express 2 is net daarvoor. Hier sal die program oordeel of i minder is as 10. As dit die geval is, gaan dan voort. As dit nie die geval is nie, spring dan uit die lus.

Daarom is die bewerkingsvolgorde van vir verklaring net so.

Uitdrukking 1 (inisialisering van plaaslike veranderlike)

Uitdrukking 2 (tevrede, hou dan aan om te werk)

Lusliggaam (eerste sirkulasie)

Uitdrukking 3 (opdatering)

Uitdrukking 2 (tevrede, hou dan aan om te werk)

Lusliggaam (tweede sirkulasie)

Uitdrukking 3 (opdatering)

Uitdrukking 2 (tevrede, hou dan aan om te werk)

Lusliggaam (derde sirkulasie) …

Uitdrukking 3 (opdatering)

Uitdrukking 2 (nie tevrede nie, spring dan uit die kringloop)

U kan hierdie volgorde van uitvoering verskeie kere in u kop simuleer. Maar dit is onmoontlik om die kode regtig te verstaan sonder om dit een keer met u hand te tik. As ons 'n vreemde konsep wil uitvind, kan ons die waarde in die konsole druk deur die println -verklaring.

Kodevoorbeeld (5-1): leemte-opstelling () {

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

println ("hardloop");

}

}

U kan die aantal uitvoer in die konsole tel. Hier is dit presies 10. Dit vertel jou hoeveel keer die kode in die lusliggaam uitgevoer is. Ons kan egter nog steeds nie agterkom watter veranderinge in die lus werklik plaasgevind het nie. Ons kan dus probeer om die karakter te verander "loop in veranderlike" i "en kyk wat sal gebeur.

Kodevoorbeeld (5-2): leemte-opstelling () {

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

println (i);

}

}

Nou kan ons sien dat die waarde i in die lusliggaam voortdurend toeneem. Later kan ons hierdie waarde gebruik om die huidige proses van die lus te verstaan.

In kodevoorbeeld (5-2) word die waarde van i verander van 0 na 9. In vergelyking met die werklike lustye blyk dit altyd 1 minder te wees. As u nie daaraan gewoond is nie, kan die uitdrukking binne hakie van vir verklaring soos volg geskryf word:

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

Dus stem ek regverdig ooreen met lustye. Die betekenis van "<＝" is minder as en gelyk aan. Dus, as ek gelyk is aan 10, sal dit steeds aan die voorwaarde voldoen. Daarom werk dit nog 'n keer in vergelyking met omskryf in i <10. Alhoewel dit vanaf 1 begin, is die lustye nog steeds 10. As daar niks spesiaals nodig is nie, stel ek voor dat u die skryfmetode in die voorbeeld aan die begin. Later stel ons u 'n vektor of skikking bekend, wat albei die element verkry deur sy subskripsie. En die standaardtekste begin almal by 0. Om die aanvanklike waarde op 0 te definieer, is die relatief algemene praktyk.

In die voorbeeld hierbo, as ons skryf i is verder as 0, sal die pogram neerstort. Omdat die veranderlike konstant toeneem, sal dit nooit aan hierdie voorwaarde voldoen nie. Dit is net asof dit nooit kan stop nie, sodat die program eindelose lus sal loop.

Plaaslike veranderlikes in die for statement kan nie net plastiektipes verklaar nie, maar ook veranderlikes in floating-point tipes verklaar. Dit kan byvoorbeeld geskryf word as (float i = 0; i <10; i + = 0.02).

Stap 2: Gebruik vir loop om wiskundige probleme op te los

Onthou jy nog 'n verhaal van wiskundige Gauss in sy kinderjare? Destyds was Guass 10 jaar oud. Sy onderwyser wou 'n taak in die klas toewys en die vraag was:

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

As u dit met u hande bereken, neem dit baie tyd. Maar dit lyk asof Guass reeds die metode van opsomming van die rekenkundige volgorde uitgevind het. Dus net nadat die vraag gegee is, het hy die antwoord met gemak uitgespreek, wat sy onderwyser baie verbaas was.

Ons onthou miskien nog nie wat die opsomming van die rekenkundige volgorde is nie, maar ons kan die antwoord op 'n primitiewe en gewelddadige manier kry. En dit is vir lus. Aangesien dit net 'n klein stukkie vir rekenaars is om te tel, moet ons die vraag beskryf in 'n taal wat deur 'n rekenaar herken kan word, en dan kan ons maklik ons antwoord kry.

Kode Voorbeeld (5-3):

ongeldige opstelling () {

int antwoord = 0;

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

antwoord += i;

}

println (antwoord);

}

Ek glo dat die resultaat wat u kry dieselfde is as die antwoord wat Guass gesê het: dit is 5050!

Wenke: Die naam van die plaaslike veranderlikes in for lus kan na willekeur verander word op voorwaarde dat dit voldoen aan die veranderlike naamregulasies. U kan dit skryf as (int k = 1; k <= 100; k ++). As daar geen spesifieke toestande plaasgevind het nie, word dit die standaard van i as die naam van die veranderlike.

Stap 3: Vir lustekening

Na 'n reeks oënskynlik vervelige beddegoed, kan ons uiteindelik in 'n meer interessante afdeling kom. Dit is om te gebruik vir 'n lus om prente te teken. Ons kan die vervelige wiskundige berekening nou tersyde stel. Ons ontwerpers is meer sensitief vir grafika.

Gebruik vir lus om 'n sirkelopstelling te teken

As ons 'n lus wil gebruik om 'n groep herhaalde elemente voor te stel, moet ons vooraf seker maak dat die elemente van die elemente relatief is, en dan kan ons dit vir lus gebruik om dit gemaklik te besef in plaas van massiewe herhalingswerk. Gestel as ons 'n sirkelry wil trek, ewe versprei in horisontale rigting. Die virtuele koördinaat daarvan is onveranderd, terwyl die horisontale koördinaat daarvan verander word. En van links na regs neem die horisontale koördinaat voortdurend toe en is die toenemende afstand dieselfde. Op die oomblik kan ons i in vir lus gebruik om die horisontale koördinaat van elke sirkel te kry.

Kodevoorbeeld (5-4): leemte-opstelling () {

grootte (700, 700);

agtergrond (83, 51, 194);

noStroke ();

}

nietige trekking () {

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

ellips (50.0 + i * 100.0, hoogte/2.0, 80.0, 80.0);

}

}

50 staan vir die beginposisie van die eerste sirkel in die linkerkant. 100 in i * 100 verteenwoordig die toenemende afstand.

Stap 4: Gebruik vir lus om 'n ewekansige ronde punt te teken

Bogenoemde grafiese posisie is voorspelbaar. Dit verminder baie belangstelling. Ons kan funksie random gebruik wat ons in die vorige hoofstuk verwys het, en probeer om dit in tekenfunksie te skryf.

Kode Voorbeeld (5-5):

ongeldige opstelling () {

grootte (700, 700);

agtergrond (0);

noStroke ();

}

nietige trekking () {

agtergrond (0);

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

float randomWidth = random (60.0);

ellips (random (breedte), random (hoogte), randomWidth, randomWidth);

}

}

Die rede waarom die posisie van die sirkel voortdurend flikker, is omdat elke keer dat funksie ewekansig vir een keer werk, die resultaat willekeurig is. Omdat funksie -trekking standaard 60 rame per sekonde uitvoer, sal elke 10 sirkels wat in 'n sekonde getrek word, sy posisie 60 keer verander. Hierdie vinnige flits laat die prentjie meer as net 10 sirkels hê. As u 'n eenvoudige waarde in die program verander, kry u 'n totaal ander effek. Ons kan die lustye verander deur die terminale toestand te hersien. Die terminale toestand op die onderstaande foto is i <100

1. Hier is die effek wanneer die terminale toestand i <1000 is:
2. RandomSeed
3. Wat kan ek doen as ek nie wil hê dat die posisie van die sirkel lukraak sowel as die flits daarvan gegenereer word nie? Een metode is om onafhanklike veranderlikes vir elke sirkel te bou en op te slaan en hierdie veranderlikes in die opset te initialiseer. Ken hierdie veranderlikes 'n ewekansige waarde toe. As ons dus die tekenfunksie binne teken gebruik, is die waarde wat ons in veranderlikes geberg het. Dit sal nooit verander nie. Om 10 sirkels te teken, kan ons hierdie metode gebruik. Maar wat as ons 1000 sirkels of 10 000 sirkels wil trek? Dit sal nogal lastig wees as ons hierdie tradisionele metode gebruik om hierdie veranderlikes te bou en dit te noem. Ons hoef nie 'n nuwe veranderlike boumetode te leer nie. Hier is 'n buigsame metode wat ons kan help om hierdie doel te bereik. Dit is om randomSeed te gebruik. Kom ons kyk na die effek daarvan nadat dit gebruik is. Kodevoorbeeld (5-6): [cceN_cpp theme = "dawn"] leemte-opstelling () {size (700, 700); agtergrond (0); noStroke ();}

4. nietige trekking () {

   agtergrond (0);

   randomSeed (1);

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

   float randomWidth = random (20.0, 60.0);

   ellips (random (breedte), random (hoogte), randomWidth, randomWidth);

   }

   } [/cceN_cpp]

   In vergelyking met die voorheen kode, het dit geen veranderinge nie, behalwe dat die radiusreeks van die sirkel van 10 na 30 verder verander word, slegs met 'n sin van ofSeedRandom. Nadat hierdie sin bygevoeg is, lyk die grafiek staties.

   Roep formaat op:

   randomSeed (a);

   Onder hierdie formaat is die instelling van a saad. U moet 'n heelgetal invul (skryf die drywende puntwaarde in P5, dit gaan nie verkeerd nie, maar behandel dit as 'n heelgetal). Die funksie van randomSeed is om die saad vir ewekansige waarde in te stel. Dan genereer dit verskillende ewekansige skikkings volgens verskillende saad. Daarna roep ons funksie ewekansig op sodat die resultaat van terugkeer definitief is. Hier is die besliste nie die resultaat nie, maar 'n bepaalde waarde, maar die gegenereerde skikking. Dit wil sê, die resultaat van opbrengs is beslis relatief tot die aanroepingstye.

   Kodevoorbeeld (5-7): [cceN_cpp tema = "dagbreek"] leemte opstelling () {

   randomSeed (0);

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

   println (random (10));

   }

   } [/cceN_cpp]

   Nou gaan ons voort met die gebruik van println om 'n eksperiment te doen. Nadat u randomSeed gebruik het, sal dit elke keer as u die program sluit en die program herlaai, terugkeer na 'n string met dieselfde resultaat. Die waarde sal een vir een ooreenstem met die volgorde. As u dit uitvee, sal dit elke keer na 'n ander waarde terugkeer. Waarom het dit hierdie instelling? Dit is omdat die ewekansige waarde self in die program pseudo -ewekansig is. Die resultaat lyk ewekansig, maar dit word gegenereer deur 'n vaste en herhaalbare berekeningsmetode. Dit is gelykstaande aan 'n primitiewe waarde vir randomSeed, en dan word die volgende resultaat volgens hierdie saad bereken. As ons egter nie die saad aandui nie, sal die program standaard die huidige tyd van die stelsel gebruik om saad te genereer. Daarom is die resultaat van elke operasie anders. Die onderstaande voorbeeld kan u help om randomSeed beter te verstaan.

   Voorbeeldkode (5-8): [cceN_cpp tema = "dagbreek"] leemte-opstelling () {

   grootte (700, 700);

   agtergrond (0);

   noStroke ();

   }

   nietige trekking () {

   randomSeed (1);

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

   float randomWidth01 = random (10, 60);

   ellips (random (breedte), random (hoogte), randomWidth01, randomWidth01);

   println (randomWidth01);

   }

   randomSeed (1);

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

   float randomWidth02 = random (10, 60);

   ellips (random (breedte), random (hoogte), randomWidth02, randomWidth02);

   println (randomWidth02);

   }

   } [/cceN_cpp]

   Probeer om die tweede randomSeed (1) na randomSeed (0) te hersien en die finale resultate te vergelyk.

   Wenke: in P5 hoef ons slegs funksie noLoop aan die einde van die trekking aan te roep, sodat ons dieselfde effek kan kry. Die funksie daarvan is om die program te beëindig. Dit is heeltemal anders as die bogenoemde werkbeginsels in die natuur.

Stap 5: Gebruik vir lus om lyn te trek

Nadat ons die gebruik van randomSeed bemeester het, kan ons probeer om die tekenfunksie te verander. Verander byvoorbeeld sirkeltekening in lyntekening. Slegs as ons 'n paar veranderende regulasies aan die einde van die reël ontwerp, kan ons baie lyne inmekaar sit om 'n unieke patroon te maak.

Kode Voorbeeld (5-9):

[cceN_cpp tema = "dagbreek"] leemte -opstelling () {

grootte (700, 700);

agtergrond (0);

}

nietige trekking () {

randomSeed (0);

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

float x1 = breedte/2.0;

float x2 = random (50.0, 650.0);

beroerte (255, 20);

reël (x1, 50, x2, 650);

}

} [/cceN_cpp]

Skep 'n eenvoudige kwas

Weer terug na lus. Bogenoemde voorbeelde is nie interaktief nie. As ons die resultaat interessanter wil maak, kan ons nie vergeet om mouseX en mouseY in ons kode te kombineer nie.

Kode Voorbeeld (5-10):

[cceN_cpp tema = "dagbreek"] leemte -opstelling () {

grootte (700, 700);

agtergrond (255);

noStroke ();

}

nietige trekking () {

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

vul (0, 30);

float x = mouseX + random (-50, 50);

float y = mouseY + random (-50, 50);

ellips (x, y, 2, 2);

}

} [/cceN_cpp]

'N "Strooi punte" kwas word geskep. Omdat elke intensiewe mini -ronde punt op die posisie van die muis gebaseer is, kan dit beperkte rigtings van die vier rigtings links, regs, op en af beweeg. Die finale vormverspreiding van die kwas is dus soortgelyk aan 'n vierkant.

Kode Voorbeeld (5-11):

[cceN_cpp tema = "dagbreek"] leemte -opstelling () {

grootte (700, 700);

agtergrond (255);

noStroke ();

}

nietige trekking () {

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

vlotverhouding = mouseX/(float) breedte;

float x = mouseX + random (-50, 50);

float y = mouseY + random (-50, 50);

fill (0, verhouding * 255, 255 * (1 - verhouding), 30);

ellips (x, y, 2, 2);

}

}

[/cceN_cpp]

As ons die waarde van mouseX gebruik om die vulkleur te beïnvloed, kry ons 'n baie meer magiese kleurgradiënt.

Stap 6: Vir Loop Nested

Want lus kan geneste word. U kan weer 'n for -lus in die for -lus skryf. As u 'n tweedimensionele puntmatriks moet teken, kan u hierdie metode kies.

Kode Voorbeeld (5-12):

[cceN_cpp tema = "dagbreek"] leemte -opstelling () {

grootte (700, 700, P2D);

agtergrond (202, 240, 107);

}

nietige trekking () {

vul (0);

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

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

dryf x = 150 + i * 100;

dryf y = 150 + j * 100;

ellips (x, y, 60, 60);

println (i + ":" + j);

}

}

}

[/cceN_cpp]

Om die geneste lus vir die eerste keer te gebruik, moet u die logiese verhoudings daarvan bepaal. Die implementering van die kode in die program is altyd van bo na onder. Daarom is die eerste implementering beslis die buitenste lus. Elke keer as die buitenste lus vir een keer werk, werk die interne lus voortdurend totdat dit nie meer aan die toestand kan voldoen nie. Daarna begin die tweede operasie van die buitenste lus. Nadat die tweede operasie begin het, gaan die interne lus in werking totdat dit nie aan die toestand kan voldoen nie. So 'n herhaling word gedoen totdat daar nie aan alle voorwaardes voldoen kan word nie en dit uit die kringloop spring.

In die kode hierbo het die lusliggaam in die buitenste lus in totaal 5 keer gewerk, terwyl die lusliggaam in die interne lus 25 keer gewerk het. Binne 25 keer, volgens die verskil van i, j waarde, kan ons die horisontale en vertikale koördinaat van die sirkel afsonderlik verseker. Ek het 'n gedeelte afdrukke ingesluit, u kan die data -uitset waarneem en dink oor die verandering daarvan. Slegs met twee geneste lusse kan ons al die kombinasies van i, j data ervaar.

Wenke

Vir lus in die tweede laag kondenseer gewoonlik met Tab aan die begin. Dit kan die kodestruktuur duideliker maak. U moet die plaaslike veranderlikes in die twee lae van vir lus met verskillende name noem. Daaronder is "i", "j", "k" die mees gebruikte.

Buigsame gebruik "i", "j"

Die twee veranderlike naam van "i", "j" verteenwoordig plaaslike veranderlikes van die twee lae van vir lus. Die onderstaande voorbeeld sal u begrip van "i" "j" verdiep. Volgens die verskillende waarde van "i", "j", kan ons parameters invoer om die elemente te groepeer.

Kodevoorbeeld (5-13): [cceN_cpp tema = "dagbreek"] ongeldige opstelling () {

grootte (700, 700);

agtergrond (0);

noStroke ();

}

nietige trekking () {

agtergrond (0);

fill (250, 233, 77);

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

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

pushMatrix ();

vertaal (50 + i * 100, 50 + j * 100);

// Instelling 1

// vlotterhoek = sin (millis ()/1000.0) * PI/2;

// Instelling 2

// vlotverhouding = i/7.0;

// vlotterhoek = sin (millis ()/1000.0 + verhouding * (PI/2)) * PI/2;

// Instelling 3

vlotverhouding = (i * 7 + j) /49.0;

vlotterhoek = sin (millis ()/1000.0 + verhouding * (PI/2)) * PI/2;

draai (hoek);

rectMode (SENTRUM);

// Teken prent 1

reg (0, 0, 80, 80);

// Teken prent 2

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

// Teken prent 3

// reg (0, 0, verhouding * 50);

popMatrix ();

}

}

} [/cceN_cpp]

Kode Verduideliking

rectMode (CENTRE) kan die tekenmetode van vierkant verander. Die oorspronklike twee parameters van rect word gebruik om die koördinaat van die linker boonste hoek van die vierkant te definieer. Nadat ons hierdie opdrag begin het, word hierdie twee parameters gebruik om die koördinaat vir die vierkantige middelpunt te stel. Omdat ons hier die patern -rotasie deur middel van rotasie bedryf, moet ons hierdie metode gebruik om die middelpunt na die oorspronklike punt van die koördinaat te trek.

millis () verkry die tyd vanaf die program begin tot die hede. Die eenheid is me. Hierdie waarde sal die veranderende spoed van sin -uitsetwaarde beïnvloed. As ons millis direk skryf, is die veranderende skaal te groot. Ons moet dit dus met 1000.0 deel.

In hierdie kode -afdeling gebruik ons kommentaar simbool "//" om verskeie instellings te verberg. U kan effekte verskuif deur te begin of te sluit. Byvoorbeeld, as ons sinne agter "Instelling 3" begin, moet ons 'n opmerking -simbool gebruik om kodeblokke te sluit agter "Instelling 1" en "Instelling 2". Wat voorbeelde van hierdie soortgelyke programstruktuur met verskillende plaaslike veranderlikes betref, kan ons in hierdie formaat skryf. Ons hoef dus nie verskeie ingenieursdokumente afsonderlik te stoor nie. Ons kan hierdie vaardigheid dikwels tydens oefening en skepping gebruik en 'n paar bevredigende parameterinstellings bewaar.

Die invloed van i, j -waarde op die program word hoofsaaklik verteenwoordig deur die verskuiwing van "Instelling 1 (Instelling 2) (Instelling 3)". U kan die uitsetresultate hieronder vergelyk.

Teken prent 1: Instelling 1

Teken prent 1: omgewing 2

Teken prent 1: omgewing 3

Teken prent 2: Instelling 1

Teken prent 2: Instelling 2

Teken prent 2: Instelling 3

In instelling 1 het ons nie i en j gebruik om die draaihoek van elke element te beïnvloed nie. So kan ons sien dat die beweging van elke element dieselfde is. Terwyl ons in instelling 2 gebruik het, gebruik ons i waarde en beide i en j in instelling 3. Uiteindelik het dit parameterinvoer van funksie sin deur verhouding beïnvloed. Dit het die periodieke hoekverandering verander. Omdat die werklike effek van instelling 2 en instelling 3 nie so duidelik is in die geanimeerde grafika nie, kan ons dit vanaf die volgende skermkiekie waarneem.

Teken prent 2 (links: instelling 2; regs: instelling 3)

Teken prent 3 (links: instelling 2; regs: instelling 3)

In die eerste prentjie word die verhouding gebruik om die vierkantige draaihoek te beïnvloed. Terwyl die tweede prentjie, is dit die doel om die radius van die sirkel direk te beheer. Ons kan sien dat dit 'n waardesin gebruik het:

vlotverhouding = i/7,0;

Die verandering van die vertikale element is konsekwent. Omdat die horisontale koördinaat vir die beheer van die prentjie slegs afhang van die waarde van i, sal patrone met dieselfde horisontale koördinaat dieselfde wees. En die waarde van verhouding, draaihoek en sirkelradius is ook dieselfde.

Terselfdertyd gebruik ons i, j sin:

vlotverhouding = (i * 7 + j) /49.0;

Dit kan 'gradient' beskryf. Hier, met die metode om 'n faktor te vermenigvuldig, het dit die invloed van rye en kolomme gekombineer. Elke element is dus anders.

Stap 7: Terwyl Loop

Daar is 'n broer vir vir lus. Dit is terwyl lus. Wat vir lus kan doen, terwyl lus dit ook kan doen. Maar die gebruiksfrekwensie van while -lus in creativeCoding is nie so hoog soos vir lus nie.

Kodevoorbeeld (5-14): [cceN_cpp tema = "dagbreek"] leemte-opstelling () {

int a = 0;

terwyl (a <10) {

druk (a);

'n ++;

}

} [/cceN_cpp]

Die grammatika -struktuur van while is makliker om te verstaan as vir. Ons kan veranderlikes voor die stelling maak. Vul dan 'n uitdrukking binne vierkantige hakies in. As dit bevredig is, gebruik dan die sinne in die lusliggaam. Uiteindelik plaas ons 'n uitdrukking in die lusliggaam om die veranderlikes by te werk, en terwyl die lus klaar is. Wat die versekerde lustye betref, gebruik ons dit gereeld vir lus. Wat die onbepaalde veranderlike waarde betref, raai ons u aan om 'n while -lus te gebruik.

Dink:

Probeer allerhande basiese elemente gebruik om tekenelemente in 'n lus te vervang om verskillende borsels te skep.

Kombineer met die trigonometriese funksie wat in die laaste hoofstuk verwys is, en probeer om die kwas van 'verstrooiingspunte' in 'n ronde kwas te verander.

Probeer om 'n tweedimensionele puntmatriks te maak met slegs 'n lus.

Soos met hierdie kursus, vind u elke nuwe kennis wat u leer, die moontlikheid om te speel, sal onmiddellik baie toeneem. Die program is 'n pandora -boks. Alles wat u kan voorstel, kan dit vir u doen. Daar is dus geen rede waarom ons nie hierdie taal leer wat met rekenaars kan kommunikeer nie. In ons volgende hoofstuk sal ons u 'n ander prosesbeheerverklaring bekendstel. Dit kan prosesvloei beheer en meer ingewikkelde en veranderlike resultate genereer. Met if statement kan u maklik u eie teks-avontuurspeletjies skep! Hierdie artikel kom van ontwerper Wenzy. Relative Readings: Interesting Programming Guidance for Designer-Processing Initial TouchInteresting Programming Guidance for Designer-Create Your First Processing Program –Laat u prent loop (deel een) Interessante programmeergeleiding vir ontwerper - laat u prentjie loop (deel twee)

Stap 8: Bron

Hierdie artikel is afkomstig van:

As u enige vrae het, kan u kontak: [email protected].