[Powered by Google Translate] [ELECTRONIC Static ხმები]
ROB: Okay, ასე რომ ჩვენ უბრალოდ მაგრამ თქვენ არ გაქვთ არის CS50 სივრცეებს.
ALI: დაველოდოთ, დაველოდოთ უკან მდე.
კეთილი იყოს მონაკვეთზე?
ROB: კეთილი მონაკვეთზე?
ALI: YAY!
ROB: Supersection!
ALI: მე ალი და ეს რობ.
Okay, ახლა ჩვენ ავუხსნათ სივრცეებს.
ROB: მერე რა ჩვენ უბრალოდ მაგრამ თქვენ არ გაქვთ არის CS50 სივრცეებს.
თქვენ გამოიყენებთ ამ უამრავი თქვენს სექციები ამ სემესტრში.
ძირითადად, ჩვენ უკვე გვქონდა გადმოვწერთ ელექტრო მოწყობილობების.
და შეგიძლიათ წარმოიდგინოთ, რომ CS50 სივრცეები როგორც web interface საუბარი ელექტრო მოწყობილობების
რომ ჩვენ გვაქვს ზოგიერთ სერვერზე სადღაც.
ასე რომ თქვენ შეგიძლიათ აწარმოებს თქვენი კოდი ამ ინტერფეისი, და ჩვენ გამოგიგზავნით
ვხედავთ თუ როგორ რამ.
თქვენ ასევე შეგიძლიათ შეხედოთ კოდექსის სხვა ხალხი მონაკვეთზე, და -
ALI: და როგორც ზოგიერთი ადამიანი გაირკვა, შეგიძლიათ სტატისტიკა ხალხის მხარეს.
და ჩვენ ყველა ვხედავთ მას, ძალიან, ასე რომ ამაღელვებელი.
Come on in, მოვა და დაჯდება.
ჩაჯექით.
>> ROB: ასე რომ, კვეთები -
ALI: არა, არა, თქვენ ბიჭები შეიძლება მოვიდეს.
ROB: კვეთები იქნება ბევრად უფრო ინტერაქტიული ამ სემესტრში.
ALI: Oh, ის მოსწონს -
Oh.
Okay, ზემოთ.
ასე რომ, თუ თქვენ ბიჭები მხოლოდ შემოდიოდნენ, შეგიძლიათ გადადით ამ ბმულზე, თუ შეგიძლიათ მიიღოთ
იქ, უფლება არსებობს.
ჩვენ ნამდვილად ვერ წერენ, რადგან იქ არ არის ფორუმში სივრცეში, მაგრამ ამ ბმულს
სწორედ აქ, მიდიან, რომ თქვენი კომპიუტერი, და თქვენ შეიყვანოთ CS50
სივრცეები, რომელიც საკმაოდ მაგარი რამ.
Okay.
გაქვთ პრობლემა?
ROB: ასე რომ თქვენ შეგიძლიათ იპოვოთ პრობლემები -
ჩვენ გვჭირდება, რომ შეუძლია დაწეროს ამ სადღაც.
ასე რომ, თუ თქვენ გადადით cs50.net/psets და ეს არის ჰაკერი supersection -
და თქვენ წასვლას Hacker გამოცემა pset ერთი, შეხედეთ სპეციფიკაცია
სადღაც ქვევით გვერდზე -
>> ALI: ასე ძირითადად, ხოლო Rob-ს ეძებს, რასაც ჩვენ ვაპირებთ გავაკეთოთ
სექცია დღეს არსებობს მონაკვეთზე პრობლემები -
ROB: - გვერდზე რვა.
ALI: - მოუწოდა მონაკვეთზე პრობლემები -
ROB: სექცია კითხვებზე.
ALI: უკაცრავად, მონაკვეთზე კითხვები.
და ეს ის, რაც ჩვენ ვაპირებთ წავიდეთ მეტი -
ეს ის, რაც ჩვენ ვაპირებთ წავიდეთ დღეს სრულდება ნაწილში.
და ჩვენ ვაპირებთ კოდი ეს CS50 სივრცეები, და იმედია, რომ იმუშავებს.
და ჩვენ შეგვიძლია მხოლოდ გაიგო მათი საშუალებით.
და შენ შეიძლება დასვას შეკითხვები, როცა ვგრძნობ -
>> ROB: ასე რომ, ეს დღითიდღე იყოს საერთო რამ ყველაზე psets.
ვფიქრობ, ამ ერთი, ის ამბობს თქვენ არ უნდა გადასცემს ამ კითხვებზე სისტემაში
მაგრამ იდეა ისაა, რომ ამ კითხვას ჩაიცვი pset, და თქვენ შეგიძლიათ მოსვლა
to განყოფილება აქვს იმ კითხვებს უპასუხეს.
ან თუ არ უნახავს განყოფილებაში თქვენ შეუძლია უპასუხოს მათ საკუთარ ან კიდევ
დაეხმაროს ოფისში საათის ან რამე.
მაგრამ ეს მხოლოდ კითხვები, რომლებიც უნდა მოსამზად თქვენ პრობლემა კომპლექტი.
და ჰაკერი გამოცემა, ბევრი კითხვები შეიძლება მხოლოდ იყოს შესახებ
გაფართოების თქვენი მიმდინარე CS ცოდნა.
ALI: Yep, საკმაოდ ბევრი.
>> Okay, ასე, არის ყველას CS50 სივრცეები?
Hi, მოდის შემოსული
დინამიკები 1: ჩვენ ვხედავთ URL კიდევ ერთხელ?
ROB: Yeah, ეს იქნება უფრო ადვილი ერთხელ თქვენ რეალურად თქვენს სექციები და
თქვენი TF უბრალოდ მისწერეთ თქვენ URL წინასწარ.
ALI: YAY, ჩაჯექით.
არსებობს ადგილების აქ.
წინა არ არის, რომ ცუდი.
რა?
ასე რომ, CS50 სივრცეები, ჩვენ ვიღებთ არსებობს.
ვინმეს აქვს რაიმე კითხვა სანამ შეღწევას - რა?
ROB: იქ არც კი ნებისმიერი ცარცი.
[INAUDIBLE]
ALI: უკაცრავად.
თქვენ შეიძლება გამოიყენოთ თქვენი fingernails?
ჩვენ ძალიან დაბალი ტექნიკური დარბაზი ძალიან მაღალტექნოლოგიური კლასი.
Okay, არის ყველას სახის კარგი?
ვინმეს აქვს ისევ კითხვები შესახებ?
როგორც ვთქვი, ჩვენ ვაპირებთ გავლა მონაკვეთზე კითხვებზე
pset სპეციფიკაციები.
ასე რომ იქ მხოლოდ რამდენიმე პრობლემა, რომელიც ჩვენ ვაპირებთ
კოდი up in CS50 სივრცეებს.
არის ყველასთვის კარგი?
Okay.
კარგი?
ROB: გაქვთ ლეპტოპი?
ALI: შეგიძლიათ გათიშეთ out ერთად Lucas.
მან სხდომაზე უფლება შემდეგი თქვენ.
შემაკავშირებელ დროს.
>> ROB: ასე რომ, იწყება პირველი პრობლემა?
ALI: ჰო.
ჩვენ შეგვიძლია დავიწყოთ.
გნებავთ me -
შემიძლია წასვლა.
ასე რომ, ჩვენ წასვლა pset specs.
ოჰ, რატომ არის ის -
ROB: კონტროლის.
ALI: Okay, ასე მივდივართ შევიდა პასუხი ეს ყველაფერი ისევე?
ROB: Oh, yeah.
ასე -
ALI: Oh, გააკეთეს ყველას Watch რობ ს როლებში შორტები?
Okay, ზემოთ.
ROB: ჰო, მე არ ვფიქრობ, რომ ჩვენ აუცილებლად მოსალოდნელია თქვენ აქვს
უყურებს ეს ადრე მოდის ამ მონაკვეთზე, მაგრამ შეგვიძლია განვიხილოთ იმ
პრობლემების წინასწარ, რადგან ისინი ქვეშ მონაკვეთზე კითხვები რამ.
ასე რომ, თუ თქვენ არ უყურებს მას, არ ინერვიულოთ.
ვისაც შეგიძლიათ სცადოთ და უპასუხოს.
>> ასე რომ, პირველი კითხვა, რა არის წინასწარ პროცესორი, როგორ ამჯამად # include
ეხება?
ასე რომ ვინმეს აქვს პასუხი, რომ?
ALI: შენ შეიძლება გაიგო ის.
რა თქმა უნდა, წავიდეთ წინ.
დინამიკები 2: # include არის რაღაც წინასწარ წერილობით კოდი და ნაცვლად
გადაწერა და pasting იგი თქვენს პროგრამაში, მხოლოდ ამბობდა, რომელშიც შედიოდა,
წინასწარი პროცესორი იცის, რომ იქ და რომ ეს უნდა დაამატოთ ეს
მოგვიანებით, ან მანამდე არაფერი ხდება.
ALI: Yeah, გასაოცარია.
ზემოთ.
ROB: ასე რომ, როდესაც თქვენ ფაქტიურად შედგენა პროგრამა, წინასწარ პროცესორი არის ამ
პირველი ნაბიჯი.
Compilation ხდება ოთხი დიდი ნაბიჯები.
ასე რომ წინასწარ პროცესორი არის პირველი დიდი ერთი და ეს ამ ბიჭს რომ მიდის
მეშვეობით და ეძებს ყველა ამ hash სიმბოლოს.
და ნებისმიერი ხაზი, რომელიც იწყება hash, წინასწარ პროცესორი უყურებს და ხედავს
თუ იგი შეიძლება პროცესის.
ასე # include ეუბნება წინასწარ პროცესორი to გადახედეთ cs50.h
ფაილი და გადააკოპირეთ და ჩასვით მისი შინაარსი შევიდა ამ ფაილის.
ასე რომ შეგიძლიათ ნამდვილად # მოიცავს არაფერი გსურთ, მაგრამ ეს ძირითადად იქნება
. თ files.
ჩვენ არ შემოსული # განსაზღვრავს მაინც, ისე, რომ მნიშვნელობა არ აქვს.
ALI: Yeah, ჩვენ კარგი რომ ერთი.
ვინმეს აქვს რაიმე კითხვა რომ?
ჩვენ კარგი?
შემდეგი შეკითხვა.
>> დინამიკები 3: მოკლე, იქ იყო რაღაც შესახებ. გ ისევე?
ის არის, რომ შესაბამისი თუ შეუსაბამო?
ROB: შესახებ. გ ერთად წინასწარ პროცესორი?
დინამიკები 3: Yeah, ან საერთოდ მე რაღაც up?
ROB: ასე მოკლე შესაძლოა გვიჩვენებს წინასწარი დამუშავების ამ ფაილის და
outputting იგი სხვა. გ ფაილი, ასე რომ თქვენ შეგიძლიათ წინასწარ დამუშავებას ამ ფაილის -
როდესაც თქვენ მხოლოდ აწარმოებს მოსწონს, მიიღოს მიესალმები ან clang hello.c, თქვენ აკეთებთ ყველა
კომპილაცია ერთ დიდ ნაბიჯს.
მაგრამ შეგიძლიათ მკაფიოდ გავაკეთებთ შევიდა მისი ცალკეული ნაბიჯები.
ამიტომ პირველ შეგიძლიათ წინასწარ პროცესის.
მაშინ თქვენ შეგიძლიათ კომპილაციის, მაშინ შეიკრიბება, და მაშინ დაუკავშირონ.
ჩვენ კიდევ იმ სხვა მიიჩნიეს.
მაგრამ წინასწარ დამუშავებას, თქვენ სახის წინასაარჩევნო პროცესის, და მერე გადადის
სხვა. გ ფაილი.
იმის გამო, რომ წინასწარ დამუშავებას ნამდვილად არ შევცვლით.
უბრალოდ bunch of ასლი და pasting.
თქვენ შეიძლება ხელით დააკოპირეთ და ჩასვით იგი საკუთარ თავს.
ALI: და იყოს ნათელი,. გ ფაილი C ფაილი, ამიტომ
დაწერილი C კოდი.
ამიტომ ვაპირებთ საწყისი C კოდი C კოდი.
თქვენ მხოლოდ დასძინა მეტი კოდექსი ფუნტი.
ROB: როცა წინასწარ დამუშავებული, ეს მაინც მოქმედებს C ფაილი.
დინამიკები 3: Okay.
ALI: კარგი კითხვაა.
მომწონს, რომ.
Okay, შემდეგი კითხვა.
>> რა არის შემდგენელი?
ვინმე?
დიახ.
დინამიკები 4: იგი შეიცვლის წინასწარ დამუშავებული კოდი შევიდა ასამბლეის.
ALI: Perfect.
ROB: დიახ.
ALI: ზემოთ.
ROB: ასე რომ რა შემდგენელი აკეთებს კონკრეტულად
როდესაც ჩვენ გამოყენებით Clang.
ძალიან ზოგადი გაგებით, შემდგენელი არის ისევე აღების კოდი ერთ ენაზე
და გარდამტეხ იგი სხვა ენაზე.
ასე რომ, C -
ან, ასევე, Clang დგამს კოდი რომ დო და ტრანსფორმირებას იგი ასამბლეის.
და თქვენ არ უნდა იყოს იგებს ასამბლეის ყველა.
მაგრამ ეს ენა რომ ის გარდამტეხი იგი.
>> ALI: Okay.
და მაშინ, რა assembler?
ვინმე?
დინამიკები 5: [INAUDIBLE] რომ ორობითი?
ALI: უკაცრავად, რა?
დინამიკები 5: [INAUDIBLE] რომ ორობითი?
ROB: Yep.
ALI: დიახ.
ROB: So assembler -
ასამბლეის კოდი მართლაც, მართლაც ახლოს რა თქვენს კომპიუტერში მესმის,
მაგრამ გახსოვდეთ, რომ იგი არ მესმის საკმაოდ ტექსტი
რომ არის ასამბლეის კოდი.
თქვენ უნდა დააკონვერტიროთ ის სწორი 1s და 0S.
ეს მოსწონს პირდაპირი თარგმანი პროცესში.
ჩვენ შეგვეძლო მხოლოდ მოგცემთ მაგიდასთან რომ რუკების რა თითოეული
ასამბლეის ინსტრუქციის ნიშნავს.
მაგრამ assembler მხოლოდ ამით თარგმანი თქვენთვის.
ეს გარდაქმნა ასამბლეის კოდი შევიდა 1s და 0S.
>> ALI: შემდეგ, ბოლო ერთი, რა linker?
და როგორ-lcs50 ეხება?
ვინმე?
ROB: ეს არის ყველაზე მძიმე და ნაკლებად განმარტა ერთი შემდგენელი ვიდეო.
ALI: ვინმეს გახსოვთ ხედავს-lcs50 წელს ბრძანება?
დინამიკები 6: როდესაც მივიდა მიიღოს.
ALI: ეს წელს მიიღოს.
ჰო, ზემოთ, okay.
არსებობს თუ მიხვდება ან ბუნდოვანი - კი, წავიდეთ.
დინამიკები 7: მე არ ვარ დარწმუნებული, რადგან თქვენს მოკლე მართლაც [INAUDIBLE], მაგრამ იყო ეს
რაღაც შესახებ აკეთებს ცალკე ფაილების თითოეული ბიბლიოთეკა და შემდეგ აყენებს
მათ ყველა ერთად ერთ ბიბლიოთეკაში?
ROB: დიახ.
ასე რომ, როდესაც თქვენ გაქვთ hello.c, ეს მართლაც მარტივი პროგრამა.
თქვენ მართლაც მხოლოდ აკეთებს ერთი რამ იყო.
მაგრამ როდესაც თქვენ შეღწევას სხვა პროგრამებს -
და ვფიქრობ, მაშინაც კი, როდესაც GetString თქვენს პროგრამებში, თქვენ უნდა დაიწყოს
მათ შორის სხვა ფაილი.
ამიტომ CS50 ბიბლიოთეკა ერთი ასეთი ფაილი, რომელშიც ჩვენ გვაქვს შესრულება
საქართველოს GetString და GetInt და ყველა იმ რამ.
მერე რა linker არ არის მიდის გარშემო გადახედეთ ყველა ამ
ფაილი ხედავს, სადაც ფუნქციები განისაზღვრება, რაც დარწმუნებული ვარ, რომ როდესაც მოვუწოდებ
GetString სადღაც, იგი დარწმუნებულია, რომ GetString ნიშნავს, რომ ის
GetString დასრულდა CS50 ბიბლიოთეკაში.
ამიტომ linker უბრალოდ იღებს ყველა ამ ფაილებს, smashes მათი ერთად, და ახლა
თქვენ გაქვთ შესრულებადი.
ასე რომ გაითვალისწინეთ, თუ თქვენ იყენებთ CS50 ბიბლიოთეკაში, საჭიროა ორივე
# მოიცავს ზედა და შემდეგ ასევე თქვენს მარკა ბრძანება, როგორც თქვენ
განაცხადა, თქვენ უნდა ჰქონდეს-lcs50.
ასე რომ თქვენ შეგიძლიათ არა მხოლოდ გვაქვს ერთი.
ასე რომ უბრალოდ რაღაც გვახსოვდეს მომავალი მითითება.
>> დინამიკები 8: ასე რომ, ასე ვთქვათ არსებობს კიდევ ერთი ბიბლიოთეკა, როგორიც cs51.h, რომ ჩვენ
ასევე უნდა დაამატოთ-lcs51?
ROB: ერთადერთი მიზეზი ამ-lcs50 მუშაობს იდეალურად არის, რადგან ჩვენ გვაქვს კომპლექტი
წელს კონკრეტული ადგილი თქვენს მოწყობილობები ისე, რომ იცის, რა
-Lcs50 საშუალებით.
ჩვენ შეგვეძლო მხოლოდ მოგცემთ cs50.c ფაილი და შემდეგ შეგიძლიათ კომპილირება და განაცხადა,
Clang hello.c cs50.c, და მაშინ რომ თქვენი შესრულებადი გამოსული
ეს ორი ფაილი ერთად.
იგი დარწმუნებულია, რომ-lcs50 ნიშნავს cs50.c მეტი ზოგიერთ დირექტორია, რომ ჩვენ მითითებული
თქვენი ტექნიკა.
ასე რომ, თუ თქვენ სურდა cs51.c იყოს specifiable მხოლოდ ამბობდა-lcs51,
მაშინ ჩვენ ასევე უნდა დააყენოს ის, რომ დირექტორია ასე რომ იცის, სად უნდა
ვეძებოთ იგი.
ALI: რა იყო თქვენი შეკითხვა?
>> დინამიკები 7: რატომ უნდა დაუკავშირონ CS50
თუ - wasn't ეს copy / pasted პირველ ნაბიჯს, როცა წინასწარ დამუშავებული ეს?
ALI: გსურთ მიიღოს ეს?
ROB: დარწმუნებული.
ამიტომ cs50.h ფაილი ცალკე საწყისი cs50.c C ფაილი.
თქვენ შემოსული ფუნქციონირებას პროტოტიპები კლასში?
Okay.
ასე რომ, ძირითადად, cs50.h ფაილი უბრალოდ აპირებს დააკოპირეთ და ჩასვით -
ALI: იცით თუ ბიჭები ვიცი, რა ხელმოწერები?
Okay, ასე საკმაოდ ბევრი, თუ გადავხედავთ -
ROB: მოდით იმიტირებული cs50.h იქ არ არის.
ახლა ეს ფაილი -
თქვენ აკეთებთ string s = GetString.
მაგრამ როდესაც ჩვენ შემოსული ამ დროისთვის კოდი, მას არანაირი იდეა რა
GetString არის.
იგი დარწმუნებულია, რომ ის ფუნქცია, რადგან თქვენ უწოდა.
მაგრამ ეს არ იცის, რომ ის რეალურად უნდა დაბრუნდეს სიმებიანი.
ასე რომ მე განაცხადა, string s = GetInt, ეს არ გაუკეთებიათ გრძნობა, რადგან
თქვენ ხელმოწერის რიცხვი, რათა სიმებიანი.
მაგრამ ეს არ იციან, რომ GetString ამჯამად აზრი, რადგან ის არ
ვიცით, რომ GetString დააბრუნებს string.
მერე რა cs50.h ამბობს არის მსგავსი რამ.
ALI: რა რობ არის აკრეფით არის, ეს დაპირება ისე, რომ ის აპირებს
აქვს ამ ფუნქციის მოუწოდა GetString.
ROB: ეს არის ყველა, რომ cs50.h არის კოპირება და pasting აქ, ისევე
როგორც GetInt და ყველა იმ რამ.
და ეს მხოლოდ ნათქვამია, რომ GetString ამჯამად დაბრუნების სიმებიანი.
თქვენ არ იცით, თუ როგორ ეს განხორციელებული არ არის, მაგრამ როცა ჩვენ ვიღებთ ამ ხაზი, ახლა
იგი დარწმუნებულია, რომ სწორად დააბრუნებს string.
>> დინამიკები 9: ასე რომ, თუ ჩვენ არ გადაიტვირთოთ ერთად # მოიცავს რამ და ნაცვლად
უბრალოდ დაწერა პროტოტიპი ამისთვის პირობა, რომ ჩვენ რეალურად აპირებს გამოიყენოს?
ROB: ჰო.
მოდით აწარმოებს ამ.
დინამიკები 9: არის ეს?
ასე რომ, ჩვეულებრივ, იგი ყველაფერს გააკეთებს-L to CS50 მხოლოდ იმიტომ, რომ -.
ROB: - გამოხატვის.
ALI: დიახ, რადგან, როგორც თქვენ განაცხადა, რომ ის წელს მარკა ფაილი.
ROB: cs50.h ასევე მოხდება უნდა იყოს typedef char * to string.
შეგიძლიათ მთლიანად იგნორირება რა ეს ნიშნავს, რომ ახლა.
მაგრამ ეს ასევე არის რაღაც შედის cs50.h.
ახლა რამ კარგად იმუშავა ჯარიმა.
ის მუშაობს ზუსტად ისევე როგორც ეს იყო, როცა ჩვენ უბრალოდ არ ჰქონდა
# მოიცავს.
და ა.შ. მათ შორის cs50.h ხდება ზედმეტად შორის რამ გჭირდებათ -
მოსწონს, ჩვენ არ ვიყენებთ GetInt ამ პროგრამით, მაგრამ არა აქვს მნიშვნელობა.
ეს კიდე ნუ მიაქცევთ ყურადღებას.
ALI: მაშინ როცა-lcs50 მეტი აქ და სწორედ აქ, რა ხდება
on არის, რომ ის მქონე ფაქტობრივი განხოციელებადი კოდი.
ასე რომ, სადაც ის რეალურად არის, აკეთებს -
წერა კოდი GetString.
ასე რომ ეს არ არის მხოლოდ დაპირება უქმნით.
იგი რეალურად გადის და აღების სიმებიანი და ყველა რომ პერსონალი.
აზრი?
კითხვები? ყველა უფლება.
ზემოთ ლობიო.
>> ROB: ახლა ჩვენ შეგვიძლია გადაადგილება, რათა ფაქტობრივი კოდი.
ALI: Okay.
ასე რომ აქ არის პირველი პრობლემა.
ასე რომ ამბობს წერენ პროგრამა, რომელიც თხოვს მომხმარებელს ამისთვის ამას
წერილში და შემდეგ გარდაქმნის მას ზედა გამოყენების გარეშე bitwise
ოპერაციები, როგორც თითო ნიმუში გამომავალი ქვემოთ.
ასე რომ თქვენ ხედავთ, თქვენ აწარმოებს პროგრამა. / A.out და შემდეგ თქვენ
გეგმავს ამას, და შემდეგ თქვენი პროგრამა უნდა გადასცენ კაპიტალი
ა ასე რომ რატომ არ ბიჭებს ყველა მისთვის გადაღებული CS50 სივრცეები?
ასე, რომ თქვენ ბიჭები შეიძლება ყველა წავიდეთ აქ.
და თქვენ შეგიძლიათ წაშალოთ ყველა კოდი აქ.
და მაშინ წავიდეთ წინ და დავიწყოთ კოდირების რამ.
ROB: თქვენ ალბათ გინდათ გამოიყენოთ GetChar, რომ
შედის CS50 ბიბლიოთეკაში.
ALI: ვფიქრობ, ეს შესაძლოა უკეთესი თუ გადარჩენა ზედა ნაწილს.
ამიტომ დაგვჭირდება უბრალოდ შეცვალეთ პერსონალის შუა.
წავიდეთ წინ და მუშაობა.
შეგიძლიათ მუშაობა ერთმანეთთან.
ROB: და შეგიძლიათ შეკითხვები თუ გაქვთ -
>> დინამიკები 10: რა არის bitwise ოპერაციას?
ROB: ასე რომ, იგნორირება, რომ ეს პრობლემა.
ALI: თუ არ ვიცით, რომ კარგია.
ROB: ჩვენ ვაპირებთ გამოიყენოს იგი შემდეგი პრობლემა.
მაგრამ თუ თქვენ არ იცით, რა bitwise ოპერატორი, რომ ჯარიმა.
დინამიკები 10: არის, რომ მოსწონს გარდამტეხ მას ASCII კოდი?
ALI: №
ROB: არა
ამის გაკეთება შეგიძლიათ, რომ ეს პრობლემა.
დინამიკები 10: როგორ გავაკეთოთ ეს?
ასე რომ, თუ მხოლოდ მე მქონდა სადღაც დაწერა -
ALI: ან რაღაც წერა.
ROB: შემეძლო უბრალოდ სახის ტიპის შევიდა ამ.
ALI: გაცნობის ზედა.
ROB: Oh, მე იჯდა mic.
>> ასე რომ, ჩვენ ვნახეთ ლექციების რომ ASCII მნიშვნელობის კაპიტალი არის 65.
და კაპიტალური B იქნება 66 და ასე შემდეგ.
ასე რომ თქვენ შეგიძლიათ სიტყვასიტყვით გამოიყენოთ '' ნიშნავს ნომერი 65.
ისევე, ეს ღირებულება 65.
შემიძლია რაღაც int x = 100 - '". და ახლა x ექნება ღირებულება
100 - 65.
ALI: შეგიძლიათ აწარმოებს, რომ და აჩვენებს, რომ.
ოჰ, თუმცა არა.
არასოდეს იბადება.
ROB: მომიწია დაბეჭდეთ.
დინამიკები 10: როგორ ჩართოთ უკან ხასიათი?
ALI: ასე რომ, თუ თქვენ don't -
უბრალოდ აიძულებს, რომ იყოს char, შეადგენს.
ROB: ამიტომ -
განსხვავება შორის char და მთელი მხოლოდ თვალსაზრისით ზომა.
ასე რომ მთელი ხდება შეძლებს წარმოადგინოს რამ up
უნდა, ისევე როგორც, ოთხი მილიარდი.
Char არის მხოლოდ შეუძლია წარმოადგინოს რამ მდე 255.
მაგრამ არ არსებობს განსხვავება, გარდა ამ.
ასე, რომ თქვენ შეიძლება ითქვას, char c = 65.
სწორედ ექვივალენტი ამბობდა char c შეადგენს ".
ALI: ო, არა.
ეს ფაქტობრივად არ შეინახოთ რამ.
ROB: არა, თქვენ ვერ გავაკეთებთ.
ALI: ეს მხოლოდ -
[GROANS]
>> ROB: Okay, ასე რომ ალი უბრალოდ დაწერა იყო პროგრამა, რომელიც პირველი ბეჭდავს 100 -
'', როგორც მთელი რიცხვი, რომელიც 35, როგორც ჩვენ ვიმედოვნებთ, რადგან 100 მინუს ASCII
ღირებულება არის 65.
მაშინ მან დაბეჭდილი გამოყენებით% C, რაც იმას ნიშნავს, ინტერპრეტაცია, როგორც char.
ასე რომ 100 - არის 35.
Interpreting, რომ როგორც პერსონაჟი ხდება იყოს hash სიმბოლო.
თუ გადავხედავთ asciitable.com ან რასაც თქვენ ხედავთ, რომ 35 არის
hash სიმბოლო.
ALI: Okay, ნებისმიერი სხვა განმარტებების შესახებ პრობლემა?
Okay, თქვენ ბიჭები შეიძლება წავიდეთ წინ და ამის გაკეთება მაშინ.
Feel free კითხვის დასმის ან ესაუბრონ ერთმანეთს.
ან თუ თქვენ უკვე გაკეთდა, შეგიძლიათ დაისვენოთ.
>> LUCAS: არიან ისინი იგივე კლასის, ყველა ამას წერილებს მიზნით და
ასევე ზედა ასევე იმისათვის, იმიტომ, რომ რაღაც სასარგებლოა
პრობლემა.
ALI: კარგი წერტილი, Lucas.
ასე რომ, თუ ბიჭები ყველა მიიღოთ, რომ?
დინამიკები 11: დიახ.
ასე თქვენ ამის გაკეთება, არა?
ALI: მარჯვენა.
ROB: ჰო.
დინამიკები 11: [INAUDIBLE]
ALI: ყველა უფლება.
ROB: რა არის კითხვას სვამს?
Just გადაიყვანოთ -
ALI: Convert to ამას ზედა.
ეს არის ის.
ROB: Okay.
ALI: უნდა დაწერა?
ვფიქრობ ჩვენ უბრალოდ შევხედოთ სხვისი.
ROB: So მათთვის, ვინც შეიძლება დავრჩებოდით, გზა -
თუ გარკვეული char c, და ასე ვთქვათ ეს ხდება იყოს წერილში დ
ახლა როგორ ხდება გაერკვნენ, რა წერილი ანბანი C არის?
არ D, მაგრამ მე ვგულისხმობ, D ხდება იყოს მეოთხე წერილი ანბანი.
და თუ ჩვენ დავიწყებთ დათვლის საწყისი 0, მაშინ ეს მესამე წერილი ანბანი.
ასე რომ, თუ არის 0, B 1, C არის 2, D არის 3, როგორ ხდება გაერკვნენ int პოზიცია -
რა პოზიცია ანბანი C არის?
ვინმეს აქვს რაიმე იდეები?
ALI: ვფიქრობ ისინი ყველა კოდირება.
ROB: რა პირველი?
დინამიკები 12: So რასაც არის, სხვაობა პირველი?
ROB: ჰო.
ALI: Yeah, გასაოცარია.
ასე, რომ თქვენ შეიძლება არ Capital D -
OH, უკაცრავად.
თქვენ მიიღოს ხასიათი და თქვენ სხვაობა პირველი, როგორც თქვენ განაცხადა.
ROB: ასე რომ, თუ D არის რაღაც 68 და ჩვენ სხვაობა, რომელიც 65, მაშინ მივიღებთ
3, გვეუბნებოდა, რომ D არის მესამე წერილი ანბანი
დაწყებული 0.
ასე, რომ თქვენ შეგიძლიათ გამოიყენოთ, რომ.
ახლა ჩვენ ვიცით, რა წერილი ანბანი, თვალსაზრისით
ასოებით, ან -
ჩვენ შეგვიძლია გავაკეთოთ იგივე რამ ამას წერილებს გაერკვნენ, რა
მხედრულ თანამდებობა ჩვენ შემოსული
და ჩვენ შეგვიძლია გამოვიყენოთ, რომ მერე კონვერტირება, რომ ზედა გამოყენებით
ძალიან მსგავსი იდეა.
მოითხოვე წინადადებები?
>> ALI: თქვენ ბიჭები - დაველოდოთ, მე არ ვიცი, თუ რამდენად შორს თქვენ ბიჭები არიან.
ყველაზე თქვენგანს გაკეთდეს, ხართ, ისევ სამუშაო, თქვენ დავრჩებოდით?
თქვენ ბიჭები შეიძლება shout out -
დავრჩებოდით.
ერთი პირის დავრჩებოდით.
ზემოთ.
მე ტენდენცია დავრჩებოდით, ძალიან.
დინამიკები 13: მე გაკეთდეს.
ALI: თქვენ გაკეთდეს?
Okay.
შესრულებულია.
დინამიკები 13: [INAUDIBLE]
ALI: ჰო, ზემოთ.
თქვენ შემოწმების რომ ამას ფორმით?
Okay, ზემოთ.
სად არიან სხვა ადამიანებს?
იყო თუ არა ასეთი მინიშნება დაგეხმაროთ, როგორც გაეროს sticking თავის?
დინამიკები 14: ნამდვილად არ, მაგრამ მხოლოდ იმიტომ, რომ, არ ვიცი, მე არ ვარ
digesting იგი ამჟამად.
ALI: Okay, ზემოთ.
გნებავთ ცადეთ -
ან გსურთ წავიდეთ და გაიგო?
>> ROB: რა მივდიოდი ვთქვა არის -
ასე გამოყენებისას.
მიგაჩნიათ თუ არა გაგება, თუ როგორ მივიღეთ რა პოზიცია ანბანი
წერილში არის?
დინამიკები 14: Okay, ასე რომ, როდესაც თქვენ დააყენა რამ ერთჯერადი ბრჭყალი,
რომ ბრუნდება ნომერი?
ROB: დიახ.
ეს თარგმნილი იქნება, რათა ASCII ღირებულების იგი წარმოადგენს.
ასე რომ გსურთ გადადით ASCII ცხრილის ან რასაც ეს?
ALI: მხოლოდ ერთი ამ?
ROB: Yep.
ასე რომ, როდესაც თქვენ დააყენა რომელიმე ამ სიმბოლოების, იგნორირება ბევრი -
ALI: [INAUDIBLE]
ROB: Oh, გამოყენებით კურსორი.
ALI: ჰო.
ეს იყო საინტერესო.
ROB: ასე რომ, იგნორირება ამ პირობა მარცხენა, რომლებიც სპეციალური ნიშნები -
თუ დააყენა რომელიმე ამ სიმბოლიკა ერთ შეთავაზებები, მაშინ ეს იქნება
თარგმნილი ამ ღირებულების მარცხენა.
ALI: ეს არის ათობითი რიცხვი ამისთვის.
ეს მოსწონს შეიცავს 65, ბ 66, და თქვენ შეამჩნევთ, რომ ისინი ყველა
ანბანური თანმიმდევრობით, რაც განსხვავება.
ასე რომ, როგორც რობ ამბობს, ადრე, რომ კოდი, ჩვენ გაანგარიშების დაშორება
პირველი წერილი, თავისთავად.
და რომ ვიქნები იგივე, თუ არა ის ზედა ან ამას.
ROB: ასე რომ, როდესაც ჩვენ გავაკეთეთ D, 68 მინუს, 65, მივიღებთ 3.
რადგან D არის სამი პოზიციები შევიდა ანბანი.
ALI: ასეა, მაშინ როგორ თარგმნოს, რომ იპოვონ პატარა დ?
ROB: ჰო.
ასე რომ, თუ მაქვს 3 ახლა, მე ვიცი, მე მინდა სამი ასო შევიდა -
ჩვენ მოხდეს უნდა ვაპირებთ ამას, მაგრამ ვთქვათ მე მინდა სამი
პოზიციები შევიდა ამას მხარეს რამ.
ასე როგორ გავაკეთო რომ?
მე ვიცი ამას არის 97.
ასე როგორ მოვძებნო სამი პოზიციები შევიდა ამას წერილებს?
>> დინამიკები 15: მე მაქვს ერთი კითხვა რეალურად.
ALI: Yeah, წავიდეთ წინ.
დინამიკები 15: ასე რომ, ეს ნამდვილად არ აქვს მნიშვნელობა, თუ ვიცი, ამ თანამდებობაზე,
მინდა, მე არ გვჭირდება ამ მაგიდასთან.
ROB: Nope.
თქვენ არასოდეს უნდა გამოვიყენოთ ამ ნომრებიდან.
და ეს არის მნიშვნელოვანი მომენტი თქვენი პროგრამების, რომ თქვენ არასდროს არ უნდა მძიმე
კოდი ნებისმიერი ამ მუდმივები.
გამოიყენეთ ''. არასდროს არ გამოიყენოთ 65 ან 97.
ALI: ეს არის მოუწოდა Magic ნომრები, და ისინი მართლაც დამაბნეველი.
მსგავსად, როცა თქვენ გამართვის კოდი, თქვენ ალბათ არ გახსოვთ რა
გამოყენებულია მათ.
და ჩვენთვის შეფასების თქვენი კოდი, ჩვენ ნამდვილად არ ვიცი, რა
თქვენ იყენებთ მათ.
ამიტომ უმჯობესია, თუ თქვენ ნამდვილად გამოიყენოს გმირები ასე აკეთებს
მეტი გრძნობა ხალხს.
Okay, ნებისმიერი სხვა კითხვები?
უფრო ადამიანები გაკეთდეს, ან -
ვფიქრობ ჩვენ შეგვიძლია შევამოწმოთ.
მართლაც creepy რომ ხედავთ ხალხის კოდი.
ROB: ჰო.
ჩვენ არ უნდა გავაკეთოთ, რომ აქ.
ჩვენ არ ვიცით ხალხის სახელები, ან.
ALI: Oh yeah, კარგად რომ ხდის უკეთესი, ამიტომ ჩვენ კიდევ უფრო ობიექტური
ნაცვლად მხოლოდ შემთხვევით კრეფა ვინმე.
არ ინერვიულოთ.
მე არ გავაკეთეთ.
თუ თქვენ გაქვთ შემთხვევითი რამ - არასდროს გონება.
Okay.
როგორ ხდება ადამიანი აკეთებს?
>> დინამიკები 17: So მეცხრე ხაზი უნდა ამობეჭდოთ ხასიათი?
ROB: დიახ.
ALI: ჰო.
ასე რომ, თუ თქვენ ქვევით -
ROB: Oh, ვერ მოხვდება.
ALI: თქვენ ნახავთ, რომ იგი ნაბეჭდი hash სიმბოლო.
დინამიკები 17: Oh, okay.
ROB: ვფიქრობ სხვა გზა შეგიძლიათ შევხედოთ რამ არის ჩვენ დაბეჭდვის ორი
სიმბოლო.
პირველი ერთი ჩვენ ბეჭდვის წერილში ა
შემდეგი ერთი ჩვენ ბეჭდვის მხოლოდ 65.
ეს ალბათ დაწეროთ at me ამ.
ასე რომ, თუ ჩვენ მხოლოდ აწარმოებს ამ თქვენ შეამჩნევთ, რომ ბეჭდავს ორივე ჯერ.
იმის გამო, რომ ჩვენ გეკითხებით ეს იგივე.
ჩვენ ეკითხება მას ბეჭდვა წერილში ა მაშინ ჩვენ ეკითხება მას ბეჭდვა
ხმების 65 აღქმული ხასიათი, რომელიც იგივე.
ALI: გაქვთ სათქმელი?
ოჰ, მხოლოდ kidding, უკაცრავად.
ყველა უფლება, თუ როგორ არიან ადამიანები -
ROB: ჩვენ შეგვიძლია უბრალოდ გავლა იგი.
>> ALI: Okay, ასე როგორ დავიწყოთ?
ვინმე?
როგორც მინიშნება, ჩვენ უნდა მიიღონ რაიმე ადამიანი, საწყისი typers.
დინამიკები 18: [INAUDIBLE]
ALI: Oh yeah, prompt, სრულყოფილი.
ამიტომ ჩვენ ტიპი -
რას ვწერთ?
ვინმე?
ან უნდა მე უნდა აკრიფოთ ეს?
ჩვენ რეალურად აკრეფის -
ROB: დარწმუნებული.
ALI: ასე ჩვენ აკრიფოთ printf უბიძგონ, ასე რომ ჩვენ შეგვიძლია ვიყოთ
მინდა, მომეცი ხასიათი.
Okay, და მერე რა?
რატომ აკეთებს ამას?
ROB: არ ვიცი.
ALI: Okay.
ახლა, ჩვენ ვეუბნებით მათ მოგვცეს ხასიათი.
მაგრამ შემდეგ როგორ რეალურად მიიღონ, რომ ხასიათი?
დინამიკები 19: Use GetString.
ALI: GetString?
GetChar?
Okay, ასე რომ სხვაობაა სიმებიანი და char?
დინამიკები 19: Strings არიან სერია, როგორიცაა მასივი სიმბოლო.
>> ALI: Cool, yeah.
ასე რომ, ეს პრობლემა, ჩვენ მხოლოდ უნდა განიხილოს ერთი ხასიათი დროს, ისე
ჩვენ მხოლოდ აპირებს GetChar რომ მაგალითად.
ROB: ჩვენ შეგვეძლო განახორციელოს ფუნქცია თუ გვინდოდა, რომ აიღო მთელი სიმებიანი
და წავიდა მეტი სიმებიანი და შეიცვალა ყველა ამას რომ ზედა და ყველა
ზედა, რათა ამას.
მაგრამ აქ, ჩვენ უბრალოდ გეკითხებით ერთი ხასიათი.
ALI: ახლა ჩვენ გვაქვს ხასიათი აქ, მაგრამ მაშინ ჩვენ უნდა შეინახოთ.
ასე რომ მაშინ ჩვენ დაამატოთ char გ - რა?
დინამიკები 20: define ცვლადი.
ALI: ჰო, ზუსტად.
ამიტომ, ჩვენ გვაქვს ჩვენი ხასიათი.
ROB: მე ვფიქრობ, თქვენ შეიძლება იყოს -
თქვენ მხოლოდ სამი ფართები, რის გამოც ის yelling at თქვენ.
>> ALI: Okay, cool, ახლა რომ ჩვენ tabbing კომპლექტი, რა მოხდება შემდეგ?
რა არის შემდეგი ნაბიჯი?
ROB: რა ჩვენი პროგრამა უნდა გავაკეთოთ არის შეცვლის ამას წერილში
ზედა წერილში.
რა მოხდება, თუ მოხდება შესვლის hash სიმბოლო?
არის, რომ -
ALI: ეს კარგი სიმბოლო.
ჩვენ ვიყენებთ მას უამრავი.
ROB: არის, რომ მოქმედებს, რაც შემიძლია კონვერრტაციისთვის ზედა ფორმა?
დინამიკები 21: №
ALI: №
ჩვენ უნდა დარწმუნდეთ რომ.
ასე, რომ შეგვიძლია, თუ განაცხადი შემოწმების ასე რომ, თუ გ მეტია
ან ტოლია ამას 'a'-
ასე რომ, თუ დავაკვირდებით ჩარტში, თქვენ შეამჩნევთ, რომ ეს უნდა იყოს აქ,
ზე 97 და ამას.
და ეს შეიძლება იყოს ნებისმიერი ამ და increments ყველა გზა down.
და შემდეგ იქ z დროს 122.
და მას ჩავარდნას შორის ამ ორი ღირებულებებს.
ამჯამად რომ აზრი?
ROB: ასე რომ, თუ გ არ არის შორის 97 და 122 -
ან თქვენ არასდროს არ უნდა უნდა გამოვიყენოთ იმ ციფრები - თუ გ არ არის შორის "ა" და
'Z', მაშინ ეს არ იყო სწორი ხასიათი ჩვენთვის ზედა.
ALI: So კოდის სახით, ჩვენ ვამბობთ, რომ თუ გ მეტია ან ტოლია ერთჯერადი
შემთხვევაში ამას -
wow, რა ვთქვა, რომ?
Okay, მეტია ან ტოლია ამას '', და იგი უნდა იყოს ზემოთ
ამას 'z'. ასე რომ, ეს უნდა იყოს ნაკლები ან ტოლია მხედრულ 'z'.
ჩვენ მიღების დარწმუნებული ის შორის.
მაშინ შეგვიძლია გავაგრძელოთ ჩვენს ბედნიერი კოდი.
რა?
ROB: So I figured ჩვენ უბრალოდ შეინახოს ეკითხება, თუ ჩვენ მოხდეს არ აქვს
მხედრულ წერილში.
ALI: Oh, მე არ იცის, რომ.
უკაცრავად.
>> Okay, ასე რომ, თუ ჩვენ ვაპირებთ, როგორც რობ ამბობს, და დარწმუნდით, რომ -
ჩვენ შეგვიძლია შევინარჩუნოთ სთხოვს, მაშინ რა უნდა გავაკეთოთ?
დინამიკები 22: [INAUDIBLE]
ROB: ჰო.
ჩვენ უნდა გამოვიყენოთ გარკვეული loop.
იმის გამო, რომ მომხმარებელს შეუძლია შევიდეს რაღაც არასწორი untold თანხის ჯერ.
ასე, რომ თქვენ შეგიძლიათ გამოიყენოთ ხოლო loop.
მიზნით do-ხოლო loop -
სიტყვასიტყვით, მხოლოდ ახლა თქვენს მთელი ცხოვრება თქვენ ოდესმე გამოიყენოს do-
ხოლო მარყუჟების, როდესაც თქვენ ითხოვს მომხმარებლის შეყვანის.
ასე რომ ფაქტი ჩვენ ითხოვს მომხმარებლის შეყვანის აქ არის მინიშნება, რომ ჩვენ უნდა
გამოყენება do-ხოლო loop.
და რატომ არის, რომ?
რადგან do-ხოლო loop ყოველთვის ხდება ერთხელ მაინც.
ასე რომ, როდესაც თქვენ ითხოვს მომხმარებლის input, გსურთ, რომ მოხდეს ერთხელ მაინც.
და თუ რამ იყო წარმატებული, შეგიძლიათ შეინახოთ აპირებს.
თუ არა, უკან და ვთხოვ კიდევ ერთხელ.
>> ALI: So სხვა სიტყვებით, ჩვენ უნდა გავაკეთოთ სექციაში.
და ამიტომ ეს ეუბნება მას რომ რამე.
ამიტომ printf -
ბეჭდვა განაცხადი, სწრაფი, და ასევე ხასიათი, ან მცდელობა
კიდევ ხასიათი.
და შემდეგ ჩვენ უნდა შეამოწმოთ, თუ იგი რეალურად ეს სწორად.
ასე რომ მაშინ ჩვენ დაამატოთ პირობებში, მაშინ ჩვენ ვამბობთ, ხოლო, შემდეგ კი გვაქვს
პირობითი განცხადებაში.
ROB: მაგრამ ახლა ჩვენ შეცვალა მატარებელი აზრის.
ახლა ჩვენ თავდაპირველად ამბობდნენ, თუ გ არის ამ სპექტრს, ეს მოქმედებს.
ახლა ჩვენ გვინდა, რომ შეცვალოს და თქვას, თუ გ არ არის ამ სპექტრს, მაშინ ჩვენ
უნდა დაბრუნება გავაკეთოთ რამ ერთხელ.
ALI: Oh, yeah.
ROB: So ხოლო ეს ასე არ არის, ჩვენ გვინდა უკან და
ითხოვენ სხვა ხასიათი.
ამჯამად ყველას ვხედავ, რომ?
კითხვები ამ?
Okay.
>> ახლა ჩვენ გვაქვს სწორი ხასიათი, რომ ჩვენ შეგვიძლია ზედა.
ALI: ასეა, მაშინ რა შემდგომი ნაბიჯი uppercasing ეს?
დინამიკები 23: სანიშნეს 32.
ALI: თქვენ დაამატოთ -
უკაცრავად, რა?
დინამიკები 23: ვერ თქვენ უბრალოდ დაამატოთ 32?
ROB: So დიახ, არ თვალსაზრისით Magic ნომრები.
თქვენ უნდა მხოლოდ გამოყენებით ერთ ციტირებით პერსონალი.
დინამიკები 23: Okay, ასევე -
ROB: მაგრამ შეგიძლიათ მიიღოთ 32 -
ALI: როგორ თქვენ მიიღებთ ნომერი 32, მე ვფიქრობ, არის ის, რაც ჩვენ დაყრდნობით.
დინამიკები 23: [INAUDIBLE]
ROB: ასე რომ, ჩვენ შეიძლება ამუშავება ხმების 32 ერთად -
დინამიკები 23: [INAUDIBLE]?
ROB: ჰო.
მაგრამ თუ ჩვენ ვაპირებთ ამას ორი ნაბიჯი გავაკეთეთ ადრე ერთად
პოზიცია პერსონალი.
ამიტომ პოზიცია ანბანი რომ გ ხდება იყოს არის გ მინუს ამას
"'. ასე რომ, თუ შევედით ამას 'დ', პოზიცია იქნება 3.
და ახლა ჩვენ გვინდა მიიღოს რამ ზედა სპექტრს რამ.
ახლა ჩვენი ახალი გ იქნება დედაქალაქის 'Plus პოზიცია.
ასე რომ ხალხს ვხედავ, როგორ მოაქვს -
ჩვენ მოძრავი ამას სპექტრი, ზუსტი სიღრმე ჩვენ შევიდა, რომ
სპექტრი, და აპირებს down შევიდა ზედა მწკრივში და ვაპირებთ, რომ შორს
შევიდა ისევ, რომელიც იქნება იგივე ხასიათი, მაგრამ ახლა
uppercased.
ALI: და იმ ადამიანებს, რომლებიც დაბნეული როგორ უბრალოდ განაცხადა 32,
ძირითადად იგი შერწყმულია ორივე ერთ განცხადებაში.
ამიტომ ექვივალენტი გზა წერა ამ ვთქვა თქვენ შეგიძლიათ მისი სახის
შემცვლელი პოზიცია, გ მინუს ',' და განათავსოთ უფლება აქ.
ასე რომ რაც მან გააკეთა, მე don't -
char newc = ზედა '' Plus C მინუს მხედრულ ''. და ამის გამო ალგებრა,
თქვენ შეგიძლიათ გადაადგილება მათ გარშემო.
შეგიძლიათ ასევე აცხადებენ, რომ შეგიძლიათ გადაადგილება ირგვლივ ასე char newc = ზედა ''
მინუს მხედრულ '' Plus გ.
და ეს თქვენ შეამჩნევთ, თუ ჩვენ დავუბრუნდებით ჩარტში.
ჩვენ გვყავს ზედა არის 65 და მხედრულ არის 97.
ასე 65 - 97 არის -32.
>> Hi.
ჩაჯექით.
Oh.
თქვენ შეგიძლიათ იჯდეს უფლება აქ.
ზემოთ, okay, გასაოცარია.
კეთილი იყოს განყოფილება.
თქვენ შეამჩნევთ, რომ განსხვავება არის 32.
ასე რომ, სადაც მას, რომ ნომერი.
მაგრამ ეს არ, როგორც რობ ამბობს, საუკეთესო გზა ამის გაკეთება, რადგან მას უცნაური
Magic ხმების დაბნეულობა.
ROB: უნდა გამოიყენოთ კაპიტალის მინუს მხედრულ.
თქვენ არ უნდა გამოიყენოს მხოლოდ სწორი 32.
დინამიკები 24: რატომ არის, რომ, კიდევ ერთხელ?
რატომ უნდა არ გამოიყენოთ 32?
ALI: თუ ჩვენ ეს გავაკეთეთ, ეს იქნება char newc = -32 + გ.
და თუ თქვენ ვერ ვხედავ რომელიმე დანარჩენი კი, თუ ეს ყველა წავიდა, და თქვენ
უბრალოდ ვხედავ ამ ერთი ხაზი, მაშინ როგორ იცით რა უარყოფითი 32 არის?
უბრალოდ გარეთ ადგილი.
ROB: ასე რომ თქვენი პროგრამა იმუშავებს მთლიანად ჯარიმა.
უბრალოდ სტილი რამ.
ვიღაც მიდის და კითხულობს თქვენი კოდი, ისინი მოსწონს რას ნიშნავს 32?
ალბათ don't -
მე ალბათ არ დაუყოვნებლივ გააცნობიეროს, რომ 32 ხდება, რომ იყოს
განსხვავება ამას წერილში და ზედა წერილი, თუმცა
ჩვენ ვაპირებთ გამოვიყენოთ, რომ ფაქტი შემდეგი პრობლემა.
32 არის -
თქვენ შეიძლება დატოვოთ კომენტარი ზემოთ იგი ამბობდა 32 არის განსხვავება
'"და". " მაგრამ იმ ეტაპზე, ამიტომ არა მხოლოდ გამოიყენოს "ა" და "ა", და თქვენ
არ გვჭირდება კომენტარის შემდეგ.
>> ALI: უბრალოდ გზები ზემოთ მას ბევრი სუფთა, სტილი-ბრძენი.
ასე რომ, რადგან თქვენ მხოლოდ დაწყებული პროგრამირების -
ან მე მგონი, არ, რადგან თქვენ ჰაკერი ედი - არასდროს გონება.
უბრალოდ კარგი გზა აქვს -
სჯობს, რომ გვქონდეს უკეთესი სტილის.
უფრო ადვილია სხვა ადამიანებისთვის წაიკითხოს.
ROB: უნდა არასოდეს უნდა გვახსოვდეს, ASCII მაგიდა, ოდესმე.
თქვენ უნდა მხოლოდ შეძლებს გამოიყენოს ერთჯერადი ციტირებით სიმბოლო.
კითხვები?
ALI: ყველას კარგი?
ROB: Okay.
ასე რომ შემდეგი პრობლემა არის მნიშვნელოვანი.
ასე რომ შემდეგი პრობლემა გვთხოვს -
ALI: შემდეგი პრობლემა ითხოვს ჩვენთვის გავაკეთოთ იგივე, მაგრამ გამოიყენოს
bitwise ოპერატორები.
ROB: და რა თქმა უნდა, ჩვენ არ მინახავს bitwise ოპერატორების ამჟამად.
ამიტომ ჩვენ ახლა განვიხილოთ იმ.
ALI: BE აღელვებს.
ისინი super fun.
>> ROB: So რეგულარული ოპერატორები, როგორიც x Plus Y, მინუს, ჯერ, გათიშე.
ALI: ტიპი იგი ამ ზოლზე.
ROB: არსებობს ასევე%, თუ არ მინახავს ეს, რომელიც შეგიძლიათ გამოიყენოთ მიერ
პროცენტი სიმბოლო.
მაგრამ ჩვენ არ გამოვიყენებთ იმ ამ პრობლემას.
ჩვენ გვინდა გამოვიყენოთ bitwise ოპერატორები.
ახლა გახსოვდეთ, ჩვენ მოუტანა მას up in ლექცია ერთი.
მე არ ვარ დარწმუნებული, თუ ჩვენ განვიხილეთ ორობითი მიღმა რომ.
მაგრამ გვახსოვდეს, რომ თითოეული ნომრის წარმოდგენილია -
ასევე, ყველაფერი -
წარმოდგენილია 1s და 0S წელს ორობითი.
ასე რომ, რაც იმას ნიშნავს, რომ როდესაც ვამბობ, რომ ხმების 8, მე მოხდეს ვიცი, რომ სწორედ
მოსწონს, 1000.
რა bitwise ოპერატორების მოდით გავაკეთოთ არის მოქმედებს ამ ბიტი -
არის მოქმედებს ამ ბიტი პირდაპირ.
ახლა მე აღარ საქმე თვალსაზრისით რვა.
მე საქმე თვალსაზრისით 1000, და მინდა გავაკეთოთ რამ იმ
ინდივიდუალური ბიტი.
ასე ალი არ გაუკეთებია bitwise ოპერატორები აქ, არამედ that's -
ხმების 8 ჩვენ ვიყენებთ როგორც ჩვენი ერთი მაგალითი ნომრები.
და ორობითი წარმომადგენლობა არის 1000.
ჩვენ შეცვალოთ ნომერი, 5 -
რეალურად მოდით გამოვიყენოთ 9 და 5.
და 5 ს ბინარულ წარმომადგენლობა არის 00 -
0101.
ALI: არის ყველასთვის კარგია, რომ?
ორობითი პერსონალის?
ეს იყო პირველი ლექცია?
>> ROB: ისე კი თუ არ არიან მთლიანად თავზე როგორ გადაიყვანოთ რამ
ორობითი, რომ მთლად მნიშვნელოვანია ეს პრობლემა.
ჩვენ უნდა გამოყენება, მაგრამ თქვენ ბევრი მეტი შანსი უნდა გაერკვნენ, თუ როგორ უნდა
სწრაფად აქციოს რამ შევიდა ორობითი.
ასე გამოყენებით 9 და 5, ახლა ჩვენ გვაქვს ჩვენი bitwise ოპერატორები.
ოჰ, და ასევე, 9 და 5, თუ ის რიცხვი, მაშინ ნამდვილად ის 32 ბიტი,
რაც იმას ნიშნავს, რომ ჩვენ გვაქვს მოსწონს 0, 0, 0, 0, ბევრი ჯერ, მაშინ
101 წლის ბოლომდე.
ეს მხოლოდ იმიტომ, რომ, არ აქვს მნიშვნელობა, თუ რას აკეთებთ, ამ რიცხვებით, 32 ბიტი.
მხოლოდ იმიტომ, რომ ჩვენ მხოლოდ ოთხი ბიტი წარმოადგენს 9 არ ნიშნავს, ჩვენ არ ვართ
გამოყენებით up სხვა 27 ბიტი მხოლოდ 0S.
ALI: Just გარკვევა, ერთი ამ ნომრებზე რომ 0 ან 1 ოდნავ.
ეს ერთი არის 4 ბიტი.
როგორც ასე რობ განაცხადა, რომ მანქანები შესანახად მათ 32.
ასეა, მაშინ ისინი 32 არც 0 ან 1.
ზემოთ?
ROB: bitwise ოპერატორები.
პირველი, რომ ჩვენ გაუმკლავდეთ, მოდით &.
ასე რომ, თუ ჩვენ გავაკეთებთ 9 & 5.
მერე რა და არ არის, ცოტა ნელა, მას ადარებს ბიტი ორი ნომრები
და თუ ორივე ნომრებია 1, მაშინ იგი დაბრუნდება 1.
თუ ერთი არის 0 და სხვა არის 1, ან ორივე 0S, მაშინ ის დააბრუნებს 0.
ასე რომ თქვენ შეგიძლიათ ვფიქრობ, რომ ეს თქვენი ლოგიკური ANDs.
თქვენნაირი გვჭირდება ნამდვილი და ჭეშმარიტი დაბრუნების ასეა, მაგრამ ნამდვილი და ყალბი სიცრუეა.
ასე რომ იგივე, მაგრამ ახლა ჩვენ საქმე გვაქვს ეს მხოლოდ ბიტი.
>> ALI: ასე რომ, თუ თქვენ შეხედეთ ამ, თქვენ უნდა 1 -
თქვენ ხაზის მათ, ასე რომ ვიქნები 1 და 0.
თქვენ ბიჭები ვფიქრობ, რომ იქნებოდა - რა, რომ შევაფასოთ, რათა?
დინამიკები 25: 1.
ALI: ზემოთ.
ან არა.
უკაცრავად.
ამიტომ ამჯამად რომ აზრი?
რა არის კოლექტიური პასუხი კვლავ?
უკაცრავად.
ასე რომ, თუ ჩვენ გვყავს 1 და 0, მაშინ რას იღებთ?
ROB: ასე ფიქრობთ, თუ როგორ ამბობთ და გარეთ ხმამაღალი.
თუ თქვენ გაქვთ ორი ბიტი, X და Y, საჭიროა x და y იყოს 1 რათა ეს
შევაფასოთ ჭეშმარიტი - ან, იმისათვის, რომ ის შეაფასოს, რათა 1.
თუ x ან y are 0, მაშინ იგი აფასებს, რათა ყალბი ან 0.
LUCAS: კარგია უნდა გვახსოვდეს ისიც, რომ 1 არის ჭეშმარიტი და 0 სიცრუეა.
ასე რომ, თუ თქვენ გაქვთ ჭეშმარიტი და ყალბი, ეს სიცრუეა.
მაგრამ შემდეგ, ჭეშმარიტი და ნამდვილი, ჭეშმარიტი.
ყალბი და ცრუ, ყალბი.
ALI: ჩვენ გვყავს ჭეშმარიტი და ყალბი.
ასე რომ 1 და 0.
ასე რომ ისევ, უკაცრავად, კიდევ ერთხელ?
დინამიკები 25: კარგი იქნება 0.
ჰო, მაგარი.
და შემდეგ ჩვენ გვყავს 0 & 1 -
დინამიკები 25: [INAUDIBLE]
ALI: ჰო.
ასე რომ თქვენ ყოველთვის შეგიძლიათ სვოპ მათ -
თუ თქვენ გაქვთ 0 და 0?
დინამიკები 4: 1?
0?
ROB: ასე რომ 0.
ეს არ არის, რომ ორივე ნომრები უნდა იყოს იგივე.
ეს რომ ორივე ნომრები უნდა იყოს 1.
ALI: ასე ორივე უნდა ითქვას, რომ იყოს ჭეშმარიტი.
ასე რომ 0.
და მაშინ აქვს 1% 1, რომელიც?
ROB: ეს არის საკმაოდ კარგი ნომრები.
მათ აქვთ ყველა შესაძლო -
ALI: კარგი მუშაობა, wow.
Okay, ზემოთ.
ამიტომ ამჯამად რომ აზრი ყველას?
>> ROB: ახლა ჩვენ გავაკეთებთ |.
და ეს იქნება ძალიან ჰგავს, მაგრამ ახლა ნაცვლად x და y სჭირდება, რათა
იყოს 1 რათა ეს შევაფასოთ ერთ, ახლა უბრალოდ x ან
Y უნდა იყოს 1.
ALI: So 1 | 0 აფასებს to -
კლასი: 1.
ALI: ზემოთ.
0 | 1 აფასებს to -
კლასი: 1.
ALI: ზემოთ, შემდეგ კი 0 | 0 -
CLASS: 0.
ALI: ჰო, და შემდეგ 1 | 1 -
კლასი: 1.
ALI: ზემოთ.
ასე რომ ასეთი ორი bitwise ოპერატორები.
გასაოცარია.
ROB: ახლა ჩვენ გავაკეთებთ ^.
ALI: უნდა გავაკეთოთ ყველა მათგანი?
ROB: Yeah, რადგან ვფიქრობ, რომ ჩვენ ვაპირებთ მის გამოყენებას -
გამოყენებით მათ ყველა.
ALI: Okay.
ასე -
ROB: ვფიქრობ, ჩვენ არ გვჭირდება.
ALI: So ^ სამუშაოები, რომ თქვენ უნდა აქვს ზუსტად ერთი ჭეშმარიტი და ერთი ყალბი.
^ ნიშნავს განსაკუთრებული ან.
ახლა ეს არ -
თუ x და y ორივე 1, ეს არის ყალბი.
სწორედ განსხვავება ^ და |, ის არის, რომ ან, თქვენ შეგიძლიათ, თუ x არის
ჭეშმარიტი ან Y ეს მართალია, მაშინ ჩვენ კარგი.
არა, ^ ამბობს, თუ x არის ჭეშმარიტი, Y უნდა იყოს ყალბი, ანდა ეს მართალი არ არის.
გაქვთ შეკითხვა?
>> დინამიკები 26: [INAUDIBLE]
ALI: ჰო.
ეს სახის მსგავსი.
ROB: Yeah, ასე რომ, როდესაც თქვენ მიიღებთ რომ დაბალი დონის აპარატურა პერსონალის, ესენი არიან
სახის ოპერაციების თქვენ საქმე.
ამავე ტექნიკის დონეს, თქვენ მხოლოდ გაუმკლავდეთ ბიტი.
თქვენ არ გაუმკლავდეთ ნომრები.
ALI: Okay, ამისთვის ^, ან თუ თქვენ გაქვთ 1 ^ 0, რა უნდა, რომ შევაფასოთ, რათა?
კლასი: 1.
ALI: ზემოთ.
თუ თქვენ გაქვთ
0 ^ 1? კლასი: 1.
ALI: ზემოთ.
0 ^ 0?
ზემოთ.
და შემდეგ 1 ^ 1?
CLASS: 0.
ALI: Cool, გასაოცარია.
შემდეგი ერთი -
ROB: ვფიქრობ, ეს არის ყველა გვაქვს საქმე.
ჩვენ მხოლოდ ამ.
ALI: მხოლოდ ახლა ჩვენ უნდა გავაკეთოთ -
ROB: Oh, რომ იქნება ბოლო პრობლემა.
დინამიკები 27: Wait, კიდევ ერთხელ?
ALI: უკაცრავად, რა იყო თქვენი შეკითხვა?
>> დინამიკები 27: შეგიძლიათ განმარტავენ, რომ კიდევ ერთხელ?
^?
დინამიკები 27: Exclus - Yeah.
ALI: რა განსაკუთრებული ან ნიშნავს, რომ იქ უნდა იყოს მხოლოდ
ერთი ჭეშმარიტი და ერთი ყალბი, ასე რომ ერთი 1 და ერთი 0, წინააღმდეგ ერთად ან, შეგიძლიათ აქვს -
ერთი მათგანი უნდა იყოს ნამდვილი, ან ორივე მათგანი შეიძლება იყოს ჭეშმარიტი, რადგან
შევაფასოთ ჭეშმარიტი.
დინამიკები 27: So 0 და 0 იქნება ყალბი.
ALI: ჰო.
მაგრამ თუ თქვენ გაქვთ 1 |
1, რომ შეაფასონ ჭეშმარიტი.
მაგრამ თუ თქვენ გაქვთ 1 ^ 1, როგორც გავაკეთეთ, რომ აფასებს, რათა ყალბი.
იმიტომ რომ არა მხოლოდ ერთი ჭეშმარიტი.
ROB: ეს შეიძლება იყოს ან არ იყოს სასარგებლო, მაგრამ გაითვალისწინეთ, რომ არის ^
ტოლია მხოლოდ აღების |
მინუს &.
და თქვენ შეგიძლიათ რეალურად ვფიქრობ ეს ამ გზით.
^ უბრალოდ ORing ყველაფერს ერთად, მაგრამ გატანა ნებისმიერ ბიტი, სადაც
ორივე მართალია.
ასე და ანაზღაურება ყველაფერი სადაც იყო ნამდვილი.
| დააბრუნებს ყველაფერს სადაც ერთი ან ორივე ჭეშმარიტი.
ამიტომ subtracting რომ გარეთ | გაძლევთ ^.
ALI: ნებისმიერი კითხვები?
ეს იყო ბევრი ინფორმაცია.
ყველას კარგი?
>> ROB: ჩვენ შეგვიძლია წავიდეთ მომდევნო პირობა მომდევნო პრობლემა, ირიბის
რომელი საათია?
მათ არ სჭირდებათ ამ მომავალ პრობლემა.
ALI: ვფიქრობდი, რომ სწორედ ეს ერთი.
ROB: ეს არ.
ALI: დარწმუნებული ხართ?
ROB: დიახ, მე ვარ დადებითი.
ALI: რატომ არ დავიწყებთ აკეთებს შემდეგი პრობლემა?
პრობლემა ისაა, კიდევ ერთხელ, შეცვალოს იგი ამას რომ ზედა, და ამ
დროს უნდა გამოიყენოთ bitwise ოპერატორები.
ROB: ასე ჩვენ -
დავიწყოთ ორობითი წარმომადგენლობა '', დედაქალაქის ',
რაც 65.
ასე რომ ორობითი -
ასე '' = 65, რაც =, წელს ორობითი -
მე ვაპირებ mess up რაოდენობის 0S - რომ.
ALI: ასე აკეთებს, რომ აზრი, რომ ყველასთვის?
ასე რომ, 1, არ 2S, არ 4S, არ 8S, არ -
არ 16s, 32s არ, და შემდეგ ერთი 64.
ROB: ჰო, მე ვფიქრობ, რომ ერთ ერთი ძალიან ბევრი 0S.
ALI: უკაცრავად.
>> ROB: Okay, ასე გვაქვს 64 კომპლექტი, და ჩვენ გვაქვს 1 კომპლექტი, და აერთიანებს იმ
ერთად, მივიღებთ 65.
ALI: Cool ლობიო?
ROB: ახლა, ამას 'a'-
შეამჩნევს 97 -
რა განსხვავებაა 97 და 65?
დინამიკები 28: 32.
ROB: ჰო.
ასე რომ 32, რომელიც თავისი bit, ისე, რომ იქნება 110001.
და ეს იქნება ჭეშმარიტი ყველა შესაძლო სიმბოლო.
ასე რომ, თუ ჩვენ ვფიქრობთ of 'D', რომელიც იქნება 68, რომ იქნება 1000011.
და შემდეგ ამას 'd' იქნება 68 Plus 32, რომელიც 100, რომელიც
იქნება იგივე, რომ ეს იყო, უბრალოდ flipping
32 ერთხელ, ამიტომ 1100011.
ასე რომ განსხვავება ზედა და ამას წერილში მხოლოდ flipping
რომ 32-bit პოზიცია.
დინამიკები 29: არ არის 1000100?
ROB: დაველოდოთ, ეს 100 -
რაღაც გავაკეთე არასწორად.
ეს არ იყო მართალი.
მე ვფიქრობდი, რომ ეს იყო სხვაობა 3, ასეა, მაშინ მე უბრალოდ გაიჭედა
ორობითი 3 დასასრულს.
ეს უნდა იყოს სწორი.
ALI: დიდი მადლობა.
კარგი მიანიშნა, რომ.
ეს იყო მკვეთრი.
ყველა უფლება, ის არის, რომ წმინდა ხალხს?
>> ROB: განსხვავება ზედა და ამას ვერსია არის
ყოველთვის მხოლოდ იქნება 32 და ამიტომ ყოველთვის იქნება ერთი ცოტა
რომელიც უნდა flipped შეცვალოს შორის.
ALI: ასე რომ, ამ შემთხვევაში, იცოდა განსხვავება კაპიტალის და
ამას კარგი რამ.
არ თქვენს კოდი, მაგრამ კონცეპტუალურად მაინც კარგია.
ასე, რომ თქვენ ბიჭები შეიძლება წავიდეთ წინ და კოდი რომ სივრცეები არის.
ან უნდა ჩვენ უბრალოდ განიხილოს?
ROB: ჩვენ შეგვიძლია მხოლოდ განიხილოს.
მე არ ვიცი.
თქვენ ბიჭები შეგიძლიათ სცადოთ.
განხილვა შორის საკუთარ თავს bit.
ჩვენ მოგცემთ შანსს კოდი იგი.
[INTERPOSING ხმები]
ALI: - მაგარია
დინამიკები 30: ეს არის მსგავსად Hacker კომედია.
ALI: Yeah, ჩვენ უბრალოდ ვეუბნებოდი ამბები, გადის ეს.
>> ROB: და ჩვენ უკან.
ALI: სწორედ სახის უცნაური.
ვგრძნობ როგორც ჩვენ უნდა ჰქონდეს CS50 ამბები სადგური და შეგვეძლო
რეალურად იჯდეს მოსწონს ეს.
ROB: Hacker ამბები.
ALI: Hacker ამბები 50.
ALI: Feel Free ვთხოვო რაიმე კითხვა თუ თქვენ დაბნეული.
ROB: ჩავთვლით ყველას დავრჩებოდით?
ALI: ჰო, კარგი რამ.
ALI: Wait, თქვენ დავრჩებოდით თქვენი სკამი?
Oh.
მე ვიყავი პატარა შეშფოთებულია.
ROB: მე უბრალოდ მიხვდა, რომ ჩვენ ვაპირებთ მინდა
სხვა bitwise ოპერატორს.
ახლა, მოდით, უბრალოდ კონვერტირება ზედა, რათა ამას.
ALI: უკაცრავად, საერთოდ ყველას კიდევ რომ განცხადება?
ჩვენ ვაპირებთ წავიდეთ საწყისი ზედა რომ მხედრულ.
ROB: მაშინ ჩვენ განვიხილავთ ამას, რათა ზედა უფლება ამის შემდეგ.
ო, არა.
ჩვენ გვყავს bug ამ, რომელიც, ვფიქრობ, ჩვენ არასოდეს ცდილობდა აწარმოებს.
რაც არის, რომ char გ საჭიროებს განაცხადა გარეთ მარყუჟის, რადგან
მისი ფარგლების შეზღუდულია loop.
დინამიკები 32: ამ შემთხვევაში, არის ის არასწორი გამოიყენოს ნომერი?
ROB: EH, თქვენ არ გჭირდებათ.
თუ მე გარანტირებულია, რომ დედაქალაქის A'- ან, მხედრულ '' მინუს კაპიტალის "'
სწორედ ერთ bit, მაგრამ რომ არ იცით მისი 32 -
რამ იმუშავებს მხოლოდ ასევე თითქოს 16 bit, რომელიც flipped - ან
არა, მე ვფიქრობ, ეს wouldn't -
ან 64 ბიტი იყო flipped, შესაძლოა.
მაგრამ თქვენ არ უნდა უნდა გამოვიყენოთ 32.
თქვენ შეიძლება ნაცვლად გამოიყენოთ მხედრულ '' მინუს დედაქალაქის ".
>> დინამიკები 32: Okay.
რა შეგიძლიათ გააკეთოთ, თუ თქვენ თავს თქვენ წერილობით ზედმეტად არის შეგიძლიათ განსაზღვროს ის
ზედა.
ასე, რომ თქვენ შეიძლება იყოს, როგორიცაა, int სხვაობა = მხედრულ '' მინუს დედაქალაქის ". და
მაშინ შეგიძლიათ აკრიფოთ განსხვავება ნაცვლად.
სწორედ მოქმედებს.
მაგრამ მხოლოდ გამოყენებით ნომერი 32 არის სახის -
დინამიკები 33: მიუხედავად იმისა, რომ ეს იმიტომ, რომ ეს 32 ბიტიანი?
ALI: ჰო.
ROB: შესაძლოა -
ერთადერთი გარანტია გვჭირდება, რათა თქვენ ის არის, რომ განსხვავება
ამას და ზედა არის ერთი ცოტა.
უნდა აქვს მნიშვნელობა, რომ ეს ხდება, რომ იყოს 32 ბიტიანი რომ flipped.
დროის მოსაზრებები, დავიწყებთ აპირებს ამ.
ეს okay თუ არ დასრულდა.
არ ინერვიულოთ შესახებ.
ROB: თუ ვთქვათ C არის კაპიტალური წერილი -
ჩვენ არ უნდა ვივარაუდოთ გ არის კაპიტალური წერილში.
ჩვენ ვიცით, გ არის კაპიტალური წერილი შემდეგ ამ ხოლო loop -
do-ხოლო loop.
ასე რომ ნიშნავს, რომ იგი გამოიყურება მსგავსი რამ '. ასე რომ, თუ ჩვენ გვინდა, რათა ამ
'' ამ '', რას უნდა გავაკეთოთ?
ასე როგორ უნდა გადაიყვანოთ და Flip bit?
ALI: როგორ უნდა Flip ეს?
>> ROB: ასე ვიცით ჩვენ გვინდა Flip 32 bit.
ასე რომ ყველაფერს გააკეთებს "" მინუს "', ან ჩვენ შეეძლო დაეწერა 32, მაგრამ -
darn იგი, ეს პირიქით.
ALI: Okay ასე რობ აქ გამოთვლის, რომ ნომერი, ჯადოსნური ხმების 32.
მან დასკვნა, თუ სად, რომ ცოტა Flip ფართობი იქნებოდა.
და მერე რას დააყენა სადაც კითხვის ნიშნები არიან?
ROB: როგორ უნდა Flip რომ ცოტა?
თვალსაზრისით ზედა წერილში, ეს 0, და ჩვენ გვინდა, რომ გახდეს 1.
დინამიკები 34: |.
ROB: ჰო.
ასე რომ, ეს ჩვენთვის ამბობდა ვიღებთ ". ჩვენ ORing იგი 0 -
1000 -
და რომ = რომ.
ALI: არა, რომ აზრი, რომ ყველასთვის?
ჩვენ შეგვიძლია გავლა იგი ნელ ცოტა თუ გინდათ.
დინამიკები 35: ხართ [INAUDIBLE]?
ALI: სად არის მინუს ნიშანი?
ROB: Oh, თქვენ გულისხმობთ აქ?
ALI: Oh, yeah.
ROB: ასე ვფიქრობ ეს ჩვენთვის.
შეიძლება ითქვას, 32, და ახლა ჩვენ უბრალოდ გამოყენებით bitwise ოპერატორები.
ALI: ჩვენ არ მოგვწონს Magic ნომრები.
ჩვენ არ ვაპირებთ გავაკეთოთ, რომ.
ასევე მიმაჩნია, რომ უნდა მხოლოდ გამოიყენოთ bitwise ოპერატორი -
დინამიკები 36: თუ იყენებთ ^, იქნება თქვენ გაქვთ 32?
დინამიკები 37: Yeah, ვფიქრობ -
ROB: ჰო თქვენ.
ALI: ეს არის, თუ როგორ იქნებოდა გაკეთდეს მას აპირებს
საწყისი კაპიტალის მხედრულ.
>> ახლა შეიძლება ვინმე მითხრათ რატომ რობ და შევცვალე სწრაფი და როგორ წავედით
საწყისი ზედა ამას, ნაცვლად ამას უნდა
ზედა როგორც გავაკეთეთ ადრე?
ვინმეს აქვს რაიმე იდეები რატომ შეიძლება იყოს უფრო რთული?
ROB: ასე ჩვენ გვინდა გავაკეთოთ -
ALI: Yeah, წავიდეთ წინ.
დინამიკები 38: | ოპერატორი იყო მხოლოდ ნამდვილად კარგი დასძინა.
ALI: ჰო, ზუსტად.
ROB: მერე რა გვინდა გავაკეთოთ ამას რომ ზედა საქმე,
გადაიყვანოთ ამ 'a'-
ამიტომ გვინდა, რომ დააყენა ზოგიერთ ნომრები აქ და გამოიყენოს ზოგიერთი ოპერატორის ისე, რომ საქმე
იმისათვის, რომ დედაქალაქში ა ჩვენ კვლავ ალბათ გამოყენებით 32 რატომღაც, მაგრამ ახლა როგორ უნდა
ამ გამოვიდეთ ამ?
ასე რომ გ -
OH, მე მაინც მინდა, რომ ძალიან -
ALI: ახლა თუ ჩვენ კონვერტაცია საწყისი ამას რომ ზედა ერთხელ, მაშინ ჩვენ
გავაკეთოთ ^ ოპერაცია, როგორც თქვენ ბიჭები განაცხადა.
ROB: სხვა გზები არსებობს შეგიძლიათ გააკეთოთ რამ.
ბევრი bitwise ოპერატორების დასრულდება მდე მიმდინარეობს ძალიან ადვილად definable თვალსაზრისით
სხვა bitwise ოპერატორები.
ასე რომ მივდიოდი არ გამოიყენოთ ^ ან, მაგრამ ^ კარგად იმუშავა ჯარიმა.
>> ALI: Okay, ამიტომ ჩვენ ვაპირებთ წავიდეთ, ბოლო პრობლემა, რომელიც ძირითადი -
ბოლო პრობლემა ის არის, რომ გადაიყვანოთ რაღაც შევიდა ორობითი.
ასე, მაგალითად, თქვენ გაქვთ 50, და მერე გადაიყვანოთ იგი
ორობითი, რომელიც 110010.
და მე ვფიქრობ, თქვენ ბიჭები ყველამ ვიცით შესახებ ბინარული საწყისი ლექცია.
თქვენ ასევე არ უნდა დააყენოს ნებისმიერი წამყვანი 0S მივანიჭო.
ROB: შეგიძლიათ იგნორირება, რომ ნაწილი ახლა.
პირველი უღელტეხილზე, თქვენ შეგიძლიათ ეს გააკეთოთ ისე, რომ არსებობს წამყვანი 0S.
და მაშინ ჩვენ შეგვიძლია ცვლილებები რომ არ აქვს წამყვანი 0S, თუ ჩვენ გვაქვს დრო.
ALI: ასე რომ არ ინერვიულოთ შესახებ, რომ.
უბრალოდ ცდილობენ მიიღონ ორობითი.
კარგი ადგილია დაიწყება იქნებოდა -
ROB: ჩვენ უნდა ითხოვენ რიცხვი.
ALI: Oh yeah, რომ კარგი ერთი.
ჩვენ შეგვიძლია დავიწყოთ, რომ.
ასე, რომ თქვენ შეგიძლიათ შეცვალოთ ზოლზე.
ასე რომ ნაცვლად ხასიათი, ახლა ჩვენ საქმე გვაქვს რიცხვებით.
ზემოთ?
>> ROB: ახლა რა არის ჩვენი do-ხოლო მდგომარეობა იქნება?
ეს ითხოვს არასამთავრობო უარყოფითი რიცხვი.
ALI: როცა გვინდა შევინარჩუნოთ რამაც მომხმარებლის რაღაც სხვა?
როცა ეს პატარა ვიდრე 0.
ALI: მარჯვენა.
ROB: მე ნაკლებია, ვიდრე 0.
ALI: ახლა ჩვენ აკონვერტირებთ იგი.
მიგაჩნიათ თუ არა ბიჭები რაიმე იდეები, თუ რა უნდა გააკეთოს?
ნებისმიერი inklings?
Yeah.
დინამიკები 39: გვაქვს გარდაქმნას იგი, თუ შეგვიძლია მხოლოდ ბეჭდვა ზოგიერთი 0S და 1s
იქნებოდა სწორი ნომერი?
იქნებ გავაკეთოთ ამისთვის მარყუჟის და დათვალეთ მიერ უფლებამოსილების 2?
ROB: დიახ.
თქვენ არ გჭირდებათ გადაიყვანოთ მე მისი ორობითი -
ორობითი წარმომადგენლობა მე არ ჯდება შიგნით მე.
თქვენ უბრალოდ უნდა ამობეჭდოთ ორობითი წარმომადგენლობა მე.
ALI: სხვა სიტყვებით, თქვენ არ უნდა წავიდეთ მიერ უფლებამოსილების ორი.
ROB: რადგან მე უკვე ჩაიწერა როგორც binaries, ასე რომ თქვენ არ გჭირდებათ
კონვერტირება მას ორობითი.
უბრალოდ მისი ორობითი, და დაბეჭდეთ.
და თქვენ აპირებს უნდა გამოვიყენოთ bitwise, რადგან გსურთ შევხედოთ
ფაქტობრივი ბიტი.
თქვენ არ უნდა გამოვიყენოთ bitwise, მაგრამ გთხოვთ.
და რომ სინამდვილეში -
შეგიძლიათ უბრალოდ უფლებამოსილების ორი გამრავლებით მიერ 2.
ჩვენ წავიდეთ მეტი ერთი ბოლო ორი ორობითი bitwise ოპერატორები,
რაც ამ ერთ.
ასე რომ, როდესაც თქვენ მიიღოს -
>> ALI: შეგიძლიათ გავლა ორივე მათგანი?
ROB: ჰო.
მოდით წავიდეთ ერთად 9.
ასე რომ 9 მარცხენა Shift 1 -
რა დაუტოვებიათ ცვლა საშუალებით მხოლოდ გადავიდეს ყველა ბიტი მარცხნივ და ჩადეთ 0.
ამიტომ ჩვენ მოძრავი ყველა ბიტი 9 დან მარცხენაში
პოზიცია, რომელიც გვაძლევს -
ასე რომ შეამჩნია ჩვენ გადაინაცვლა ყველაფერი ერთი და ჩასმული 0 შესახებ
მარჯვენა მხარეს.
თუ ჩვენ გადავიდა მიერ დატოვებული ორი, გვინდა გადაეტანა ყველაფერს მიერ დატოვებული ორი,
და ჩადეთ ორი 0S შევსება ხარვეზები.
კითხვა?
ALI: ასეა, მაშინ მარჯვენა Shift ს მსგავსი რამ.
თუ თქვენ გაქვთ 9 მარჯვენა Shift 1 მაშინ თქვენ მხოლოდ მოძრავი ყველაფერი გადასცა
უფლება, დაკარგვის ციფრი, ასე რომ 100 მაგივრად.
ROB: ასე, რომ თქვენ ეს ჯარიმა, რომ თქვენ დაკარგვის bit, რაც მოხდა, რომ იყოს ყველა
გზა უფლება.
არსებობს სხვადასხვა სახის უფლება ცვლაში, მაგრამ ძირითადად შეგიძლიათ წარმოიდგინოთ, რომ
მარჯვენა Shift როგორც მხოლოდ გამყოფი მიერ 2.
და შეგიძლიათ წარმოიდგინოთ, რომ მარცხენა Shift როგორც გამრავლებით მიერ 2.
ასე რომ, თუ თქვენ ამ მოაქცია -
თუ მოაქცია 9 Shift 1, რომელიც უდრის 10010, თუ თქვენ ნამდვილად მივიდა
მეშვეობით ორობითი და figured რა რომ იყო, ეს იქნებოდა მხოლოდ 18.
ჩვენ მხოლოდ გამრავლების მიერ 2.
1001 მარცხენა Shift 2 იქნება 36.
ჩვენ გამრავლების მიერ 4.
Okay, ზემოთ, ასე რომ მოსახერხებელი bitwise ოპერატორს ამ ერთ.
გაძლიერებული დაბნეულობა?
თქვენ ბიჭებს შევეცდები ის?
ან შეგვიძლია მხოლოდ ხტომა უფლება და დაიწყოს ეს?
ROB: ჩვენ უნდა ალბათ ხტომა უფლება შემოსული
ALI: Yeah, Okay.
ROB: და გავლა ერთად.
>> ALI: Well მე უბრალოდ მივანიჭო.
ასე რომ, როგორც მან განაცხადა, წლის დასაწყისში, ჩვენ ვაპირებთ უბრალოდ გავლა ნელ bit.
ამიტომ, ჩვენ ვაპირებთ გვჭირდება loop.
ვინმეს აქვს იდეა საუკეთესო სახის მარყუჟის გავლა ამ?
ჩვენ გვყავს ხოლო მარყუჟების, do-ხოლო მარყუჟების, ამისთვის მარყუჟების.
დინამიკები 40: do-ხოლო loop?
ROB: ასე მახსოვს რა ვთქვი დაახლოებით, ჩვენ მხოლოდ გამოყენებით do-ხოლო
მარყუჟების მიიღოს მომხმარებლის შეყვანის.
თქვენ არასოდეს საკმაოდ ბევრი ოდესმე მათი არაფერი.
ALI: პრობლემა do-ხოლო მარყუჟების არის ეს ასეა რაღაც სანამ ამოწმებს ამისთვის
მდგომარეობა.
ასე რომ, შეიძლება რაღაც ცუდი -
მინდა, ავნებს -
რაღაც რომ შეუძლებელია.
ასე რომ გსურთ შეამოწმოთ პირველი.
ROB: არსებობს უამრავი შემთხვევა, როდესაც თქვენ შეგიძლიათ გამოიყენოთ do-ხოლო მარყუჟების, მაგრამ ხალხი
არ ველით თქვენ მათი გამოყენება, თუ იგი არის მომხმარებლის შეყვანის.
ამიტომ ჩვენ გამოყენებული ჩვენი do-ხოლო loop მისაღებად მე.
რამდენჯერ არის ჩვენი loop აპირებს გვინდა loop?
ჩვენ გვინდა, რომ მარყუჟი აღემატება თითოეული ბიტი, I.
რამდენი ბიტი არიან მე?
დინამიკები 41: 32.
ALI: ჰო.
ROB: ასე რომ 32 ბიტი.
ჩვენ არ გვინდა იმის თქმა, 32.
ჩვენ ნაცვლად მინდა ვთქვა sizeof -
რომელიც, გინახავთ, რომ კლასში არის?
ALI: Nope.
ROB: რატომ ამბობენ გამოიყენონ, რომ -
sizeof (int) ჯერ 8 -
ALI: ასე რომ, sizeof არის -
>> დინამიკები 42: [INAUDIBLE]
ALI: საინტერესო.
ასე რომ, sizeof არის ჩამონტაჟებული C ფუნქცია, სადაც იგი მხოლოდ გიჩვენებთ
პუნქტების ბიტი წელს -
ROB: Bytes.
ALI: ბაიტი, ბოდიში -
ბაიტების რაოდენობას, რომ ცვლადი აქვს შესანახად ღირებულება.
ამიტომ, მე ვფიქრობ, რომ ის წავიდა მეტი კლასში, მაშინ, int არის 4 ბაიტი იქნებ.
ზემოთ?
ROB: მაგრამ თქვენ არ უნდა უნდა იცოდეთ, რომ int არის 4 ბაიტი.
თქვენ უნდა შეეძლოს ამბობენ -
თქვენ უნდა გამოიყენოთ sizeof (int) მიიღოს 4 ბაიტი.
და ეს რეალურად მნიშვნელოვანია ზოგიერთი რამ.
Int შეიძლება არ იყოს 4 ბაიტი.
სხვა კომპიუტერის, int, შესაძლოა, 8 ბაიტი.
ასე რომ თქვენი პროგრამა არ იმუშავებს იმ კომპიუტერში იმიტომ, რომ თქვენ მყარი კოდირებული 32
ბიტი როდესაც რომ კომპიუტერული ხდება იყოს 64 ბიტი.
ALI: ასე რომ თქვენ არ საერთო რაოდენობის ბიტი, რომ გნებავთ შეცვალოს.
ROB: ხოლო სხვაობა byte და ცოტა ის არის, რომ იქ
არის 8 ბიტი წელს byte.
ამიტომ sizeof (int) დააბრუნებს 4 ბაიტი, მაშინ ჩვენ უნდა გავამრავლოთ, რომ
დაახლოებით 8 მისაღებად 32 ბიტი.
>> ALI: Okay, ასე ვიცით მაქსიმალური და ვიცით, ჩვენ გვინდა აქედან -
ჩვენ გვინდა გავლა ყველა მათგანი.
ასე რომ ჩვენ გვინდა აქედან 0 to numBits.
ასე რომ ვინმეს იციან, როგორ დაწერონ loop რომ?
ვინმე?
დინამიკები 43: [INAUDIBLE]
ALI: ასე გსურთ traverse ხმების მე საწყისი zeroth მწირი
პირველი bit, მეორე ბიტი, მესამე ცოტა, ყველა გზა numBits.
მაქსიმალური რაოდენობის ბიტი რომ თქვენ შეგიძლიათ მიიღოთ.
ROB: რა არის საერთო loop ვიყენებთ რაც ჩვენ გვინდა, რომ რამე x ჯერ?
ALI: იყიდება.
Perfect.
ამიტომ ჩვენ გვაქვს ამისთვის.
და შემდეგ ჩვენ დაგიმზადებთ iterator, რომელიც არ იქნება მე.
ROB: კ.
ALI: J = 0.
ასე დავიწყებთ at 0.
და შემდეგ ჩვენ ვაპირებთ აქვს მდგომარეობა რომ დავრწმუნდეთ, ხოლო თქვენ
გადის ეს თითოეული დრო -
[INTERPOSING ხმები]
ROB: კ.
ALI: კ ნაკლებია, ვიდრე numBits.
ამიტომ, ჩვენ არ გვსურს რომ ფაქტობრივი შეადგენს ერთი, რადგან ისინი numBits
სულ, და ჩვენ ვიწყებთ at 0.
ასე რომ ჩვენ რეალურად გვექნება -
დინამიკები 44: Oh.
ALI: ინდექსების არ დასრულდება numBits მინუს 1.
ROB: ჩვენ წარწერა ბიტი 0 to 31, ჩვენ არ წარწერა მათ 1 დან 32.
ALI: და შემდეგ ჩვენ ვაპირებთ ნამატი ყოველ ჯერზე ერთი, იმიტომ, რომ ჩვენ გვინდა
შეამოწმეთ თითოეული.
ასე რომ ჩვენ წავიდეთ j + +.
>> დინამიკები 45: რატომ აკეთებთ ამას?
დინამიკები 46: რატომ გადის ყველა bit?
ROB: ასე გვინდა გავლა ყველა bit და -
ასე ვთქვათ ჩვენ გვაქვს გარკვეული რაოდენობის.
ALI: 68.
ROB: ჩვენ შეგვიძლია გამოვიყენოთ 68.
ასე რომ ორობითი იქნება 100100.
ასე რომ, ეს არის შიგნით მე და გვინდა წასვლა მეტი თითოეული ბიტი.
არის თუ არა 1?
ბეჭდვა 1.
არის თუ არა 0?
ამობეჭდვა 0.
მაშინ ჩვენ წავიდეთ შემდეგ bit.
არის თუ არა 1?
ბეჭდვა 1.
არის 0?
ამობეჭდვა 0.
ALI: Cool, okay.
ახლა ჩვენ დროს სწორი მაჩვენებელია, სადაც ცოტა არის.
როგორ შეგვიძლია შევამოწმოთ, რომ კონკრეტული ერთი?
ვთქვათ ჩვენ დროს j = 0, ამიტომ ჩვენ გვინდა შევამოწმოთ 0 მაჩვენებელი bit.
ასე რომ, ამ შემთხვევაში, ეს ერთი.
>> ახლა როგორ უნდა წავიდეს შესახებ შეამოწმოს - Oh, იქნება ეს ერთი.
ROB: ჰო.
ALI: უკაცრავად.
როგორ ჩვენ შესახებ შემოწმების რომ, ამ გაგებით?
როგორ ჩვენ შეამოწმოს თუ 0 ან 1?
კარგად let's -
CLASS: და 1?
ALI: და?
Yeah.
ROB: ასე ვთქვათ ჩვენ უკვე გვაქვს 1.
მაშინ ეს და ეს დაბრუნდება იყო თუ არა 1 ან 0.
ALI: ასე შეგვიძლია დაცემას.
და ჩვენ შეგვიძლია გავაკეთოთ, რადგან თქვენ ბიჭები განაცხადა, კეთების და ფუნქცია.
ROB: int -
როგორ მინდა ვთქვა, ამ -
isOne = i.
და პირველად ცოტა ჩვენ მოხდეს უნდა ეძებს, ვაკეთებთ მე და 1.
ახლა რას ვაპირებთ გვინდა & მიერ მეორე ცოტა?
დინამიკები 47: 2.
ROB: Yeah, მეორე, რომ ჩვენ 2.
ALI: თქვენ შეამჩნევთ, რომ 1 გადავიდა მეტი მარცხნივ ერთი.
ასე რომ არ გავიგეთ ნებისმიერი bitwise ოპერატორების გავაკეთოთ, რომ ფუნქცია?
ROB: ერთი -
ALI: Yeah, უფლება, ზუსტად.
ასე რომ მარცხენა Shift.
ნაცვლად ყოველთვის შემოწმების ერთად 1, ჩვენ ვაპირებთ გადაეტანა იგი.
და რამდენჯერ მივდივართ გადაეტანა ეს?
თუ ჩვენ შემოწმების zeroth ერთი მაშინ ჩვენ ვაპირებთ მისი გადატანა მეტი ნულოვანი.
ჰო, ზუსტად.
ასე, რომ თქვენ დაუტოვებიათ გადაეტანა იგი კ.
Perfect.
ახლა ჩვენ ვიცით, -
ჩვენ გვაქვს ამ int of თუ 1 და შემდეგ -
ასე რობ მისი სახის მოტყუების აქ -
და ახლა იგი აპირებს წინ და ის მხოლოდ ამბობდა, რომ თუ ის რეალურად არის 1,
რადგან 1 აფასებს ჭეშმარიტი, ამიტომ ჩვენ არ გვაქვს იმის თქმა ISF isOne შეადგენს 1 -
ასე რომ, თუ isOne, მაშინ ჩვენ ბეჭდვა 1, და სხვაგვარად ჩვენ ბეჭდვა 0.
>> ROB: ჩვენი პროგრამა მთლიანობაში bug.
ისე, კითხვები ამ პირველი.
დინამიკები 48: შეიძლება ოდესმე დააყენა isOne შიგნით ოთხი ოპერაციის ნაწილი და
მაშინ არ ეს გადაეტანა თავს ბოლო ნაწილი?
ამიტომ isOne შეადგენს 1, ხოლო შემდეგ -
ROB: დიახ, შეგიძლიათ.
ჩვენ შეგვიძლია რეალურად ნახოთ, რომ ერთხელ ჩვენ დაფიქსირება bug რომ მე უნდა
განვიხილოთ თქვენთან ერთად ყველა.
გაითვალისწინეთ რათა ჩვენ ვაპირებთ მეტი რამ.
აქედან გამომდინარე ორობითი წარმომადგენლობა, ჩვენ დაწყებული zeroth bit.
თუ ეს 0, მაშინ ჩვენ დაბეჭდვის -
ასევე, ის არის 0, ასე რომ, ჩვენ დაბეჭდვის 0.
მაშინ ჩვენ წასვლა მეორე bit.
ეს 0, ამიტომ ჩვენ ბეჭდვა 0.
მაშინ ჩვენ წასვლა მესამე bit.
ეს არის 1, ასე რომ ჩვენ ბეჭდვა 1.
ALI: ამიტომ ვაპირებთ უკან.
ასე როგორ ბიჭებს მიაჩნიათ, რომ ჩვენ დაფიქსირება, რომ და წავიდეთ, სხვა გზა?
დინამიკები 49: [INAUDIBLE]
ROB: ჰო.
ასე რომ ნაცვლად აპირებს საწყისი 0 to numBits, ჩვენ აქედან numBits ბიტი უნდა 0.
ALI: So [INAUDIBLE]
ყოველთვის შეუძლია წავიდეს სხვა გზით.
ROB: NumBits მინუს 1, რადგან ისინი ბოლო nubmer -
ALI: იმიტომ, რომ მიემართება 0 to 31.
და მაშინ საბოლოოდ დავრწმუნდებით ყოველთვის დარწმუნდით, რომ უფრო მეტი, ვიდრე 0 იმისთვის, რომ არ წასულიყვნენ
შორს მარჯვნივ.
და მაშინ ყოველთვის გექნებათ სხვაობა მიერ 1 წასვლა უფლება.
>> ROB: ახლა ჩვენ გვაქვს საპირისპირო მარყუჟი, და ნომერი ისევ ბეჭდვის
სწორი გზა.
დინამიკები 50: ხომ არ უნდა შეიცვალოს ცვლა რამ ძალიან?
ALI: ასე არ.
ROB: ვაკეთებთ იგივე ზუსტი ოპერაციები, გარდა არის
საპირისპირო მიზნით.
ასე რომ ნაცვლად აკეთებს გადასვლის მიერ numBits მინუს 1 მისაღებად რასაც ამ
ცოტა არის, ნაცვლად აკეთებს, რომ ბოლო, ჩვენ უბრალოდ ეს პირველი.
By უკუქცევის ამ აქ, ჩვენ დავამარცხებთ ბრძანებით ყველაფერი
რაც ხდება შიგნით.
მაგრამ ჩვენ არ გვინდა, რომ შეიცვალოს რა ხდება შიგნით ყველა.
ALI: არა, რომ აზრი?
გენერაციის?
Okay, ასე ამჯამად ვინმეს აქვს რაიმე სხვა კონცეპტუალური კითხვები?
ALI: სანამ წასვლას მისი წერტილი რომელიც -
ALI: ყველა უფლება, კარგად წავიდეს.
ROB: ნაცვლად გამოყენებით კ იყოს ჩვენი -
ნაცვლად გამოყენებით კ ყოველთვის გადაეტანა მიერ, როგორც ერთი მარცხენა Shift j, ვფიქრობ რა
თქვენ ამბობდა ჰგავს, რომ კ გამოიყენოთ თვით.
ასე რომ j -
ვფიქრობ ეს არის რთული - j = 1 << 31.
ის არის, რომ რაც მე მინდა?
ვფიქრობ << 31.
j> = 1.
კ >>, >> isOne, მე & J -
ახლა ნაცვლად გამოყენებით -
ALI: თქვენ მუდმივად მოძრავი კ ნაცვლად, რომელმაც
ინდექსი, რათა შეამოწმოს იგი.
ეს არ არის, რომ ცუდი.
ჩვენ გამოყენებით მსგავსი ლოგიკა.
ასე რომ, თუ თქვენ დაბრუნდებით -
OH, მაგრამ გვეკარგება იგი.
Okay, თქვენ მხოლოდ ამ აპირებს აკრიფოთ ისევ.
თუ თქვენ შეამჩნევთ, რომ ჩვენ გვყავს 1 << კ თანხის ჯერ, და ჩვენ
დამატება j თითოეული დროს ერთი წუთობრივი, მაგრამ ამ დროს ნაცვლად
ისინი აკეთებენ მატების კ ზედა შიგნით ამისთვის loop.
ასე რომ ნაცვლად ყოველთვის მოძრაობს მისი დანგრევა -
ROB: პირველივე iteration of ამისთვის მარყუჟის, ჩვენ გვაქვს j არის 10000.
შემდეგი iteration of ამისთვის loop არის 01000.
შემდეგი iteration არის, რომ.
და 1 არის უბრალოდ აპირებს შეინარჩუნოს სათესლე ქვემოთ სანამ ჩვენ მოხვდა ძალიან
ბოლოს, სადაც ახლა ამ.
შემდეგი ერთი, 1 იქნება უბიძგა, და კ აღარ არის მეტ
ვიდრე ან ტოლია 1.
შემეძლო ასევე დააყენა მეტი 0, იგივე განსხვავება.
და მაშინ ეს არის ის.
კითხვები?
Yeah.
>> დინამიკები 51: [INAUDIBLE]
ROB: ასე რომ იგივე როგორც -
გინახავთ j + = 3?
ასე რომ, ეს არის იგივე როგორც j = j + 3?
ამის გაკეთება შეგიძლიათ, რომ პრაქტიკულად ნებისმიერი ოპერატორი C. ასე კ >> = 3 არის
ტოლია j = j >> 3.
ასე რომ მუშაობს ასევე bitwise ოპერატორები.
და მე არ უნდა დააყენოს 31 აქ.
მე უნდა დააყენოს numBits - 1.
ALI: YAY, არ Magic ნომრები.
Okay, ეს 4:00 თუმცა, ასე რომ, თუ თქვენ ბიჭები უნდა წავიდეთ - მაგრამ ჯერ ამ აზრი?
მიგაჩნიათ თუ არა ბიჭები რაიმე სხვა კითხვები?
ROB: მე ასევე აპირებს ჩააგდოს, თუ გვინდოდა -
უკვე საუბარი ternary ოპერატორი ყველა?
ALI: №
ეს okay.
ROB: ასე, რომ თქვენ შეიძლება შეესწავლათ ეს მომავალი დრო.
ALI: Okay, ნამდვილად?
ახლა თქვენ უბრალოდ იწონებდნენ.
ROB: არა, ახლა it's -
ეს რა იღებს დაინტერესებული, და ახლა ისინი ყველაფერს წასვლა ნახვა მივანიჭო.
ახლა, რომ აკეთებს იმავეს, ერთ ნაბიჯს.
ამიტომ პირველ შეამოწმოთ, არის I და კ 1?
ეს მართალია?
თუ ასეა, ბეჭდვა 1, სხვას, ბეჭდვა 0.
ALI: მაგრამ ამით მას სხვა გზა სრულიად ჯარიმა ისევე.
მას აქვს იგივე ლოგიკით.
ასე რომ არ მოსწონს ერთი არის -
ROB: ამ ეტაპზე, ჩვენ შეგვიძლია თავი დავაღწიოთ იმ Curly braces, რადგან მხოლოდ
ერთი ხაზი loop.
ALI: Okay, ასე რომ ამჯამად აზრი?
ეს იყო ერთგვარი ნახტომი.
მაგრამ ეს მხოლოდ სახის სინტაქსური, მითუმეტეს.
>> ზემოთ?
ნებისმიერი სხვა კითხვები?
ROB: ყველა უფლება.
ALI: ყველა უფლება, ზემოთ.
მადლობა მოდის მონაკვეთზე.