რობ Bowden: Hi, მე ვარ Rob Bowden, და მოდით ვისაუბროთ quiz0.
>> ასე რომ, პირველი კითხვა.
ეს არის საკითხი, სადაც თქვენ საჭირო კოდექსის ნომერი
127 წელს ორობითი ნათურებით.
თუ უნდოდა, შეიძლება გავაკეთოთ რეგულარული კონვერტაციის
საწყისი bi-- ან, ეხლა ათობითი ორობითი.
მაგრამ ეს, ალბათ, მიიღოს ბევრი დრო.
ვგულისხმობ, თქვენ ვერ გაერკვნენ, რომ OK, 1 არის იქ, 2 არის იქ,
4 იქ, 8 არის იქ.
ადვილი გზა, 127 128 მინუს ერთი.
რომ leftmost ნათურა არის 128-bit.
ასე 127 არის ნამდვილად ყველა სხვა ნათურებით,
რადგან ეს არის ის leftmost ნათურა მინუს 1.
ეს არის ის, რომ საკითხი.
>> ერთი კითხვა.
ასე 3 ბიტი თქვენ შეგიძლიათ წარმოადგენს 8 მკაფიო ღირებულებებს.
მაშ, რატომ არის 7 უდიდესი არასამთავრობო უარყოფითი ათობითი რიცხვი, თქვენ შეგიძლიათ წარმოადგენს?
ისე, თუ ჩვენ შეგვიძლია მხოლოდ წარმოადგენს 8 მკაფიო ღირებულებები,
შემდეგ, რაც ჩვენ ვაპირებთ, რომ იყოს წარმოადგენს, რომ 0-დან 7.
0 იკავებს ერთი ღირებულებებს.
>> კითხვა ორი.
With n ბიტი, რამდენი განსხვავებული ღირებულებები შეიძლება წარმოადგენს?
ასე რომ, n ბიტი, თქვენ გაქვთ 2 შესაძლო მნიშვნელობებია თითოეული bit.
ამიტომ ჩვენ გვაქვს 2 შესაძლო ღირებულებების პირველი ცოტა, 2 შესაძლო მნიშვნელობებია
მეორე, 2 შესაძლებელია მესამე.
და ისე, რომ 2 ჯერ 2 ჯერ 2 და საბოლოო ჯამში, პასუხი არის 2 ო.
>> კითხვა სამი.
რა არის 0x50 ორობითი?
ასე მახსოვს, რომ თექვსმეტობითი აქვს ძალიან პირდაპირი კონვერტაციის ორობითი.
ასე რომ, ჩვენ უბრალოდ უნდა შევხედოთ 5 და 0 დამოუკიდებლად.
რა არის 5 ორობითი?
0101, რომელიც არის 1 bit და 4 bit.
რაც 0 ორობითი?
არ არის სახიფათო.
0000.
ასე რომ, მხოლოდ ისინი ერთად, და რომ არის სრული რაოდენობის ორობითი.
01010000.
და თუ უნდოდა, რომ თქვენ შეიძლება მიიღოს off, რომ leftmost ნულოვანი.
ეს შეუსაბამო.
>> ასე რომ, მაშინ, გარდა ამისა, რა არის 0x50 ათობით?
თუ უნდოდა, რომ თქვენ შეიძლება, თუ თქვენ უფრო კომფორტულად ორობითი,
თქვენ შეიძლება, რომ ორობითი პასუხი და რომ გარდაქმნას შევიდა ათობითი.
ან შეიძლება უბრალოდ გვახსოვდეს, რომ თექვსმეტობითი.
ასე რომ 0 არის 0-ე ადგილი, და 5 არის 16 პირველი ადგილი.
ასე რომ, ჩვენ გვაქვს 5 ჯერ 16 პირველი, ასევე 0-ჯერ 16 დან ნულოვანი,
80.
და თუ შევხედე სათაური რათა კითხვაზე,
ეს იყო CS 80, რომელიც იყო ერთგვარი მინიშნება პასუხი ამ პრობლემას.
>> კითხვა ხუთ.
ჩვენ გვაქვს ამ Scratch სკრიპტი, რომელიც იმეორებს 4-ჯერ არაქისის კარაქი რძე.
ასე როგორ უნდა ახლა კოდი რომ C?
ასევე, ჩვენ არ აქ ნაწილი თამამი არის მხოლოდ ნაწილი თქვენ უნდა შეესრულებინა.
ამიტომ ჩვენ გვაქვს 4 loop რომ looping 4 ჯერ, printf-Ing არაქისის კარაქი რძე,
ახალი ხაზის პრობლემა ითხოვს.
>> კითხვა ექვსი, ერთი Scratch პრობლემა.
ჩვენ ვხედავთ, რომ ჩვენ ვართ სამუდამოდ loop.
ჩვენ ვამბობთ, ცვლადი i და შემდეგ დამატება i 1.
ახლა ჩვენ გვინდა გავაკეთოთ, რომ C. არსებობს სხვადასხვა გზები შეგვეძლო გავაკეთეთ ეს.
აქ ჩვენ მოხდა კოდექსის სამუდამოდ loop რადგან ხოლო (ნამდვილი).
ამიტომ ვაცხადებთ ცვლადი i, უბრალოდ როგორც ჩვენ გვქონდა ცვლადი i ნულიდან.
განაცხადოს ცვლადი i და სამუდამოდ ხოლო (ნამდვილი), ჩვენ ვამბობთ, ცვლადი მე.
ამიტომ printf% შევიდე ან შეიძლება უკვე გამოყენებული% d.
ჩვენ ვამბობთ, რომ ცვლადი, და მაშინ ნამატი, მე ++.
>> კითხვა შვიდი.
ახლა ჩვენ გვინდა, რომ რაღაც ძალიან ჰგავს მარიო dot გ from პრობლემა მითითებული ერთი.
ჩვენ გვინდა, რომ ამობეჭდოთ ეს hashtags, ჩვენ გვინდა ბეჭდვა ხუთ
სამი მართკუთხედი ეს ჰეშები.
ასე რომ, როგორ ვაპირებთ ამის გაკეთება?
ასევე, ჩვენ მოგცემთ მთელი bunch of კოდი და უბრალოდ
უნდა შეავსოთ ბეჭდვითი ქსელის ფუნქცია.
>> ასე რომ, რას PrintGrid ჰგავს?
ასევე თქვენ წარსულში სიგანე და სიმაღლე.
ამიტომ ჩვენ გვაქვს გარე 4 loop, რომ looping
მეტი ყველა რიგები ამ ქსელის, რომ ჩვენ გვინდა, რომ ამობეჭდოთ.
მაშინ ჩვენ გვაქვს შიდა წყობილი 4 loop, რომ არის ბეჭდვის მეტი თითოეული სვეტი.
ასე რომ თითოეული მწკრივი, ჩვენ ბეჭდვა ყოველი სვეტი, ერთი hash.
მაშინ ბოლოს ზედიზედ ბეჭდვა ერთი ახალი ხაზი წასვლა მომდევნო მწკრივში.
და ეს არის ის, რომ მთელი ქსელის.
>> კითხვა რვა.
ფუნქცია, როგორიცაა PrintGrid განაცხადა, აქვს გვერდითი ეფექტი, მაგრამ არა დაბრუნება
ღირებულება.
ახსენით განსხვავება.
ასე რომ, ეს დამოკიდებულია თქვენ დამახსოვრების რა გვერდითი ეფექტი არის.
ასევე, დაბრუნების ღირებულება ჩვენ ვიცით, PrintGrid არ
აქვს დაბრუნების ღირებულება, რადგან სწორედ აქ იგი აცხადებს ბათილად.
ისე არაფერი რომ ბრუნდება ბათილად ნამდვილად არ დაბრუნდება არაფერი.
რა არის გვერდითი ეფექტი?
ასევე, გვერდითი ეფექტი არის ყველაფერი, რაც სახის გრძელდება
შემდეგ ფუნქცია მთავრდება ეს არ იყო მხოლოდ დაბრუნდა,
და ეს არ იყო მხოლოდ იმ საშუალებებით.
>> ასე, მაგალითად, ჩვენ შეგვიძლია შეცვლა გლობალური ცვლადი.
ეს იქნება გვერდითი ეფექტი.
ამ კონკრეტულ შემთხვევაში, ძალიან მნიშვნელოვანი გვერდითი ეფექტი
ბეჭდვის ეკრანზე.
ასე, რომ ეს გვერდითი ეფექტი რომ PrintGrid აქვს.
ჩვენ ბეჭდვა ეს ყველაფერი ეკრანზე.
და შეგიძლიათ წარმოიდგინოთ, რომ როგორც გვერდითი ეფექტი,
რადგან ეს არის ის, რომ რაღაც გრძელდება მას შემდეგ, რაც ეს ფუნქცია მთავრდება.
ეს რაღაც ფარგლებს გარეთ ამ ფუნქციას, რომელიც, საბოლოო ჯამში,
იცვლება, შინაარსი ეკრანზე.
>> კითხვა ცხრა.
განვიხილოთ პროგრამა ქვემოთ, რომლის ხაზის ნომრები
დაემატა გულისთვის დისკუსია.
ასე რომ ამ პროგრამის ჩვენ უბრალოდ მოუწოდებდა GetString, შენახვა,
ამ ცვლადი s, ხოლო შემდეგ ბეჭდვის რომ ცვლადი s.
OK.
ასე ახსნა, თუ რატომ შეესაბამება ერთი იმყოფება.
მოიცავს cs50 dot თ.
რატომ ჩვენ უნდა შეიცავდეს # cs50 dot h?
ასევე ჩვენ მოუწოდებდა GetString ფუნქცია,
და GetString განისაზღვრება CS50 ბიბლიოთეკაში.
ასე რომ, თუ ჩვენ არ გვაქვს მოიცავს cs50 dot h,
ჩვენ კიდევ, რომ დაფარული დეკლარაცია საქართველოს GetString ფუნქცია შეცდომა
საწყისი შემდგენელი.
ასე რომ, ჩვენ უნდა შეიცავდეს ბიბლიოთეკა ჩვენ უნდა შეიცავდეს header ფაილი,
ანდა შემდგენელი არ ვაღიარებთ, რომ GetString არსებობს.
>> ახსენით, რატომ ხაზი ორი იმყოფება.
ასე სტანდარტული io dot თ.
ეს არის ზუსტად იგივე როგორც წინა პრობლემა,
გარდა ნაცვლად საქმე GetString, ჩვენ ვსაუბრობთ printf.
ასე რომ, თუ ჩვენ არ ვამბობ, რომ ჩვენ უნდა მოიცავს სტანდარტული io dot h,
მაშინ ჩვენ ვერ შევძლებთ გამოვიყენოთ printf ფუნქცია,
რადგან შემდგენელი არ ვიცი ამის შესახებ.
>> Why-- რა მნიშვნელობა ბათილად ხაზის ოთხი?
ასე რომ აქ გვაქვს int ძირითადი (void).
ეს მხოლოდ ამბობდა, რომ ჩვენ ვერ ვიღებთ ნებისმიერი ბრძანების
არგუმენტები ძირითადი.
გახსოვდეთ, რომ ჩვენ შეგვიძლია ვთქვათ, int მთავარი int argc სიმებიანი argv ფრჩხილებში.
ასე რომ აქ ჩვენ უბრალოდ, ვამბობთ ბათილად, რომ ჩვენ იგნორირება ბრძანება ხაზი არგუმენტები.
>> ავუხსნათ, მიმართ მეხსიერება, ზუსტად რა GetString ხაზი ექვსი ბრუნდება.
GetString ბრუნდება ბლოკი მეხსიერება, მასივი სიმბოლო.
ეს მართლაც დაბრუნების მაჩვენებელი პირველი ხასიათი.
გახსოვდეთ, რომ სიმებიანი არის char ვარსკვლავი.
ამიტომ, მომცეთ პირველი ხასიათი რასაც სიმებიანი არის
რომ მომხმარებლის შევიდა კლავიატურაზე.
და რომ მეხსიერების ხდება malloced, ასე რომ მეხსიერება არის ბევრი.
>> კითხვა 13.
განვიხილოთ პროგრამა ქვემოთ.
ასე რომ ყველა ეს პროგრამა აკეთებს არის printf-Ing 1 დაყოფილი 10.
ასე რომ, როდესაც შედგენილი და შესრულებული, ამ პროგრამის
შედეგები 0.0, მიუხედავად იმისა, 1 იყოფა 10 0.1.
ასე რატომ არის 0.0?
ისე, ეს იმიტომ, რომ მთელი სამმართველოს.
ასე რომ 1 არის მთელი რიცხვი, 10 რიცხვი.
ასე 1 დაყოფილი 10, ყველაფერი განიხილება, როგორც მთელი რიცხვები,
და C, როდესაც ჩვენ გავაკეთებთ მთელი განყოფილება, ჩვენ შეკვეცავს ნებისმიერი ათობითი წერტილი.
ასე რომ 1 დაყოფილი 10 0, და მაშინ ჩვენ ვცდილობთ
ბეჭდვა float, ასე ნულოვანი დაბეჭდილი როგორც float არის 0.0.
და სწორედ ამიტომ, ჩვენ კიდევ 0.0.
>> განვიხილოთ პროგრამა ქვემოთ.
ამჟამად ჩვენ დაბეჭდვის 0.1.
ასე რომ, არ მთელი განყოფილება, ჩვენ უბრალოდ ბეჭდვის 0.1,
მაგრამ ჩვენ ბეჭდვა ეს 28 ათობითი ადგილებში.
და ჩვენ ამ 0,1000, მთელი bunch of zeros, 5 5 5, blah blah blah.
ასე რომ, კითხვა აქ რატომ აკეთებს ამას ბეჭდვა, ნაცვლად ზუსტად 0.1?
>> ასე რომ მიზეზი აქ არის მცურავი პუნქტიანი ორაზროვნება.
გვახსოვდეს, რომ float მხოლოდ 32 ბიტი.
ასე რომ ჩვენ შეგვიძლია მხოლოდ წარმოადგენენ სასრულ ნომერი მცურავი პუნქტიანი ღირებულებებს იმ 32
ბიტი.
ასევე არსებობს საბოლოოდ უსასრულოდ ბევრი მცურავი პუნქტიანი ღირებულებებს,
და იქ უსასრულოდ ბევრი მცურავი პუნქტიანი ღირებულებებს შორის 0 და 1,
და ჩვენ, რა თქმა შეუძლია წარმოადგენს უფრო მეტი ღირებულებები, ვიდრე, რომ.
ამიტომ, ჩვენ უნდა მსხვერპლს შეძლებს წარმოადგინოს ყველაზე ღირებულებებს.
>> იმდენად მნიშვნელობა, როგორიცაა 0.1, როგორც ჩანს, ჩვენ არ შეგვიძლია წარმოადგენს, რომ ზუსტად.
ასე რომ, ნაცვლად წარმოადგენს 0.1 ვაკეთებთ საუკეთესო წარმოვადგინოთ ეს 0.100000 5 5
5.
და ეს საკმაოდ ახლო, მაგრამ უამრავი პროგრამები
თქვენ არ უნდა ფიქრი მცურავი პუნქტიანი ორაზროვნება,
იმიტომ, რომ ჩვენ უბრალოდ ვერ წარმოადგენს ყველა მცურავი რაოდენობა ზუსტად.
>> კითხვა 15.
განვიხილოთ ქვემოთ მოყვანილი კოდი.
ჩვენ უბრალოდ ბეჭდვის 1 plus 1.
ასე რომ, არ შეასრულა აქ.
1 + 1 აფასებს 2, მაშინ ჩვენ დაბეჭდვისას რომ.
ეს უბრალოდ ბეჭდავს 2.
>> კითხვა 16.
ამჟამად ჩვენ დაბეჭდვის ხასიათი 1 plus ხასიათი 1.
ასე რატომ არა ბეჭდვა იგივე?
ისევე ხასიათი 1 plus ხასიათი 1, ხასიათი 1 აქვს ASCII ღირებულების 49.
ასე რომ, ეს მართლაც ამბობდა 49 პლუს 49, საბოლოო ჯამში, ამ აპირებს ბეჭდვა 98.
ასე რომ, ეს არ ბეჭდვა 2.
>> კითხვა 17.
შეავსოთ განხორციელება უცნაური ქვემოთ ისე,
ფუნქცია დააბრუნებს ასეა თუ n უცნაური და ცრუ თუ n კი.
ეს არის დიდი მიზანი რომ mod ოპერატორი.
ამიტომ ჩვენ ჩვენი არგუმენტი n, თუ n mod 2 უდრის 1, კარგად
ეს ნიშნავს, რომ n იყოფა 2 ჰქონდა დარჩენილი.
თუ n იყოფა 2 ჰქონდა დარჩენილი, რომ იმას ნიშნავს, რომ n უცნაური, ასე რომ, ჩვენ დაუბრუნოს ჭეშმარიტი.
სხვაგან ჩვენ დაბრუნების ცრუ.
თქვენ ასევე შეიძლება გაკეთდეს n mod 2 ტოლობის ნულოვანი, დაბრუნების ცრუ, სხვა TRUE.
>> განვიხილოთ რეკურსიული ფუნქცია ქვემოთ.
ასე რომ, თუ n ნაკლებია ან უდრის 1, დაბრუნდებიან 1,
სხვაგან დაბრუნების N ჯერ ვ ო მინუს 1.
რა არის ეს ფუნქცია?
ისე, ეს მხოლოდ factorial ფუნქცია.
ეს არის ლამაზად წარმოდგენილი როგორც n factorial.
>> ასე ეჭვქვეშ 19 ახლა, ჩვენ გვინდა მიიღოს ამ რეკურსიული ფუნქცია.
ჩვენ გვინდა, რომ მას განმეორებითი.
ასე რომ, როგორ გავაკეთოთ ეს?
ასევე თანამშრომლებისათვის გამოსავალი, და ისევ იქ
სხვადასხვა გზები შეიძლება გაკეთდეს რომ, ჩვენ ვიწყებთ ამ int პროდუქტი
უდრის 1.
და მთელი ამ ამისთვის მარყუჟის, ჩვენ ვაპირებთ
უნდა გამრავლებით პროდუქტის საბოლოო ჯამში, დასრულდება up ერთად სრული factorial.
ასე int i უდრის 2, მე ნაკლები ან ტოლია n, i ++.
>> თქვენ შეიძლება გაინტერესებთ, რატომ უდრის 2.
გახსოვდეთ, რომ აქ გვაქვს დარწმუნდით, ჩვენი ბაზის შემთხვევაში არის სწორი.
ასე რომ, თუ n ნაკლებია ან ტოლი 1, ჩვენ უბრალოდ დაბრუნების 1.
ასე რომ აქ, ჩვენ ვიწყებთ უდრის 2.
ასევე, თუ მე 1, მაშინ the-- ან თუ n, 1, მაშინ for loop
არ შეასრულოს ყველა.
ასე რომ, ჩვენ გვინდა მხოლოდ დაბრუნების პროდუქტი, რომელიც არის 1.
ანალოგიურად, თუ n იყვნენ არაფერი ნაკლები 1--
თუ ეს იყო 0, -1, whatever-- ჩვენ მაინც უნდა დაბრუნება 1,
სწორედ იმას, რასაც რეკურსიული ვერსია აკეთებს.
>> ახლა, თუ N არის დიდი 1-ზე, მაშინ ჩვენ ვაპირებთ
უნდა გავაკეთოთ მინიმუმ ერთი iteration ამ loop.
ასე ვთქვათ, n არის 5, მაშინ ჩვენ ვაპირებთ, რომ გავაკეთოთ პროდუქტი ჯერ უდრის 2.
ასე რომ, ახლა პროდუქტი 2.
ახლა ჩვენ ვაპირებთ, რომ გავაკეთოთ პროდუქტი ჯერ უდრის 3.
ახლა ის 6.
პროდუქტი ჯერ შეადგენს 4, ახლა ეს 24.
პროდუქტი ჯერ შეადგენს 5, ახლა 120.
ასე რომ, მაშინ, საბოლოო ჯამში, ჩვენ დაბრუნების 120, რომელიც სწორად 5 factorial.
>> კითხვა 20.
ეს არის, სადაც თქვენ უნდა შეავსოთ ამ მაგიდასთან ნებისმიერი მოცემული ალგორითმი,
ყველაფერი, რაც ჩვენ ვნახეთ, რომ შეესაბამება ამ ალგორითმული პერსპექტივაში
ჯერ ეს asymptotic პერსპექტივაში ჯერ.
რა არის ალგორითმი, რომელიც არის ომეგა 1, მაგრამ დიდი ო ო?
ასე რომ შეიძლება იყოს უსასრულოდ ბევრი პასუხი აქ.
ერთი, რომ ჩვენ ვნახეთ, ალბათ, ყველაზე ხშირად უბრალოდ ხაზოვანი ძებნა.
>> ასე რომ, საუკეთესო შემთხვევაში, სცენარი, საქონლის ჩვენ
ეძებს არის დასაწყისი სია
და ასე ომეგა 1 ნაბიჯები, პირველი, რაც ჩვენ შეამოწმოთ,
ჩვენ უბრალოდ დაუყოვნებლივ დაბრუნებას რომ ჩვენ ვნახეთ ერთეულზე.
უარეს შემთხვევაში, საქონელი ბოლოს,
ან საქონელი არ არის სიაში ყველა.
ამიტომ, ჩვენ უნდა ვეძებოთ სრული სია, ყველა n
ელემენტები, და ამიტომაც ეს O of n.
>> ასე რომ, ახლა ეს არის ის, რომ ორივე ომეგა N შესვლა N, და დიდი O of n შესვლა n.
ასევე ყველაზე შესაბამისი, ჩვენ ვნახეთ აქ არის შერწყმა ჯიშია.
ასე რომ შერწყმა დალაგების, გახსოვდეთ, საბოლოო ჯამში, თეტა
of N შესვლა N, სადაც თეტა არის განსაზღვრული თუ ორივე omega და დიდი O იგივეა.
როგორც N შესვლა n.
>> რა არის ის, რაც არის omega ო, და O of n კვადრატში?
ასევე, კიდევ ერთხელ არ არის მრავალი შესაძლო პასუხი.
აქ ჩვენ არ უნდა ვთქვათ bubble sort.
Insertion დალაგების ასევე იმუშავებს აქ.
გვახსოვდეს, რომ bubble sort აქვს ოპტიმიზაცია, სადაც,
თუ თქვენ შეუძლია მიიღოს მთელი სია
გარეშე სჭირდება ამის გაკეთება ნებისმიერი სვოპების, მაშინ, ისევე,
ჩვენ შეგვიძლია დაუყოვნებლივ დაბრუნებას, რომ სია დახარისხებული უნდა დაიწყოს.
ასე რომ, საუკეთესო შემთხვევაში, ეს მხოლოდ omega of n.
თუ ეს არ არის მხოლოდ ლამაზად დახარისხებული სია, დაიწყოს,
მაშინ ჩვენ გვაქვს O of n კვადრატში გაცვლებს.
და ბოლოს, ჩვენ გვაქვს შერჩევის დალაგების for n კვადრატში, როგორც omega და დიდი ო
>> კითხვა 21.
რა არის მთელი რიცხვი overflow?
ასევე, კიდევ ერთხელ, მსგავსი ადრე, ჩვენ მხოლოდ finitely ბევრი ბიტი
წარმოადგენს მთელი რიცხვი, იქნებ 32 ბიტი.
მოდით ვთქვათ რომ ჩვენ გვაქვს ხელმოწერილი რიცხვი.
მაშინ საბოლოოდ უმაღლესი დადებითი რიცხვი ჩვენ შეგვიძლია
2 31 მინუს 1.
რა მოხდება, თუ ჩვენ ვცდილობთ მაშინ ნამატი, რომ რიცხვი?
ასევე, ჩვენ ვაპირებთ წასვლა, 2-დან 31 მინუს 1, ყველა გზა ქვემოთ უარყოფითი 2
31.
ასე რომ, ეს რიცხვი overflow არის როდესაც თქვენ გაქვთ დამატება,
და საბოლოო ჯამში, თქვენ არ შეგიძლიათ მიიღოს ნებისმიერი უმაღლესი და ეს მხოლოდ
დასრულდება ყველა გზა უკან გარშემო უარყოფითი მნიშვნელობა.
>> რაც შეეხება ბუფერული overflow?
ასე ბუფერული overflow-- მახსოვს რა ბუფერი.
ეს მხოლოდ ბლოკი მეხსიერება.
რაღაც მასივი არის ბუფერული.
ასე ბუფერული overflow არის, როდესაც ცდილობენ ხელმისაწვდომობის მეხსიერება
მიღმა ბოლოს, რომ მასივი.
ასე რომ, თუ თქვენ გაქვთ მასივი ზომა 5 და
ცდილობენ, რათა შეამოწმონ მასივი bracket 5 ან bracket 6 ან bracket 7
ან არაფერი მიღმა ბოლოს, ან კი არაფერი
below-- მასივი bracket უარყოფითი 1-- ყველა იმ ბუფერული overflows.
თქვენ ეხება მეხსიერების ცუდ გზებს.
>> კითხვა 23.
ასე რომ ამ ერთი თქვენ უნდა განახორციელოს strlen.
და ჩვენ გეტყვით, რომ თქვენ შეგიძლიათ ვივარაუდოთ s არ იქნება null,
ასე რომ თქვენ არ უნდა გავაკეთოთ ნებისმიერი გამშვები null.
და არსებობს მრავალი გზა შეიძლება გაკეთდეს ეს.
აქ ჩვენ უბრალოდ მიიღოს პირდაპირი.
ჩვენ დავიწყებთ counter, n. ო დათვლის რამდენი გმირები არსებობს.
ასე რომ, ჩვენ ვიწყებთ 0, და მაშინ ჩვენ iterate მთელ სიაში.
>> არის s bracket 0 ტოლი null terminator ხასიათი?
დამახსოვრება, ჩვენ ვეძებთ null terminator ხასიათი
განსაზღვროს რამდენ ხანს ჩვენი სტრიქონს.
რომ წყვეტს ნებისმიერი შესაბამისი სიმებიანი.
ასე რომ, არის s bracket 0 თანაბარი რომ null terminator?
თუ ეს არ, მაშინ ჩვენ ვაპირებთ შევხედოთ s bracket 1, s bracket 2.
ჩვენ შენარჩუნება აპირებს, სანამ ჩვენ მოვძებნოთ null terminator.
მას შემდეგ, რაც ჩვენ ვერ, მაშინ n შეიცავს საერთო სიგრძეზე სიმებიანი,
და ჩვენ შეგვიძლია უბრალოდ დააბრუნოს, რომ.
>> კითხვა 24.
ასე რომ, ეს არის, სადაც თქვენ უნდა მიიღოს სავაჭრო მოედანი.
ასე რომ ერთი რამ არის კარგი ერთი გზა, მაგრამ რა გზით არის ამაში ცუდი?
ასე რომ, აქ, შერწყმა დალაგების ტენდენცია უფრო სწრაფად, ვიდრე bubble sort.
მას შემდეგ განაცხადა, that--, ისევე, რამდენიმე პასუხი აქ.
მაგრამ მთავარი ის არის, რომ ბუშტი დალაგების არის ომეგა n for დახარისხებული სია.
>> გვახსოვდეს, რომ მაგიდასთან ჩვენ ვნახეთ ადრე.
ამიტომ ბუშტი ჯიშები ომეგა n, საუკეთესო შემთხვევაში სცენარი
არის ის საშუალება, უბრალოდ მეტი სიაში ერთხელ, განსაზღვრავს
hey ეს ის არის უკვე დახარისხებული და სანაცვლოდ.
შერწყმა დალაგების, არ აქვს მნიშვნელობა რა თქვენ აკეთებთ, არის ომეგა N შესვლა n.
ასე დახარისხებული სია, bubble სახის იქნება უფრო სწრაფად.
>> ახლა რაც შეეხება უკავშირდება სიები?
ასე უკავშირდება სიაში ვერ გაიზრდება და შემცირება შეესაბამება ბევრი ელემენტები, როგორც საჭიროა.
მას შემდეგ განაცხადა, that-- ასე როგორც წესი, პირდაპირი შედარება
იქნება დაკავშირებული სიაში მასივი.
მიუხედავად იმისა, კოლექტორები ადვილად იზრდება და მცირდება,
შეესაბამება ბევრი ელემენტები საჭიროების შემთხვევაში, უკავშირდება სია
შედარებით მასივი მასივი აქვს წვდომის.
ჩვენ შეგვიძლია ინდექსი ნებისმიერი კონკრეტულ ელემენტს მასივი.
>> ასე უკავშირდება სია, ჩვენ ვერ უბრალოდ მეხუთე ელემენტის,
ჩვენ უნდა traverse თავიდანვე სანამ არ მივიღებთ მეხუთე ელემენტს.
და რომ აპირებს გვიშლის ამით რაღაც ორობითი ძებნა.
ვსაუბრობ ორობითი ძებნა, ორობითი ძებნა tends უნდა იყოს უფრო სწრაფად, ვიდრე წრფივი ძებნა.
მას შემდეგ განაცხადა, that-- ასე რომ, ერთ-ერთი შესაძლო რამ
არის, რომ თქვენ ამის გაკეთება არ შეუძლიათ ორობითი ძიება უკავშირდება სიები
თქვენ შეგიძლიათ მხოლოდ ამის გაკეთება მასივები.
მაგრამ, ალბათ, უფრო მნიშვნელოვანია, თქვენ არ შეუძლია ორობითი ძებნა
მასივი, რომელიც არ არის დახარისხებული.
Upfront თქვენ უნდა დასალაგებლად მასივი, და მხოლოდ ამის შემდეგ შეიძლება
თქვენ აკეთებთ ორობითი ძებნა.
ასე რომ, თუ თქვენი რამ არ არის დახარისხებული უნდა დაიწყოს,
მაშინ ხაზოვანი ძებნა შეიძლება სწრაფად.
>> კითხვა 27.
ამიტომ მიგვაჩნია, რომ პროგრამა ქვემოთ, რომელიც იქნება მომდევნო slide.
და ეს არის, სადაც ჩვენ ვართ აპირებთ მინდა მკაფიოდ განვაცხადო,
ღირებულებათა სხვადასხვა ცვლადები.
მოდით შევხედოთ, რომ.
>> ისე გამოდიან ერთი.
ჩვენ გვაქვს int x უდრის 1.
ეს არის ერთადერთი რამ, რაც მოხდა.
ასე ერთი ხაზი, ერთი, ჩვენ ვხედავთ, ჩვენს მაგიდა, რომელიც y, a, b, და tmp ყველა
ჩაბნელებულ.
რა არის x?
ასევე, ჩვენ უბრალოდ ვაყენებთ მას ტოლი 1.
და შემდეგ ხაზი ორი, ასევე, ჩვენ ვხედავთ, რომ y არის მითითებული 2,
და მაგიდაზე უკვე შევსებული us.
ასე რომ, x არის 1 და y 2.
>> ახლა, ხაზი სამი, ჩვენ ახლა შიგნით swap ფუნქცია.
რა მივიღეთ გაივლის სვოპ?
ჩვენ გავიდა ampersand x for და ampersand y ბ.
სადაც პრობლემა ადრე განაცხადა, რომ მისამართი x
არის 0x10 და მისამართი Y არის 0x14.
ასე და ბ არის ტოლი 0x10 და 0x14, შესაბამისად.
>> ახლა ხაზი სამი, რა არის x და y?
ისე, არაფერი შეცვლილა შესახებ x და y ამ ეტაპზე.
მიუხედავად იმისა, რომ ისინი შიგნით ძირითადი დასტის ჩარჩო,
მათ ჯერ კიდევ აქვთ იგივე ღირებულებები ადრე.
ჩვენ არ შეცვლილია ნებისმიერი მეხსიერება.
ასე რომ, x 1, y 2.
ყველა უფლება.
ასე რომ, ახლა ჩვენ განაცხადა int tmp ტოლი ვარსკვლავი.
ისე ხაზი ოთხი, ყველაფერი არის იგივე გარდა tmp.
ჩვენ არ შეიცვალა ღირებულებები არაფერი გარდა tmp.
ჩვენ ვქმნით tmp ტოლი ვარსკვლავი.
რა არის ვარსკვლავი?
ასევე, მიუთითებს x, ასე რომ ვარსკვლავი აპირებს თანაბარი x, რომელიც 1.
ასე რომ, ყველაფერი დაკოპირებული ქვემოთ, და tmp არის 1.
>> ახლა მომდევნო ხაზი.
Star შეადგენს ვარსკვლავი ბ.
ასე რომ, ონლაინ ხუთ კარგად ერთხელ, ყველაფერი არის იგივე, გარდა რასაც ვარსკვლავი არის.
რა არის ვარსკვლავი?
ასევე, ჩვენ უბრალოდ განაცხადა ვარსკვლავი არის x.
ასე რომ, ჩვენ შეცვლის x თანაბარი ვარსკვლავი ბ.
რა არის ვარსკვლავი b? y. b რაოდენობა წ.
ასე ვარსკვლავი ბ შ.
ასე რომ, ჩვენ შექმნის x უდრის y, და ყველაფერი იგივე.
ასე რომ, ჩვენ ვხედავთ, რომ მომდევნო გრაფაში, რომ x არის 2, ხოლო დანარჩენი უბრალოდ აკოპირებთ ქვემოთ.
>> ახლა, მომდევნო ხაზი, ვარსკვლავი ბ უდრის tmp.
ასევე, ჩვენ უბრალოდ განაცხადა, რომ ვარსკვლავი ბ არის y, ასე რომ, ჩვენ შექმნის y ტოლია tmp.
ყველაფერი არის იგივე, ასე რომ ყველაფერი იღებს გადაწერა ქვემოთ.
ჩვენ შექმნის y ტოლია tmp, რომელიც ერთ-ერთი, და ყველაფერი იგივეა.
>> საბოლოოდ, ხაზი შვიდი.
ჩვენ უკან მთავარ ფუნქციას.
ჩვენ შემდეგ swap დასრულდა.
დავკარგეთ, b, და tmp, მაგრამ საბოლოო ჯამში ჩვენ
არ იცვლება ღირებულებები არაფერი ამ ეტაპზე,
ჩვენ უბრალოდ ასლი x და y ქვემოთ.
და ჩვენ ვხედავთ, რომ x და y ახლა 2 და 1 ნაცვლად 1 და 2.
Swap წარმატებით შესრულებული.
>> კითხვა 28.
დავუშვათ, რომ თქვენ ექმნებათ შეცდომის შეტყობინებები
ქვემოთ საათებში მომავალ წელს CA ან TF.
ვურჩევ, თუ როგორ უნდა დააფიქსიროს თითოეული ეს შეცდომები.
ასე გაურკვეველი მინიშნება GetString.
რატომ შეიძლება ხედავთ ამ?
ისე, თუ სტუდენტი გამოყენებით GetString მათ კოდი
მათ სათანადოდ hash შედის cs50 dot h მოიცავს CS50 ბიბლიოთეკაში.
>> ისე, რა ისინი ეს უნდა გამოვასწოროთ შეცდომა?
მათ უნდა გავაკეთოთ dash lcs50 ზე ბრძანების ხაზი, როდესაც ისინი შედგენა.
ასე რომ, თუ არ გაივლის clang dash lcs50, ისინი
არ აპირებს ფაქტობრივი კოდი, რომელიც ახორციელებს GetString.
>> კითხვა 29.
მინიშნებით გამოცხადების ბიბლიოთეკის ფუნქცია strlen.
კარგად, ახლა, მათ არ აქვთ კეთდება სათანადო hash მოიცავს.
ამ კონკრეტულ შემთხვევაში, header ფაილი ისინი უნდა შეიცავდეს სიმებიანი dot h,
და მათ შორის string dot h, ახლა სტუდენტი ახლა შემდგენელი
ხელმისაწვდომობის დეკლარაციების strlen,
და იგი დარწმუნებულია, რომ თქვენი კოდი გამოყენებით strlen სწორად.
>> კითხვა 30.
მეტ პროცენტს კონვერტაციის ვიდრე მონაცემები არგუმენტები.
რა არის ეს?
კარგად მახსოვს, რომ ეს პროცენტი signs-- როგორ ისინი შესაბამისი printf.
ასე რომ, printf ჩვენ შეიძლება percent-- ჩვენ შეიძლება ბეჭდვა რაღაც
როგორიცაა პროცენტი i წარმატებული ო.
ან შეიძლება ბეჭდვა, როგორიცაა პროცენტი i, სივრცეში, პროცენტი i, სივრცე, პროცენტი i.
ასე რომ, თითოეული მათგანი პროცენტი ნიშნები, ჩვენ გვჭირდება
გაიაროს ცვლადი ბოლოს printf.
>> ასე რომ, თუ ჩვენ ვამბობთ, printf paren პროცენტი i წარმატებული ო ახლო paren,
ასევე, ჩვენ ვამბობთ, რომ ჩვენ ვართ აპირებს ბეჭდვა რიცხვი,
მაგრამ მაშინ ჩვენ არ გაივლის printf რიცხვი რეალურად ბეჭდვა.
ასე რომ, აქ უფრო პროცენტი კონვერტაციის ვიდრე მონაცემები არგუმენტები?
რომ ვამბობ, რომ ჩვენ გვაქვს მთელი bunch of პროცენტით,
და ჩვენ არ გვაქვს საკმარისი ცვლადები რეალურად შეავსოთ იმ პროცენტით.
>> შემდეგ კი აუცილებლად, რადგან შეკითხვა 31 ნამდვილად დაკარგული 40 ბაიტი ერთ ბლოკად.
ასე რომ, ეს Valgrind შეცდომა.
ეს ამბობს, რომ სადღაც თქვენი კოდი,
თქვენ უნდა განაწილდეს, რომ 40 bytes დიდი, ასე რომ თქვენ malloced 40 ბაიტი,
და თქვენ არასდროს გათავისუფლდა.
სავარაუდოდ, თქვენ უბრალოდ უნდა რათა იპოვოს რაღაც მეხსიერების გაჟონვის,
და იპოვოს, სადაც თქვენ უნდა გასათავისუფლებლად ბლოკი მეხსიერება.
>> და კითხვა 32, არასწორი ჩაწერის საქართველოს ზომა 4.
ერთხელ ეს Valgrind შეცდომა.
ეს არ უნდა გავაკეთოთ მეხსიერების გაჟონვის ახლა.
ეს, likely-- ვგულისხმობ, ის გარკვეული არასწორი მეხსიერება უფლებები.
და, სავარაუდოდ, ეს არის გარკვეული ერთგვარი ბუფერული overflow.
სადაც თქვენ გაქვთ მასივი, შესაძლოა, მთელი მასივი, და მოდით
ამბობენ, რომ ეს ზომა 5 და ცდილობენ შეეხოთ მასივი bracket 5.
ასე რომ, თუ თქვენ ცდილობენ წერენ, რომ ღირებულება, რომელიც არ არის ნაჭერი მეხსიერება
რომ თქვენ ნამდვილად აქვს წვდომა, და ასე რომ თქვენ აპირებთ მისაღებად ეს შეცდომა,
განაცხადა, რომ არასწორი ჩაწერის საქართველოს ზომა 4.
Valgrind აღიარებას აპირებს თუ არა ცდილობს შეეხოთ მეხსიერება არამიზნობრივად.
>> და რომ ეს quiz0.
მე Rob Bowden, და ეს არის CS50.