Programրագրավորման հետաքրքիր ուղեցույց դիզայների համար. Processրագրի գործընթացի վերահսկում- Loop հայտարարություն. 8 քայլ

2024 Հեղինակ: John Day | [email protected]. Վերջին փոփոխված: 2024-01-30 09:52

Processրագրի գործընթացի վերահսկում- Loop Statement

Այս գլխից դուք կկապվեք կարևոր և հզոր գիտելիքի կետի ՝ Loop Statement- ի հետ:

Այս գլուխը կարդալուց առաջ, եթե ցանկանում եք ծրագրում նկարել 10 000 շրջանակ, ապա դա կարող եք անել միայն սարսափելի մեթոդով: Այսինքն ՝ գրել 10 000 տող էլիպսային ծածկագիր: Այն ծույլ ծածկագրերի դիզայներները, ովքեր ցանկանում են ամեն կերպ բարելավել արդյունավետությունը, միանշանակ թույլ չեն տա, որ դա տեղի ունենա: Այսպիսով, ստեղծվում է loop հայտարարություն: Այս հայտարարությամբ դուք կարող եք ինտուիտիվ կերպով զգալ համակարգչային ավտոմատացման հզորությունը:

Քայլ 1. Օղակի համար

Կան բազմաթիվ հանգույցային հայտարարություններ, որոնցից ամենատարածվածը For Loop- ն է: Մենք բոլորս գիտենք, որ ֆունկցիայի գծումը շարունակաբար գործում է շրջանառության մեջ: Սկսեք սկզբի առաջին նախադասությունից, այն կիրականացվի վերևից ներքև մինչև վերջին նախադասությունը: Գործողությունը ավարտելուց հետո այն նորից կսկսվի առաջին նախադասությունից: For statement- ը մի փոքր նման է draw draw- ին: Հայտարարության ներսում գտնվող ծածկագիրը կարող է բազմիցս կատարվել:

Ահա դրա քերականական կառուցվածքը.

For (արտահայտություն 1; արտահայտություն 2; արտահայտություն 3) {

Օղակաձև մարմին

}

Ակնհայտ է, որ շրջանակի ներսում նախադասություններն այն են, ինչ մենք ակնկալում էինք, որ բազմիցս կիրականացվեն: 1 արտահայտությունը օգտագործվում է օղակի փոփոխականի առաջին արժեքը սկզբնավորելու և նշանակելու համար: 2 -րդ արտահայտությունը հանգույցի վիճակի համար է: 3 -րդ արտահայտությունը կթարմացնի հանգույցի փոփոխական արժեքը:

Ի՞նչ է հանգույցի փոփոխականը: Այն իրականում համարժեք է տեղական փոփոխականին: Եկեք նայենք ամբողջական գրությանը:

համար (int i = 0; i <10; i ++) {

Օղակաձև մարմին

}

Օղակի գործառույթն իրականացնելու համար հայտարարությունը հիմնականում հենվում է տեղական փոփոխականի վրա, որը կօգտագործվի օղակի ավարտման ժամանակ: Վերոնշյալ օրինակի տեղական փոփոխականը i է: 1 -ին արտահայտությունն ավարտեց տեղական փոփոխականի սկզբնավորումը: Հետագայում, ամեն անգամ, երբ օղակը գործում է մեկ անգամ, այս փոփոխականը պետք է թարմացվի: Վերոնշյալ օրինակի մեջ i ++ արտահայտության 3 -ում օգտագործվում է թարմացման գործառույթը իրականացնելու համար: Դրա միջոցով փոփոխականն ամեն անգամ թարմացվելուց կավելանա 1 -ով: Ի վերջո, օղակի մարմնի ծածկագիրը չի կարող անվերջ հանգչել, այլապես վերջին հայտարարությունները չեն կարող կատարվել: Այսպիսով, մեզ անհրաժեշտ է տերմինալային պայման: Express 2 -ը հենց դրա համար է: Այստեղ ծրագիրը կորոշի ՝ արդյոք ես 10 -ից փոքր եմ, եթե դա այդպես է, ապա շարունակեք վիրահատությունը: Եթե դա այդպես չէ, ապա ցատկեք շրջանակից:

Հետեւաբար, հայտարարության գործողությունների հաջորդականությունը հենց այսպիսին է.

Արտահայտություն 1 (Տեղական փոփոխականի սկզբնավորում)

Արտահայտություն 2 (Բավարարված, ապա շարունակիր գործել)

Օղակաձև մարմին (Առաջին շրջանառություն)

Արտահայտություն 3 (թարմացում)

Արտահայտություն 2 (Բավարարված, ապա շարունակիր գործել)

Օղակի մարմին (երկրորդ շրջան)

Արտահայտություն 3 (Թարմացում)

Արտահայտություն 2 (Բավարարված, ապա շարունակիր գործել)

Օղակաձև մարմին (երրորդ շրջանառություն)…

Արտահայտություն 3 (թարմացում)

Արտահայտություն 2 (Չբավարարված, ապա ցատկիր օղակից)

Դուք կարող եք նմանակել կատարման այս հաջորդականությունը ձեր գլխում մի քանի անգամ: Բայց անհնար է իսկապես հասկանալ ծածկագիրը ՝ առանց այն մեկ անգամ ձեռքով մուտքագրելու: Երբ մենք ցանկանում ենք պարզել մի տարօրինակ հասկացություն, մենք կարող ենք տպել արժեքը մխիթարելում println հայտարարության միջոցով:

Կոդի օրինակ (5-1). Void setup () {

համար (int i = 0; i <10; i ++) {

println («գործարկել»);

}

}

Դուք կարող եք հաշվել վազքի արդյունքի քանակը վահանակում: Այստեղ այն ճշգրիտ է 10. Սա ձեզ ասում է, թե քանի անգամ է կատարվել հանգույցի մարմնի կոդը: Այնուամենայնիվ, մենք դեռ չենք կարող հայտնաբերել, թե իրականում ինչ փոփոխություններ են տեղի ունեցել օղակում: Այսպիսով, մենք կարող ենք փորձել փոխել բնույթը «բախվել փոփոխական« i » - ի հետ և տեսնել, թե ինչ կլինի:

Կոդի օրինակ (5-2). Void setup () {

համար (int i = 0; i <10; i ++) {

println (i);

}

}

Այժմ մենք կարող ենք տեսնել, որ օղակի մարմնի i արժեքը անընդհատ աճում է: Հետագայում, մենք կարող ենք օգտագործել այս արժեքը `օղակի ընթացիկ ընթացքը հասկանալու համար:

Կոդի օրինակում (5-2) i- ի արժեքը փոխվում է 0-ից 9-ի: Իրական հանգույցի ժամանակների համեմատ, թվում է, թե այն միշտ ունի 1 պակաս: Եթե դուք սովոր չեք դրան, ապա հայտարարության փակագծում արտահայտությունը կարող է գրվել հետևյալի վրա.

համար (int i = 1; i <＝ 10; i ++)

Այսպիսով, ես իրավամբ համապատասխանում եմ հանգույցի ժամանակներին: «<＝» -ի իմաստը փոքր է և հավասար: Այսպիսով, երբ ես հավասար եմ 10 -ի, այն դեռ կհամապատասխանի պայմանին: Հետևաբար, այն նորից կգործի ի համեմատ i <10 -ում գրված լինելու հետ: Չնայած այն սկսվում է 1 -ից, ապա հանգույցի ժամանակը դեռ 10 -ն է: Իհարկե, եթե հատուկ բան պետք չէ, ես կցանկանայի ձեզ առաջարկել գրելու եղանակը օրինակ սկզբում: Հետագայում մենք ձեզ կներկայացնենք վեկտորը կամ զանգվածը, որոնք երկուսն էլ ստանում են դրա տարրը իր ենթագրով: Իսկ կանխադրված ենթագրերը բոլորը սկսվում են 0 -ից: Նախնական արժեքը 0 սահմանելը համեմատաբար սովորական պրակտիկա է:

Վերոնշյալ օրինակում, եթե i- ն գրենք 0 -ից բարձր, ապա սյունը կփլուզվի: Քանի որ փոփոխականն անընդհատ աճում է, այն երբեք չի բավարարի այս պայմանը: Սա այնպիսին է, ինչպիսին այն երբեք չի կարող դադարեցվել, որպեսզի ծրագիրը բախվի անվերջ հանգույցի:

For հայտարարության մեջ տեղային փոփոխականները կարող են ոչ միայն հայտարարել պլաստիկի տեսակներ, այլև փոփոխականներ հայտարարել լողացող կետերի տեսակների մեջ: Օրինակ, այն կարող է գրվել որպես (float i = 0; i <10; i + = 0.02):

Քայլ 2. Օղակի համար օգտագործեք մաթեմատիկական խնդիրներ լուծելու համար

Դեռ հիշու՞մ եք մանկության տարիներին մաթեմատիկոս Գաուսի պատմությունը: Այդ ժամանակ Գուասը 10 տարեկան էր: Նրա ուսուցիչը ցանկանում էր առաջադրանք տալ դասարանում, և հարցն այն էր

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

Եթե հաշվեք ձեր ձեռքերով, դա ձեզ շատ ժամանակ կպահանջի: Կարծես թե Գուասը արդեն պարզել է թվաբանական հաջորդականության գումարման մեթոդը: Ուստի հարցը տալուց անմիջապես հետո նա հեշտությամբ ասաց պատասխանը, ինչը մեծապես զարմացրել էր իր ուսուցչին:

Հիմա, գուցե, մենք դեռ չենք հիշում, թե որն է թվաբանական հաջորդականության գումարը, բայց պատասխանը կարող ենք ստանալ պարզունակ և բռնի եղանակով: Եվ դա հանգույցի համար է: Քանի որ համակարգիչների համար դա ընդամենը մի փոքր կտոր տորթ է, մենք պետք է հարցը նկարագրենք այն լեզվով, որը կարող է ճանաչվել համակարգչով, այդ դեպքում մենք կարող ենք հեշտությամբ ստանալ մեր պատասխանը:

Կոդի օրինակ (5-3):

void setup () {

int պատասխան = 0;

համար (int i = 1; i <= 100; i ++) {

պատասխան += i;

}

println (պատասխան);

}

Կարծում եմ, որ ձեր ստացած արդյունքը նույնն է, ինչ պատասխանել է Guass- ը. Դա 5050 է:

Խորհուրդներ. Loop- ի մեջ տեղակայված տեղական փոփոխականների անվանումը կարող է փոփոխվել ըստ ցանկության `փոփոխականների անվանման կանոններին համապատասխան: Դուք կարող եք այն գրել (int k = 1; k <= 100; k ++): Եթե կոնկրետ պայմաններ տեղի չունեցան, ապա դա փոփոխականի անունը լռելյայն i է:

Քայլ 3. Օղակ գծելու համար

Մի շարք թվացյալ ձանձրալի անկողնային պարագաներից հետո, վերջապես, մենք կարող ենք գալ ավելի հետաքրքիր հատվածի: Այսինքն օգտագործել հանգույցը նկարներ նկարելու համար: Մենք այժմ կարող ենք մի կողմ դնել այդ հոգնեցուցիչ մաթեմատիկական հաշվարկը: Մենք ՝ դիզայներներս, ավելի զգայուն ենք գրաֆիկայի նկատմամբ:

Օղակի համար օգտագործեք շրջանագծի զանգված նկարելու համար

Երբ մենք ցանկանում ենք օգտագործել loop- ը `կրկնվող տարրերի խումբ ներկայացնելու համար, մենք պետք է նախապես համոզվենք այս տարրերի թվային հարաբերականությամբ, այնուհետև կարող ենք օգտագործել loop- ի համար` այն հարմար իրացնելու փոխարեն `զանգվածային կրկնվող աշխատանք կատարելու փոխարեն: Ենթադրենք, եթե ուզում ենք հորիզոնական ուղղությամբ հավասարաչափ տարածված շրջանագծ նկարել: Նրա վիրտուալ կոորդինատը անփոփոխ է, մինչդեռ հորիզոնական կոորդինատը փոխվում է: Իսկ ձախից աջ ՝ հորիզոնական կոորդինատը անընդհատ աճում է, իսկ աճող տարածությունը ՝ նույնը: Այս պահին մենք կարող ենք i in loop- ի միջոցով օգտագործել յուրաքանչյուր շրջանակի հորիզոնական կոորդինատը ստանալու համար:

Կոդի օրինակ (5-4). Void setup () {

չափը (700, 700);

ֆոն (83, 51, 194);

noStroke ();

}

դատարկ վիճակահանություն () {

համար (int i = 0; i <7; i ++) {

էլիպս (50.0 + i * 100.0, բարձրություն/2.0, 80.0, 80.0);

}

}

50 նշանակում է ձախում առաջին շրջանի մեկնարկային դիրքը: 100 -ը i * 100 -ում ներկայացնում է աճող հեռավորությունը:

Քայլ 4. Օգտագործեք Loop- ի համար ՝ պատահական կլոր կետ նկարելու համար

Վերոնշյալ գրաֆիկական դիրքը կանխատեսելի է: Սա նվազագույնի կհասցնի մեծ հետաքրքրությունը: Մենք կարող ենք օգտագործել պատահական գործառույթը, որին անդրադարձել էինք նախորդ գլխում և փորձել այն գրել գծագրության գործառույթում:

Կոդի օրինակ (5-5):

void setup () {

չափը (700, 700);

ֆոն (0);

noStroke ();

}

դատարկ վիճակահանություն () {

ֆոն (0);

համար (int i = 0; i <10; i ++) {

float randomWidth = պատահական (60.0);

էլիպս (պատահական (լայնություն), պատահական (բարձրություն), պատահական լայնություն, պատահական լայնություն);

}

}

Այստեղ, պատճառը, թե ինչու է շրջանագծի դիրքը անընդհատ փայլում, այն է, որ ամեն անգամ, երբ գործառույթը պատահականորեն գործում է մեկ անգամ, արդյունքը պատահական է: Քանի որ ֆունկցիայի նկարչությունը կանխադրված է 60 վայրկյան վայրկյանում, այնպես որ մեկ վայրկյանում գծված յուրաքանչյուր 10 շրջանակը կփոխի իր դիրքը 60 անգամ: Այս արագ բռնկումը ստիպում է նկարին ավելի քան 10 շրջան ունենալ: Changeրագրում պարզ արժեք փոխելը ձեզ բոլորովին այլ էֆեկտ կբերի: Մենք կարող ենք փոխել հանգույցի ժամանակները ՝ վերանայելով տերմինալի վիճակը: Ստորև բերված նկարի տերմինալային պայմանը i <100 է:

1. Ահա ազդեցությունը, երբ տերմինալի վիճակը i <1000 է:
2. Պատահական սերմ
3. Եթե ես չեմ ուզում, որ շրջանի դիրքը պատահականորեն ստեղծվի, ինչպես նաև նրա բռնկումը, ինչ կարող եմ անել: Մեթոդներից մեկն այն է, որ յուրաքանչյուր շրջանի համար կառուցվի և պահվի անկախ փոփոխականներ և սկզբնականացվի այդ փոփոխականները կարգաբերման ընթացքում: Այս փոփոխականներին նշանակեք պատահական արժեք: Այսպիսով, նկարչության գործառույթն օգտագործելիս վիճակահանության ընթացքում, այն, ինչին մենք կանչում ենք, փոփոխականներում պահվող արժեքն է: Այն ոչ մի պահի չի փոխվի: 10 շրջանակ նկարելու համար կարող ենք պարզապես օգտագործել այս մեթոդը: Բայց ի՞նչ անել, եթե մենք ուզում ենք նկարել 1000 շրջան, կամ 10 000 շրջան: Բավականին անհանգստացնող կլինի, եթե օգտագործենք այս ավանդական մեթոդը `այս փոփոխականները կառուցելու և այն անվանելու համար: Պարտադիր չէ սովորել փոփոխական կառուցման նոր մեթոդ: Ահա ճկուն մեթոդ, որը կարող է օգնել մեզ հասնել այս նպատակին: Այսինքն օգտագործել randomSeed- ը: Այժմ, եկեք նայենք դրա ազդեցությանը օգտագործելուց հետո: Կոդի օրինակ (5-6). [CceN_cpp theme = "dawn"] void setup () {size (700, 700); ֆոն (0); noStroke ();}

4. դատարկ վիճակահանություն () {

   ֆոն (0);

   պատահական սերմ (1);

   համար (int i = 0; i <10; i ++) {

   float randomWidth = պատահական (20.0, 60.0);

   էլիպս (պատահական (լայնություն), պատահական (բարձրություն), պատահական լայնություն, պատահական լայնություն);

   }

   } [/cceN_cpp]

   Նախկին կոդի համեմատ, այն չունի որևէ փոփոխություն, բացառությամբ այն, որ շրջանագծի շառավիղը 10 -ից փոխում է 30 -ի և անցնում է միայն SeedRandom- ի նախադասությամբ: Այս նախադասությունն ավելացնելուց հետո գրաֆիկը ստատիկ է դառնում:

   Հրավիրման ձևաչափ.

   պատահական սերմ (ա);

   Այս ձևաչափի մեջ a- ի կարգավորումը սերմն է: Դուք պետք է լրացնեք մի ամբողջ թիվ (P5- ում գրեք լողացող կետի արժեքը, այն սխալ չի գնա, այլ վերաբերվեք որպես ամբողջ թիվ): RandomSeed- ի գործառույթն է սերունդը սահմանել պատահական արժեքի համար: Այնուհետև այն կստեղծի տարբեր պատահական զանգված ՝ ըստ տարբեր սերմերի: Դրանից հետո մենք կանչում ենք պատահական գործառույթ, որպեսզի վերադարձի արդյունքը որոշակի լինի: Այստեղ որոշվածը ոչ թե արդյունքի համար է որոշակի արժեք, այլ գեներացվող զանգվածի համար: Ասել է թե ՝ վերադարձի արդյունքը որոշակի է ՝ համեմատած կանչերի ժամանակների հետ:

   Կոդի օրինակ (5-7). [CceN_cpp theme = "dawn"] void setup () {

   պատահական սերմ (0);

   համար (int i = 0; i <5; i ++) {

   println (պատահական (10));

   }

   } [/cceN_cpp]

   Այժմ մենք շարունակում ենք println- ի օգտագործումը փորձեր կատարելու համար: RandomSeed- ից օգտվելուց հետո ամեն անգամ, երբ փակում եք ծրագիրը և վերագործարկում ծրագիրը, այն կվերադառնա նույն արդյունքի տողին: Արժեքը կհամապատասխանի հաջորդականությանը մեկ առ մեկ: Եթե ջնջեք այն, ապա ամեն անգամ այն կվերադառնա այլ արժեքի: Ինչու է այն ունի այս կարգավորումը: Դա պայմանավորված է նրանով, որ ծրագրում պատահական արժեքը ինքնին կեղծ պատահական է: Արդյունքը թվում է պատահական, բայց իրականում այն առաջանում է ֆիքսված և կրկնվող հաշվարկի մեթոդով: Այն համարժեք է նախնական արժեք նշանակել randomSeed- ի համար, ապա հետևյալ արդյունքը կհաշվարկվի ըստ այս սերմի: Այնուամենայնիվ, եթե մենք չնշանակենք սերմը, ծրագիրը լռելյայն կօգտագործի համակարգի ներկա ժամանակը սերմ արտադրելու համար: Հետևաբար, յուրաքանչյուր գործողության արդյունքը տարբեր է: Ստորև բերված օրինակը կարող է օգնել ձեզ ավելի լավ հասկանալ randomSeed- ը:

   Օրինակ կոդ (5-8). [CceN_cpp theme = "dawn"] void setup () {

   չափը (700, 700);

   ֆոն (0);

   noStroke ();

   }

   դատարկ վիճակահանություն () {

   պատահական սերմ (1);

   համար (int i = 0; i <10; i ++) {

   float randomWidth01 = պատահական (10, 60);

   էլիպս (պատահական (լայնություն), պատահական (բարձրություն), պատահական լայնություն 01, պատահական լայնություն 01);

   println (պատահական լայնություն 01);

   }

   պատահական սերմ (1);

   համար (int i = 0; i <10; i ++) {

   float randomWidth02 = պատահական (10, 60);

   էլիպս (պատահական (լայնություն), պատահական (բարձրություն), randomWidth02, randomWidth02);

   println (պատահական լայնություն 02);

   }

   } [/cceN_cpp]

   Փորձեք վերանայել երկրորդ randomSeed- ը (1) randomSeed- ի (0) և համեմատեք վերջնական արդյունքները:

   Խորհուրդներ. P5- ում վիճակահանության վերջում մենք պետք է կանչենք noLoop գործառույթը, որպեսզի կարողանանք ստանալ նույն էֆեկտը: Նրա գործառույթն է `ծրագիրը դադարեցնելը: Այն բավականին տարբերվում է բնության վերը նշված աշխատանքային սկզբունքներից:

Քայլ 5. Օգտագործեք Loop գծի գծման համար

RandomSeed- ի օգտագործումը յուրացնելուց հետո կարող ենք փորձել փոխել գծագրման գործառույթը: Օրինակ ՝ շրջանաձև գծագրությունը փոխեք գծային գծագրի: Միայն եթե գծի վերջը մշակենք որոշ փոփոխվող կանոնակարգեր, մենք կարող ենք օգտագործել բազմաթիվ տողեր, որոնք խճճված են `յուրահատուկ օրինակ ստեղծելու համար:

Կոդի օրինակ (5-9):

[cceN_cpp theme = "լուսաբաց"] անվավեր կարգավորում () {

չափը (700, 700);

ֆոն (0);

}

դատարկ վիճակահանություն () {

պատահական սերմ (0);

համար (int i = 0; i <2000; i ++) {

բոց x1 = լայնություն/2.0;

float x2 = պատահական (50.0, 650.0);

կաթված (255, 20);

տող (x1, 50, x2, 650);

}

} [/cceN_cpp]

Ստեղծեք պարզ խոզանակ

Կրկին վերադառնալ օղակի համար: Վերոնշյալ օրինակները ինտերակտիվ չեն: Եթե ցանկանում ենք արդյունքն ավելի հետաքրքիր դարձնել, ապա չենք կարող մոռանալ mouseX- ի և mouseY- ի համատեղումը մեր կոդի մեջ:

Կոդի օրինակ (5-10):

[cceN_cpp theme = "լուսաբաց"] անվավեր կարգավորում () {

չափը (700, 700);

ֆոն (255);

noStroke ();

}

դատարկ վիճակահանություն () {

համար (int i = 0; i <1000; i ++) {

լրացնել (0, 30);

float x = mouseX + պատահական (-50, 50);

float y = mouseY + պատահական (-50, 50);

էլիպս (x, y, 2, 2);

}

} [/cceN_cpp]

Ստեղծվում է «ցրման կետեր» վրձին: Քանի որ յուրաքանչյուր ինտենսիվ մինի կլոր կետ հիմնված է մկնիկի դիրքի վրա, այն կարող է սահմանափակ ուղղություններ տեղափոխել ձախ, աջ, վեր և վար չորս ուղղություններից: Այսպիսով, խոզանակի վերջնական ձևի տարածումը նման է քառակուսիի:

Կոդի օրինակ (5-11):

[cceN_cpp theme = "լուսաբաց"] անվավեր կարգավորում () {

չափը (700, 700);

ֆոն (255);

noStroke ();

}

դատարկ վիճակահանություն () {

համար (int i = 0; i <1000; i ++) {

float ratio = mouseX/(float) լայնություն;

float x = mouseX + պատահական (-50, 50);

float y = mouseY + պատահական (-50, 50);

լրացնել (0, հարաբերակցությունը * 255, 255 * (1 - հարաբերակցությունը), 30);

էլիպս (x, y, 2, 2);

}

}

[/cceN_cpp]

Եթե մենք օգտագործում ենք mouseX- ի արժեքը `ազդելու լրացման գույնի վրա, ապա մենք կստանանք շատ ավելի կախարդական գույնի գրադիենտ:

Քայլ 6. Loop Nested- ի համար

For loop- ը կարող է բնադրվել: Դուք կարող եք կրկին գրել loop for for loop- ի մեջ: Երբ անհրաժեշտ է գծել երկչափ կետային մատրիցա, կարող եք ընտրել այս մեթոդը:

Կոդի օրինակ (5-12):

[cceN_cpp theme = "լուսաբաց"] անվավեր կարգավորում () {

չափը (700, 700, P2D);

ֆոն (202, 240, 107);

}

դատարկ վիճակահանություն () {

լրացնել (0);

համար (int i = 0; i <5; i ++) {

համար (int j = 0; j <5; j ++) {

բոց x = 150 + i * 100;

բոց y = 150 + j * 100;

էլիպս (x, y, 60, 60);

println (i + ":" + j);

}

}

}

[/cceN_cpp]

Ներդրված հանգույցն առաջին անգամ օգտագործելու համար պետք է պարզել դրա տրամաբանական հարաբերությունները: Codeրագրում կոդի ներդրումը միշտ վերևից ներքև է: Հետևաբար, առաջին իրականացվողը, անշուշտ, ծայրահեղ օղակն է: Ամեն անգամ, երբ արտաքին օղակը գործում է մեկ անգամ, ներքին հանգույցը շարունակաբար կգործի, մինչև այն այլևս չբավարարի պայմանը: Դրանից հետո այն կսկսի երկրորդ արտաքին օղակի գործողությունը: Երկրորդ գործողության մեկնարկից հետո ներքին հանգույցը կշարունակվի մինչև այն չկարողանա բավարարել պայմանը: Նման կրկնությունը դա անում է այնքան ժամանակ, մինչև բոլոր պայմանները չբավարարվեն, և այն դուրս թռչի շրջանակից:

Վերոնշյալ ծածկագրում արտաքին հանգույցի օղակի մարմինը գործել է ընդհանուր առմամբ 5 անգամ, իսկ ներքին հանգույցի օղակի մարմինը `25 անգամ: 25 անգամ, i, j արժեքի տարբերության համաձայն, մենք կարող ենք առանձին ապահովել շրջանագծի հորիզոնական և ուղղահայաց կոորդինատները: Ես տեղադրել եմ տպագրության մի հատված, կարող եք դիտել տվյալների ելքը և մտածել դրա փոփոխության մասին: Միայն երկու ներկառուցված հանգույցներով մենք կարող ենք զգալ i, j տվյալների բոլոր համակցությունները:

Խորհուրդներ

Երկրորդ շերտի հանգույցի համար սկզբում սովորաբար խտացրեք Tab- ի հետ: Սա կարող է ավելի հստակ դարձնել ծածկագրի կառուցվածքը: Տարբեր փոփոխական անուններով for loop- ի երկու շերտերում պետք է անվանել տեղական փոփոխականներ: Դրա մեջ ամենից հաճախ օգտագործվում է «i», «j», «k»:

Iկուն օգտագործում «i», «j»

«I», «j» երկու փոփոխական անվանումը ներկայացնում են for loop- ի երկու շերտերի տեղական փոփոխականները: Ստորև բերված օրինակը կխորացնի ձեր ըմբռնումը «i» - ի «j» - ի համար: «I», «j» տարբեր արժեքների համաձայն, մենք կարող ենք պարամետրեր մուտքագրել տարրերը խմբավորելու համար:

Կոդի օրինակ (5-13). [CceN_cpp theme = "dawn"] void setup () {

չափը (700, 700);

ֆոն (0);

noStroke ();

}

դատարկ վիճակահանություն () {

ֆոն (0);

լցնել (250, 233, 77);

համար (int i = 0; i <7; i ++) {

համար (int j = 0; j <7; j ++) {

pushMatrix ();

թարգմանել (50 + i * 100, 50 + j * 100);

// Կարգավորում 1

// բոց անկյուն = մեղք (միլիլ ()/1000.0) * PI/2;

// Կարգավորում 2

// բոց հարաբերակցություն = i/7.0;

// լողացող անկյուն = մեղք (millis ()/1000.0 + հարաբերակցություն * (PI/2)) * PI/2;

// Կարգավորում 3

բոց հարաբերակցություն = (i * 7 + j) /49.0;

float անկյուն = մեղք (millis ()/1000.0 + հարաբերակցությունը * (PI/2)) * PI/2;

պտտել (անկյուն);

rectMode (CENTER);

// Նկարել նկարը 1

ուղիղ (0, 0, 80, 80);

// Նկարել նկարը 2

// ուղղ (0, 0, 100, 20);

// Նկարել նկարը 3

// rect (0, 0, հարաբերակցությունը * 50);

popMatrix ();

}

}

} [/cceN_cpp]

Կոդի բացատրություն

rectMode- ը (CENTER) կարող է փոխել քառակուսու գծագրման մեթոդը: Ուղղահայաց սկզբնաղբյուրի երկու նախնական պարամետրերը օգտագործվում են կղզու ձախ վերին անկյունի կոորդինատը որոշելու համար: Այս հրամանը սկսելուց հետո այս երկու պարամետրերը կօգտագործվեն քառակուսի կենտրոնական կետի կոորդինատը սահմանելու համար:Քանի որ այստեղ մենք գործարկում ենք հայրական պտույտը պտտման միջոցով, ուստի մենք պետք է օգտագործենք այս մեթոդը ՝ կենտրոնական կետը կոորդինատի սկզբնական կետին գծելու համար:

millis () ձեռք է բերում ծրագրի մեկնարկից մինչ օրս ժամանակը: Միավորը ms է: Այս արժեքը կազդի մեղքի ելքային արժեքի փոփոխվող արագության վրա: Եթե մենք ուղղակիորեն գրում ենք millis- ը, փոփոխվող մասշտաբը չափազանց մեծ է: Այսպիսով, մենք պետք է այն բաժանենք 1000.0 -ի:

Կոդի այս բաժնում մենք օգտագործում ենք մեկնաբանության խորհրդանիշ «//» ՝ մի քանի կարգավորումներ թաքցնելու համար: Դուք կարող եք փոփոխել էֆեկտները ՝ սկսելով կամ փակելով: Օրինակ, եթե նախադասությունները սկսենք «Կարգավորում 3» -ի հետևում, մենք պետք է օգտագործենք մեկնաբանության խորհրդանիշ ՝ «Կարգավորում 1» և «Կարգավորում 2» կոդերի բլոկները փակելու համար: Ինչ վերաբերում է տարբեր տեղական փոփոխականներով նմանատիպ ծրագրի կառուցվածքի օրինակներին, ապա կարող ենք գրել այս ձևաչափով: Այսպիսով, մենք չպետք է առանձին պահենք մի քանի ինժեներական փաստաթղթեր: Մենք կարող ենք հաճախ օգտագործել այս հմտությունը պրակտիկայի և ստեղծման ընթացքում և պահպանել որոշ գոհացուցիչ պարամետրերի պարամետրեր:

Դրա մեջ i, j արժեքի ազդեցությունը ծրագրի վրա հիմնականում ներկայացված է «Կարգավորում 1 (կարգավորում 2) (կարգավորում 3)» տեղաշարժով: Ստորև կարող եք համեմատել արդյունքների արդյունքները:

Նկարեք նկար 1: 1 -ի կարգավորում

Նկարեք նկար 1: Կարգավորում 2

Նկարեք նկար 1: Կարգավորում 3

Նկարեք նկար 2: 1 -ի կարգավորում

Նկարեք նկար 2: 2 -ի կարգավորում

Նկարեք 2 -րդ նկարը. 3 -րդ կարգավորում

1 -ի պարամետրում մենք չենք օգտագործել i- ն և j- ը `ազդելու յուրաքանչյուր տարրի պտտման անկյունի վրա: Այսպիսով, մենք կարող ենք տեսնել, որ յուրաքանչյուր տարրի շարժումը նույնն է: 2 -ի պարամետրերում մենք օգտագործել ենք i արժեքը, իսկ i- ն և j- ն ՝ 3. -ում: Վերջապես, նրանք ազդել են գործակից sin- ի հարաբերակցության միջոցով պարամետրերի մուտքագրման վրա: Սա փոխել է անկյունի պարբերական փոփոխությունը: 2 -ի և 3 -ի տեղադրման իրական ազդեցության պատճառով անիմացիոն գրաֆիկայում այնքան էլ ակնհայտ չէ, մենք կարող ենք դա դիտել հետևյալ սքրինշոթից:

Նկար 2 -րդ նկարը (ձախ ՝ կարգավորումը 2, աջը ՝ կարգավորումը 3)

Նկար 3 -րդ նկարը (ձախ ՝ կարգավորումը 2, աջը ՝ կարգավորումը 3)

Առաջին նկարում հարաբերակցությունը օգտագործվում է քառակուսի պտտման անկյունի վրա ազդելու համար: Մինչ երկրորդ նկարը, այն պետք է ուղղակիորեն վերահսկել շրջանագծի շառավիղը: Մենք տեսնում ենք, որ այն օգտագործել է i value նախադասությունը.

բոց հարաբերակցություն = i/7.0;

Նրա ուղղաձիգ տարրի փոփոխությունը հետևողական է: Քանի որ պատկերը վերահսկող հորիզոնական կոորդինատը կախված է միայն i- ի արժեքից, ուստի նույն հորիզոնական կոորդինատով գծերը նույնը կլինեն: Հարաբերակցության, պտույտի անկյունի և շրջանագծի շառավիղի արժեքը նույնպես նույնն է:

Միևնույն ժամանակ, մենք օգտագործում ենք i, j նախադասությունը.

բոց հարաբերակցություն = (i * 7 + j) /49.0;

Այն կարող է նկարագրել «գրադիենտ»: Այստեղ գործոնը բազմապատկելու մեթոդով այն համադրել է տողերի և սյուների ազդեցությունը: Այսպիսով, յուրաքանչյուր տարր տարբեր է:

Քայլ 7: Մինչև օղակը

Օղակի համար կա եղբայր: Դա, իսկ loop- ը: Այն, ինչ loop- ի համար կարող է անել, մինչդեռ loop- ը նույնպես կարող է դա անել: Սակայն creativeCoding- ում while loop- ի հաճախականությունը այնքան մեծ չէ, որքան loop- ի համար:

Կոդի օրինակ (5-14). [CceN_cpp theme = "dawn"] void setup () {

int a = 0;

մինչդեռ (ա <10) {

println (a);

ա ++;

}

} [/cceN_cpp]

While- ի քերականական կառուցվածքը ավելի հեշտ է հասկանալ, քան դրա համար: Մենք կարող ենք փոփոխականներ ստեղծել մինչ while հայտարարությունը: Այնուհետև լրացրեք արտահայտություն քառակուսի փակագծում: Երբ այն բավարարվում է, ապա գործածիր նախադասությունները հանգույցի ներսում: Վերջապես, մենք արտահայտություն ենք դնում օղակի մարմնում ՝ փոփոխականները թարմացնելու համար, այնուհետև, երբ օղակն ավարտված է: Ինչ վերաբերում է ապահովված հանգույցի ժամանակներին, մենք հաճախ օգտագործում ենք հանգույցի համար: Ինչ վերաբերում է անորոշ փոփոխականի արժեքին, խորհուրդ ենք տալիս օգտագործել while loop- ում:

Մտածեք

Փորձեք օգտագործել բոլոր տեսակի հիմնական տարրերը, որոնք փոխարինում են loop- ի գծապատկերային տարրերը `տարբեր տարբեր խոզանակներ ստեղծելու համար:

Համակցեք վերջին գլխում նշված եռանկյունաչափական ֆունկցիայի հետ, փորձեք վերանայել «ցրման կետեր» վրձինը կլոր ձևի խոզանակի մեջ:

Փորձեք կատարել երկչափ կետային մատրիցա միայն for loop- ով:

Հաջորդ գլխի նախադիտում Ինչպես այս դասընթացին, այնպես էլ դուք կգտնեք ձեր սովորած յուրաքանչյուր նոր գիտելիք, խաղալու հնարավորությունը միանգամից շատ կբարձրանա: Isրագիրը պանդորայի արկղ է: Այն ամենը, ինչ դուք կարող եք պատկերացնել, կարող է դա անել ձեզ համար: Այսպիսով, ոչ մի պատճառ չկա, որ մենք չսովորենք այս լեզուն, որը կարող է հաղորդակցվել համակարգիչների հետ: Մեր հաջորդ գլխում մենք ձեզ կներկայացնենք գործընթացի վերահսկման մեկ այլ հայտարարություն: Այն կարող է վերահսկել գործընթացի հոսքը և առաջացնել ավելի բարդ և փոփոխական արդյունքներ: If հայտարարությամբ դուք կարող եք հեշտությամբ ստեղծել ձեր սեփական տեքստային արկածային խաղերը: Այս հոդվածը գալիս է դիզայներ Wenzy- ից: Հարաբերական ընթերցումներ. Հետաքրքիր ծրագրավորման ուղեցույց դիզայների համար. Նախնական հպում մշակելը: Հետաքրքիր ծրագրավորման ուղեցույց դիզայների համար. Ստեղծեք ձեր առաջին մշակման ծրագիրը: - Ստացեք ձեր նկարը վազող (առաջին մաս) Programրագրավորման հետաքրքիր ուղեցույց դիզայների համար - Ստացեք ձեր նկարը վազող (երկրորդ մաս)

Քայլ 8: Աղբյուր

Այս հոդվածը ՝ https://www.elecfreaks.com/11037.html կայքից է

Եթե ունեք հարցեր, կարող եք կապվել ： [email protected].