[Powered by Google Translate] Tommy MACWILLIAM: ვისაუბროთ იმაზე მარყუჟების, ერთი საერთო
პროგრამირების აშენებს ვნახავთ მთელ CS50.
ჩვენ ვიყენებთ მარყუჟების, როდესაც ჩვენ გვინდა, რომ შეასრულოს
ამოცანა მეტი ერთხელ.
მაგალითად, ჩვენ დაგვჭირდება ბეჭდვა "hi" 100 ჯერ ან ბეჭდვითი
ყველა ასო ანბანი.
ორივე ამ შემთხვევაში, ჩვენ გვაქვს ერთი რამ ჩვენ გვსურს რომ
რამდენჯერმე, ბეჭდვა რაღაც გარეთ.
თუმცა, რაც ჩვენ ამობეჭდოთ ყოველ ჯერზე შეიძლება იცვლებოდეს.
ასე რომ ჩვენ შეგვიძლია გავაკეთოთ რაღაც ოდნავ განსხვავებული თითოეულ
iteration, ან აწარმოებს გავლით, საქართველოში loop.
ჩვენ დავინახავთ, სამი სხვადასხვა ტიპის მარყუჟების დო, ხოლო
მარყუჟების, ამისთვის მარყუჟების, და ნუ ხოლო მარყუჟების.
თუმცა ამ სამი სახის მარყუჟების აქვს სხვადასხვა სინტაქსი,
იდეები მათ უკან არის იგივე.
ჩვენ განსაზღვრავს ზოგიერთი ბლოკის კოდი ფარგლებში Curly braces,
მოუწოდა ორგანოს მარყუჟი, რომ ჩვენ გვინდა შესრულდება
ზოგიერთი რამდენჯერმე.
შეცვლით ღირებულებებს ცვლადები გამოიყენება სხეულის, ჩვენ
შეუძლია ჩვენი loop რაღაც განსხვავებული ყოველ ჯერზე ის აწარმოებს.
ნებისმიერ loop ჩვენ წერენ, ჩვენ ასევე უნდა გადაწყვიტოს, როდესაც
loop შეწყდება გაშვებული.
თუ ჩვენ არ გავაკეთებთ, მაშინ ჩვენი სანდო კომპიუტერი გაგრძელდება
გასაშვებად, რომ მარყუჟი სანამ ჩვენ მოკვლა პროგრამა.
In Scratch, შეიძლება გამოიყენოთ განმეორებითი N ჯერ
ბლოკირება შექმნათ loop.
ყველა დარტყმები შიგნით ბლოკი რომ განაცხადა განმეორებითი 10
იქნებოდა აწარმოებს 10 ჯერ.
და მაშინ ჩვენ ავღნიშნო გადაადგილება, რათა დარტყმები შემდეგ რომ მარყუჟი.
ასე რომ ჩვენი გაჩერება მდგომარეობა იყო უბრალოდ, ამ ბლოკში უკვე
აწარმოებს 10 ჯერ.
მოდით ხელახლა ეს C. იმისათვის Scratch, რათა უზრუნველყოს
რომ დარტყმები ფარგლებში განმეორებითი ბლოკი სრულდება
ზუსტად 10 ჯერ, Scratch სჭირდება ტრეკზე ყოველი
აღსრულების განმეორებითი ბლოკი.
შენარჩუნება ტრეკზე რამდენჯერ ჩვენი loop ორგანოს უკვე
შესრულებული, მოდით შევქმნათ ცვლადში მე.
დავიწყოთ მე გამორთვას ნულოვანი, რადგან ჩვენი loop
არ იქნა აწარმოებს ამჟამად.
OK
ახლა ჩვენ ვიყენებთ ხოლო სიტყვით უნდა დაიწყოს off ჩვენი loop.
ახლა ჩვენ უნდა გაერკვნენ, როდესაც ჩვენი loop შეწყდება, თუმცა
მოდით დატოვეთ ეს ახლა და შემდეგ დაუბრუნდეს მას.
ყველა უფლება.
შიგნით ჩვენი მარყუჟის, მოდით უბრალოდ ბეჭდვა გაგზავნა გარეთ, ისევე როგორც
"Hi". ჩვენ შეგვიძლია გამოვიყენოთ printf ფუნქცია ამ.
ყველა უფლება.
ახლა ჩვენ ჩანაწერის iteration of loop ორგანოს აქვს
აღსრულებულა.
ჩვენ შეგვიძლია გავაკეთოთ, რომ დამატებით 1 ან დამატება, ჩვენი counter
ცვლადი, მე.
ამისათვის, ჩვენ შეგვიძლია ვთქვათ, მე უდრის მე პლუს 1 ან მეტი
უბრალოდ, მე Plus Plus.
დიდი.
ახლა ვხედავთ, რომ ყოველ ჯერზე ჩვენი მარყუჟი აწარმოებს, ჩვენი
Counter ცვლადი მიდის up ერთი.
ასე რომ, ჩვენ ვიცით ზუსტად რამდენი iterations ჩვენ აწარმოებს ჯერჯერობით.
შემდეგ ერთი iteration of მარყუჟის, ჩვენი ღირებულება
საქართველოს მე ვიქნები 1.
შემდეგ ორი iterations, მე ვიქნები 2.
ხოლო მას შემდეგ 10 iterations, მე ვიქნები 10.
ასე რომ, თუ ჩვენ გვინდა აწარმოებს ამ loop ზუსტად 10 ჯერ, მაშინ
ეს მაშინ, როცა ჩვენ გვინდა შეჩერება.
ასე რომ ჩვენ გვინდა აწარმოებს ამ loop ხოლო მე ნაკლებია 10, და
სწორედ ის, რაც ჩვენ გავხდით წერენ, ხოლო მე
ნაკლებია 10.
ეს მდგომარეობა გამოიყურება ისევე პირობებში ჩვენ გამოიყენება, თუ
სხვაგან ბლოკები.
შემდეგ სხეულის ჩვენი მარყუჟი უკვე შესრულებული, ჩვენი პროგრამა
იქნება ხტომა უკან მდე მარყუჟების მდგომარეობა.
თუ მდგომარეობა მართალია, მაშინ ორგანოს
loop იქნება აწარმოებს ერთხელ.
თუ მდგომარეობა აღარ არის მართალია, მაშინ ჩვენი loop არ იქნება
აწარმოებს უქმნით და გადავა შემდეგ ხაზი კოდი
ქვევმოთ ჩვენი loop.
ყველა უფლება.
მოდით შევხედოთ მეორე ტიპის
მარყუჟის, ამისთვის loop.
შემდეგი to ხოლო სიტყვით, ფრჩხილებში, გვქონდა ერთი რამ,
პირობით, რომ საჭიროა იყოს ეხება
loop ორგანოს უნდა აწარმოებს.
ანუ ჩვენ უნდა შევქმნათ ჩვენი Counter ცვლადი გარეთ
საქართველოს მარყუჟი და მახსოვს ნამატი ეს რაღაც მომენტში
შიგნით loop.
Header ჩვენი ამისთვის მარყუჟის, მეორეს მხრივ, აქვს სამი
ნაწილები, რომელთაგან თითოეული იქნება გამოყოფილი ერთად მძიმით.
ჩვენი პირველი მესამე, ჩვენ შეგვიძლია განაცხადოს ნებისმიერი Counter ან დამხმარე
ცვლადების ჩვენ გვინდა გამოვიყენოთ ჩვენს loop.
პრაქტიკაში, ეს შეიძლება იყოს მართლაც გამოგადგებათ.
ჩვენ ნამდვილად არ გვჭირდება, რომ ცვლადი, I, შემდეგ ჩვენი ხოლო
loop უკვე აწარმოებს, ამიტომ ჩვენ ნამდვილად არ უნდა გამოაცხადოს ის
გარეთ loop.
მეორე მესამე იქნება იმ პირობით, რომ უნდა იყოს ჭეშმარიტი
ამისთვის სხეულის შესრულდება კვლავ, ისევე, როგორც
ჩვენს ხოლო loop.
ჩვენი ბოლო მესამე, ჩვენ შეგვიძლია მას მოვთხოვოთ განცხადება, რომ იქნება
შემდეგ განხორციელებული თითოეული iteration of მარყუჟის, ამიტომ ჩვენ არ გვაქვს
ავაშენოთ იგი loop ორგანო.
მოდით დავწეროთ ამისთვის loop რომ ითვლის ქვემოთ 5 დან 1.
დავიწყოთ იმ სიტყვით.
ჩვენ შეგვიძლია შევქმნათ counter ცვლადი პირველი, რაც ჩვენ გამოგიგზავნით
მითითებული 5 ამჯერად რადგან ჩვენ დათვლის down,
მოჰყვა მძიმით.
შემდეგი არის ჩვენი მდგომარეობა, რომელიც ჩვენ დაბრუნდება.
მესამე, ჩვენ მინდა decrement ჩვენი Counter ცვლადი შემდეგ
ყოველ iteration of loop.
ასე რომ, ვიდრე ამბობდა მე Plus Plus, ჩვენ ვთქვა მინუს მინუს.
ყველა უფლება.
ასე რომ ჩვენ გვინდა loop ორგანო აწარმოებს, ხოლო მე ჯერ კიდევ
უფრო მეტი, ვიდრე 0.
სხეულში მარყუჟის, მოდით ამობეჭდოთ ღირებულება მე.
ამისათვის ჩვენ ვიყენებთ printf ფუნქცია გამოყენებით% d
placeholder.
გახსოვდეთ, რომ placeholder შეიცვლება
ღირებულება მე.
საბოლოოდ, მოდით დაამატოთ განაცხადი შემდეგ ჩვენი ამისთვის loop.
როდესაც ჩვენ აწარმოებს ამ მარყუჟის, დავიწყებ გამორთვას 5,
ასე 5 დაიბეჭდება.
ერთხელ იღებს 0, გაგრძელება მდგომარეობა, მე არის
უფრო მეტი, ვიდრე 0, აღარ გამართავს.
ასე რომ ჩვენი loop შეწყდება შესრულებაში, და ვნახავთ
განაცხადი შემდეგ loop.
მოდით აწარმოებს ამ კოდი.
პირველი, ჩვენ კომპილაციის
countdown.c ერთად მიიღოს countdown.
ახლა შეგვიძლია, აწარმოებს ამ კოდი ერთად. / Countdown.
ორივე ხოლო მარყუჟების და მარყუჟების, ჩვენი გაგრძელება
მდგომარეობა მოწმდება სანამ სხეული
საქართველოს loop ხორციელდება.
ეს იმას ნიშნავს, რომ, თუ ჩვენი მდგომარეობა არ არის თავდაპირველად
მართალია, მაშინ სხეულის ჩვენი loop არასოდეს აწარმოებს.
ასე რომ ხანდახან სასარგებლოა, რათა შეამოწმოს მდგომარეობა მას შემდეგ, რაც
ორგანოს loop ვიდრე ადრე იყო.
მოდით დავწეროთ loop უბიძგონ მომხმარებლის რიგი
სანამ პოზიტიური ხმების მიეწოდება.
თუ მომხმარებლის საშუალებებით უარყოფითი ნომერი, ჩვენ გვინდა ვთხოვოთ მათ
მეორე ნომერი.
ასე რომ ჩვენ გვინდა ამ სწრაფი იქნება შიგნით
სხეულის off loop.
თუმცა, როდესაც მარყუჟი აწარმოებს პირველად, მომხმარებლის
არ მოგვცა ხმების ამჟამად.
ასე რომ არ აქვს აზრი, რათა შეამოწმოთ, თუ ის დადებითია.
სამაგიეროდ, ჩვენ გვინდა, რომ შეამოწმოთ ნომერი შემდეგ ორგანოს
მარყუჟი აწარმოებს.
ჩვენ შეგვიძლია გავაკეთოთ ამ do ხოლო loop.
პირველი, ჩვენ დაგიმზადებთ ცვლადი, N, რომ გამართავს
მომხმარებლის შეყვანის.
ახლა ჩვენ ვიყენებთ do სიტყვით, რასაც მოჰყვა Curly braces რომ
დაიწყება off ორგანოს ჩვენი loop.
სხეულში, ჩვენ შეგვიძლია შეეკითხება მომხმარებელს ამისთვის ნომერი
GetInt ფუნქცია.
ახლა ჩვენ გვინდა ორგანო ამ loop შეასრულოს ერთხელ თუ
მომხმარებლის აკრეფილი უარყოფითი ნომერი, ამიტომ ჩვენ ვიტყვით, ხოლო n
ნაკლებია, ვიდრე 0.
გაითვალისწინეთ მძიმით აქ შემდეგ ხოლო განცხადებაში.
მოდით აწარმოებს ამ კოდი.
პირველი, ჩვენ შეადგინონ ამ გახადოს დადებითი.
ახლა ჩვენ შეგვიძლია მას მოვთხოვოთ პროგრამა. / დადებითი.
თუ ვაძლევთ ამ პროგრამის უარყოფითი ნომერი, როგორიც უარყოფითი
4, მაშინ ჩვენ უნდა აიძულა კვლავ ხმების წლიდან
მდგომარეობა ჩვენი do ხოლო loop იყო ჭეშმარიტი.
ერთხელ ვაძლევთ დადებითი ნომერი, როგორიც 8, მაშინ
მდგომარეობა ჩვენი do ხოლო loop აღარ იქნება ჭეშმარიტი.
ასე რომ მარყუჟი არ იქნება შესრულებული ერთხელ.
სწორედ ეს სამი ტიპის მარყუჟების ჩვენ გამოიყენონ C.
ჩემი სახელი არის ტომი, და ეს არის CS50.