დიზაინერისათვის საინტერესო პროგრამირების სახელმძღვანელო-პროგრამის პროცესის კონტროლი-მარყუჟის განცხადება: 8 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:21

პროგრამის პროცესის კონტროლი- მარყუჟის განცხადება

ამ თავში თქვენ დაუკავშირდებით მნიშვნელოვან და ძლიერ ცოდნის პუნქტს-მარყუჟს.

ამ თავის წაკითხვამდე, თუ გსურთ პროგრამაში 10 000 წრის დახაზვა, ამის გაკეთება მხოლოდ საშინელი მეთოდით შეგიძლიათ. ეს არის ელიფსის კოდის 10 000 ხაზის დაწერა. ის ზარმაცი კოდის დიზაინერები, რომელთაც სურთ ეფექტურობის გაუმჯობესება ყოველმხრივ, ნამდვილად არ დაუშვებენ ამას. ასე რომ, მარყუჟის განცხადება იქმნება. ამ განცხადებით, თქვენ შეგიძლიათ ინტუიციურად იგრძნოთ კომპიუტერის ავტომატიზაციის ძალა.

ნაბიჯი 1: მარყუჟისთვის

არსებობს უამრავი მარყუჟის განცხადება, რომელთა შორის ყველაზე ფართოდ გამოიყენება For Loop. ჩვენ ყველამ ვიცით, რომ ფუნქციის გათამაშება განუწყვეტლივ მოქმედებს მიმოქცევაში. დაიწყეთ პირველი წინადადებიდან დასაწყისში, ის განხორციელდება ზემოდან ქვემომდე ბოლო წინადადებამდე. ოპერაციის დასრულების შემდეგ, ის კვლავ დაიწყება პირველი წინადადებიდან. იყიდება განცხადება ცოტა მსგავსი ფუნქციის გათამაშება. განცხადების შიგნით კოდი შეიძლება განმეორებით შესრულდეს.

აქ არის მისი გრამატიკული სტრუქტურა:

იყიდება (გამოთქმა 1; გამოთქმა 2; გამოთქმა 3) {

მარყუჟის სხეული

}

ცხადია, წინადადებები მარყუჟის შიგნით არის ის, რასაც ჩვენ ველოდით განმეორებით განხორციელებას. გამოთქმა 1 გამოიყენება მარყუჟის ცვლადის პირველი მნიშვნელობის დასაწყებად და მინიჭებისთვის. გამოხატვა 2 არის მარყუჟის მდგომარეობისთვის. გამოთქმა 3 განაახლებს მარყუჟის ცვლად მნიშვნელობას.

რა არის მარყუჟის ცვლადი? ის ფაქტიურად უტოლდება ადგილობრივ ცვლადს. მოდით შევხედოთ სრულ ნაწერს.

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

მარყუჟის სხეული

}

მარყუჟის ფუნქციის რეალიზაციის მიზნით, განცხადება ძირითადად ეყრდნობა ადგილობრივ ცვლადს, რომელიც გამოყენებული იქნება მარყუჟის შეწყვეტისას. ზემოთ მოყვანილ მაგალითში ადგილობრივი ცვლადი არის i. გამოთქმა 1 -მა დაასრულა ლოკალური ცვლადის ინიციალიზაცია. მოგვიანებით, ყოველ ჯერზე, როდესაც მარყუჟი მუშაობს ერთხელ, ეს ცვლადი უნდა განახლდეს. ზემოთ მოყვანილ მაგალითს შორის, i ++ გამოხატვაში 3 გამოიყენება განახლების ფუნქციის განსახორციელებლად. მისი საშუალებით, ცვლადი გაიზრდება 1 ყოველ ჯერზე, როდესაც განახლდება. საბოლოო ჯამში, მარყუჟის სხეულში არსებული კოდი არ შეიძლება განუსაზღვრელი მარყუჟით, სხვაგან, როდესაც ეს უკანასკნელი განცხადებები არ შეიძლება შესრულდეს. ამრიგად, ჩვენ გვჭირდება ტერმინალური მდგომარეობა. ექსპრესი 2 მხოლოდ მისთვისაა. აქ, პროგრამა განსჯის მე ვარ 10 -ზე ნაკლები. თუ არის, მაშინ გააგრძელე ოპერაცია. თუ ეს ასე არ არის, მაშინ გადადით მარყუჟიდან.

ამრიგად, განაცხადის ოპერაციის თანმიმდევრობა სწორედ ასეთია.

გამოთქმა 1 (ლოკალური ცვლადის ინიციალიზაცია)

გამოთქმა 2 (კმაყოფილი, შემდეგ გააგრძელე მოქმედება)

მარყუჟის სხეული (პირველი მიმოქცევა)

გამოთქმა 3 (განახლება)

გამოთქმა 2 (კმაყოფილი, შემდეგ გააგრძელე მოქმედება)

მარყუჟის სხეული (მეორე წრე)

გამოთქმა 3 (განახლება)

გამოთქმა 2 (კმაყოფილი, შემდეგ გააგრძელე მოქმედება)

მარყუჟის სხეული (მესამე ტირაჟი)…

გამოთქმა 3 (განახლება)

გამოთქმა 2 (არ დაკმაყოფილდა, შემდეგ გადმოდი მარყუჟიდან)

თქვენ შეგიძლიათ რამდენჯერმე მოახდინოთ შესრულების ამ თანმიმდევრობის სიმულაცია თქვენს თავში. მაგრამ შეუძლებელია კოდის ნამდვილად გაგება ხელის ერთხელ დაწერის გარეშე. როდესაც ჩვენ გვინდა გავარკვიოთ უცნაური კონცეფცია, ჩვენ შეგვიძლია ამობეჭდოთ მნიშვნელობა კონსოლში println განცხადების საშუალებით.

კოდის მაგალითი (5-1): void setup () {

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

println ("გაშვება");

}

}

თქვენ შეგიძლიათ დაითვალოთ გაშვებული გამომუშავების რაოდენობა კონსოლში. აქ არის ზუსტად 10. ეს გეუბნებათ რამდენჯერ არის შესრულებული მარყუჟის კოდის კოდი. თუმცა, ჩვენ ჯერ კიდევ ვერ ვადგენთ რა ცვლილებები მოხდა რეალურად მარყუჟში. ჩვენ შეგვიძლია შევეცადოთ შეცვალოთ ხასიათი "გადავიდეთ ცვლადი" i " - ში და ვნახოთ რა მოხდება.

კოდის მაგალითი (5-2): void setup () {

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

println (i);

}

}

ახლა, ჩვენ ვხედავთ, რომ მარყუჟის სხეულში მნიშვნელობა მუდმივად იზრდება. მოგვიანებით, ჩვენ შეგვიძლია გამოვიყენოთ ეს მნიშვნელობა მარყუჟის მიმდინარე პროცესის გასაგებად.

კოდის მაგალითში (5-2), i მნიშვნელობა იცვლება 0-დან 9-მდე. რეალურ მარყუჟის დროთან შედარებით, როგორც ჩანს, მას ყოველთვის აქვს 1 ნაკლები. თუ თქვენ არ ხართ შეჩვეული მას, გამოთქმის ფრჩხილებში მოცემული განცხადება შეიძლება დაიწეროს შემდეგზე:

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

ამრიგად, მე სამართლიანად შეესაბამება მარყუჟის დროს. "<＝" - ის მნიშვნელობა ნაკლებია და ტოლია. როდესაც მე უდრის 10 -ს, ის მაინც აკმაყოფილებს პირობას. ამიტომ, ის იმოქმედებს ი <10 – ში ჩაწერილთან შედარებით. მიუხედავად იმისა, რომ ის იწყება 1 – დან, მარყუჟის დრო ჯერ კიდევ 10. რა თქმა უნდა, თუ განსაკუთრებული არაფერია საჭირო, მინდა შემოგთავაზოთ გამოიყენოთ წერის მეთოდი მაგალითი დასაწყისში. მოგვიანებით ჩვენ გაგაცნობთ ვექტორს ან მასივს, რომელიც ორივე მიიღებს მის ელემენტს მისი ხელმოწერით. და ნაგულისხმევი ხელმოწერები იწყება 0 -დან. საწყისი მნიშვნელობის 0 -ის დადგენა შედარებით ჩვეულებრივი პრაქტიკაა.

ზემოაღნიშნულ მაგალითში, თუ ჩვენ ვწერთ i- ს 0 -ს მიღმაა, pogram იქნება crash. იმის გამო, რომ ცვლადი მუდმივად იზრდება, ის არასოდეს დააკმაყოფილებს ამ პირობას. ეს იგივეა, რაც მისი შეჩერება შეუძლებელია, ისე რომ პროგრამა გაუთავებელ მარყუჟში გადადის.

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;

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

პასუხი += i;

}

println (პასუხი);

}

მე მჯერა, რომ შედეგი, რასაც თქვენ მიიღებთ, იგივეა, რაც გუასმა განაცხადა: ეს არის 5050!

რჩევები: ლოკალური ცვლადების სახელი მარყუჟში შეიძლება შეიცვალოს სურვილისამებრ იმ პირობით, რომ იგი იცავს ცვლადების დასახელების დებულებებს. თქვენ შეგიძლიათ ჩაწეროთ ის (int k = 1; k <= 100; k ++). თუ რაიმე კონკრეტული პირობა არ მოხდა, ის ნაგულისხმევია i, როგორც ცვლადის სახელი.

ნაბიჯი 3: მარყუჟის ნახაზისთვის

ერთი შეხედვით მოსაწყენი საწოლების შემდეგ, საბოლოოდ ჩვენ შეგვიძლია უფრო საინტერესო განყოფილებაში შევიდეთ. ეს არის მარყუჟის გამოყენება სურათების დახატვისთვის. ჩვენ შეგვიძლია ახლა გამოვყოთ ეს დამღლელი მათემატიკური გაანგარიშება. ჩვენ დიზაინერები უფრო მგრძნობიარენი ვართ გრაფიკის მიმართ.

გამოიყენეთ მარყუჟისათვის წრეების მასივის დახაზვისთვის

როდესაც ჩვენ გვსურს გამოვიყენოთ მარყუჟი განმეორებითი ელემენტების ჯგუფის წარმოსაჩენად, ჩვენ წინასწარ უნდა დავრწმუნდეთ ამ ელემენტების რიცხვით ნათესაობაში, შემდეგ ჩვენ შეგვიძლია გამოვიყენოთ მარყუჟი ამის მოხერხებულად გასაცნობად, მასიური განმეორებითი მუშაობის ნაცვლად. დავუშვათ, თუ გვსურს დავხატოთ ჰორიზონტალური მიმართულებით თანაბრად გაშლილი წრის რიგი. მისი ვირტუალური კოორდინატი უცვლელია, ხოლო მისი ჰორიზონტალური კოორდინატი იცვლება. მარცხნიდან მარჯვნივ, ჰორიზონტალური კოორდინატი მუდმივად იზრდება და მზარდი მანძილი იგივეა. ამ დროს, ჩვენ შეგვიძლია გამოვიყენოთ i in loop თითოეული წრის ჰორიზონტალური კოორდინატის მისაღებად.

კოდის მაგალითი (5-4): void setup () {

ზომა (700, 700);

ფონი (83, 51, 194);

noStroke ();

}

ბათილად გათამაშება () {

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

ელიფსი (50.0 + i * 100.0, სიმაღლე/2.0, 80.0, 80.0);

}

}

50 ნიშნავს პირველი წრის დაწყების პოზიციას მარცხნივ. 100 i * 100 – ში წარმოადგენს გაზრდილ მანძილს.

ნაბიჯი 4: გამოიყენეთ მარყუჟისთვის შემთხვევითი მრგვალი წერტილის დასახატად

ზემოთ მოყვანილი გრაფიკული პოზიცია პროგნოზირებადია. ეს შეამცირებს უამრავ ინტერესს. ჩვენ შეგვიძლია გამოვიყენოთ წინა თავში მითითებული შემთხვევითი ფუნქცია და შევეცადოთ დავწეროთ იგი ნახაზის ფუნქციაში.

კოდის მაგალითი (5-5):

void setup () {

ზომა (700, 700);

ფონი (0);

noStroke ();

}

ბათილად გათამაშება () {

ფონი (0);

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

float randomWidth = შემთხვევითი (60.0);

ელიფსი (შემთხვევითი (სიგანე), შემთხვევითი (სიმაღლე), შემთხვევითი სიგანე, შემთხვევითი სიგანე);

}

}

აქ, მიზეზი, რის გამოც წრის პოზიცია განუწყვეტლივ ციმციმებს, არის იმის გამო, რომ ყოველ ჯერზე შემთხვევითი ფუნქცია მოქმედებს ერთხელ, შედეგი არის შემთხვევითი. იმის გამო, რომ ფუნქციის გათამაშება ნაგულისხმევია 60 კადრი წამში გაშვებისთვის, ამიტომ წამში დახატული ყოველი 10 წრე შეცვლის მის პოზიციას 60 -ჯერ. ეს სწრაფი მოციმციმე სურათი აჩვენებს, რომ მას აქვს 10 წრეზე მეტი. პროგრამის მარტივი მნიშვნელობის შეცვლა სულ სხვა ეფექტს მოგიტანთ. ჩვენ შეგვიძლია შევცვალოთ მარყუჟის დრო ტერმინალური მდგომარეობის გადახედვით. ტერმინალური მდგომარეობა ქვემოთ მოცემულ სურათზე არის i <100

1. აქ არის ეფექტი, როდესაც ტერმინალური მდგომარეობა არის i <1000:
2. RandomSeed
3. თუ არ მინდა წრის პოზიცია შემთხვევით გენერირდეს ისევე როგორც მისი ბზინვა, რა ვქნა? ერთი მეთოდია თითოეული წრისთვის დამოუკიდებელი ცვლადების შექმნა და შენახვა და ამ ცვლადების ინიციალიზაცია კონფიგურაციაში. მიანიჭეთ ამ ცვლადებს შემთხვევითი მნიშვნელობა. ამრიგად, ნახაზის ფუნქციის გამოყენებისას გათამაშებაში, რასაც ჩვენ ვიძახებთ არის ცვლადებში შენახული მნიშვნელობა. ის არ შეიცვლება ნებისმიერ დროს. 10 წრის დასახატად შეგვიძლია უბრალოდ გამოვიყენოთ ეს მეთოდი. მაგრამ რა მოხდება, თუ გვინდა 1000 წრე დავხატოთ, ან 10 000 წრე? საკმაოდ პრობლემური იქნება, თუ ჩვენ გამოვიყენებთ ამ ტრადიციულ მეთოდს ამ ცვლადების შესაქმნელად და დავარქვით მას. ჩვენ არ უნდა ვისწავლოთ ცვალებადი აგების ახალი მეთოდი. აქ არის მოქნილი მეთოდი, რომელიც დაგვეხმარება ამ მიზნის მიღწევაში. ეს არის შემთხვევითი Seeed– ის გამოყენება. ახლა მოდით შევხედოთ მის ეფექტს გამოყენების შემდეგ. კოდის მაგალითი (5-6): [cceN_cpp theme = "dawn"] void setup () {size (700, 700); ფონი (0); noStroke ();}

4. ბათილად გათამაშება () {

   ფონი (0);

   შემთხვევითი თესლი (1);

   for (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 () {

   randomSeed (0);

   for (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);

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

   float randomWidth01 = შემთხვევითი (10, 60);

   ელიფსი (შემთხვევითი (სიგანე), შემთხვევითი (სიმაღლე), შემთხვევითი სიგანე 01, შემთხვევითი სიგანე 01);

   println (შემთხვევითი სიგანე 01);

   }

   შემთხვევითი თესლი (1);

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

   float randomWidth02 = შემთხვევითი (10, 60);

   ელიფსი (შემთხვევითი (სიგანე), შემთხვევითი (სიმაღლე), randomWidth02, randomWidth02);

   println (შემთხვევითი სიგანე 02);

   }

   } [/cceN_cpp]

   სცადეთ გადახედოთ მეორე randomSeed (1) შემთხვევით random (0) და შეადარეთ საბოლოო შედეგები.

   რჩევები: P5– ში ჩვენ უნდა გამოვიძახოთ noLoop ფუნქცია გათამაშების ბოლოს, რათა იგივე ეფექტი მივიღოთ. მისი ფუნქციაა პროგრამის დასრულება. იგი სრულიად განსხვავდება ზემოაღნიშნული მუშაობის პრინციპებისგან.

ნაბიჯი 5: გამოიყენეთ მარყუჟისთვის ხაზის დახაზვისთვის

მას შემდეგ რაც დავისწავლეთ randomSeed– ის გამოყენება, ჩვენ შეგვიძლია შევეცადოთ შევცვალოთ ხატვის ფუნქცია. მაგალითად, შეცვალეთ წრის ნახაზი ხაზოვან ნახატად. მხოლოდ იმ შემთხვევაში, თუ ჩვენ შევიმუშავებთ რამდენიმე ცვალებად რეგლამენტს ხაზის ბოლომდე, ჩვენ შეგვიძლია გამოვიყენოთ ბევრი ხაზი ერთმანეთში გადახლართული უნიკალური ნიმუშის შესაქმნელად.

კოდის მაგალითი (5-9):

[cceN_cpp theme = "გამთენიისას"] ბათილად დაყენება () {

ზომა (700, 700);

ფონი (0);

}

ბათილად გათამაშება () {

randomSeed (0);

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

float 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 ();

}

ბათილად გათამაშება () {

for (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 ();

}

ბათილად გათამაშება () {

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

float თანაფარდობა = 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 ისევ for for loop. როდესაც თქვენ გჭირდებათ ორგანზომილებიანი წერტილოვანი მატრიცის დახაზვა, შეგიძლიათ აირჩიოთ ეს მეთოდი.

კოდის მაგალითი (5-12):

[cceN_cpp theme = "გამთენიისას"] ბათილად დაყენება () {

ზომა (700, 700, P2D);

ფონი (202, 240, 107);

}

ბათილად გათამაშება () {

შევსება (0);

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

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

float x = 150 + i * 100;

float y = 150 + j * 100;

ელიფსი (x, y, 60, 60);

println (i + ":" + j);

}

}

}

[/cceN_cpp]

ჩადგმული მარყუჟის პირველად გამოყენებისათვის, თქვენ უნდა გაარკვიოთ მისი ლოგიკური ურთიერთობები. კოდის დანერგვა პროგრამაში ყოველთვის ხდება ქვემოდან ქვემოდან. ამიტომ, პირველი განხორციელებული ნამდვილად არის უკიდურესი მარყუჟი. ყოველ ჯერზე, როდესაც გარე მარყუჟი მუშაობს ერთხელ, შიდა მარყუჟი განუწყვეტლივ იმუშავებს მანამ, სანამ იგი ვეღარ დააკმაყოფილებს პირობას. ამის შემდეგ, ის დაიწყებს მეორე გარე მარყუჟის მუშაობას. მეორე ოპერაციის დაწყების შემდეგ, შიდა მარყუჟი გააგრძელებს განხორციელებას მანამ, სანამ ის ვერ დააკმაყოფილებს პირობას. ასეთ გამეორებას აკეთებს მანამ, სანამ ყველა პირობა არ დაკმაყოფილდება და ის ამოხტება მარყუჟიდან.

ზემოაღნიშნულ კოდში, გარე მარყუჟის მარყუჟის სხეული სულ 5 -ჯერ მუშაობდა, ხოლო შიდა მარყუჟის მარყუჟის სხეული 25 -ჯერ. 25 -ჯერ, i, j მნიშვნელობის სხვაობის მიხედვით, ჩვენ შეგვიძლია დავარწმუნოთ წრის ჰორიზონტალური და ვერტიკალური კოორდინატები ცალკე. მე ჩავრთე ბეჭდვის ნაწილი, თქვენ შეგიძლიათ დააკვირდეთ მონაცემების გამომუშავებას და იფიქროთ მის შეცვლაზე. მხოლოდ ორი წყობილი მარყუჟით, ჩვენ შეგვიძლია განვიცადოთ i, j მონაცემების ყველა კომბინაცია.

Რჩევები

მეორე ფენის მარყუჟისთვის, ჩვეულებრივ, კონდენსირდება Tab– ით დასაწყისში. ამან შეიძლება კოდის სტრუქტურა უფრო ნათელი გახადოს. თქვენ უნდა დაასახელოთ ლოკალური ცვლადები for მარყუჟის ორ ფენაში განსხვავებული სახელებით. მათ შორის "ი", "ჯ", "კ" ყველაზე ხშირად გამოიყენება.

მოქნილი გამოყენება "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);

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

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

pushMatrix ();

თარგმნა (50 + i * 100, 50 + j * 100);

// დაყენება 1

// float angle = sin (millis ()/1000.0) * PI/2;

// დაყენება 2

// float თანაფარდობა = i/7.0;

// float angle = sin (millis ()/1000.0 + ratio * (PI/2)) * PI/2;

// დაყენება 3

float თანაფარდობა = (i * 7 + j) /49.0;

float angle = sin (millis ()/1000.0 + ratio * (PI/2)) * PI/2;

როტაცია (კუთხე);

rectMode (ცენტრი);

// დახაზეთ სურათი 1

სწორი (0, 0, 80, 80);

// დახაზეთ სურათი 2

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

// დახაზეთ სურათი 3

// rect (0, 0, თანაფარდობა * 50);

popMatrix ();

}

}

} [/cceN_cpp]

კოდის ახსნა

rectMode- ს (CENTER) შეუძლია შეცვალოს კვადრატის ხატვის მეთოდი. სწორი ნაწილის ორი წინა პარამეტრი გამოიყენება სკაურის მარცხენა ზედა კუთხის კოორდინატის დასადგენად. ამ ბრძანების დაწყების შემდეგ, ეს ორი პარამეტრი გამოყენებული იქნება კვადრატული ცენტრალური წერტილის კოორდინატის დასადგენად.ვინაიდან აქ ჩვენ ვმუშაობთ მამის როტაციაზე ბრუნვის გზით, ამიტომ ჩვენ უნდა გამოვიყენოთ ეს მეთოდი ცენტრალური წერტილის კოორდინატის თავდაპირველ წერტილზე დასახატად.

millis () იძენს დროს პროგრამის დაწყებიდან დღემდე. ერთეული არის ms. ეს მნიშვნელობა გავლენას მოახდენს ცოდვის გამომავალი მნიშვნელობის შეცვლის სიჩქარეზე. თუ პირდაპირ ვწერთ მილის, ცვალებადი მასშტაბი ძალიან დიდია. ამრიგად, ჩვენ უნდა გავყოთ იგი 1000.0 -ზე.

კოდის ამ ნაწილში ჩვენ ვიყენებთ კომენტარის სიმბოლოს "//" რამდენიმე პარამეტრის დასამალად. თქვენ შეგიძლიათ შეცვალოთ ეფექტები დაწყებით ან დახურვით. მაგალითად, თუ ჩვენ ვიწყებთ წინადადებებს "3 -ის დაყენების" მიღმა, ჩვენ უნდა გამოვიყენოთ კომენტარის სიმბოლო კოდების ბლოკების დახურვისთვის "Setting 1" და "Setting 2". რაც შეეხება მსგავსი პროგრამის სტრუქტურის მაგალითებს სხვადასხვა ადგილობრივი ცვლადებით, ჩვენ შეგვიძლია დავწეროთ ამ ფორმატში. ამრიგად, ჩვენ არ გვჭირდება რამდენიმე საინჟინრო დოკუმენტის ცალკე შენახვა. ჩვენ შეგვიძლია გამოვიყენოთ ეს უნარი ხშირად პრაქტიკის და შექმნის დროს და შევინარჩუნოთ დამაკმაყოფილებელი პარამეტრების პარამეტრები.

მათ შორის, i, j მნიშვნელობის გავლენა პროგრამაზე ძირითადად წარმოდგენილია გადაადგილებით "Setting 1 (Setting 2) (Setting 3)". თქვენ შეგიძლიათ შეადაროთ გამომავალი შედეგები ქვემოთ.

დახაზეთ სურათი 1: პარამეტრი 1

დახაზეთ სურათი 1: პარამეტრი 2

დახაზეთ სურათი 1: პარამეტრი 3

დახაზეთ სურათი 2: პარამეტრი 1

დახაზეთ სურათი 2: პარამეტრი 2

დახაზეთ სურათი 2: პარამეტრი 3

პარამეტრ 1 -ში ჩვენ არ გამოვიყენეთ i და j თითოეული ელემენტის ბრუნვის კუთხეზე გავლენის მოხდენისთვის. ამრიგად, ჩვენ ვხედავთ, რომ ყველა ელემენტის მოძრაობა ერთნაირია. მე –2 პარამეტრში ჩვენ ვიყენებთ i მნიშვნელობას და i და j მნიშვნელობას 3. საბოლოოდ მათ გავლენა მოახდინეს ფუნქციის ცოდნის შეყვანაზე თანაფარდობით. ამან შეცვალა კუთხის პერიოდული ცვლილება. იმის გამო, რომ ფაქტობრივი ეფექტის დაყენება 2 და პარამეტრი 3 არც ისე აშკარაა ანიმაციურ გრაფიკაში, ჩვენ შეგვიძლია დავაკვირდეთ მას შემდეგი ეკრანის სურათიდან.

დახაზეთ სურათი 2 (მარცხნივ: 2 დაყენება; მარჯვნივ: 3)

დახაზეთ სურათი 3 (მარცხნივ: პარამეტრი 2; მარჯვნივ: 3 დაყენება)

პირველ სურათზე თანაფარდობა გამოიყენება კვადრატული ბრუნვის კუთხეზე ზემოქმედებისათვის. მეორე სურათის მიუხედავად, ის აკონტროლებს წრის რადიუსს პირდაპირ. ჩვენ ვხედავთ, რომ მან გამოიყენა i value წინადადება:

float თანაფარდობა = i/7.0;

მისი ვერტიკალური ელემენტის ცვლილება თანმიმდევრულია. იმის გამო, რომ სურათის კონტროლის ჰორიზონტალური კოორდინატი მხოლოდ i- ის მნიშვნელობაზეა დამოკიდებული, ამიტომ ერთი და იგივე ჰორიზონტალური კოორდინატის პატერმები იგივე იქნება. თანაფარდობის, ბრუნვის კუთხისა და წრის რადიუსიც იგივეა.

ამავე დროს, ჩვენ ვიყენებთ i, j წინადადებას:

float თანაფარდობა = (i * 7 + j) /49.0;

მას შეუძლია აღწეროს "გრადიენტი". აქ, ფაქტორის გამრავლების მეთოდით, მან გააერთიანა რიგების და სვეტების გავლენა. ასე რომ, თითოეული ელემენტი განსხვავებულია.

ნაბიჯი 7: მარყუჟის დროს

არსებობს ძმა მარყუჟისთვის. ეს არის ხოლო მარყუჟი. რისი გაკეთება შეუძლია მარყუჟს, ხოლო მარყუჟს ასევე შეუძლია. ხოლო შემოქმედებითი კოდირებისას while მარყუჟის გამოყენების სიხშირე არ არის მაღალი როგორც მარყუჟისთვის.

კოდის მაგალითი (5-14): [cceN_cpp theme = "dawn"] void setup () {

int a = 0;

ხოლო (a <10) {

println (a);

a ++;

}

} [/cceN_cpp]

გრამატიკული სტრუქტურა უფრო ადვილი გასაგებია ვიდრე ამისთვის. ჩვენ შეგვიძლია შევქმნათ ცვლადები სანამ შემდეგ შეავსეთ გამოთქმა კვადრატულ ფრჩხილში. როდესაც ის დაკმაყოფილდება, მაშინ გამოიყენეთ წინადადებები მარყუჟის სხეულში. დაბოლოს, ჩვენ ვდებთ გამოხატულებას მარყუჟის სხეულში ცვლადების განახლებისთვის, ხოლო სანამ მარყუჟი დასრულდება. რაც შეეხება გარანტირებულ მარყუჟს, ჩვენ ხშირად ვიყენებთ მარყუჟისთვის. რაც შეეხება განუსაზღვრელ ცვლად მნიშვნელობას, ჩვენ გირჩევთ გამოიყენოთ მარყუჟის while.

დაფიქრდი:

შეეცადეთ გამოიყენოთ ყველა სახის ძირითადი ელემენტი, რომ შეცვალოთ ხატვის ელემენტები მარყუჟში, რათა შექმნათ სხვადასხვა ჯაგრისები.

შეუთავსეთ ტრიგონომეტრიულ ფუნქციას, რომელიც მითითებულია ბოლო თავში, შეეცადეთ გადახედოთ ფუნჯს "მიმოფანტული წერტილების" მრგვალი ფორმის ფუნჯად.

შეეცადეთ შექმნათ ორგანზომილებიანი წერტილოვანი მატრიცა მხოლოდ მარყუჟისთვის for.

შემდეგი თავი გადახედვა ამ კურსის მსგავსად, თქვენ ნახავთ ყველა ახალ ცოდნას, რომელსაც ისწავლით, თამაშის შესაძლებლობა მაშინვე მნიშვნელოვნად გაიზრდება. პროგრამა არის პანდორას ყუთი. ყველაფერი, რისი წარმოდგენაც შეგიძლიათ, მას შეუძლია გააკეთოს თქვენთვის. ასე რომ, არ არსებობს მიზეზი იმისა, რომ ჩვენ არ ვისწავლოთ ეს ენა, რომელსაც შეუძლია კომპიუტერებთან ურთიერთობა. მომდევნო თავში ჩვენ შემოგთავაზებთ პროცესის კონტროლის სხვა განცხადებას. მას შეუძლია გააკონტროლოს პროცესის ნაკადი და გამოიწვიოს უფრო რთული და ცვალებადი შედეგები. If განცხადებით, თქვენ შეგიძლიათ მარტივად შექმნათ თქვენი საკუთარი ტექსტური სათავგადასავლო თამაშები! ეს სტატია მოდის დიზაინერი Wenzy– დან. შედარებითი საკითხავი: საინტერესო პროგრამირების სახელმძღვანელო დიზაინერისთვის-საწყისი შეხების დამუშავება დიზაინერისათვის საინტერესო პროგრამირების სახელმძღვანელო-შექმენით თქვენი პირველი დამუშავების პროგრამა საინტერესო პროგრამირების სახელმძღვანელო დიზაინერისთვის - მიიღეთ თქვენი სურათის გაშვება (ნაწილი პირველი) პროგრამირების საინტერესო სახელმძღვანელო დიზაინერისთვის - მიიღეთ თქვენი სურათის გაშვება (მეორე ნაწილი)

ნაბიჯი 8: წყარო

ეს სტატია არის:

თუ თქვენ გაქვთ რაიმე შეკითხვა, შეგიძლიათ დაუკავშირდეთ ： [email protected].