[Powered by Google Translate] [მიმოხილვა] [Quiz 0]
>> [ძაან მაგარი Ross, ტომი MacWilliam, Lucas Freitas, ჯოზეფ Ong] [ჰარვარდის უნივერსიტეტის]
>> [ეს არის CS50.] [CS50.TV]
>> Hey, ყველას.
კეთილი იყოს განხილვის სხდომაზე Quiz 0, რომელსაც ადგილი ამ ოთხშაბათს.
რა ჩვენ ვაპირებთ ამაღამ, მე 3 სხვა TFs,
და ერთად ჩვენ ვაპირებთ გავლა მიმოხილვას, რაც ჩვენ გავაკეთეთ მსვლელობისას ჯერჯერობით.
ეს არ იქნება 100% სრულყოფილი, მაგრამ ეს უნდა გადმოგცეთ უკეთესი იდეა
თუ რა თქვენ უკვე გაქვთ ქვემოთ და რა თქვენ კვლავ უნდა შეისწავლოს ადრე ოთხშაბათი.
და მოგერიდებათ გაზარდოთ თქვენი მხრივ, კითხვები, როგორც ჩვენ ვაპირებთ გასწვრივ,
მაგრამ გახსოვდეთ, რომ ჩვენ ასევე გვაქვს ცოტა დრო დასასრულს-
თუ მივიღებთ მეშვეობით რამდენიმე წუთში სათადარიგო-გავაკეთოთ ზოგადი კითხვები,
გააგრძელეთ, რომ გონება, და ამიტომ ჩვენ ვაპირებთ იწყება იწყება კვირა 0.
>> [Quiz 0 მიმოხილვა] [Part 0] [ძაან მაგარი Ross] მაგრამ სანამ ჩვენ გავაკეთებთ, რომ ვისაუბროთ იმაზე
ლოგისტიკის ინტელექტუალური.
>> [ლოგისტიკის] [Quiz ხდება ოთხშაბათს 10/10 ნაცვლად ლექცია]
>> [(იხილეთ http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf დეტალებისთვის)] ეს ოთხშაბათს, 10 ოქტომბერს.
>> სწორედ ამ ოთხშაბათს, და თუ ამ URL აქ,
რაც ასევე ხელმისაწვდომი CS50.net-იქ ბმული it-
ხედავთ ინფორმაციას სად ეფუძნება
თქვენი გვარი ან სკოლის კუთვნილების ასევე
იგი მოგვითხრობს, თუ რა ინტელექტუალური დაფარავს და სახის კითხვებით, რომ თქვენ აპირებს მიიღოს.
გაითვალისწინეთ, რომ თქვენ ასევე აქვს შანსი რეცენზია Quiz ნაწილში,
ასე რომ თქვენი TFs უნდა აპირებს მეტი გარკვეული პრაქტიკის პრობლემები,
და ეს კიდევ ერთი კარგი შანსი, რომ ნახოთ სადაც თქვენ მაინც უნდა შეისწავლოს up for ვიქტორინა.
დავიწყოთ დასაწყისში ერთად Bits 'n' Bytes.
დამახსოვრება bit მხოლოდ 0 ან 1,
და byte არის კოლექცია 8 იმ ბიტი.
მოდით შევხედოთ ამ კოლექცია ბიტი უფლება აქ.
ჩვენ უნდა შეეძლოს გაერკვნენ რამდენი ბიტი არსებობს.
სადაც ჩვენ ითვლიან არსებობს მხოლოდ 8 მათგანი, რვა 0 ან 1 ერთეული.
და რადგან იქ 8 ბიტი, რომ 1 ნაწილად,
და მოდით კონვერტირება მას თექვსმეტობითი.
თექვსმეტობითი არის ბაზა 16, და ეს საკმაოდ ადვილი დააკონვერტიროთ
ნომერი ორობითი, რაც რომ არის, რომ ნომერი თექვსმეტობითი.
ყველა ვაკეთებთ არის შევხედავთ ჯგუფების 4,
და ჩვენ კონვერტირება მათ შესაბამისი თექვსმეტობითი ციფრი.
ჩვენ დავიწყებთ მარჯვენა საუკეთესო ჯგუფის 4, ამიტომ 0011.
რომ იქნება ერთი 1 და ერთი 2, ასე ერთად რომ აკეთებს 3.
და მაშინ მოდით შევხედოთ სხვა ბლოკი 4.
1101. რომ იქნება ერთი 1, ერთი 4, და ერთი 8.
ერთად რომ იქნება 13, რაც დ
და ჩვენ გვახსოვს, რომ თექვსმეტობითი ჩვენ არ უბრალოდ 0 მეშვეობით 9.
ჩვენ წავიდეთ 0 მეშვეობით F, ასე შემდეგ 9, 10 შეესაბამება,
11 დან B, et cetera, სადაც F არის 15.
აქ არის 13 D,
ასე გარდაქმნას იგი ათობითი ყველა ვაკეთებთ ჩვენ რეალურად
მკურნალობა თითოეული პოზიცია, როგორც ძალა 2.
სწორედ ერთ 1 ერთი 2, ნულოვანი 4S, ნულოვანი 8S, ერთი 16, et cetera,
და ეს პატარა მძიმე გამოთვლაც თქვენს უფროსს, მაგრამ თუ ჩვენ გადასვლა შემდეგ slide
ვხედავთ პასუხი რომ.
>> არსებითად ჩვენ ვაპირებთ მოპირდაპირე უფლება უკან მარცხნივ,
და ჩვენ გამრავლებით თითოეული ციფრი შესაბამისი ძალა 2.
და მახსოვს, ამისთვის თექვსმეტობითი ჩვენ აღინიშნოს ამ ნომრები 0x დასაწყისში
ასე რომ, ჩვენ არ აღრეული შინაარსობრივი თვალსაზრისით, ათობითი რიცხვი.
გაგრძელებით, ეს ASCII მაგიდა,
და რა ჩვენ ვიყენებთ ASCII ამისთვის არის MAP-დან პერსონაჟს რიცხვითი ღირებულებებს.
მახსოვს კრიპტოგრაფიის pset მივიღეთ ფართო გამოყენების ASCII მაგიდა
რათა სხვადასხვა მეთოდების გამოყენება კრიპტოგრაფიის,
Caesar და Vigenère cipher, გადაიყვანოთ სხვადასხვა წერილებს
in string მიხედვით გასაღები მოცემული მომხმარებლის მიერ.
მოდით შევხედოთ ცოტა ASCII მათემატიკის.
ეძებს 'P' + 1, ხასიათს ფორმა იქნებოდა Q,
და გვახსოვდეს, რომ '5 '≠ 5.
და როგორ ზუსტად რომ ჩვენ დააკონვერტიროთ შორის 2 ფორმები?
ეს არ არის რეალურად ძალიან ძნელი.
იმისათვის, რომ მიიღოთ 5 ჩვენ სხვაობა '0 '
რადგან არსებობს 5 ადგილებში შორის '0 'და '5'.
იმისათვის, რომ წავიდეს სხვა გზა ჩვენ უბრალოდ დაამატოთ 0,
ამიტომ სახის მოსწონს რეგულარული არითმეტიკული.
უბრალოდ გვახსოვდეს, რომ როცა რაიმე აქვს შეთავაზებები გარშემო ის ხასიათი
და ამით შეესაბამება ღირებულების ASCII მაგიდასთან.
მოძრავი შევიდა უფრო ზოგადი კომპიუტერულ მეცნიერებათა თემები.
ჩვენ გავიგეთ რა არის ალგორითმი და როგორ ვიყენებთ პროგრამირების
განახორციელოს ალგორითმები.
მაგალითები ალგორითმები მართლაც რაღაც მარტივი მოსწონს
შემოწმების თუ არა რიცხვი კი ან უცნაური.
ამისათვის ჩვენ გვახსოვს mod ნომერი მიერ 2 და შეამოწმოთ, თუ შედეგი არის 0.
თუ ასეა, ეს კი. თუ არა, ეს უცნაური.
და ეს მაგალითი ნამდვილად ძირითადი ალგორითმი.
>> ცოტა მეტი ჩართული ერთი არის ორობითი ძებნა,
რაც ჩვენ წავიდეთ მეტი მოგვიანებით საანგარიშო სხდომამდე.
და პროგრამირების არის ტერმინი ჩვენ ვიყენებთ აღების ალგორითმი
და კონვერტაცია მას კოდი კომპიუტერი წაიკითხოს.
2 მაგალითები პროგრამირების არის Scratch,
რაც ჩვენ გააკეთა კვირა 0.
მიუხედავად იმისა, რომ ჩვენ არ რეალურად აკრიფოთ გარეთ კოდი ეს გზა განხორციელების
ეს ალგორითმი, რომელიც დაბეჭდვის ნომრები 1-10,
და აქ ჩვენ გავაკეთებთ იგივეს C პროგრამირების ენაზე.
ეს არის ფუნქციურად ექვივალენტური, მხოლოდ წერილობითი სხვადასხვა ენებზე ან სინტაქსი.
ჩვენ მაშინ შეიტყო ლოგიკური გამოთქმები,
და ლოგიკური არის ღირებულება, რომელიც არის ან ნამდვილი ან ყალბი,
და აქ oftentimes ლოგიკური გამონათქვამები
წასვლა შიგნით პირობები ასე რომ, თუ (x ≤ 5),
ასევე, ჩვენ უკვე მითითებული x = 5, ასე რომ მდგომარეობა აპირებს შეაფასოს ჭეშმარიტი.
და თუ ეს ასეა, რასაც კოდი არის ქვეშ მდგომარეობა
აპირებს შეფასდება კომპიუტერი, ასე, რომ სიმებიანი აპირებს დაიბეჭდება
სტანდარტულ output, და ტერმინი მდგომარეობა
ეხება რაც შიგნით ფრჩხილებში of თუ განცხადებაში.
დამახსოვრება ყველა ოპერატორები.
დამახსოვრება მისი && და | | როდესაც ჩვენ ვცდილობთ დააკავშიროთ 2 ან მეტი პირობები,
== არ = რათა შეამოწმოს თუ არა 2 რამ თანაბარი.
გახსოვდეთ, რომ = არის დავალება ხოლო == არის ლოგიკური ოპერატორი.
≤, ≥ და შემდეგ საბოლოო 2 are თვითმმართველობის განმარტებითი.
ზოგადი მიმოხილვა ლოგიკური ლოგიკა აქ.
და ლოგიკური გამონათქვამები ასევე მნიშვნელოვანია მარყუჟების,
რაც ჩვენ წავიდეთ მეტი არის.
ჩვენ შეიტყო 3 სახის მარყუჟების ამ დრომდე CS50, ამისთვის, ხოლო, და ნუ ხოლო.
და მნიშვნელოვანია იცოდეს, რომ სანამ ყველაზე მიზნებისათვის
ჩვენ შეგვიძლია რეალურად გამოიყენოს ნებისმიერი ტიპის loop ზოგადად
არსებობს გარკვეული სახის მიზნებისათვის ან საერთო თარგების
პროგრამირებაში რომ კონკრეტულად მოვუწოდებთ ერთი ამ მარყუჟების
რომ ეს ყველაზე ეფექტური ან ელეგანტური, რათა კოდექსის ის, რომ გზა.
მოდით წავიდეთ მეტი რა თითოეულ ამ მარყუჟების tends გამოიყენება ყველაზე ხშირად.
>> In for loop ჩვენ ზოგადად უკვე ვიცით რამდენჯერ გვინდა iterate.
რაც ჩვენ პირობებში.
ამისთვის, i = 0, I <10, მაგალითად.
ჩვენ უკვე კარგად ვიცით, რომ ჩვენ გვინდა რაღაც 10 ჯერ.
ახლა, ცოტა ხნით მარყუჟის, ზოგადად ჩვენ არ ემთხვეოდეს
ვიცი რამდენჯერ გვინდა loop გასაშვებად.
მაგრამ ჩვენ ვიცით, გარკვეული პირობით, რომ ჩვენ გვსურს
ყოველთვის იყოს ჭეშმარიტი ან ყოველთვის იქნება ყალბი.
მაგალითად, მაშინ, როდესაც არ არის მითითებული.
ვთქვათ რომ ლოგიკური ცვლადი.
მიუხედავად იმისა, რომ მართალია ჩვენ გვინდა კოდი შესაფასებლად,
ასე ცოტა მეტი გააფართოვოთ, ცოტა უფრო ზოგადი ვიდრე ამისთვის მარყუჟის,
მაგრამ ნებისმიერი ამისთვის loop ასევე შეიძლება მოაქცია ხოლო loop.
საბოლოოდ, ნუ ხოლო მარყუჟების, რომელიც შეიძლება trickiest აღქმა დაუყოვნებლივ,
ხშირად გამოიყენება, როდესაც ჩვენ გვინდა შევაფასოთ კოდი პირველი
სანამ პირველად ჩვენ შეამოწმოს მდგომარეობა.
საერთო სარგებლობის შემთხვევაში გააკეთოს ხოლო loop
როდესაც გსურთ მიიღოთ მომხმარებლის input, და თქვენ იცით, თქვენ მინდა ვკითხო მომხმარებლის
ამისთვის შეყვანის ერთხელ მაინც, მაგრამ თუ ისინი არ მოგცემთ კარგი შეყვანის დაუყოვნებლივ
დატოვება გსურთ სთხოვს, სანამ ისინი მოგცემთ კარგი შეყვანის.
სწორედ ყველაზე გავრცელებული გამოყენების ნუ ხოლო მარყუჟის,
და მოდით შევხედოთ რეალურ სტრუქტურას ამ მარყუჟების.
ისინი, როგორც წესი, ყოველთვის ტენდენცია მოჰყვება ამ შაბლონებს.
>> On ამისთვის loop შიგნით თქვენ 3 კომპონენტი:
ინიციალიზაციისას, როგორც წესი, მსგავსი რამ int i = 0, სადაც მე არის Counter,
მდგომარეობა, სადაც ჩვენ გვინდა ვთქვათ აწარმოებს ამ loop რადგან ამ მდგომარეობა კვლავ ფლობს,
მოსწონს I <10, ხოლო შემდეგ საბოლოოდ, განახლება, რომელიც არის როგორ ჩვენ ნამატი
Counter ცვლადი ყოველ წერტილი loop.
საერთო რამ დაინახოს არსებობს მხოლოდ მე + +,
რაც იმას ნიშნავს, ნამატი მე მიერ 1 ყოველ ჯერზე.
თქვენ შეიძლება ასევე რაღაც მოსწონს i + = 2,
რაც იმას ნიშნავს, დაამატოთ 2 დან მე ყოველ დროს, თქვენ გავლა loop.
და შემდეგ ამის გაკეთება მხოლოდ ეხება რაიმე კოდი, რომელიც რეალურად მუშაობს როგორც ნაწილი loop.
და ცოტა ხნით მარყუჟის, ამ დროს ჩვენ რეალურად ინიციალიზაციისას გარეთ მარყუჟის,
ასე მაგალითად, ვთქვათ ჩვენ ცდილობს იგივე ტიპის loop როგორც მე უბრალოდ აღწერილი.
ჩვენ ვიტყოდი int i = 0 ადრე loop იწყება.
მაშინ შეიძლება ითქვას, ხოლო I <10 ამის გაკეთება,
ასე იგივე ბლოკი კოდი როგორც ადრე,
და ამ დროს update ნაწილი კოდი, მაგალითად, მე + +,
რეალურად მიდის შიგნით loop.
და ბოლოს, ამისთვის გააკეთებს ხოლო, ის მსგავსია, ხოლო მარყუჟის,
მაგრამ ჩვენ უნდა გვახსოვდეს, რომ კოდი შეაფასებს ერთხელ
სანამ მდგომარეობა შემოწმება, ასე რომ ხდის უფრო გრძნობა
თუ გადავხედავთ ეს გამოიტანს ყველაზე ქვედა.
In გავაკეთოთ ხოლო loop კოდი აფასებს თქვენს წინაშე კი შევხედოთ ხოლო მდგომარეობა,
ხოლო ხოლო მარყუჟის, ის ამოწმებს პირველი.
განცხადებები და ცვლადები.
როდესაც ჩვენ გვინდა შევქმნათ ახალი ცვლადი ჩვენ გვინდა პირველი ინიციალიზაცია იგი.
>> მაგალითად, int ბარი ველში ცვლადი ბარი,
მაგრამ ეს არ აძლევს მას ღირებულება, ასე რომ რა არის ბარი ღირებულების არის?
ჩვენ არ ვიცით.
ეს შეიძლება იყოს რაღაც ნაგავი ღირებულება, რომელიც ადრე შენახული მეხსიერების იქ,
და ჩვენ არ გვინდა, რომ გამოიყენოს ცვალებად
სანამ ჩვენ რეალურად მისცეს მას ღირებულება,
ამიტომ ვაცხადებთ აქ.
მაშინ ჩვენ ინიციალიზაცია, რომ იყოს 42 ქვემოთ.
ახლა, რა თქმა უნდა, ჩვენ ვიცით, ეს შეიძლება გაკეთდეს ერთ ხაზს, int ბარი = 42.
მაგრამ მხოლოდ იმიტომ, რომ განვმარტო მრავალჯერადი ნაბიჯებს, რომლებიც მიმდინარეობს,
დეკლარაციის და ინიციალიზაციისას ხდება ცალკე აქ.
ეს ხდება ერთ ნაბიჯს და შემდეგი ერთი, int baz = ბარი + 1,
ამ განცხადებას ქვემოთ, რომ increments baz, ასე დასასრულს ამ კოდექსის ბლოკი
თუ ჩვენ უნდა ბეჭდვა ღირებულება baz იქნებოდა 44
იმიტომ, რომ ჩვენ ვაცხადებთ და ვრთავ, რომ იყოს 1> ბარი,
და მაშინ ჩვენ ნამატი კიდევ ერთხელ ერთად + +.
წავედით ამ საკმაოდ მოკლედ, მაგრამ კარგია, რომ გვქონდეს ზოგადად
გაგება, თუ რა თემა და მოვლენები.
ჩვენ ძირითადად ეს იმ Scratch,
ასე რომ თქვენ შეგიძლიათ წარმოიდგინოთ, რომ თემა როგორც მრავალჯერადი sequences of კოდი
გაშვებული ამავე დროს.
რეალურად, ეს ალბათ არ არის გაშვებული, ამავე დროს,
მაგრამ სახის აბსტრაქტულად შეგვიძლია ვიფიქროთ, ის, რომ გზა.
>> In Scratch, მაგალითად, ჩვენ გვქონდა მრავალი sprites.
შეიძლება შესრულებაში სხვადასხვა კოდი, ამავე დროს.
ერთი შეიძლება ფეხით ხოლო მეორე ამბობს, რაღაც
სხვადასხვა ნაწილი ეკრანზე.
მოვლენები კიდევ ერთი გზა ჰყოფს გარეთ ლოგიკა
შორის სხვადასხვა ელემენტები თქვენი კოდი,
და Scratch შევძელით სიმულაცია მოვლენების გამოყენებით სამაუწყებლო,
და რომ სინამდვილეში როდესაც მივიღო, არ როდესაც მესმის,
მაგრამ არსებითად ეს გზა გადასცეს ინფორმაცია
ერთი Sprite სხვა.
მაგალითად, შეგიძლიათ გადასცემს თამაშის გამო,
და როდესაც მეორე Sprite იღებს თამაშის გამო,
იგი პასუხობს გარკვეული გზა.
ეს მნიშვნელოვანია მოდელის გვესმოდეს, პროგრამირების.
უბრალოდ წასვლა მეტი ძირითადი კვირა 0, რა ჩვენ წავიდა მეტი ჯერჯერობით
მოდით შევხედოთ ამ მარტივი C პროგრამა.
ტექსტი შეიძლება იყოს ცოტა პატარა აქედან, მაგრამ მე წასვლა მას ნამდვილად სწრაფი.
ჩვენ მათ შორის 2 header ფაილი ზედა, cs50.h და stdio.h.
ჩვენ მაშინ განსაზღვრის მუდმივი მოუწოდა ლიმიტი იყოს 100.
ჩვენ მაშინ ახორციელებს ჩვენი მთავარი ფუნქცია.
მას შემდეგ, რაც ჩვენ არ ვიყენებთ command line არგუმენტები აქ ჩვენ უნდა დააყენოს ბათილად
როგორც არგუმენტები ძირითადი.
ჩვენ ვხედავთ, int ზემოთ ძირითადი. სწორედ დაბრუნების ტიპის, შესაბამისად დაბრუნებას 0 ბოლოში.
და ჩვენ გამოყენებით CS50 ბიბლიოთეკის ფუნქცია კიდევ int
ვთხოვო მომხმარებლის ამისთვის შეყვანის და ჩვენ ჩაწეროთ იგი ამ ცვლადი x,
ამიტომ ვაცხადებთ x ზემოთ და ჩვენ ინიციალიზაცია იგი x = GetInt.
>> ჩვენ მაშინ შეამოწმეთ, რომ მომხმარებლის მოგვცა კარგი შეყვანის.
თუ ეს ≥ LIMIT გვინდა დაბრუნების შეცდომის კოდი 1 და ბეჭდვა შეცდომა.
და ბოლოს, თუ მომხმარებლის მოგვცა კარგი შეყვანის
ჩვენ ვაპირებთ მოედანზე ნომერი და ბეჭდვა, რომ შედეგი.
უბრალოდ, დარწმუნდით, რომ ის ყველა Hit მთავარი
ხედავთ ეტიკეტები სხვადასხვა ნაწილების კოდი აქ.
აღვნიშნე მუდმივი, header ფაილი.
ოჰ, int x. დარწმუნდით გვახსოვდეს, რომ ადგილობრივი ცვლადი.
რომ კონტრასტს ის გლობალური ცვლადი, რომელიც ჩვენ ვსაუბრობთ
ცოტა მოგვიანებით საანგარიშო სხდომამდე,
და ჩვენ გთხოვთ ბიბლიოთეკის ფუნქცია printf,
ასე რომ, თუ ჩვენ არ შედის stdio.h header ფაილი
ჩვენ ვერ მოვუწოდებთ printf.
და მე მჯერა, რომ arrow გაბმულ შეწყვიტა აქ მიუთითებს% d,
რაც გაფორმებით string in printf.
განცხადებაში ნათქვამია, ამობეჭდოთ ეს ცვლადი როგორც ნომერი,% d.
და სწორედ ეს კვირა 0.
ახლა ლუკას აპირებს გააგრძელოს.
Hey, guys. ჩემი სახელი არის ლუკასი.
მე მეორე საუკეთესო სახლში კამპუსში, Mather,
და მე ვაპირებ გაიგო ცოტა შესახებ კვირა 1 და 2.1.
[კვირა 1 და 2.1!] [Lucas Freitas]
როგორც ძაან მაგარი ამბობდა, როდესაც ჩვენ დავიწყეთ თარგმნა თქვენი კოდი ნულიდან to C
ერთი რამ, რომ ჩვენ შენიშნა ისაა, რომ თქვენ არა მხოლოდ
დაწეროთ თქვენი კოდი და გაუშვით გამოყენებით მწვანე დროშა უქმნით.
სინამდვილეში, თქვენ უნდა გამოიყენოთ ზოგიერთ ნაბიჯს, რათა თქვენი C პროგრამის
გახდეს შესრულებად ფაილს.
ძირითადად, თუ რას აკეთებთ თქვენ პროგრამის წერა ის არის, რომ
თქვენ თარგმნოს თქვენი იდეა შევიდა ენა რომ შემდგენელი მესმის,
ასე რომ, როდესაც თქვენ წერილობით პროგრამა C
თუ რას აკეთებს რეალურად წერა რაღაც რომ თქვენი შემდგენელი აპირებს მესმის,
და მაშინ კომპილატორი აპირებს თარგმნოს, რომ კოდი
შევიდა რაღაც, რომ თქვენს კომპიუტერში მიხვდება.
>> და ის კი, კომპიუტერი ძალიან მუნჯები.
თქვენს კომპიუტერში შეიძლება მხოლოდ მესმის 0S და 1s,
ასე რეალურად პირველ კომპიუტერები ხალხი ჩვეულებრივ პროგრამირდება
გამოყენებით 0S და 1s, მაგრამ აღარ, მადლობა ღმერთს.
ჩვენ არ უნდა გვემახსოვრება sequences for 0S და 1s
ამისთვის ამისთვის მარყუჟი ან ხოლო მარყუჟის და ასე შემდეგ.
ამიტომ ჩვენ გვაქვს შემდგენელი.
რა შემდგენელი არ არის ეს ძირითადად ითარგმნება C კოდი,
ჩვენს შემთხვევაში, რომ ენა, რომ თქვენს კომპიუტერში მიხვდება,
რომელიც ობიექტის კოდი და შემდგენელი რომ ჩვენ გამოყენებით
ეწოდება clang, ამიტომ ეს არის რეალურად სიმბოლო clang.
როდესაც თქვენ გაქვთ თქვენი პროგრამა, თქვენ უნდა გააკეთოთ 2 რამ.
პირველი, თქვენ უნდა დააკომპილიროთ თქვენი პროგრამა, და მერე ვაპირებთ აწარმოებს თქვენი პროგრამის.
შედგენა თქვენი პროგრამის გაქვთ უამრავი პარამეტრები ამისათვის.
პირველი ის არის, რომ გააკეთოთ clang program.c
რომელშიც პროგრამის სახელი თქვენი პროგრამა.
ამ შემთხვევაში თქვენ შეგიძლიათ ნახოთ ისინი უბრალოდ რომ "Hey, კომპილაციის ჩემი პროგრამა."
თქვენ არ ვამბობ "მე მინდა ეს სახელი, ჩემი პროგრამა" ან არაფერი.
>> მეორე ვარიანტი იძლევა სახელი თქვენი პროგრამა.
შეიძლება ითქვას clang-o და შემდეგ სახელი რომ გსურთ
შესრულებადი ფაილი უნდა დაასახელა და შემდეგ program.c.
და ასევე შეგიძლიათ გააკეთებს გააკეთოს პროგრამა და ვნახავთ, როგორ პირველ 2 შემთხვევა
მე ზუსტად. გ, ხოლო მესამე მე მხოლოდ პროგრამებს?
ჰო, თქვენ ნამდვილად არ უნდა დააყენოს. გ როდესაც თქვენ გამოიყენოთ მიიღოს.
წინააღმდეგ შემთხვევაში შემდგენელი ფაქტობრივად აპირებს დაწეროთ თქვენ.
და ასევე, არ ვიცი თუ ბიჭები გახსოვთ,
მაგრამ ბევრი ჯერ ჩვენ ასევე გამოიყენება-lcs50 ან-LM.
რომ ჰქვია აკავშირებს.
უბრალოდ ეუბნება შემდგენელი რომ თქვენ გამოიყენოთ იმ ბიბლიოთეკების უფლება არსებობს,
ასე რომ, თუ გსურთ გამოიყენოთ cs50.h თქვენ ნამდვილად უნდა აკრიფოთ
clang program.c-lcs50.
თუ არ გავაკეთებთ, შემდგენელი არ აპირებს ვიცი
რომ თქვენ იყენებთ იმ ფუნქციების cs50.h.
ხოლო როდესაც გსურთ აწარმოებს თქვენი პროგრამის გაქვთ 2 ვარიანტი.
თუ თქვენ არ clang program.c თქვენ არ მიუცია სახელი თქვენი პროგრამა.
თქვენ უნდა გაუშვათ გამოყენებით. / A.out.
A.out არის სტანდარტული სახელი რომ clang იძლევა თქვენი პროგრამის თუ არ მისცეს მას სახელი.
წინააღმდეგ შემთხვევაში თქვენ აპირებს. / პროგრამა თუ მისცა სახელი თქვენი პროგრამა,
და ასევე თუ რა გააკეთეთ მიიღოს პროგრამის სახელი რომ პროგრამა აპირებს მიიღოს
უკვე აპირებს იყოს დაპროგრამებული ამავე სახელწოდების როგორც გ ფაილი.
მაშინ ჩვენ ვისაუბრეთ მონაცემთა ტიპები და მონაცემთა.
>> ძირითადად მონაცემთა ტიპები არიან იგივე როგორც პატარა ყუთები ისინი იყენებენ
შესანახად ღირებულებებს, ამიტომ მონაცემთა ტიპები რეალურად ისევე Pokémons.
ისინი მოდის ყველა ზომის და ტიპები.
არ ვიცი თუ ეს ანალოგია აზრი.
მონაცემები ზომა რეალურად დამოკიდებულია მანქანის არქიტექტურა.
ყველა მონაცემები ზომის, რომ მე ვაპირებ ნახოთ აქ
რეალურად ამისთვის 32-bit მანქანა, რომელიც არის საქმე ჩვენი ელექტრო მოწყობილობების,
მაგრამ თუ ფაქტობრივად კოდირების თქვენი Mac ან Windows ასევე
ალბათ თქვენ აპირებს აქვს 64-bit მანქანა,
ასე მახსოვს, რომ მონაცემები ზომის, რომ მე ვაპირებ ნახოთ აქ
განკუთვნილია 32-bit მანქანა.
პირველი, რომ ჩვენ ვნახეთ იყო int,
რაც საკმაოდ მარტივია.
თქვენ გამოიყენოთ int შესანახად რიცხვი.
ჩვენ ასევე ვნახეთ ხასიათი, char.
თუ გსურთ გამოიყენოთ ასო ან პატარა სიმბოლო თქვენ ალბათ აპირებს გამოიყენოს char.
Char აქვს 1 byte, რაც იმას ნიშნავს, 8 ბიტი, მოსწონს ძაან მაგარი განაცხადა.
ძირითადად გვაქვს ASCII მაგიდა, რომელსაც აქვს 256
შესაძლო კომბინაციები 0S და 1s,
და მაშინ, როდესაც თქვენ ტიპი char ის აპირებს თარგმნოს
ხასიათი რომ საშუალებებით თქვენ ნომერი რომ გაქვთ ASCII მაგიდა, როგორიც ძაან მაგარი განაცხადა.
ჩვენ ასევე გვაქვს float, რომელიც ჩვენ ვიყენებთ შესანახად ათობითი ნომრები.
თუ გსურთ აირჩიოს 3,14, მაგალითად, თქვენ აპირებს გამოიყენოს float
ან ორმაგი რომ უფრო მეტი სიზუსტით.
Float აქვს 4 ბაიტი.
ორმაგი არის 8 ბაიტი, ამიტომ ერთადერთი განსხვავება არის სიზუსტით.
ჩვენ ასევე გვაქვს ხანგრძლივი, რომელიც გამოიყენება მთელი რიცხვები,
და ხედავთ ამისთვის 32-bit მანქანა int და ხანგრძლივი აქვთ იგივე ზომა,
ასე რომ ნამდვილად არ აქვს აზრი, გამოიყენოს დიდხანს 32-bit მანქანა.
>> მაგრამ თუ თქვენ იყენებთ Mac და 64-bit მანქანა, რეალურად ხანია ზომა 8,
ასე რომ ნამდვილად დამოკიდებულია არქიტექტურა.
For 32-bit მანქანა მას არ აქვს აზრი გამოიყენოს ხანგრძლივი ნამდვილად.
და შემდეგ ხანგრძლივი ხანგრძლივი, მეორეს მხრივ, არის 8 ბაიტი,
ასე რომ ძალიან კარგია, თუ გსურთ აქვს აღარ რიცხვი.
და ბოლოს, ჩვენ გვაქვს ტექსტი, რომელიც რეალურად char *,
რაც მომცეთ char.
ძალიან ადვილია, რომ ვიფიქროთ, რომ ზომის სიმებიანი იქნება მოსწონს
პუნქტების გმირები, რომ თქვენ გაქვთ იქ,
მაგრამ რეალურად char * თავად
აქვს ზომის მომცეთ char, რომელიც 4 ბაიტი.
ზომა char * არის 4 ბაიტი.
არ აქვს მნიშვნელობა, თუ თქვენ გაქვთ პატარა სიტყვა ან ასო ან არაფერი.
ეს იქნება 4 ბაიტი.
ჩვენ ასევე შეიტყო ცოტა შესახებ ჩამოსხმის,
ასე როგორც ხედავთ, თუ გაქვთ, მაგალითად, პროგრამა, რომელიც ამბობს
int x = 3 და შემდეგ printf ("% d", X / 2)
თუ ბიჭები ვიცი რასაც ის აპირებს ბეჭდვა ეკრანზე?
>> ვიღაცამ? >> [სტუდენტთა] 2.
1. >> 1, yeah.
როცა 3/2 ის აპირებს მიიღებთ 1,5,
მაგრამ რადგან ჩვენ გამოყენებით მთელი ის აპირებს იგნორირება ათობითი ნაწილი,
და თქვენ აპირებს აქვს 1.
თუ თქვენ არ გსურთ, რომ მოხდეს რა შეგიძლიათ გააკეთოთ, მაგალითად,
არის განაცხადოს, float y = x.
შემდეგ x, რომ გამოყენებული იყოს 3 არის იქნება 3.000 in წ.
და მაშინ ბეჭდვა Y / 2.
სინამდვილეში, მე უნდა ჰქონდეს 2. იქ.
ის აპირებს 3.00/2.00,
და თქვენ აპირებს მიიღოს 1.5.
და ჩვენ გვაქვს ამ .2 f უბრალოდ მოითხოვოს 2 ათობითი ერთეული ათობითი ნაწილი.
თუ თქვენ გაქვთ .3 F ის აპირებს რეალურად 1.500.
თუ ეს 2 ეს იქნება 1.50.
ჩვენ ასევე გვაქვს ამ შემთხვევაში აქ.
თუ float x = 3,14 და მაშინ printf x
თქვენ აპირებს მიიღოს 3,14.
და თუ x = int of x,
რაც იმას ნიშნავს, მკურნალობა x როგორც int და თქვენ ბეჭდვა x ახლა
თქვენ აპირებს აქვს 3,00.
ამჯამად რომ აზრი?
იმიტომ, რომ თქვენ პირველი მკურნალობის x როგორც მთელი რიცხვი, ასე რომ თქვენ იგნორირება ათობითი ნაწილი,
და მაშინ თქვენ დაბეჭდვის x.
და ბოლოს, თქვენ შეგიძლიათ ასევე ამის გაკეთება,
int x = 65, და მერე განაცხადოს char c = x,
და მაშინ, თუ თქვენ ბეჭდვა გ თქვენ რეალურად აპირებს მიიღოს
, ასე რომ ძირითადად თუ რას აკეთებს აქ
არის თარგმნის მთელი შევიდა ხასიათი,
ისევე ASCII მაგიდა აკეთებს.
ჩვენ ასევე ვისაუბრეთ მათემატიკის ოპერატორები.
მათი უმრავლესობა საკმაოდ მარტივია, ასე რომ +, -, *, /,
და ასევე ვისაუბრეთ თავდაცვის სამინისტროს, რომელიც დარჩენილი სამმართველოს 2 ნომრები.
თუ თქვენ გაქვთ 10% 3, მაგალითად,
ეს იმას ნიშნავს, დაყოს 10 მიერ 3, და რა არის დარჩენილი?
ეს იქნება 1, ამიტომ რეალურად ძალიან სასარგებლო ბევრი პროგრამების.
იყიდება Vigenère და ცეზარ მე საკმაოდ დარწმუნებული ვარ, რომ ყველა თქვენგანს ბიჭებს გამოყენებული mod.
შესახებ მათემატიკის ოპერატორები, იყოს ძალიან ფრთხილად, როცა აერთიანებს * და /.
>> მაგალითად, თუ თქვენ (3/2) * 2 რას აპირებს მიიღოს?
[სტუდენტთა] 2.
ჰო, 2, რადგან 3/2 იქნება 1.5,
მაგრამ რადგან თქვენ აკეთებთ ოპერაციების შორის 2 რიცხვებით
თქვენ რეალურად მხოლოდ აპირებს განიხილოს 1,
და შემდეგ 1 * 2 იქნება 2, ასე რომ ძალიან, ძალიან ფრთხილად
როდესაც აკეთებს არითმეტიკული ერთად მთელი რიცხვები, რადგან
შესაძლოა, რომ 2 = 3, ამ შემთხვევაში.
და ასევე ძალიან ფრთხილად პრეცენდენტის.
თქვენ უნდა გამოვიყენოთ ჩვეულებრივ ფრჩხილებში დარწმუნებული უნდა იყოს, რომ თქვენ იცით, თუ რას აკეთებს.
ზოგიერთი სასარგებლო კომბინაციები, რა თქმა უნდა, ერთი არის მე + + ან i + = 1
ან + =.
ეს იგივე რამ, როგორც აკეთებს i = i + 1.
თქვენ ასევე შეგიძლიათ შემიძლია - ან მე - = 1,
რაც იგივე როგორც მე = მე -1,
რაღაც თქვენ ბიჭები გამოიყენოთ ბევრი ამისთვის მარყუჟების, მინიმუმ.
ასევე, *, თუ თქვენ იყენებთ * = და თუ, მაგალითად,
მე * = 2 არის იგივე დაყრდნობით მე = i * 2,
და იგივე შეეხება განაწილებას.
თუ შემიძლია / = 2 ეს იგივე როგორც მე = I / 2.
>> რაც შეეხება ფუნქციებს.
თქვენ ბიჭები შეიტყო, რომ ფუნქციები ძალიან კარგი სტრატეგია გადარჩენა კოდი
ხოლო თქვენ პროგრამირების ასე რომ, თუ გსურთ შეასრულოს იგივე ამოცანა
კოდის ისევ და ისევ, ალბათ გსურთ გამოიყენოთ ფუნქცია
უბრალოდ, ასე რომ თქვენ არ უნდა დააკოპირეთ და ჩასვით კოდი უსასრულოდ.
სინამდვილეში, მთავარი არის ფუნქცია, და როცა მე გაჩვენებთ ფორმატის ფუნქცია
თქვენ აპირებს, რომ რომ საკმაოდ ნათელია.
ჩვენ ასევე ვიყენებთ ფუნქციებს რამდენიმე ბიბლიოთეკა,
მაგალითად, printf, GetIn, რომელიც საწყისი CS50 ბიბლიოთეკა,
და სხვა ფუნქციების მსგავსად toupper.
ყველა იმ ფუნქციებს ფაქტობრივად განხორციელებული სხვა ბიბლიოთეკების,
და როდესაც თქვენ დააყენა იმ tether ფაილი დასაწყისში თქვენი პროგრამა
თქვენ ამბობდა შეგიძლიათ გთხოვთ მომეცი კოდი ამ ფუნქციების
ასე რომ არ უნდა განახორციელონ მათ მიერ თავს?
და ასევე შეგიძლიათ დაწეროთ ფუნქციების, ასე რომ, როდესაც თქვენ დავიწყოთ პროგრამირების
ხვდები, რომ ბიბლიოთეკების არ აქვს ყველა ფუნქცია, რაც თქვენ გჭირდებათ.
უკანასკნელი pset, მაგალითად, ჩვენ წერდა მიაპყროს, scramble, და საძიებელი,
და ეს ძალიან, ძალიან მნიშვნელოვანია შეძლონ წერა ფუნქციები
რადგან ისინი სასარგებლო და ჩვენ მათი გამოყენება ყველა დროის პროგრამირებაში,
და ეს ზოგავს ბევრი კოდი.
ფორმატის ფუნქცია ამ ერთ.
ჩვენ გვყავს დაბრუნების ტიპის დასაწყისია. რა არის დაბრუნების ტიპის?
უბრალოდ, როცა თქვენი ფუნქციის დაბრუნებას აპირებს.
თუ თქვენ გაქვთ ფუნქცია, მაგალითად, factorial,
რომ აპირებს გამოთვლა factorial of რიცხვი,
ალბათ ის დაბრუნებას აპირებს მთელი რიცხვი ასევე.
მაშინ დაბრუნების ტიპის იქნება int.
Printf რეალურად აქვს დაბრუნების ტიპის ბათილად
იმიტომ, რომ თქვენ არ დაბრუნების არაფერი.
თქვენ მხოლოდ დაბეჭდვის რამ ეკრანზე
და წასვლის ფუნქციის შემდეგ.
მაშინ თქვენ გაქვთ სახელით ფუნქცია რომ შეგიძლიათ.
თქვენ უნდა იყოს პატარა გონივრული, როგორიც არ ვირჩევთ სახელი როგორიცაა xyz
ან მოსწონს x2f.
ცდილობს, მოიგონოს სახელი რომ აზრი.
>> მაგალითად, თუ ის factorial, ამბობენ factorial.
თუ ეს ფუნქცია, რომ აპირებს გავამახვილო რაღაც, დაარქვით მიაპყროს.
და მაშინ ჩვენ გვაქვს პარამეტრებს, რომლებიც ასევე მოუწოდა არგუმენტები,
რომლებიც მოსწონს რესურსების, რომ თქვენი ფუნქცია სჭირდება
თქვენი კოდი შეასრულოს თავისი ამოცანა.
თუ გსურთ გამოთვლა factorial რიგი
ალბათ უნდა გქონდეს რაოდენობის გამოთვლა factorial.
ერთი არგუმენტები, რომ თქვენ აპირებს აქვს არის ნომერი თავად.
და მერე ხდება რაღაც და დაბრუნდნენ ღირებულება დასასრულს
თუ იგი არ არის ბათილად ფუნქცია.
ვნახოთ მაგალითი.
თუკი მინდა დაწერა ფუნქციის რომ თანხები ყველა ნომრები მასივი რიცხვებით,
პირველ რიგში, დაბრუნების ტიპის იქნება int
რადგან მაქვს მასივი რიცხვებით.
და შემდეგ მე ვაპირებ აქვს ფუნქცია სახელი როგორიცაა sumArray,
და შემდეგ ის აპირებს მასივი ქვეყნისათვის, int nums,
და მერე სიგრძეზე მასივი ასე ვიცი რამდენი ციფრები უნდა თანხა.
მაშინ მე უნდა ინიციალიზაცია ცვლადში თანხა, მაგალითად, 0,
და ყოველ ჯერზე ვხედავ ელემენტია მასივი მე უნდა დაამატოთ ეს თანხა, ასე რომ მე ამისთვის loop.
ისევე, როგორც ძაან მაგარი განაცხადა, თქვენ int i = 0, I <სიგრძე და მე + +.
და ყველა ელემენტს მასივი მე თანხა + = nums [i],
და შემდეგ დავბრუნდი თანხა, ამიტომ ძალიან მარტივია, და ეს ზოგავს ბევრი კოდი
თუ თქვენ იყენებთ ამ ფუნქციას უამრავი ჯერ.
მაშინ ავიღეთ შევხედოთ პირობებს.
ჩვენ გვყავს თუ სხვაგან, და სხვას თუ.
ვნახოთ რა განსხვავებაა იმ.
შეხედეთ ამ 2 კოდები. რა განსხვავებაა მათ შორის?
პირველი ერთი-ძირითადად კოდები მინდა ვუთხრა
თუ რიცხვი +, -, ან 0.
პირველი ამბობს, თუ ის> 0 მაშინ ეს დადებითი.
თუ ეს = 0 მაშინ ეს 0, და თუ ეს <0, მაშინ ეს უარყოფითი.
>> და მეორე აკეთებს, თუ, სხვას თუ სხვაგან.
განსხვავება ორ არის ის, რომ ამ ერთი რეალურად აპირებს
შეამოწმეთ თუ> 0, <0 ან = 0 სამჯერ,
ასე რომ, თუ თქვენ გაქვთ ნომერი 2, მაგალითად, ის აპირებს ჩამოვიდეს აქ და თქვას
თუ (x> 0) და ეს ხდება იმის თქმა კი, ამიტომ ბეჭდვა დადებითი.
მაგრამ მიუხედავად იმისა, რომ მე ვიცი, რომ ეს> 0 და ეს არ იქნება 0 ან <0
მე ჯერ კიდევ აპირებს თუ არა 0, არის ის <0,
ამიტომ მე რეალურად აპირებს შიგნით IFS, რომ არ უნდა
იმიტომ, რომ მე უკვე ვიცი, რომ ის არ აპირებს დააკმაყოფილოს ნებისმიერი ამ პირობებში.
შემიძლია თუ სხვაგან, თუ სხვაგან განცხადებაში.
იგი ძირითადად ამბობს, თუ x = 0 მე ბეჭდვა დადებითი.
თუ ეს არ, მე ვაპირებ ასევე შეამოწმოთ ამ.
თუ ეს 2 არ მე ვაპირებ ამის გაკეთებას.
ძირითადად მე რომ x = 2 თქვენ ვიტყოდი
თუ (x> 0), დიახ, ასე ბეჭდვა ამ.
ახლა, მე ვიცი, რომ ეს> 0 და რომ იგი კმაყოფილი პირველი თუ
მე კი არ აპირებს ამ კოდექსით.
კოდი ეშვება სწრაფად, ფაქტობრივად, 3 ჯერ უფრო სწრაფად, თუ თქვენ იყენებთ ამ.
ჩვენ ასევე შეიტყო და და ან.
მე არ ვაპირებ გავლა რადგან ძაან მაგარი უკვე ისაუბრა მათ.
უბრალოდ && და | | ოპერატორი.
>> ერთადერთი, რაც მე ვთქვა, ფრთხილად, როდესაც თქვენ 3 პირობები.
გამოიყენეთ ფრჩხილებში იმიტომ რომ ძალიან დამაბნეველი როცა მდგომარეობა
და კიდევ ერთი ან მეორე.
გამოიყენეთ ფრჩხილებში მხოლოდ დარწმუნებული უნდა იყოს, რომ თქვენი პირობები აზრი
რადგან ამ შემთხვევაში, მაგალითად, თქვენ შეგიძლიათ წარმოიდგინოთ, რომ
ეს შეიძლება იყოს პირველი მდგომარეობა და ერთი ან მეორე
ან 2 პირობების შერწყმული და
ან მესამე, ასე რომ მხოლოდ ფრთხილად.
და ბოლოს, ჩვენ ვისაუბრეთ კონცენტრატორები.
შეცვლა არის ძალიან სასარგებლო, როდესაც თქვენ გაქვთ ცვლადი.
ვთქვათ, რომ თქვენ გაქვთ ცვლადი, როგორიცაა N
რომ შეიძლება იყოს 0, 1, ან 2, და თითოეული იმ შემთხვევაში
თქვენ აპირებს შეასრულოს დავალება.
შეიძლება ითქვას გადართოთ ცვლადი, და ეს მიუთითებს იმაზე, რომ
ღირებულება მაშინ ჰგავს value1 მე ვაპირებ ამის გაკეთებას,
და მერე შესვენება, რაც იმას ნიშნავს, მე არ ვაპირებ შეხედოთ ნებისმიერ სხვა შემთხვევებში
იმიტომ, რომ ჩვენ უკვე დარწმუნებულია იმაში, რომ საქმე
და შემდეგ value2 და ასე შემდეგ, და მე ასევე შეგიძლიათ აქვს რა შეცვლა.
ეს იმას ნიშნავს, თუ ის არ აკმაყოფილებს ნებისმიერი შემთხვევები, რომ მქონდა
რომ მე ვაპირებ რაღაც სხვას, მაგრამ ეს აუცილებელი.
ეს იყო ჩემთვის. ახლა მოდით ტომი.
ყველა უფლება, ეს იქნება კვირა 3-ish.
ეს არის ზოგიერთი თემები ჩვენ გააშუქებს, შიფრის, მასშტაბების, მასივები, et cetera.
უბრალოდ სწრაფი სიტყვა Crypto. ჩვენ არ ვაპირებთ, რომ ჩაქუჩი ამ სახლში.
>> ეს გავაკეთეთ წელს pset 2, არამედ ინტელექტუალური დარწმუნდით თქვენ იცით განსხვავება
შორის კეისრის კოდი და Vigenère cipher,
როგორ ორივე ciphers მუშაობა და რა მოსწონს დაშიფვრა
და გაშიფვრა ტექსტი გამოყენებით იმ 2 ciphers.
გახსოვდეთ, კეისრის კოდი უბრალოდ ბრუნავს თითოეული ხასიათი იგივე თანხა,
მიღების დარწმუნებული თქვენ mod მიერ პუნქტების წერილები ანბანი.
და Vigenère cipher, მეორეს მხრივ, ბრუნავს თითოეული ხასიათი
მიერ სხვადასხვა თანხა, ასე რომ, ვიდრე ამბობდა
ყველა ხასიათი გარდამავალია მიერ 3 Vigenère ჩაენაცვლება თითოეული ხასიათი
მიერ სხვადასხვა თანხა დამოკიდებულია რამდენიმე სიტყვით
სადაც თითოეული ასო სიტყვის წარმოადგენს განსხვავებული თანხა
რომ როტაცია წმინდა ტექსტი.
მოდით პირველი საუბარი ცვლადი ფარგლებს.
არის 2 სხვადასხვა ტიპის ცვლადი.
ჩვენ გვყავს ადგილობრივი ცვლადები და ამ ვაპირებთ განისაზღვრება
გარეთ ძირითად ან გარეთ ნებისმიერი ფუნქცია ან ბლოკი,
და ეს იქნება ხელმისაწვდომი ნებისმიერ წერტილში თქვენი პროგრამა.
თუ თქვენ გაქვთ ფუნქცია და ამ ფუნქციის ხოლო loop
დიდი გლობალური ცვლადი არის ხელმისაწვდომი ყველგან.
ადგილობრივი ცვლადი, მეორეს მხრივ, არის scoped იქ, სადაც ის არ არის დადგენილი.
>> თუ თქვენ გაქვთ ფუნქცია აქ, მაგალითად, ჩვენ გვაქვს ამ ფუნქციის გ,
და შიგნით გ არსებობს ცვლადი აქ მოუწოდა Y,
და ეს იმას ნიშნავს, რომ ეს არის ლოკალური ცვლადი.
მიუხედავად იმისა, რომ ამ ცვლადის ეწოდება Y
და ამ ცვლადის ეწოდება Y ამ 2 ფუნქციები
არ ვიცი რა ერთმანეთის ადგილობრივი ცვლადებია.
მეორეს მხრივ, აქ ვამბობთ int x = 5,
და ეს არის სცილდება ნებისმიერი ფუნქცია.
ეს სცილდება მთავარ, ისე ეს გლობალური ცვლადი.
ეს იმას ნიშნავს, რომ შიგნით ამ 2 ფუნქციების როდესაც ვამბობ, რომ X - ან x + +
მე წვდომის იგივე x რომლითაც ამ Y და ამ Y არიან სხვადასხვა ცვლადები.
რომ სხვაობაა გლობალური ცვლადი და ლოკალური ცვლადი.
რამდენადაც დიზაინი ეხება, ზოგჯერ ეს ალბათ უკეთესი იდეა
შენარჩუნება ცვლადები ადგილობრივი როდესაც თქვენ შეგიძლიათ
წლიდან მქონე bunch გლობალური ცვლადები შეუძლიათ მიიღონ მართლაც დამაბნეველი.
თუ თქვენ გაქვთ bunch ფუნქციების ყველა შეცვლის იგივე
თქვენ შეიძლება დაგვავიწყდეს რა, თუ ამ ფუნქციას შემთხვევით modifies ამ გლობალურ,
და ეს სხვა ფუნქცია არ იცის ამის შესახებ,
და ეს სულაც კიდევ საკმაოდ დამაბნეველი, როგორც თქვენ უფრო კოდი.
Keeping ცვლადები ადგილობრივი როდესაც თქვენ შეგიძლიათ
უბრალოდ კარგი დიზაინით.
მასივები, გახსოვდეთ, უბრალოდ სიები ელემენტები იგივე ტიპის.
შიგნით CI არ შეიძლება სიაში მოსწონს 1, 2.0, hello.
ჩვენ უბრალოდ ვერ გავაკეთებთ.
>> როდესაც ვაცხადებთ, array in C ყველა ელემენტები უნდა იყოს იგივე ტიპის.
აქ მაქვს მასივი 3 რიცხვებით.
აქ მაქვს სიგრძეზე მასივი, მაგრამ თუ მე უბრალოდ გამოცხადების იგი ამ სინტაქსის
სადაც მე მიუთითოთ ყველა ელემენტები არიან მე არ ტექნიკურად გვჭირდება ეს 3.
შემდგენელი არის smart საკმარისი გაერკვნენ, თუ როგორ დიდი მასივი უნდა იყოს.
ახლა, როდესაც მე მინდა კიდევ ან ღირებულების მასივი
ეს სინტაქსი გაგვაჩნია.
ეს რეალურად ცვლილებები მეორე ელემენტია მასივი, რადგან, გახსოვდეთ,
ნუმერაციის იწყება 0, არა 1.
თუკი მინდა წაიკითხონ, რომ ღირებულება შემიძლია ვთქვა რაღაც int x = array [1].
ან თუ მინდა, რომ მითითებული ღირებულება, ისევე როგორც მე ვაკეთებ აქ,
შემიძლია ვთქვა, array [1] = 4.
იმ დროს წვდომის ელემენტების მიერ მათი ინდექსი
ან მათი პოზიცია ან სადაც ისინი მასივი,
და რომ ჩამონათვალი იწყება 0.
ჩვენ შეგვიძლია ასევე აქვს კოლექტორები მასივი,
და ეს ჰქვია მრავალ განზომილებიანი მასივი.
როდესაც გვაქვს მრავალ განზომილებიანი მასივი
რაც იმას ნიშნავს, რომ შეგვიძლია რაღაც სტრიქონები და სვეტები,
და ეს არის მხოლოდ ერთი გზა ვიზუალურ ამა თუ ფიქრობს ამის შესახებ.
როდესაც მაქვს მრავალ განზომილებიანი მასივი, რაც იმას ნიშნავს მე ვაპირებ დაიწყება სჭირდება
ზე მეტი 1 ინდექსი რადგან თუ მაქვს ბადე
უბრალოდ ამბობს იმას, რაც ზედიზედ თქვენ არ მოგვცეს ნომერი.
რომ მართლაც მხოლოდ აპირებს მოგვცეს სიაში ნომრები.
ვთქვათ მაქვს ამ მასივი აქ.
მაქვს მასივი მოუწოდა ქსელის, და მე რომ მისი 2 რიგები და 3 მწკრივი,
და ა.შ. ეს არის ერთი გზა ვიზუალურ იგი.
როდესაც ვამბობ მინდა კიდევ ელემენტს ზე [1] [2]
რაც იმას ნიშნავს, რომ რადგან ეს რიგები და შემდეგ სვეტები
მე ვაპირებ გადადით Row 1 წლიდან ვთქვი 1.
>> მაშინ მე ვაპირებ გადმოდიოდნენ აქ სვეტი 2, და მე ვაპირებ კიდევ ღირებულება 6.
აზრი?
Multi-განზომილებიანი მასივები, გახსოვდეთ, ტექნიკურად უბრალოდ მასივი მასივები.
ჩვენ შეგვიძლია აქვს კოლექტორები მასივი მასივი.
ჩვენ შეგვიძლია შევინარჩუნოთ აპირებს, მაგრამ რეალურად ერთი გზა ვიფიქროთ
როგორ მიმდინარეობს ასახული და რა ხდება არის ვიზუალიზაციისთვის ეს
წელს ქსელის მოსწონს ეს.
როდესაც ჩვენ გაიაროს კოლექტორები ფუნქციაში, ისინი აპირებენ მოიქცევა
ცოტა განსხვავებულად, ვიდრე როდესაც ჩვენ გაიაროს რეგულარული ცვლადები ფუნქციები
მოსწონს ავლით int ან float.
როდესაც ჩვენ კორიდორი int ან char ან რომელიმე ამ სხვა მონაცემთა ტიპები
ჩვენ უბრალოდ აიღო შევხედოთ თუ ფუნქცია modifies
ღირებულება რომ ცვლადი, რომ ცვლილება არ აპირებს პროპაგანდაა up
to მოუწოდებდა ფუნქცია.
With მასივი, მეორეს მხრივ, რომ მოხდება.
თუ მე კორიდორი მასივი ზოგიერთი ფუნქცია და რომ ფუნქცია ცვლის ზოგიერთი ელემენტების,
როცა დავბრუნდებით მდე ფუნქცია, რომელიც მას
ჩემი array არის განსხვავებული უნდა იყოს, და ლექსიკა რომ
არის კოლექტორები გავლის მიერ მინიშნება, როგორც ვნახავთ, მოგვიანებით.
ეს უკავშირდება თუ როგორ პოინტერები მუშაობა, სადაც ეს ძირითადი მონაცემთა ტიპები,
მეორეს მხრივ, მათ მიერ მიღებულ ღირებულება.
>> ჩვენ შეგვიძლია ვიფიქროთ, რომ როგორც მიღების ასლი ზოგიერთი ცვლადი და შემდეგ გადადის ასლი.
არ აქვს მნიშვნელობა, თუ რას ვაკეთებთ, რომ ცვლადი.
მოუწოდებდა ფუნქცია არ იქნება იცოდეს, რომ შეიცვალა.
კოლექტორები უბრალოდ ცოტა სხვანაირად, რომ დაკავშირებით.
მაგალითად, როგორც ჩვენ მხოლოდ დაინახეს, მთავარ უბრალოდ ფუნქცია
რომელსაც შეუძლია მიიღოს 2 არგუმენტები.
პირველი არგუმენტი მთავარი ფუნქცია არის argc, ან რაოდენობის არგუმენტები,
და მეორე არგუმენტი ეწოდება argv,
და ეს ის ფაქტობრივი ღირებულებების იმ არგუმენტებს.
ვთქვათ მაქვს პროგრამა მოუწოდა this.c,
და მე ვიტყვი, რომ ეს, და მე ვაპირებ აწარმოებს ამ ბრძანებათა ზოლს.
ახლა უნდა გაიაროს ზოგიერთ არგუმენტები ჩემი პროგრამა უწოდა,
მე შეიძლება ითქვას, მსგავსი რამ. / ეს არის cs 50.
ეს არის ის, რაც ჩვენ წარმოიდგინეთ დავით გავაკეთოთ ყოველდღე ტერმინალში.
მაგრამ ახლა მთავარი ფუნქცია შიგნით რომ პროგრამა
აქვს ამ ფასეულობების, ისე argc არის 4.
ეს შეიძლება იყოს პატარა დამაბნეველი რადგან ნამდვილად ჩვენ მხოლოდ გადადის არის cs 50.
რომ მხოლოდ 3.
მაგრამ გახსოვდეთ, რომ პირველი ელემენტი argv ან პირველი არგუმენტი
არის სახელწოდება ფუნქცია თავად.
ასე რომ, რაც იმას ნიშნავს, რომ ჩვენ გვყავს 4 რამ აქ,
და პირველ ელემენტს იქნება. / ამ.
და ეს იქნება წარმოდგენილია როგორც სიმებიანი.
შემდეგ დარჩენილი ელემენტების რაც ჩვენ აკრეფილი შემდეგ პროგრამის დასახელება.
ამიტომ ისევე როგორც განზე, როგორც ჩვენ ალბათ დაინახა pset 2,
გვახსოვდეს, რომ სიმებიანი 50 არის ≠ რიცხვი 50.
ამიტომ, ჩვენ ვერ ვიტყვით, რაღაც, 'int x = argv 3.'
>> ეს მხოლოდ არ აპირებს აზრი, რადგან ეს არის ტექსტი, და ეს არის მთელი რიცხვი.
ასე რომ, თუ თქვენ აკონვერტირებთ შორის 2, გახსოვდეთ, ჩვენ ვაპირებთ
ეს ჯადოსნური ფუნქცია მოუწოდა atoi.
რომ იღებს სიმებიანი და გამოიტანს მთელ რიცხვს წარმოდგენილია შიგნით რომ სიმებიანი.
ასე რომ მარტივი შეცდომა, რათა on ვიქტორინა,
უბრალოდ ფიქრობდა, რომ ამ ავტომატურად იქნება სწორი ტიპის.
მაგრამ ვიცი, რომ ეს ყოველთვის იქნება სტრიქონები
მაშინაც კი, თუ სიმებიანი მხოლოდ შეიცავს მთელ რიცხვს ან სიმბოლოს ან float.
ახლა ვისაუბროთ იმაზე ქრონომეტრაჟი.
როდესაც ჩვენ ყველა ამ ალგორითმები, რომ ყველაფერი ეს გიჟები ნივთებს,
ხდება ნამდვილად სასარგებლო ვთხოვო კითხვა, "როდემდე იღებს თუ არა?"
ჩვენ წარმოვადგენთ, რომ რაღაც მოუწოდა asymptotic ნოტაცია.
ასე რომ, ეს იმას ნიშნავს, რომ - კარგად, ვთქვათ ვაძლევთ ჩვენი ალგორითმი
ზოგიერთი მართლაც, მართლაც, მართლაც დიდი შეყვანის.
ჩვენ გვინდა ვთხოვოთ კითხვაზე, "რამდენ ხანს იგი აპირებს?
რამდენი ნაბიჯები დასჭირდება ჩვენი ალგორითმი გასაშვებად
როგორც ფუნქცია ზომა შეყვანის? "
ამიტომ პირველ გზა ჩვენ შეგვიძლია აღვწეროთ აწარმოებს დრო არის დიდი ო
და ეს ჩვენი უარესი ქრონომეტრაჟი.
ასე რომ, თუ გვინდა, რომ დასალაგებლად მასივი, და ვაძლევთ ჩვენი ალგორითმი მასივი
რომ მიხედვით კლებადობით როდესაც ეს უნდა იყოს აღმავალი შეკვეთა,
რომ იქნება უარეს შემთხვევაში.
ეს არის ჩვენი ზედა შეკრული წელს მაქსიმალური დრო ჩვენი ალგორითმი მიიღებს.
მეორეს მხრივ, ამ Ω აპირებს აღწერს საუკეთესო შემთხვევაში ქრონომეტრაჟი.
ასე რომ, თუ ვაძლევთ უკვე დახარისხებული მასივი დახარისხება ალგორითმი,
რამდენი ხანი დასჭირდება დასალაგებლად ეს?
და ეს, მაშინ, აღწერს ქვედა ბლოკნოტის on გაშვებული დრო.
ასე რომ აქ არის რამოდენიმე სიტყვა, რომ ზოგიერთი საერთო გაშვებული ჯერ.
ეს არის იმ აღმავალი შეკვეთა.
სწრაფი გაშვებული დროს ჩვენ ეწოდება მუდმივი.
>> ეს იმას ნიშნავს, არა აქვს მნიშვნელობა თუ რამდენი ელემენტები ვაძლევთ ჩვენი ალგორითმი,
რაც არ უნდა დიდი ჩვენი მასივი, დახარისხება იგი
ან აკეთებს რასაც ვაკეთებთ მასივს ყოველთვის მიიღოს იმავე დროის.
ასე რომ ჩვენ შეგვიძლია იმას რომ მხოლოდ 1, რაც მუდმივი.
ჩვენ ასევე შევხედე ლოგარითმული პერსპექტივაში დრო.
ასე რომ რაღაც ბინარული ძებნის ლოგარითმული,
სადაც ჩვენ გაჭრა პრობლემა ნახევარი ყოველ ჯერზე
და შემდეგ რამ უბრალოდ უმაღლესი იქიდან.
და თუ თქვენ ოდესმე წერა O ნებისმიერი factorial ალგორითმი,
თქვენ ალბათ არ უნდა განიხილოს ეს თქვენი დღის სამუშაო.
როდესაც შევადარებთ გაშვებული ჯერ მნიშვნელოვანია გვახსოვდეს ეს ყველაფერი.
ასე რომ, თუ მაქვს ალგორითმი რომ O (N), და სხვისი
უკვე ალგორითმი O (2n) ეს არის რეალურად asymptotically ექვივალენტს.
ასე რომ, თუ ჩვენ წარმოიდგინეთ n უნდა იყოს დიდი რაოდენობით მოსწონს eleventy მილიარდი:
ასე რომ, როდესაც ჩვენ შედარებით eleventy მილიარდი რაღაც eleventy მილიარდი + 3,
მოულოდნელად რომ +3 ნამდვილად არ მიიღოს დიდი განსხვავება აღარ არის.
ამიტომ, ჩვენ ვაპირებთ დავიწყოთ გათვალისწინებით ეს ყველაფერი უნდა იყოს ექვივალენტს.
ასე რამ, როგორიცაა ამ მუდმივები აქ, იქ 2 x ამ, ან დაამატონ 3,
ეს უბრალოდ მუდმივები და ამ ვაპირებთ ვარდნა up.
ასე ამიტომ ყველა 3 ამ პერსპექტივაში times are იგივე დაყრდნობით ისინი O (N).
ანალოგიურად, თუ გვაქვს 2 სხვა პერსპექტივაში ჯერ, ვთქვათ O (N ³ + 2n ²), ჩვენ შეგვიძლია დაამატოთ
+ N, + 7 და შემდეგ გვაქვს მეორე ტურის დროს ეს მხოლოდ O (N ³).
ერთხელ, ეს არის იგივე რადგან ეს - ეს არ არის ერთი და იგივე.
ეს არის იგივე რამ, უკაცრავად. ასე რომ ეს არის იგივე იქნება
ამ n ³ აპირებს დომინირება ამ 2n ².
>> რა არ არის იგივე რამ არის, თუ ჩვენ არ აწარმოებს ჯერ მოსწონს O (N ³) და O (N ²)
რადგან ამ N ³ ბევრად აღემატება ამ n ².
ასე რომ, თუ ჩვენ გვაქვს ექსპონატები, მოულოდნელად ამ იწყებს მნიშვნელობა,
მაგრამ როცა ჩვენ უბრალოდ საქმე ფაქტორების როგორც ჩვენ აქ,
მაშინ ის არ აპირებს მნიშვნელობა, რადგან ისინი უბრალოდ აპირებს ვარდნა გარეთ.
მოდით შევხედოთ ზოგიერთი ალგორითმის ჩვენ ვნახეთ ჯერჯერობით
და ვისაუბროთ მათ პერსპექტივაში დრო.
პირველი გზა ეძებს ნომერი სიაში, რომ დავინახეთ, იყო ხაზოვანი ძებნა.
და განხორციელების ხაზოვანი ძებნა არის სუპერ მარტივია.
ჩვენ უბრალოდ უნდა სიაში, და ჩვენ ვაპირებთ შევხედოთ თითოეული ელემენტი სია
სანამ ჩვენ პუნქტების ჩვენ ვეძებთ.
ასე რომ, რაც იმას ნიშნავს, რომ უარეს შემთხვევაში, ამ O (N).
და უარეს შემთხვევაში აქ შეიძლება იყოს თუ ელემენტი არის
ბოლო ელემენტს, მაშინ გამოყენებით ხაზოვანი ძებნა გვაქვს შევხედოთ თითოეული ელემენტს
სანამ არ მივიღებთ, რომ ბოლო ერთი, რათა იცოდეს, რომ ეს იყო რეალურად სიაში.
ჩვენ არ შეგვიძლია უბრალოდ დათმობას შუა ნაწილამდე იყვნენ და ამბობენ, "ეს, ალბათ, არ არსებობს."
With ხაზოვანი ძებნა გვაქვს შევხედოთ მთელი რამ.
საუკეთესო შემთხვევაში ქრონომეტრაჟი, მეორეს მხრივ, არის მუდმივი
რადგან საუკეთესო შემთხვევაში ელემენტს ჩვენ ვეძებთ მხოლოდ პირველი სიაში.
ამიტომ აპირებს us ზუსტად 1 ნაბიჯი, რაც არ უნდა დიდი სია
თუ ჩვენ ვეძებთ პირველ ელემენტს ყოველ ჯერზე.
>> ასე რომ, როდესაც თქვენ მოძებნოთ, გახსოვდეთ, ეს არ მოითხოვს, რომ ჩვენს სიაში იყოს დახარისხებული.
იმის გამო, რომ ჩვენ უბრალოდ აპირებს გამოიყურებოდეს მეტი თითოეული ელემენტის, და ეს ნამდვილად არ აქვს მნიშვნელობა
რა მიზნით იმ ელემენტების სისტემაში
უფრო ინტელექტუალური ძებნა ალგორითმი არის რაღაც ორობითი ძებნა.
გახსოვდეთ, განხორციელების ორობითი ძებნა არის, როდესაც თქვენ აპირებთ
შენარჩუნება ეძებს შუა სიაში.
და რადგან ჩვენ ეძებს ახლო, ჩვენ მოითხოვს, რომ სიაში დალაგებულია
ანდა არ ვიცით, სადაც ახლო არის, და ჩვენ უნდა გამოიყურებოდეს მეტი
მთელი სია მის საპოვნელად, და შემდეგ იმ ეტაპზე ჩვენ უბრალოდ დროის გაყვანაა.
ასე რომ, თუ ჩვენ გვაქვს დახარისხებული სია და ჩვენ ახლო, ჩვენ ვაპირებთ შედარების ახლო
რათა ელემენტს ჩვენ ვეძებთ.
თუ ძალიან მაღალია, მაშინ ჩვენ შეგვიძლია დავივიწყოთ მარჯვენა ნახევარში
რადგან ჩვენ ვიცით, რომ თუ ჩვენი ელემენტს უკვე ძალიან მაღალი
და ყველაფერი უფლებას ამ ელემენტის არის კიდევ უფრო მაღალი,
მაშინ ჩვენ არ გვჭირდება თვალი იქ უქმნით.
სად მეორეს მხრივ, თუ ჩვენი ელემენტს ძალიან დაბალია,
ჩვენ ვიცით ყველაფერი მარცხნივ რომ ელემენტს ასევე ძალიან დაბალია,
ასე რომ ნამდვილად არ აქვს აზრი, თვალი იქ, არც.
ამ გზით, ყველა ნაბიჯი და ყოველ ჯერზე შევხედავთ შუაში სია,
ჩვენ ვაპირებთ გაჭრა ჩვენი პრობლემა ნახევარი რადგან მოულოდნელად ვიცით
მთელი bunch of ციფრები, რომ არ შეიძლება იყოს ერთი ჩვენ ვეძებთ.
>> In pseudocode ამ გამოიყურება მსგავსი რამ,
და რადგან ჩვენ ჭრის სია ნახევარ თითოეული დრო,
ჩვენი უარესი პერსპექტივაში დრო jumps საწყისი ხაზოვანი to ლოგარითმული.
ასე მოულოდნელად გვაქვს შესვლა ნაბიჯები, რათა ელემენტს სიაში.
საუკეთესო შემთხვევაში ქრონომეტრაჟი, თუმცა, ჯერ კიდევ მუდმივი
რადგან ახლა, მოდით უბრალოდ, ვამბობთ, რომ ელემენტს ჩვენ ვეძებთ არის
ყოველთვის ზუსტი შუა ორიგინალური სიაში.
ასე რომ ჩვენ შეგვიძლია იზრდება ჩვენს სიაში, როგორც დიდი, როგორც ჩვენ გვინდა, მაგრამ თუ ელემენტს ჩვენ ვეძებთ არის ახლო,
მაშინ ეს მხოლოდ აპირებს us 1 ნაბიჯი.
ასე რომ სწორედ ამიტომ ჩვენ O (შესვლა N) და Ω (1) ან მუდმივი.
მოდით რეალურად აწარმოებს ორობითი ძებნა ამ სიაში.
მოდით ვთქვათ, რომ ჩვენ ვეძებთ ელემენტს 164.
პირველი, რასაც ჩვენ ვაპირებთ გავაკეთოთ, არის მოვძებნოთ შუაში ამ სიაში.
ეს უბრალოდ ისე ხდება, რომ შუაში აპირებს ჩავარდებიან შორის 2 ნომრები,
მოდით უბრალოდ თვითნებურად ამბობენ, ყოველ ჯერზე შუაში მოდის შორის 2 ნომრები,
მოდით უბრალოდ გარშემო up.
ჩვენ უბრალოდ უნდა დავრწმუნდეთ, ჩვენ ამას ვაკეთებთ, ყოველ ეტაპზე გზა.
ამიტომ, ჩვენ ვაპირებთ გარშემო up, და ჩვენ ვაპირებთ ვთქვა, რომ 161 არის შუა ჩვენს სიაში.
ასე რომ 161 <164, და ყველა ელემენტს მარცხნივ 161
ასევე <164, ასე რომ, ჩვენ ვიცით, რომ ის არ აპირებს დაგვეხმარება ყველა
დაიწყოს ეძებს მეტი აქ იმიტომ ელემენტს ჩვენ ვეძებთ ვერ იქნება იქ.
რა შეგვიძლია გავაკეთოთ არის შეგვიძლია უბრალოდ დაივიწყოს, რომ მთელი მარცხენა ნახევარში სია,
და ახლა მხოლოდ განიხილოს მარჯვენა მხრიდან 161 Onward.
>> ასე რომ კიდევ ერთხელ, ეს არის შუაში, მოდით უბრალოდ გარშემო up.
არის 175 ძალიან დიდია.
ასე რომ, ჩვენ ვიცით, ეს არ დაგვეხმაროს ეძებს აქ ან აქ,
ამიტომ ჩვენ შეგვიძლია მხოლოდ გადაყარეთ, რომ მოშორებით, და საბოლოოდ ჩვენ მოხვდა 164.
ნებისმიერი შეკითხვა ორობითი ძებნა?
მოდით გადაადგილება საწყისი ძებნას მეშვეობით უკვე დახარისხებული სია
რეალურად აღების სიაში ნომრები ნებისმიერი თანმიმდევრობით
და მიღების, რომ სიაში აღმავალი შეკვეთა.
პირველი ალგორითმის ჩვენ შევხედეთ ერქვა bubble sort.
და ეს იქნება მარტივი of ალგორითმები დავინახეთ.
Bubble დალაგების ამბობს, რომ როდესაც რაიმე 2 ელემენტების შიგნით სია გამოსულია ადგილი,
რაც იმას ნიშნავს, არსებობს უმაღლესი ნომრის მარცხენა ქვედა ნომერი,
მაშინ ჩვენ ვაპირებთ სვოპ მათ, რადგან ეს იმას ნიშნავს, რომ სიაში იქნება
"უფრო დალაგებულია", ვიდრე ეს იყო ადრე.
და ჩვენ უბრალოდ გავაგრძელებთ ამ პროცესს ისევ და ისევ და ისევ
სანამ საბოლოოდ ელემენტები სახის ბუშტი მათი სწორი მდებარეობის და ჩვენ გვაქვს დახარისხებული სია.
>> გაუშვათ დროის ამ იქნება O (N ²). რატომ?
ასევე, ვინაიდან უკიდურეს შემთხვევაში, ჩვენ ვაპირებთ მიიღოს ყველა ელემენტს, და
ჩვენ ვაპირებთ დასრულდება მდე შედარებით მას ყველა სხვა ელემენტს სიაში.
მაგრამ საუკეთესო შემთხვევაში, ჩვენ გვაქვს უკვე დახარისხებული სია, bubble sort ს
უბრალოდ აპირებს გავლა ერთხელ, რომ "Nope. მე არ გაუკეთებია გაცვლებს, ამიტომ მე გაკეთდეს."
ასე რომ, ჩვენ გვაქვს საუკეთესო შემთხვევაში გაშვებული დრო Ω (N).
მოდით აწარმოებს bubble sort წლის სიაში.
ან პირველი, მოდით შევჩერდეთ ზოგიერთ pseudocode მართლაც სწრაფად.
ჩვენ გვინდა ვთქვათ, ჩვენ გვინდა ტრეკზე, ყოველ iteration of მარყუჟის,
ტრეკზე თუ არა ჩვენ შეიცვალა რაიმე ელემენტებს.
ასე რომ მიზეზი, რომ არის, ჩვენ შევწყვეტთ, როდესაც ჩვენ არ swapped ნებისმიერი ელემენტები.
ასე სტარტზე ჩვენი loop ჩვენ არ swapped არაფერი, ისე ჩვენ ვთქვათ, რომ არის ყალბი.
ახლა ჩვენ ვაპირებთ გავლა სიაში და შედარების ელემენტს მე რომ ელემენტს მე + 1
და თუ ეს საქმე, რომ არსებობს უფრო დიდი რაოდენობის მარცხნივ პატარა ნომერი,
მაშინ ჩვენ უბრალოდ აპირებს სვოპ მათ.
>> და შემდეგ ჩვენ ვაპირებთ გვახსოვდეს, რომ ჩვენ swapped ელემენტს.
ეს იმას ნიშნავს, რომ ჩვენ უნდა გაიაროს სიაში მინიმუმ 1 მეტი დრო
რადგან მდგომარეობა, რომელშიც ჩვენ შეწყვიტა, როდესაც მთელი სია უკვე დახარისხებული,
რაც იმას ნიშნავს, რომ ჩვენ არ გაუკეთებიათ გაცვლებს.
ასე რომ სწორედ ამიტომ ჩვენი მდგომარეობა ქვევით აქ არის "ხოლო ზოგიერთი ელემენტები უკვე swapped. '
ახლა მოდით შევჩერდეთ ამ გაშვებული სიაში.
მაქვს სია 5,0,1,6,4.
Bubble დალაგების იწყებს ყველა გზა at მარცხენა და ეს აპირებს შესადარებლად
მე ელემენტებს, ასე რომ 0 დან I + 1, რომელიც ელემენტს 1.
იგი აპირებს ამბობენ, კარგად 5> 0, მაგრამ ახლავე 5 არის მარცხენა
ამიტომ მე უნდა სვოპ 5 და 0.
როდესაც მე სვოპ მათ, მოულოდნელად მივიღებ ამ სხვადასხვა სიაში.
არის 5> 1, ამიტომ ჩვენ ვაპირებთ სვოპ მათ.
5 არ არის> 6, ამიტომ ჩვენ არ გვჭირდება არაფრის აქ.
მაგრამ 6> 4, ამიტომ ჩვენ უნდა სვოპ.
ისევ და ისევ, ჩვენ გვჭირდება აწარმოებს მთელ სიაში საბოლოოდ აღმოჩენა
რომ ეს მწყობრიდან გამოსულია, ჩვენ სვოპ მათ,
და ამ ეტაპზე ჩვენ გვჭირდება აწარმოებს მეშვეობით სია 1 მეტი დრო
დავრწმუნდეთ, რომ ყველაფერი თავის იმისათვის, და ამ ეტაპზე bubble sort დასრულდა.
სხვადასხვა ალგორითმი აღების ზოგიერთი ელემენტები და დახარისხება მათ შერჩევას ჯიშია.
იდეა უკან შერჩევის დალაგება, რომ ჩვენ ვაპირებთ დაამყარონ დახარისხებული ნაწილი სიაში
1 ელემენტს დროს.
>> და გზა ჩვენ ვაპირებთ, რომ არის მშენებლობაზე მარცხენა სეგმენტი სიაში.
და ძირითადად, ყოველ - ყოველ ნაბიჯს, ჩვენ აპირებს პატარა ელემენტს ჩვენ არ დაუტოვებიათ
რომ არ იქნა დახარისხებული არ არის, და ჩვენ ვაპირებთ მისი გადატანა შევიდა, რომ დალაგებულია სეგმენტი.
ეს იმას ნიშნავს, რომ ჩვენ უნდა მუდმივად იპოვოს მინიმალური არასორტირებული ელემენტს
და შემდეგ მიიღოს, რომ მინიმალური ელემენტს და სვოპ ის რასაც
მარცხენა საუკეთესო ელემენტს, რომელიც არ არის დახარისხებული.
გაუშვათ დროის ამ იქნება O (N ²) რადგან უარეს შემთხვევაში
ჩვენ გვჭირდება შედარების თითოეული ელემენტს ყველა სხვა ელემენტს.
იმის გამო, რომ ჩვენ ვამბობთ, რომ თუ ჩვენ იწყება მარცხენა ნახევარში სია, ჩვენ გვჭირდება
გავლა მთელი უფლება სეგმენტი იპოვონ ყველაზე მცირე ელემენტს.
და შემდეგ, კიდევ ერთხელ, ჩვენ გვჭირდება მთელ უფლება სეგმენტი და
შენარჩუნება აპირებს მეტი რომ დასრულდა და უსასრულოდ.
რომ იქნება n ². ჩვენ ვაპირებთ გვჭირდება ამისთვის loop შიგნით მეორე მარყუჟის
რომელიც გვთავაზობს n ².
საუკეთესო შემთხვევაში აზრის, ვთქვათ ვაძლევთ მას უკვე დახარისხებული სიაში;
ჩვენ რეალურად არ რაიმე უკეთესი, ვიდრე n ².
რადგან შერჩევა sort ვიზიტორების გზა იცის, რომ
მინიმალური ელემენტს მხოლოდ ერთი მე მოხდეს უნდა ეძებს.
იგი ჯერ კიდევ დარწმუნდით რომ ეს რეალურად მინიმალური.
>> და ერთადერთი გზა, დარწმუნდით, რომ ის მინიმალური გამოყენებით ამ ალგორითმი,
არის შევხედოთ თითოეული ელემენტს ერთხელ.
ასე ნამდვილად, თუ თქვენ მისცეს მას - თუ მისცეს შერჩევის დალაგების უკვე დახარისხებული სია,
ეს არ აპირებს რაიმე უკეთესი, ვიდრე ვაძლევთ მას სიაში რომ არ არის დახარისხებული ამჟამად.
სხვათა შორის, თუ ეს მოხდება, რომ იყოს საქმე, რომ რაღაც არის O (რაღაც)
და ომეგა რაღაცის, ჩვენ შეგვიძლია უბრალოდ, ვამბობთ მეტი succinctly რომ θ რაღაცის.
ასე რომ, თუ ხედავთ, რომ ამუშავება არსად არის ის, რაც, რომ უბრალოდ ნიშნავს.
>> თუ რამე არის Theta of n ², ეს როგორც დიდი O (N ²) და Ω (n ²).
ასე რომ საუკეთესო შემთხვევაში და უარეს შემთხვევაში, ეს არ მიიღოს განსხვავება,
ალგორითმი აპირებს იგივე ყოველ ჯერზე.
ასე რომ, ეს არის ის, რაც pseudocode შერჩევის დალაგება შეიძლება გამოიყურებოდეს.
ჩვენ ძირითადად აპირებს ვთქვა, რომ მინდა iterate მეტი სია
მარცხნიდან მარჯვნივ, და ყოველ iteration of მარყუჟის, მე ვაპირებ გადაადგილება
მინიმალური ელემენტს ამ დახარისხებული ნაწილი სიაში.
და კიდევ მე გადაადგილება რაღაც არსებობს, მე არასოდეს უნდა შევხედოთ, რომ ელემენტს ერთხელ.
იმის გამო, რომ როგორც კი სვოპ ელემენტია მარცხნივ სეგმენტი სიაში, ეს დახარისხებული
რადგან ვაკეთებთ ყველაფერს აღმავალი შეკვეთა გამოყენებით მინიმუმების.
ამიტომ, ჩვენ განაცხადა, okay, ჩვენ პოზიციაში მე, და ჩვენ გვჭირდება შევხედოთ ყველა ელემენტები
მარჯვნივ მე, რათა მინიმალური.
ასე რომ, რაც იმას ნიშნავს, რომ ჩვენ გვინდა გამოიყურებოდეს საწყისი i + 1 სიის ბოლოში.
და ახლა, თუ ის ელემენტი, რომელიც ჩვენ გაკეთებული ეძებს ნაკლებია, ვიდრე ჩვენი მინიმალური ჯერჯერობით
რომელიც, გახსოვდეთ, რომ ჩვენ დაწყებული მინიმუმ off უბრალოდ იყოს
რასაც ელემენტს ჩვენ ამჟამად, მე ვივარაუდოთ, რომ მინიმუმ.
თუ მე ელემენტს, რომ უფრო მცირე, ვიდრე ის, რომ მაშინ მე ვაპირებ ვთქვა, okay,
ასევე, მე აღმოვაჩინე ახალი მინიმალური.
მე ვაპირებ გახსოვთ სადაც ეს მინიმალური იყო.
>> ახლა, ერთხელ მე გავიარეთ, რომ უფლება არასორტირებული სეგმენტი,
შემიძლია ვთქვა, მე ვაპირებ სვოპ მინიმალური ელემენტს ერთად ელემენტს, რომელიც თანამდებობა მე.
რომ აპირებს შექმნას ჩემი სია, ჩემი დახარისხებული ნაწილი სიაში მარცხნიდან მარჯვნივ,
და ჩვენ არ ოდესმე უნდა შევხედოთ ელემენტს ერთხელ კიდევ ის, რომ ნაწილი.
ერთხელ ჩვენ swapped იგი.
მოდით აწარმოებს შერჩევას დალაგების ამ სიაში.
ლურჯი ელემენტს აქ იქნება მე და წითელი ელემენტს იქნება მინიმალური ელემენტს.
ასე რომ იწყება ყველა გზა at მარცხენა სიის, ისე 5.
ახლა ჩვენ გვჭირდება, მინიმუმ არასორტირებული ელემენტს.
ამიტომ ვამბობთ 0 <5, ასე 0 არის ჩემი ახალი მინიმალური.
>> მაგრამ მე ვერ შეაჩერებს იქ, რადგან მიუხედავად იმისა, რომ ჩვენ შეგვიძლია ვაღიაროთ, რომ 0 არის ყველაზე პატარა,
ჩვენ გვჭირდება აწარმოებს მეშვეობით ყველა სხვა ელემენტის სიაში რომ დავრწმუნდეთ.
ამგვარად 1 მეტია, 6 მეტია, 4 მეტია.
ეს იმას ნიშნავს, რომ მას შემდეგ ეძებს ყველა ამ ელემენტების, მე განსაზღვრული 0 არის ყველაზე პატარა.
ამიტომ მე ვაპირებ სვოპ 5 და 0.
ერთხელ სვოპ რომ, მე ვაპირებ, რომ მიიღოთ ახალი სია, და ვიცი, რომ არასოდეს უნდა შევხედოთ, რომ 0 ერთხელ
რადგან ერთხელ მე swapped იგი, მე დახარისხებული და ჩვენ გავაკეთეთ.
ახლა კი ასე ხდება, რომ ლურჯი ელემენტს კვლავ 5,
და ჩვენ გვჭირდება შევხედოთ 1, 6 და 4 რათა დადგინდეს, რომ 1
არის პატარა მინიმალური ელემენტს, ამიტომ ჩვენ სვოპ 1 და 5.
ერთხელ, ჩვენ უნდა შევხედოთ - შედარების 5 დან 6 და 4,
და ჩვენ ვაპირებთ სვოპ 4 და 5 და ბოლოს, შედარების
იმ 2 ნომრები და სვოპ მათ სანამ არ მივიღებთ ჩვენი დახარისხებული სია.
ნებისმიერი კითხვები შერჩევის დალაგება?
Okay. მოდით გადავა ბოლო თემა აქ, და რომ არის უკან.
>> უკან, გახსოვდეთ, ეს მართლაც მეტა რამ სადაც ფუნქცია
არაერთხელ უწოდებს თავად.
ასე რომ რაღაც მომენტში, მაშინ, როდესაც ჩვენი ფუნქციის გამოსართავად არის არაერთხელ მოუწოდებდა თავად,
იქ უნდა იყოს რაღაც მომენტში, რომლის დროსაც ჩვენ შეწყვიტოს მოუწოდებენ საკუთარ თავს.
რადგან თუ ჩვენ არ გავაკეთებთ, მაშინ ჩვენ უბრალოდ გავაგრძელებთ ამის გაკეთებას სამუდამოდ,
და ჩვენი პროგრამა უბრალოდ არ აპირებს შეწყვიტოს.
ჩვენ მოვუწოდებთ ამ მდგომარეობა ბაზის შემთხვევაში.
და ბაზის შემთხვევაში ამბობს, ვიდრე მოუწოდებდა ფუნქციის ერთხელ,
მე უბრალოდ დაბრუნებას აპირებს გარკვეული მნიშვნელობა.
ასე რომ ერთხელ ჩვენ დაბრუნდა ღირებულება, ჩვენ შეწყვიტა მოუწოდებდა საკუთარ თავს,
და დანარჩენ მოუწოდებს ჩვენ ამ დრომდე ასევე შეუძლია დაბრუნდეს.
საპირისპირო ბაზის საქმე რეკურსიული შემთხვევაში.
და ეს არის, როცა ჩვენ გვსურს კიდევ ერთი ზარი ფუნქცია რომ ჩვენ გაკეთებული სისტემაში
და ჩვენ ალბათ, თუმცა არა ყოველთვის, გინდათ გამოიყენოთ სხვადასხვა არგუმენტები.
>> ასე რომ, თუ ჩვენ გვაქვს ფუნქცია მოუწოდა ვ და ვ უბრალოდ მოუწოდა მიიღოს 1 არგუმენტი,
და ჩვენ უბრალოდ შეინახოს მოუწოდებდა ვ (1), ვ (1), ვ (1), და ეს ასე მოხდება, რომ
არგუმენტი 1 იყოფა რეკურსიული შემთხვევაში, ჩვენ მაინც არასოდეს შევწყვეტთ.
მაშინაც კი, თუ ჩვენ გვაქვს ბაზის შემთხვევაში, ჩვენ უნდა დავრწმუნდეთ, რომ საბოლოოდ ჩვენ ვაპირებთ მოხვდა, რომ ბაზის შემთხვევაში.
ჩვენ არა მარტო შენარჩუნება დარჩენის ამ რეკურსიული შემთხვევაში.
საერთოდ, როცა ჩვენ მოვუწოდებთ თავს, ჩვენ ალბათ გვექნება სხვადასხვა არგუმენტი ყოველ ჯერზე.
აქ არის ნამდვილად მარტივი რეკურსიული ფუნქცია.
ასე რომ, ეს იქნება გამოთვლაც factorial რიგი.
Up ზემოთ აქ ჩვენ გვაქვს ჩვენი ბაზის შემთხვევაში.
იმ შემთხვევაში, რომ n ≤ 1, ჩვენ არ ვაპირებთ, რომ მოვუწოდო factorial ერთხელ.
ჩვენ ვაპირებთ შეჩერება, ჩვენ უბრალოდ დაბრუნებას აპირებს გარკვეული მნიშვნელობა.
თუ ეს ასე არ არის, მაშინ ჩვენ ვაპირებთ მოხვდა ჩვენი რეკურსიული შემთხვევაში.
გაითვალისწინეთ, რომ ჩვენ არა მხოლოდ მოუწოდებდა factorial (N), იმიტომ, რომ არ შეიძლება იყოს ძალიან სასარგებლო.
ჩვენ ვაპირებთ, რომ მოვუწოდო factorial of რაღაც.
>> და ა.შ. ხედავთ, საბოლოოდ, თუ ჩვენ გაიაროს factorial (5) ან რამე,
ჩვენ ვაპირებთ მოვუწოდებთ factorial (4) და ასე შემდეგ, და საბოლოოდ ჩვენ ვაპირებთ მოხვდა ამ ბაზის შემთხვევაში.
ასე რომ, ეს გამოიყურება კარგი. ვნახოთ რა მოხდება, როდესაც ჩვენ რეალურად აწარმოებს ამ.
ეს არის დასტის, და ვთქვათ, რომ ძირითადი აპირებს მოვუწოდებთ ამ ფუნქციის არგუმენტი (4).
ასე რომ ერთხელ factorial ხედავს და = 4, factorial კვლავ თავს.
ახლა, მოულოდნელად, ჩვენ გვაქვს factorial (3).
ასე რომ ამ ფუნქციების ვაპირებთ შენარჩუნება იზრდება, სანამ საბოლოოდ ჩვენ მოხვდა ჩვენი ბაზის შემთხვევაში.
ამ ეტაპზე, დაბრუნების ღირებულება ეს დაბრუნების (NX დაბრუნებული მნიშვნელობა ამ),
დაბრუნების ღირებულება ეს არის NX დაბრუნებული მნიშვნელობა ამ.
საბოლოოდ ჩვენ უნდა მოხვდა რამდენიმე ნომერზე.
ზედა აქ, ვამბობთ დაბრუნების 1.
ეს იმას ნიშნავს, რომ ერთხელ ვბრუნდებით, რომ ნომერი, ჩვენ შეგვიძლია პოპ ამ off Stack.
ასე რომ, ეს factorial (1) კეთდება.
როდესაც 1 ანაზღაურება, ამ factorial (1) ანაზღაურება, ამ დაბრუნების 1.
დაბრუნებული მნიშვნელობა ამ, გახსოვდეთ, იყო NX დაბრუნებული მნიშვნელობა ამ.
ასე მოულოდნელად, ამ ბიჭს იცის, რომ მინდა დაბრუნების 2.
>> ასე მახსოვს, დაბრუნდნენ ღირებულების ეს მხოლოდ NX დაბრუნებული მნიშვნელობა აქ.
ახლა შეგვიძლია ვთქვათ, 3 x 2, და ბოლოს, აქ შეგვიძლია ვთქვათ,
ეს მხოლოდ იქნება 4 x 3 x 2.
და კიდევ ამ ანაზღაურება, მივიღებთ ქვემოთ ერთი მთელი რიცხვი შიგნით ძირითადი.
ნებისმიერი შეკითხვა უკან?
ყველა უფლება. ასე რომ იქ მეტი დრო კითხვები დასასრულს,
მაგრამ ახლა ჯოზეფ დაფარავს დარჩენილი თემები.
>> [ჯოზეფ Ong] ყველა უფლება. ახლა რომ ჩვენ ვისაუბრეთ recursions,
ვისაუბროთ ცოტა იმაზე, თუ რა შერწყმა დალაგების არის.
შერწყმა დალაგების ძირითადად სხვა გზა დახარისხება სიაში ნომრები.
და როგორ მუშაობს არის, ერთად შერწყმა დალაგების გაქვთ სიაში, და რას ვაკეთებთ არის
ჩვენ ვამბობთ, მოდით გაყოფილი ამ შევიდა 2 halves.
ჩვენ პირველი აწარმოებს შერწყმა დალაგების კვლავ მარცხენა ნახევარში,
მაშინ ჩვენ აწარმოებს შერწყმა დალაგების მარჯვენა ნახევარში,
და რომ გვაძლევს არის 2 halves, რომლებიც დალაგებულია, და ახლა ჩვენ ვაპირებთ დააკავშიროთ იმ halves ერთად.
ეს ცოტა რთული ვხედავ გარეშე მაგალითად, ასე ჩვენ გავლა შუამდგომლობა და ვნახოთ, რა მოხდება.
ასე, რომ თქვენ იწყება ამ სიაში, ჩვენ გაყოფილი იგი 2 halves.
ჩვენ აწარმოებს შერწყმა დალაგების მარცხენა ნახევარში პირველი.
ასე რომ მარცხენა ნახევარში, და ახლა ჩვენ აწარმოებს მათ ამ სიაში კვლავ
რომელიც იღებს შევიდა შერწყმა დალაგების, და შემდეგ გადავხედავთ, კიდევ ერთხელ,
at მარცხენა მხარეს ამ სიაში და ჩვენ აწარმოებს შერწყმა დალაგების მასზე.
ახლა ჩვენ კიდევ ქვევით სიაში 2 ნომრები,
და ახლა მარცხენა ნახევარში არის მხოლოდ 1 ელემენტს ხანგრძლივი, და ჩვენ არ შეგვიძლია
გაყოფილი სია რომ მხოლოდ 1 ელემენტს შევიდა ნახევარი, ასე რომ ჩვენ უბრალოდ, ვამბობთ, ერთხელ ჩვენ გვყავს 50,
რომელიც მხოლოდ 1 ელემენტს, უკვე დახარისხებული.
>> ერთხელ ჩვენ გაკეთდეს, რომ, ჩვენ ვხედავთ, რომ შეგვიძლია
გადასვლა მარჯვნივ ნახევარში ამ სიაში,
და 3 ასევე დახარისხებული და ა.შ. არის, რომ ორივე halves ამ სიაში არიან დახარისხებული
ჩვენ შეგიძლიათ შეუერთდება ამ ნომრებზე უკან ერთად.
ამიტომ, ჩვენ შევხედოთ 50 და 3; 3 მცირეა 50, ასე რომ მიდის და შემდეგ 50 მოდის შემოსული
ახლა, რომ კეთდება, ჩვენ დავბრუნდებით მდე რომ სიაში და დალაგების ის მარჯვენა ნახევარში.
42 არის საკუთარი ნომერი, ამიტომ უკვე დახარისხებული.
ახლა შევადარებთ ამ 2 და 3 მცირეა 42, ასე რომ იღებს დასვა პირველი,
ახლა 42 იღებს დასვა და 50 იღებს დააყენა სისტემაში
ახლა, რომ დახარისხებული, ჩვენ წავიდეთ ყველა გზა თავში დაბრუნება, 1337 და 15.
ასევე, ჩვენ ახლა შევხედოთ მარცხენა ნახევარში ამ სიაში; 1337 არის თავისთავად ამიტომ დახარისხებული და იგივე 15.
ახლა ჩვენ დააკავშიროთ ამ 2 ნომრები დასალაგებლად რომ ორიგინალური სიაში, 15 <1337,
ასე რომ მიდის პირველი, მაშინ 1337 ღებულობენ სისტემაში
და ახლა ჩვენ დახარისხებული ორივე halves of ორიგინალური სიაში up დაბრუნება.
და ყველა ჩვენ უნდა გააკეთოთ დააკავშიროთ ამ.
ჩვენ შევხედოთ პირველი 2 ნომრები ამ სიაში, 3 <15, ასე რომ გადადის დალაგების array პირველი.
15 <42, ასე რომ მიდის შემოსული ახლა, 42 <1337, რომ მიდის შემოსული
50 <1337, ასე რომ მიდის შემოსული და შეამჩნია, რომ ჩვენ უბრალოდ აიღო 2 ნომრები off ამ სიაში.
ამიტომ ჩვენ არა მხოლოდ ალტერნატიული შორის 2 სიები.
ჩვენ უბრალოდ ეძებს დასაწყისში, და ჩვენ აღების ელემენტს
რომ უფრო მცირე და შემდეგ აყენებს იგი ჩვენი მასივი.
ახლა ჩვენ გაერთიანდა ყველა halves და ჩვენ გავაკეთეთ.
>> რაიმე კითხვა შერწყმა დალაგება? დიახ?
[სტუდენტური] თუ ეს გაყოფის შევიდა სხვადასხვა ჯგუფების, რატომ არ მხოლოდ გაყოფილი ეს ერთხელ
და თქვენ 3 და 2 ჯგუფი? [დანარჩენი კითხვა გაუგებარია]
მიზეზი - ასე კითხვა არის, რატომ არ შეიძლება ჩვენ მხოლოდ შერწყმა მათ, რომ პირველი ნაბიჯი შემდეგ ჩვენ გვაქვს მათთან?
მიზეზი ჩვენ შეგვიძლია ამის გაკეთება, იწყება მარცხენა საუკეთესო ელემენტები ორივე მხარეს,
და შემდეგ მიიღოს პატარა ერთი და დააყენოს ის, ის არის, რომ ჩვენ ვიცით, რომ ეს
ინდივიდუალური სიები არიან დახარისხებული ბრძანებებს.
ასე რომ, თუ მე ვერ მარცხენა საუკეთესო ელემენტები ორივე halves,
მე ვიცი, ისინი იქნება ყველაზე პატარა შემადგენელი ნაწილი იმ სიებში.
ასე, რომ შეიძლება დააყენა მათი პატარა ელემენტს ლაქების ამ დიდი სია.
მეორეს მხრივ, თუ გავითვალისწინებთ იმ 2 სიები მეორე დონეზე იქ,
50, 3, 42, 1337 და 15, ეს ის არ დახარისხებული.
ასე რომ, თუ გავითვალისწინებთ 50 და 1337, მე ვაპირებ დააყენა 50 ჩემს სიაში პირველი.
მაგრამ ეს ნამდვილად არ აქვს აზრი, რადგან 3 არის ყველაზე პატარა ელემენტს გარეთ ყველა იმ.
ასე რომ ერთადერთი მიზეზი, ჩვენ შეგვიძლია გავაკეთოთ ეს აერთიანებს ნაბიჯი არის, რადგანაც ჩვენი სიები უკვე დახარისხებული.
სწორედ ამიტომ ჩვენ უნდა Get Down ყველა გზა ბოლოში
რადგან, როდესაც ჩვენ გვაქვს მხოლოდ ერთი ნომერი, თქვენ იცით, რომ ერთი ნომერი
და თავისთავად უკვე დახარისხებული სია.
>> ნებისმიერი კითხვები? არარის?
სირთულის? კარგად, ხედავთ, რომ ყოველი ნაბიჯი არსებობს ბოლომდე ნომრები,
და ჩვენ შეგვიძლია დაყოფის სია ნახევარ შესვლა N ჯერ,
რომელიც სადაც ჩვენ ამ N x შესვლა N სირთულის.
და თქვენ ნახავთ საუკეთესო შემთხვევაში შერწყმა დალაგების არის N შესვლა n, და ეს ასე მოხდება
რომ უარეს შემთხვევაში, ან Ω იქ, ასევე N შეხვიდეთ n.
რაღაც გვახსოვდეს.
მოძრავი, მოდით გაგრძელდება ზოგიერთ სუპერ ძირითადი ფაილის I / O.
თუ შევხედე Scramble თქვენ შეამჩნევთ გვქონდა გარკვეული სისტემა
სადაც თქვენ შეიძლება ჩაწერის შესვლა ფაილს თუ წაიკითხავთ მეშვეობით კოდი.
ვნახოთ თუ როგორ შეიძლება გავაკეთოთ, რომ.
ასევე, ჩვენ არ fprintf, რომელიც შეგიძლიათ წარმოიდგინოთ, რომ როგორც მხოლოდ printf,
მაგრამ დაბეჭდვის to მაგივრად, და შესაბამისად ვ დასაწყისში.
ეს ერთგვარი კოდი აქ, თუ რას აკეთებს არის, როგორც თქვენ ალბათ ჩანს Scramble,
იგი გადის თქვენი 2 განზომილებიანი მასივი დაბეჭდვისას row მიერ მწკრივი, რა რაოდენობით.
ამ შემთხვევაში, printf ბეჭდავს out თქვენს ტერმინალში ან რა ჩვენ მოვუწოდებთ სტანდარტული გამოშვება მონაკვეთზე.
>> და ახლა, ამ შემთხვევაში, ყველა ჩვენ უნდა გავაკეთოთ არის ჩაანაცვლოს printf ერთად fprintf,
გეტყვით იმას, რაც ფაილის გსურთ ბეჭდვა, და ამ შემთხვევაში ეს უბრალოდ ბეჭდავს მას აღმოჩნდება, რომ ფაილი
ნაცვლად ბეჭდვა ეს იმისათვის, რომ თქვენი ტერმინალში.
კარგად, მაშინ ეს სთხოვს კითხვა: სად მივიღებთ ამ სახის ფაილის, არა?
ჩვენ გავიდა შესვლა ამ ფუნქციის გამოსართავად fprintf მაგრამ ჩვენ წარმოდგენაც კი არ ჰქონდათ, სადაც იგი მოვიდა.
ისე, დასაწყისში კოდი, რაც ჩვენ გვქონდა იყო ამ ბლოკი კოდი მეტი აქ,
რომლებიც ძირითადად ნათქვამია, რომ ღია ფაილი მოუწოდებს log.txt.
რას ვაკეთებთ შემდეგ, რაც ჩვენ უნდა დავრწმუნდეთ, რომ ფაილი არის რეალურად გაიხსნა წარმატებით.
ასე რომ, შესაძლოა, ვერ ამისთვის რამდენიმე მიზეზი, თქვენ არ გაქვთ საკმარისი სივრცე თქვენს კომპიუტერში, მაგალითად.
ამიტომ ყოველთვის მნიშვნელოვანია, სანამ რაიმე ოპერაციების ფაილი
რომ ჩვენ შეამოწმოს თუ არა რომ ფაილი გაიხსნა წარმატებით.
მერე რა რომ, რომ არგუმენტი fopen, ასევე, ჩვენ შეგვიძლია გავხსნათ ფაილი ბევრი თვალსაზრისით.
რა შეგვიძლია გავაკეთოთ არის, ჩვენ შეგვიძლია მსგავ W, რაც იმას ნიშნავს, override ფაილს თუ ის ითიშება უკვე,
ჩვენ შეგვიძლია გაივლის, რომელიც მათ დამატება ბოლომდე ფაილის ნაცვლად მნიშვნელოვანი ის,
ან ჩვენ შეუძლია მიუთითოს r, რაც იმას ნიშნავს, მოდით გავხსნათ ფაილი, როგორც წაუკითხავი.
ასე რომ, თუ პროგრამა ცდილობს ნებისმიერი ცვლილება ფაილი,
დაწეროთ მათ და ნუ მათ ამის გაკეთება.
და ბოლოს, ერთხელ ჩვენ გაკეთდეს ფაილი, შესრულებულია აკეთებს ოპერაციებს მასზე,
ჩვენ უნდა დავრწმუნდეთ, ჩვენ დახურვა ფაილი.
და ა.შ. დასასრულს თქვენი პროგრამა, თქვენ არ გეგმავენ მათ ხელახლა
ამ ფაილის რომ თქვენ გახსნა, და მხოლოდ ვხურავთ მას.
ასე რომ, ეს არის რაღაც მნიშვნელოვანი, რომ თქვენ უნდა დავრწმუნდეთ, რომ თქვენ ამის გაკეთება.
ასე გვახსოვს შეგიძლიათ გახსნათ ფაილი, მაშინ ვწერ ფაილი,
გავაკეთოთ ოპერაციების ფაილი, მაგრამ მაშინ თქვენ უნდა დახუროთ ფაილის დასასრულს.
>> ნებისმიერი კითხვები ძირითადი ფაილის I / O? დიახ?
[სტუდენტური კითხვაზე, გაუგებარია]
მარჯვენა აქ. კითხვაზე, სადაც ამჯამად ამ log.txt ფაილი გამოჩნდება?
ისე, თუ უბრალოდ მისცეს მას log.txt, ის უქმნის მას იგივე დირექტორიაში, როგორც გაშვება.
ასე რომ, თუ you're - >> [სტუდენტური კითხვაზე, გაუგებარია]
დიახ. იმავე საქაღალდეში, ან იგივე დირექტორიაში, როგორც თქვენ ეძახით.
ახლა მეხსიერება, დასტის, და ბევრი.
მაშ როგორ არის მეხსიერება ასახული კომპიუტერი?
კარგად, თქვენ შეგიძლიათ წარმოიდგინოთ მეხსიერების როგორც დალაგების ამ ბლოკის აქ.
და მეხსიერებაში გვაქვს რასაც ბევრი დავრჩებოდით იქ, და დასტის რომ დახვდა.
და ბევრი იზრდება დაღმავალ და დასტის იზრდება აღმავალი.
ასე რომ, როგორც ტომი აღნიშნული - Oh, ისევე, და ჩვენ გვაქვს ამ სხვა 4 სეგმენტების რომელიც მე კიდევ ამ მეორე -
როგორც Tommy განაცხადა ადრე, თქვენ იცით, თუ რა იქნება მისი ფუნქციები მოვუწოდებთ თავს და მოვუწოდებთ ერთმანეთს?
მათ დაამყარონ ამ სახის დასტის ჩარჩო.
ისე, თუ მთავარ მოუწოდებს foo, foo იღებს ჩაიცვი Stack.
Foo მოუწოდებს ბარი, ბარი მიიღოს მისი დადგმა დასტის, და რომ იღებს ჩაიცვი დასტის შემდეგ.
და როგორც ისინი დაბრუნდებიან, ისინი ყოველ მისაღებად წაიყვანეს Stack.
რა თითოეულ ამ ადგილებში და მეხსიერების გამართავს?
ისე, ყველაზე, რომელიც ტექსტის სეგმენტის შეიცავს პროგრამა თავისთავად.
ასე რომ მანქანა კოდი, რომ იქ, ერთხელ თქვენ კომპილაციის თქვენი პროგრამა.
შემდეგი, ნებისმიერი ინიციალიზაცია გლობალური ცვლადები.
>> ასე რომ თქვენ არ გლობალური ცვლადები თქვენს პროგრამაში, და თქვენ ამბობთ, როგორიცაა, = 5,
რომ იღებს დასვა, რომ სეგმენტი, და უფლების რომ,
თქვენ გაქვთ რაიმე uninitialized გლობალური მონაცემები, რომელიც მხოლოდ int,
მაგრამ თქვენ არ ვამბობ, რომ ეს ტოლია არაფერი.
გააცნობიეროს ეს გლობალური ცვლადები, ამიტომ ისინი გარეთ მთავარი.
ასე რომ, ეს ნიშნავს ნებისმიერ გლობალური ცვლადები, რომლებიც გამოცხადდა, მაგრამ არ ინიციალიზდება.
ასე რომ რა ბევრი? მეხსიერება გამოყოფილი გამოყენებით malloc, რომელიც ჩვენ კიდევ ამ ცოტა.
და ბოლოს, ერთად დასტის თქვენ გაქვთ რაიმე ადგილობრივი ცვლადები
და ნებისმიერი ფუნქციები შეიძლება მოვუწოდებთ ნებისმიერი მათი პარამეტრების.
ბოლო რამ, თქვენ ნამდვილად არ უნდა ვიცოდეთ, თუ რა გარემოში ცვლადები გავაკეთოთ,
მაგრამ როდესაც თქვენ აწარმოებს პროგრამა, არსებობს რაღაც ასოცირდება, ისევე როგორც
ეს სახელი იმ პირზე, რომელიც გაიქცა პროგრამა.
და ეს იქნება ერთგვარი ბოლოში.
თვალსაზრისით მეხსიერების მისამართები, რომლებიც თექვსმეტობითი ღირებულებებს,
ღირებულებები ზედა იწყება 0, და ისინი წავიდეთ ყველა გზა ქვემოთ ბოლოში.
ამ შემთხვევაში, თუ თქვენ წლის 32-bit სისტემა,
მისამართი ბოლოში იქნება 0x, მოჰყვა AF, რადგან ისინი 32 ბიტი,
რომელიც 8 ბაიტი, და ამ შემთხვევაში 8 ბაიტი შეესაბამება 8 თექვსმეტობითი ციფრები.
ასე ქვევით აქ თქვენ აპირებს აქვს, ისევე, 0xffffff, და იქ თქვენ აპირებს აქვს 0.
რა არის პოინტერები? ზოგიერთ თქვენგანს შეიძლება არ დაფარული ამ ნაწილში ადრე.
მაგრამ ჩვენ არ წასვლა მას ლექციების, ამიტომ კურსორი არის უბრალოდ მონაცემები ტიპის
რომელიც მაღაზიებში, ნაცვლად გარკვეული ღირებულება, როგორიცაა 50, იგი ინახავს მისამართი ზოგიერთი საიდან მეხსიერებაში.
მომწონს, რომ მეხსიერების [გაუგებარია].
ასე რომ, ამ შემთხვევაში, რაც ჩვენ არ არის, ჩვენ გვაქვს მომცეთ მთელი რიცხვი ან int *,
და იგი შეიცავს ამ თექვსმეტობითი მისამართი 0xDEADBEEF.
>> ასე რომ, რაც გვაქვს არის, ახლა, ამ მაჩვენებელმა რაოდენობა რაღაც საიდან მეხსიერებაში,
და ეს მხოლოდ, ღირებულება 50 არის ამ მეხსიერების საიდან.
ზოგიერთ 32-bit სისტემები, ყველა 32-bit სისტემები, მითითებები დასჭირდეს 32 ბიტი ან 4 ბაიტი.
მაგრამ, მაგალითად, 64-bit სისტემა, მითითებები 64 ბიტი.
ასე რომ რაღაც თქვენ მინდა გვახსოვდეს.
ასე ბოლომდე ბიტიანი სისტემა, კურსორი არის ბოლომდე ბიტი ხანგრძლივი.
მითითებები სახის რთული დაიჯესტს გარეშე ზედმეტი ნივთები,
მოდით გავლა მაგალითი დინამიური მეხსიერების გამოყოფის.
რა დინამიური მეხსიერების გამოყოფის აკეთებს თქვენთვის, ან ის, რაც ჩვენ მოვუწოდებთ malloc,
იგი საშუალებას გაძლევთ გამოყოს გარკვეული მონაცემები გარეთ კომპლექტი.
ასე რომ, ეს მონაცემები არის ერთგვარი უფრო ხანგრძლივვადიანი ამისთვის პროგრამის ხანგრძლივობა.
რადგან, როგორც იცით, თუ განაცხადოს x შიგნით ფუნქცია, და რომ ფუნქცია დააბრუნებს,
თქვენ აღარ ხელმისაწვდომობის მონაცემები, რომელიც ინახება x.
რა პოინტერები მოდით გავაკეთოთ არის ისინი მოდით შესანახად მეხსიერებაში ან მაღაზიის ღირებულებები
სხვადასხვა სეგმენტი მეხსიერება, კერძოდ ბევრი.
ახლა კიდევ ერთხელ ვბრუნდებით გარეთ ფუნქცია, რადგან ჩვენ გვაქვს მაჩვენებელი
იმ ადგილას მეხსიერება, მაშინ რა შეგვიძლია გავაკეთოთ არის შეგვიძლია შევჩერდეთ ღირებულებები არსებობს.
მოდით შევხედოთ მაგალითს: ეს არის ჩვენი მეხსიერება ერთხელ.
და ჩვენ გვაქვს ამ ფუნქციის მთავარი.
რა ეს იმას არის - Okay, ასე მარტივი, არა? - Int x = 5, ეს მხოლოდ ცვლადი on დასტის მთავარ.
>> მეორეს მხრივ, ახლა ვაცხადებთ მაჩვენებელი რომელიც მოუწოდებს ფუნქცია giveMeThreeInts.
და ა.შ. ახლა ჩვენ წასვლას ამ ფუნქციას და ჩვენ შევქმნით ახალ დასტის ჩარჩო ამისთვის.
თუმცა, ამ დასტის ჩარჩო ვაცხადებთ, int * temp,
რომელიც mallocs 3 რიცხვებით ჩვენთვის.
ასე ზომა int მოგვცემს რამდენი ბაიტი ამ int არის,
და malloc გვაძლევს, რომ ბევრი bytes სივრცის შესახებ ბევრი.
ასე რომ, ამ შემთხვევაში, ჩვენ შევქმენით საკმარისი ფართი 3 მთელი რიცხვები,
და ბევრი არის გზა up there, რის გამოც მე შედგენილი ეს უმაღლესი up.
ერთხელ ჩვენ გავაკეთეთ, ჩვენ დავბრუნდებით აქ, თქვენ საჭიროა მხოლოდ 3 ints დაბრუნდა,
და ის დააბრუნებს მისამართი, ამ შემთხვევაში მეტი აქ რომ მეხსიერება არის.
და ჩვენ დავსახეთ მაჩვენებელი = შეცვლა, და იქ გვაქვს კიდევ ერთი მაჩვენებელი.
მაგრამ რა, რომ ფუნქცია დააბრუნებს არის stacked აქ და ქრება.
ამიტომ temp ქრება, მაგრამ ჩვენ მაინც შევინარჩუნოთ მისამართი სადაც
იმ 3 რიცხვებით არის შიგნით მაგისტრალური.
ასე რომ ამ კომპლექტი, მითითებები scoped ადგილობრივად ამისთვის stacked ჩარჩო,
მაგრამ მეხსიერების რომელიც მათ ეხება არის ბევრი.
>> ამჯამად რომ აზრი?
[სტუდენტური] იქნებ გავიმეორო, რომ? >> [ჯოზეფ] დიახ.
ასე რომ, თუ მე დავუბრუნდეთ უბრალოდ ცოტა, ხედავთ, რომ Temp გამოყოფილი
ზოგიერთი მეხსიერების შესახებ ბევრი up there.
ასე რომ, როდესაც ამ ფუნქციას, giveMeThreeInts ანაზღაურება, ამ დასტის აქ აპირებს გაქრება.
და მასთან ერთად ნებისმიერ ცვლადები, ამ შემთხვევაში, ეს მაჩვენებელი, იყო გამოყოფილი stacked ჩარჩო.
რომ აპირებს ქრება, მაგრამ რადგან დავბრუნდით temp
და ჩვენ დავსახეთ მაჩვენებელი = temp, კურსორი ახლა ვაპირებ იგივე ხსოვნას საიდან როგორც temp იყო.
ახლა, მიუხედავად იმისა, რომ ჩვენ დასაკარგი temp, რომ ადგილობრივი მაჩვენებელი,
ჩვენ კვლავ ინარჩუნებს მეხსიერების მისამართი, რაც იყო მიუთითებს შიგნით რომ ცვლადი მაჩვენებელი.
კითხვები? რომელიც შეიძლება სახის დამაბნეველი თემის თუ არ წავიდა მას ნაწილში.
ჩვენ შეგვიძლია, თქვენი TF აუცილებლად წასვლა მას და რა თქმა უნდა უპასუხოს კითხვებს
დასასრულს საანგარიშო სხდომამდე ამ.
მაგრამ ეს არის ერთგვარი კომპლექსი თემის, და მე უფრო მეტი მაგალითები, რომ ვაპირებთ გამოჩნდება
რაც ხელს შეუწყობს გაერკვია რა პოინტერები რეალურად არიან.
>> ამ შემთხვევაში, მითითებები ექვივალენტი მასივები,
ასე, რომ შეიძლება უბრალოდ გამოიყენოს ეს მაჩვენებელი, როგორც იგივე როგორც int მასივი.
ამიტომ მე ინდექსირებას შევიდა 0, და შეცვლის პირველი რიცხვი 1,
შეცვლის მეორე რიცხვი 2, და მე -3 რიცხვი დან 3.
ასე უფრო პოინტერები. ისე, გავიხსენოთ Binky.
ამ შემთხვევაში ჩვენ გამოყოფილი კურსორი, ან ჩვენ დეკლარირებული მაჩვენებელი,
მაგრამ თავიდან, როცა მე მხოლოდ დეკლარირებული მაჩვენებელი, ეს არ მიუთითებს სადმე მეხსიერება.
უბრალოდ ნაგვის ღირებულებების შიგნით მას.
ასე რომ არ ვიცი, სადაც ეს მაჩვენებელი არის მიუთითებს.
მას აქვს მისამართზე, რომელიც მხოლოდ ივსება 0 და 1 ს, სადაც მას თავდაპირველად გამოაცხადა.
მე ვერაფერს ამ სანამ მოვუწოდებ malloc მასზე
და მაშინ მაძლევს პატარა სივრცე ბევრი სადაც შემიძლია დააყენა ღირებულებების შიგნით.
მერე ისევ, არ ვიცი რა შიგნით ამ მეხსიერებაში.
ასე რომ პირველი რაც უნდა გავაკეთოთ, არის თუ არა შეამოწმოთ სისტემა ჰქონდა საკმარისი მეხსიერება
მისცეს ჩემს უკან 1 რიცხვი პირველ რიგში, რის გამოც მე ამით შეამოწმოს.
თუ მაჩვენებელი არის null, რაც იმას ნიშნავს, რომ ეს არ გვაქვს საკმარისი სივრცე ან სხვა შეცდომა,
ასე რომ მე უნდა გამოხვიდეთ გარეთ ჩემი პროგრამა.
მაგრამ თუ ეს მოხდა გამოუვათ, ახლა შემიძლია, რომ მომცეთ
და რა * მაჩვენებელი არ არის ეს შემდეგნაირად სადაც მისამართი
იქ, სადაც, რომ ღირებულება, და ის ისეთ ის ტოლია 1.
ასე რომ აქ, ჩვენ შემოწმების თუ მეხსიერების არსებობდა.
>> ერთხელ თქვენ იცით, რომ იგი არსებობს, შეგიძლიათ იდგა
რა ღირებულება გსურთ იდგა; ამ შემთხვევაში 1.
ერთხელ ჩვენ გავაკეთეთ ის, რაც თქვენ გჭირდებათ გასათავისუფლებლად რომ მომცეთ
რადგან ჩვენ უნდა დავუბრუნდეთ სისტემა, რომელიც მეხსიერების რომ თქვენ სთხოვა პირველ რიგში.
იმის გამო, რომ კომპიუტერი არ იცის, როდესაც ჩვენ გავაკეთეთ ეს.
ამ შემთხვევაში ჩვენ მკაფიოდ ვეუბნებოდი მას, okay, ჩვენ გაკეთდეს, რომ მეხსიერებაში.
თუ რაიმე სხვა პროცესი სჭირდება, ზოგიერთი სხვა პროგრამა სჭირდება, მოგერიდებათ წავიდეთ წინ და მიიღოს იგი.
რა შეგვიძლია ასევე გააკეთოთ შეგვიძლია უბრალოდ მისამართი ადგილობრივი ცვლადები on კომპლექტი.
ასე int x არის შიგნით stacked ფარგლებში ძირითადი.
ხოლო როდესაც ჩვენ ვიყენებთ ამ ampersand, ამ და ოპერატორს, თუ რას აკეთებს არის
სჭირდება x, და x არის რამოდენიმე მონაცემები მეხსიერებაში, მაგრამ მას აქვს მისამართზე.
მდებარეობს სადღაც. ასე დარეკვით & x, რა ეს არ არის ის გვაძლევს მისამართი x.
ამით, ჩვენ მიღების მაჩვენებელი წერტილი, სადაც x არის მეხსიერებაში.
ახლა ჩვენ უბრალოდ რაღაც * x, ჩვენ ვაპირებთ, რომ მიიღოთ 5 უკან.
ვარსკვლავი ეწოდება dereferencing იგი.
თქვენ დაიცვას მისამართი და თქვენ მიიღებთ ღირებულება შენახულ არსებობს.
>> ნებისმიერი კითხვები? დიახ?
[სტუდენტური] თუ არ გააკეთებს 3 აღნიშნა რამ, იგი ჯერ კიდევ ადგენენ?
დიახ. თუ არ გააკეთებს 3-კურსორი რამ, ეს გრძელდება შედგენა,
მაგრამ მე შენ გაჩვენებ რა ხდება მეორე, და გარეშე აკეთებს, რომ,
არის ის, რაც ჩვენ მოვუწოდებთ მეხსიერების გაჟონვის. თქვენ არ აძლევდა სისტემა
უკან მისი მეხსიერება, ასე შემდეგ, ხოლო პროგრამის აპირებს დაგროვება
მეხსიერება რომ ის გამოყენებით და სხვა არაფერი შეუძლია მისი გამოყენება.
თუ თქვენ ოდესმე მინახავს Firefox with 1.5 მილიონი kilobytes თქვენს კომპიუტერში,
in ამოცანა მენეჯერი არის ის, რაც ხდება.
თქვენ გაქვთ მეხსიერების გაჟონვის პროგრამაში რომ ისინი არ გატარება.
ასე როგორ მაჩვენებელი არითმეტიკა მუშაობს?
ისე, კურსორი არითმეტიკული არის ერთგვარი მოსწონს ინდექსირებას შევიდა მასივი.
ამ შემთხვევაში, მე მაქვს მაჩვენებელი, და რა გავაკეთო არის მე მაჩვენებელი წერტილი პირველ ელემენტს
ამ მასივი 3 მთელი რიცხვები, რომ მე გამოყოფილი.
ახლა რა ვქნა, ვარსკვლავი მაჩვენებელი მხოლოდ ცვლის პირველი ელემენტია სიაში.
Star მაჩვენებელი +1 რაოდენობა მეტი აქ.
ამიტომ კურსორი დასრულდა აქ, კურსორი +1 დასრულდა აქ, მაჩვენებელი +2 დასრულდა აქ.
>> ასე რომ მხოლოდ დასძინა 1 არის იგივე როგორც მოძრავი გასწვრივ ამ მასივი.
რას ვაკეთებთ არის, როდესაც ჩვენ გავაკეთებთ მაჩვენებელი +1 იღებთ მისამართი ზე მეტი აქ,
და მისაღებად ღირებულების აქ, თქვენ დააყენა ვარსკვლავს მთელი გამოხატვის
to dereference იგი.
ასე რომ, ამ შემთხვევაში, მე შექმნის პირველი საიდან ამ მასივი 1,
მეორე საიდან 2, და მესამე ადგილიდან 3.
აბა რა მე ვაკეთებ აქ არის მე დაბეჭდვის ჩვენი მაჩვენებელი +1,
რომელიც მხოლოდ მაძლევს 2.
ახლა მე დამატება მაჩვენებელი, ამიტომ კურსორი შეადგენს მაჩვენებელი +1,
რომელიც მოძრაობს ეს ნაბიჯი.
და ა.შ. ახლა თუ ამობეჭდოთ მაჩვენებელი +1, კურსორი +1 არის 3,
რომელიც ამ შემთხვევაში ბეჭდავს out 3.
და იმისთვის, უფასო რაღაც, მაჩვენებელი, მე ვაძლევ მას
უნდა მიუთითებს დასაწყისში მასივი, რომელიც მე მივიღე უკან malloc.
ასე რომ, ამ შემთხვევაში, მე რომ მოვუწოდო 3 უფლება აქ, ამ შემთხვევაში არ იქნება სწორი,
იმიტომ რომ შუა მასივი.
მე უნდა სხვაობა მისაღებად ორიგინალური საიდან
საწყის პირველ ადგილზე სანამ შეუძლია მას.
ასე რომ, აქ უფრო მეტად ჩართულნი მაგალითად.
ამ შემთხვევაში, ჩვენ გამოყოფის 7 სიმბოლოების ხასიათი მასივი.
>> და ამ შემთხვევაში იმას თუ რას ვაკეთებთ არის ჩვენ looping ზე პირველი 6 მათგანი,
და ჩვენ შექმნის მათ ზ
ასე რომ, ამისთვის int i = 0, i> 6, მე + +,
ასე რომ, კურსორი + მე მხოლოდ მოგვცეს, ამ შემთხვევაში,
მაჩვენებელი, რომელიც მაჩვენებელმა +1, +2 მაჩვენებელი, კურსორი +3 და ა.შ. და ა.შ. in loop.
რასაც ის აპირებს არის იგი იღებს, რომ მისამართი, dereferences რომ მივიღოთ ღირებულება,
და ცვლილებები, რომ ღირებულებას ზ
შემდეგ კი ბოლომდე გახსოვთ ეს სიმებიანი, არა?
ყველა სიმები უნდა დასრულდეს null შეწყვეტის ხასიათი.
ასე რომ, რა გავაკეთო არის მაჩვენებელი 6 მე ზუსტად null terminator ხასიათი სისტემაში
ხოლო რაც ახლა ხდება მე ძირითადად აკეთებს აქ ახორციელებს printf ამისთვის სიმებიანი, არა?
>> ასე რომ, როდესაც ამჯამად printf ახლა, როცა ის მიაღწია ბოლოს სიმებიანი?
როდესაც ის იგებს null შეწყვეტის ხასიათი.
ასე რომ, ამ შემთხვევაში, ჩემი ორიგინალური მაჩვენებელი მიუთითებს დასაწყისში მასივი.
მე ბეჭდვა პირველ სიმბოლოს გარეთ. მე გადატანა მეტი ერთი.
მე ბეჭდვა რომ ხასიათი გარეთ. მე გადატანა დასრულდა.
მე აკეთეთ ამ სანამ მიაღწევს ბოლომდე.
და ახლა ბოლომდე * მაჩვენებელი იქნება dereference ამ და კიდევ null შეწყვეტის ხასიათი უკან.
და ა.შ. ჩემი ხოლო loop გადის მხოლოდ იმ შემთხვევაში, რომ ღირებულება არ null შეწყვეტის ხასიათი.
ასე რომ, ახლა მე გაითიშება ამ loop.
და ასე თუ სხვაობა 6 ამ მაჩვენებელმა,
მე დაბრუნდეს ყველა გზა დასაწყისია.
გახსოვდეთ, მე ამით, რადგან მე წასვლა დასაწყისში, რათა გაათავისუფლონ იგი.
>> ასე რომ, მე ვიცი, რომ იყო ბევრი. არსებობს რაიმე კითხვები?
გთხოვთ, დიახ?
[სტუდენტური კითხვა გაუგებარია]
შეგიძლიათ აცხადებენ, რომ louder? უკაცრავად.
[სტუდენტური] On ბოლო slide უფლება სანამ გათავისუფლდა მაჩვენებელი,
სადაც თქვენ რეალურად შეცვლის ღირებულება მაჩვენებელი?
[ჯოზეფ] ასე რომ, უფლება აქ. >> [სტუდენტური] Oh, okay.
[ჯოზეფ] ასე რომ, მე მაჩვენებელი მინუს მინუს, უფლება,
რომელიც მოძრაობს რამ თავში ერთი, და მერე გასათავისუფლებლად ეს,
რადგან ეს მაჩვენებელი უნდა აღინიშნოს, რომ დასაწყისში მასივი.
[სტუდენტური] მაგრამ ეს არ იქნება საჭირო იყო თქვენ შეწყვიტეთ შემდეგ რომ ხაზი.
[ჯოზეფ] ასე რომ, თუ შეწყდა მას შემდეგ, რაც ამ, ამ შემთხვევაში განიხილება მეხსიერების გაჟონვის,
იმიტომ, რომ მე არ აწარმოებს უფასო.
[სტუდენტური] მე [გაუგებარია] შემდეგ პირველი სამი ხაზები სადაც თქვენ ჰქონდა მაჩვენებელი +1 [გაუგებარია].
[ჯოზეფ] Uh-huh. რა არის კითხვა არსებობს?
უკაცრავად. არა, არა. წადი, წადით, გთხოვთ.
[სტუდენტური] ასე რომ, თქვენ არ შეცვლის ღირებულება პოინტერები.
თქვენ არ უნდა გაეკეთებინათ მაჩვენებელი მინუს მინუს.
[ჯოზეფ] დიახ, ზუსტად.
ასე რომ, როდესაც გავაკეთო მაჩვენებელი +1 და +2 მაჩვენებელი,
მე არ აკეთებს მაჩვენებელი შეადგენს მაჩვენებელი +1.
ასე რომ, მხოლოდ კურსორი რჩება მიუთითებს დასაწყისში მასივი.
ეს მხოლოდ მაშინ, როცა გავაკეთო Plus Plus, რომ ის ისეთ ღირებულება უკან შიგნით მაჩვენებელი,
რომ ის რეალურად მოძრაობს ამ გასწვრივ.
ყველა უფლება.
სხვა კითხვები?
>> ისევ და ისევ, თუ ეს ერთგვარი აბსოლუტური, ეს იქნება დაფარული სხდომაზე.
დასვით თქვენი სწავლების თანამემამულე ამის შესახებ, და ჩვენ შეგვიძლია უპასუხოს კითხვებს დასასრულს.
და ჩვეულებრივ ჩვენ არ მოგვწონს ამის მინუს რამ.
ეს უნდა მოითხოვოს ჩემთვის შენახვა ტრეკზე, თუ რამდენად მე ოფსეტური მასივში.
ასე რომ, ზოგადად, ეს მხოლოდ ასახსნელად, თუ როგორ მაჩვენებელი არითმეტიკული სამუშაოები.
მაგრამ ის, რაც ჩვენ, ჩვეულებრივ, მინდა გააკეთოთ ჩვენ გვსურს შევქმნათ ასლი მაჩვენებელი,
და მაშინ საბოლოოდ დავრწმუნდებით, რომ გამოიყენოთ ასლი, როდესაც ჩვენ გადაადგილდებოდნენ in string.
ასე რომ, ამ შემთხვევაში თუ თქვენ გამოიყენოთ ასლი ბეჭდვა მთელი ტექსტი,
მაგრამ ჩვენ არ უნდა გავაკეთოთ, როგორიცაა მაჩვენებელი მინუს 6 ან ტრეკზე რამდენად გადავედით ამ,
მხოლოდ იმიტომ, რომ ჩვენ ვიცით, რომ ჩვენი ორიგინალური წერტილი კვლავ აღნიშნა, რომ დასაწყისში სიაში
და ყველა, რომ ჩვენ შეცვლილი იყო ეს ასლი.
ასე რომ, ზოგადად, შეცვალოს ასლები თქვენი ორიგინალური მაჩვენებელი.
ნუ ეცდებით სახის მოსწონს - don't შეცვალოს ორიგინალური ასლები.
ცდილობს შეცვალოს მხოლოდ ასლები თქვენი ორიგინალური.
ასე რომ, თქვენ შეამჩნევთ, როდესაც ჩვენ გაიაროს სიმებიანი შევიდა printf
თქვენ არ უნდა დააყენოს ვარსკვლავი წინაშე მას ისე, როგორც ყველა სხვა dereferences, არა?
ასე რომ, თუ თქვენ ამობეჭდოთ მთელი სიმებიანი% s მოელის არის მისამართი,
და ამ შემთხვევაში მაჩვენებელი ან ამ შემთხვევაში, როგორიცაა მასივი სიმბოლო.
>> პერსონაჟები, char * s, და კოლექტორები არის იგივე.
Pointer არის გმირები, და ხასიათი კოლექტორები არის იგივე.
ასე რომ, ყველა ჩვენ უნდა გააკეთოთ კორიდორი მაჩვენებელი.
ჩვენ არ უნდა გაიარონ მსგავსად * კურსორი ან არაფერი რომ.
ასე რომ, კოლექტორები და მითითებები იგივე.
როდესაც თქვენ აკეთებთ რაღაც x [y] მეტი აქ მასივი,
რასაც ის აკეთებს ქვეშ hood არის ის ამბობდა, okay, ეს ხასიათი მასივი,
ამიტომ კურსორი.
და ა.შ. x არიან იგივე,
და ასე თუ რას აკეთებს არის ის დასძენს y to x,
რაც იგივე როგორც წინსვლის მეხსიერებაში, რომ ბევრი რამ.
და ახლა x + y გვაძლევს გარკვეული მისამართი,
და ჩვენ dereference მისამართი ან მიჰყევით arrow
იქ, სადაც, რომ მდებარეობის მეხსიერება და მივიღებთ მნიშვნელობა საზღვრებს რომ საიდან მეხსიერებაში.
ასე რომ, ისე ამ ორ ზუსტად იმავეს.
უბრალოდ სინტაქსური შაქარი.
ისინი იგივე. ისინი უბრალოდ სხვადასხვა syntactics ერთმანეთის.
>> ასე რომ, რა შეიძლება ცუდი პოინტერები? მსგავსად, უამრავი. Okay. ასე რომ, ცუდი რამ.
ზოგიერთი ცუდი რამ რისი გაკეთებაც შეგიძლიათ არ შემოწმების თუ თქვენი malloc ზარის ბრუნდება null, არა?
ამ შემთხვევაში, მე გეკითხებით სისტემის მომეცი - რა არის ეს რიცხვი?
მსგავსად 2 მილიარდი ჯერ 4, რადგან ზომის მთელი რიცხვი არის 4 ბაიტი.
მე გეკითხებით ეს მოსწონს 8 მილიარდ ბაიტს.
რა თქმა უნდა, ჩემი კომპიუტერი არ აპირებს შეძლებენ მაძლევს, რომ ბევრი რამ მეხსიერებაში უკან.
და ჩვენ არ შეამოწმოთ თუ ეს null, ამიტომ, როდესაც ვცდილობთ dereference მას იქ -
დაიცვას ისარი სადაც იგი აპირებს - ჩვენ არ გვაქვს, რომ მეხსიერებაში.
ეს არის ის, რაც ჩვენ მოვუწოდებთ dereferencing null მაჩვენებელი.
და ეს არსებითად იწვევს თქვენ segfault.
ეს არის ერთ გზები შეგიძლიათ segfault.
სხვა ცუდი რამ რისი გაკეთებაც შეგიძლიათ - Oh კარგად.
ამის dereferencing null მაჩვენებელი. Okay.
სხვა ცუდი - კარგად, დაფიქსირება, რომ თქვენ მხოლოდ დააყენა გამშვები იქ
რომელიც ამოწმებს თუ არა კურსორის არის null
და გასვლის გარეთ პროგრამა თუ ეს მოხდება, რომ malloc ბრუნდება null მაჩვენებელი.
სწორედ xkcd კომიკური. ხალხს კარგად ესმის ის არის. სახის.
>> ასე რომ, მეხსიერება. და მივედი ამ.
ჩვენ მოუწოდებდა malloc in loop, მაგრამ ყოველ ჯერზე ჩვენ მოვუწოდებთ malloc
ჩვენ ვკარგავთ კვალს, სადაც ეს მაჩვენებელი არის მიუთითებს,
რადგან ჩვენ clobbering იგი.
ასე რომ, საწყის ზარი malloc მაძლევს მეხსიერების მეტი აქ.
ჩემი კურსორი მითითებას ამ.
ახლა, მე არ გასათავისუფლებლად, ასე რომ ახლავე მოვუწოდებ malloc ერთხელ.
ახლა კი მიუთითებს მეტი აქ. არის ჩემი მეხსიერების მიუთითებს მეტი აქ.
მიმანიშნებელი მეტი აქ. მიმანიშნებელი მეტი აქ.
მაგრამ მე დავკარგე კვალს მისამართები ყველა მეხსიერების მეტი აქ, რომ მე გამოყოფილი.
და ახლა მე არ მაქვს რაიმე მინიშნება მათ უქმნით.
ასე რომ, მე ვერ გასათავისუფლებლად მათ გარეთ ამ loop.
და რათა მოხდეს დაფიქსირება მსგავსი რამ,
თუ თქვენ დაგავიწყდებათ თავისუფალი მეხსიერების და თქვენ მიიღებთ ამ მეხსიერების გაჟონვის,
თქვენ უნდა გასათავისუფლებლად მეხსიერების შიგნით ამ loop ერთხელ თქვენ კეთდება ეს.
ისე, ეს რა ხდება. მე ვიცი ბევრი თქვენ სიძულვილი ამ.
მაგრამ ახლა - YAY! თქვენ მიიღებთ მოსწონს 44.000 kilobytes.
ასე რომ, თქვენ გასათავისუფლებლად ეს დასასრულს მარყუჟის,
და რომ აპირებს მხოლოდ გასათავისუფლებლად მეხსიერების ყოველ ჯერზე.
არსებითად, თქვენი პროგრამა არ აქვს მეხსიერების გაჟონვის უქმნით.
>> და ახლა რაღაც შეგიძლიათ გააკეთოთ უფასოა ზოგიერთი მეხსიერების რომ თქვენ სთხოვა ორჯერ.
ამ შემთხვევაში, თქვენ malloc რაღაც, თქვენ შეცვალოს მისი ღირებულება.
თქვენ გასათავისუფლებლად ეს ერთხელ რადგან თქვენ თქვით თქვენ კეთდება ეს.
მაგრამ მაშინ ჩვენ გათავისუფლდა ხელახლა.
ეს არის ის, რაც საკმაოდ ცუდი.
ის არ აპირებს თავდაპირველად segfault,
მაგრამ მას შემდეგ, ხოლო რა ამ ამჯამად არის ორმაგი ათავისუფლებს ამ თვალსაზრისით თქვენი ბევრი სტრუქტურა,
და თქვენ ვისწავლოთ ცოტა მეტი ამ შემთხვევაში თქვენ მიიღოს კლასის მოსწონს CS61.
მაგრამ არსებითად შემდეგ, ხოლო თქვენი კომპიუტერი აპირებს მისაღებად დაბნეული
იმაზე, თუ რა მეხსიერების ადგილებში არიან სად და სადაც ეს ინახება -
სადაც მონაცემები ინახება მეხსიერებაში.
და ასე გამონთავისუფლების მაჩვენებელი ორჯერ არის ცუდი რამ რომ თქვენ არ გსურთ.
>> სხვა რამ, რაც შეიძლება წავიდეთ არასწორი არ არის გამოყენებით sizeof.
ასე რომ, ამ შემთხვევაში თქვენ malloc 8 ბაიტი,
და ეს იგივე როგორც ორი მთელი რიცხვები, არა?
ასე რომ, რომ შესანიშნავად უსაფრთხოა, მაგრამ არის ეს?
ისე, როგორც ლუკას ისაუბრა სხვადასხვა არქიტექტორები,
მთელი რიცხვები სხვადასხვა lengths.
ასე რომ, მე ელექტრო მოწყობილობების, რომ თქვენ იყენებთ, მთელი რიცხვები დაახლოებით 4 ბაიტი,
მაგრამ ზოგიერთ სხვა სისტემაში, შესაძლოა, მათ 8 ბაიტი ან, შესაძლოა, მათ 16 ბაიტი.
ასე რომ, თუ უბრალოდ გამოიყენოთ ეს რიცხვი მეტი აქ,
ამ პროგრამის შეიძლება მუშაობა ელექტრო მოწყობილობების,
მაგრამ ეს არ გამოყოს საკმარისი მეხსიერების ზოგიერთ სხვა სისტემაში.
ამ შემთხვევაში, ეს არის ის, რაც sizeof ოპერატორი გამოიყენება.
როდესაც ჩვენ მოვუწოდებთ sizeof (int), რა ეს არ არის
ეს გვაძლევს ზომა რიცხვი on სისტემა, რომელიც პროგრამა გაშვებული.
ასე რომ, ამ შემთხვევაში, sizeof (int) დაბრუნდება 4 წლის რაღაც ელექტრო მოწყობილობების,
და ახლა ეს ნება 4 * 2, რომელიც 8,
რომელიც მხოლოდ თანხის სივრცეში აუცილებელია ორი რიცხვებით.
წლის სხვადასხვა სისტემა, თუ int ჰგავს 16 ბაიტი ან 8 ბაიტი,
უბრალოდ დაბრუნებას აპირებს საკმარისი bytes შესანახად, რომ თანხა.
>> და ბოლოს, structs.
ასე რომ, თუ თქვენ სურდა შესანახად Sudoku საბჭოს მეხსიერება, როგორ შეიძლება გავაკეთოთ ეს?
თქვენ ალბათ ფიქრობთ, მსგავსი ცვლადი პირველად რამ,
ცვლადი მეორე რამ, ცვლადი მესამე რამ,
ცვლადი უკვე მეოთხედ რამ - ცუდი, არა?
ასე რომ, ერთი გაუმჯობესება შეგიძლიათ თავზე ეს რათა 9 x 9 მასივი.
სწორედ ჯარიმა, მაგრამ რა თუ თქვენ სურდა გაერთიანების სხვა რამ ერთად Sudoku ფორუმში
მსგავსი იმისა, რაც სირთულე გამგეობა,
ან, მაგალითად, თუ რა თქვენი ანგარიშით, ან რამდენ დროს ის წაიყვანეს თქვენ გადაჭრის ამ ფორუმის?
ისე, თუ რა შეგიძლიათ გააკეთოთ შეგიძლიათ შექმნათ struct.
რა მე ძირითადად ამბობდა არის მე განსაზღვრის ამ სტრუქტურის მეტი აქ,
და მე განსაზღვრის Sudoku საბჭო, რომლის შემადგენლობაში შედის ფორუმში, რომელიც 9 x 9.
>> და რა აქვს მას მითითებას სახელით დონეზე.
მას ასევე X და Y, რომელთა კოორდინატები სადაც მე ვარ ახლა.
მას ასევე აქვს გატარებული დრო [გაუგებარია], და მას აქვს საერთო რაოდენობის გადადის მე inputted ჯერჯერობით.
და ა.შ. ამ შემთხვევაში, შემიძლია ჯგუფი A მთელი bunch of მონაცემები შევიდა მხოლოდ ერთი სტრუქტურა
ნაცვლად, რომელმაც მას მოსწონს საფრენი გარშემო, როგორიცაა ცვლადის სხვადასხვა
რომ მე ნამდვილად ვერ ტრეკზე.
და ეს საშუალებას გვაძლევს მხოლოდ ლამაზი სინტაქსი სახის referencing სხვადასხვა რამ შიგნით ამ struct.
მე შემიძლია უბრალოდ board.board, და მივიღებ Sudoku გამგეობის უკან.
Board.level, მივიღებ როგორ მკაცრი ეს.
Board.x და board.y მომეცი კოორდინატები სადაც მე შეიძლება ამ ფორუმში.
და ა.შ. მე წვდომის, რაც ჩვენ მოვუწოდებთ დარგების struct.
ეს განსაზღვრავს sudokuBoard, რომელიც ტიპი რომ მაქვს.
და ახლა ჩვენ აქ. მაქვს ცვლადში "ფორუმში" ტიპის sudokuBoard.
და ა.შ. ახლა მე შეუძლიათ ყველა სფეროებში, რომ შეადგინოს ამ სტრუქტურის მეტი აქ.
>> რაიმე კითხვა structs? დიახ?
[სტუდენტური] For int x, y, თქვენ განაცხადა, ორივე ერთ ხაზს? >> [ჯოზეფ] Uh-huh.
[სტუდენტური] ასე, იქნებ უბრალოდ, რომ ყველა მათგანი?
როგორც X, Y მძიმით ჯერ რომ სულ?
[ჯოზეფ] დიახ, თქვენ შეიძლება აუცილებლად გავაკეთებთ, მაგრამ მიზეზი მე ზუსტად x და y იმავე ხაზის -
და საკითხია, თუ რატომ შეგვიძლია უბრალოდ ამ იმავე ხაზის?
რატომ არ გვაქვს მხოლოდ დააყენა ყველა ამ იმავე ხაზზე
x და y არიან დაკავშირებული ერთმანეთთან,
და ეს მხოლოდ სტილისტურად უფრო ზუსტი, წელს გრძნობა,
რადგანაც ეს დაჯგუფება ორი რამ იმავე ხაზის
რომ მოსწონს სახის ეხება იგივე.
და მე მხოლოდ გაყოფილი ამ გარდა. უბრალოდ სტილი რამ.
იგი ფუნქციურად არ აკეთებს განსხვავება განაწილებაზე.
ნებისმიერი სხვა შეკითხვებს structs?
თქვენ შეგიძლიათ განსაზღვროს Pokédex ერთად struct.
Pokemon აქვს ნომერი და მას წერილი, მფლობელი, ტიპის.
ხოლო შემდეგ, თუ თქვენ გაქვთ მასივი pokemon, შეგიძლიათ შეადგინოს Pokédex, არა?
Okay, ზემოთ. ასე რომ, შეკითხვა structs. იმ დაკავშირებულია structs.
>> საბოლოოდ, GDB. რას GDB მოგცემთ გავაკეთოთ? იგი საშუალებას გაძლევთ გამართვის თქვენი პროგრამა.
და თუ თქვენ არ გამოიყენება GDB, მინდა რეკომენდირებული თვალს მოკლე
და მხოლოდ აპირებს მეტი რა GDB არის, თუ როგორ ვიმუშაოთ ის, თუ როგორ შეიძლება მისი გამოყენება,
დააგემოვნოთ ეს პროგრამა.
და მერე რა GDB გაძლევთ გააკეთოთ ეს საშუალებას პაუზის [გაუგებარია] თქვენი პროგრამა
და პრაქტიკული ხაზი.
მაგალითად, მინდა პაუზის შესრულების დროს, როგორიცაა ხაზი 3 ჩემი პროგრამა,
და სანამ მე დილის ხაზი 3 შემიძლია ამობეჭდოთ ყველა ღირებულებებს, რომ იქ არიან.
და მერე რა ჩვენ მოვუწოდებთ მოსწონს დაპაუზება in ხაზი
ჩვენ მოვუწოდებთ ამ აყენებს breakpoint რომ ხაზი
და მაშინ ჩვენ შეგვიძლია ბეჭდვა გარეთ ცვლადები სახელმწიფო პროგრამის იმ დროს.
>> ჩვენ შეგვიძლია ამის შემდეგ იქ დაიხევს მეშვეობით პროგრამა ხაზის მიერ ხაზი.
და მაშინ ჩვენ შეგვიძლია შევხედოთ მდგომარეობას დასტის დროს.
და ა.შ. რათა GDB, თუ რას ვაკეთებთ ჩვენ მოვუწოდებთ clang on C ფაილი,
მაგრამ უნდა გაიაროს ეს-ggdb დროშა.
და კიდევ ჩვენ გაკეთდეს, რომ ჩვენ მხოლოდ აწარმოებს GDB შესახებ მიღებული გამომავალი ფაილი.
და ასე რომ თქვენ მიიღეთ რაიმე მოსწონს მასობრივი ტექსტის მოსწონს,
მაგრამ რეალურად ყველა თქვენ უნდა გააკეთოთ აკრიფოთ ბრძანებები დასაწყისში.
დაარღვიე მთავარ აყენებს breakpoint დროს ძირითადი.
სია 400 ჩამოთვლილია ხაზების კოდი გარშემო ხაზი 400.
და ა.შ. ამ შემთხვევაში შეგიძლიათ მხოლოდ მიმოიხედე გარშემო და ამბობენ, ოჰ,
მინდა მითითებული breakpoint დროს ხაზი 397, რომელიც ამ ხაზს,
და შემდეგ თქვენი პროგრამა ეშვება შევიდა, რომ ნაბიჯი და ის აპირებს დაარღვიოს.
იგი აპირებს პაუზის არსებობს, და თქვენ შეგიძლიათ ამობეჭდოთ, მაგალითად, ღირებულება დაბალი ან მაღალი.
და ასე რომ bunch of ბრძანებები საჭიროა იცოდეთ,
და ამ Slideshow წავა up on ნახვა,
ასე რომ, თუ გსურთ მითითებას ამ ან like დააყენა მათ თქვენი მოტყუებას sheets, ვგრძნობ უფასო.
>> ზემოთ. ეს იყო Quiz მიმოხილვა 0, და ჩვენ გამყარებაში გარშემო თუ თქვენ გაქვთ რაიმე შეკითხვებს.
ყველა უფლება.
>> [ტაში]
>> [CS50.TV]