>> LUCAS Freitas: OK, ვფიქრობ ახლა ჩვენ პირდაპირ ეთერში.
მოგესალმებით CS50 Supersection.
ჩვენ ნაკლებად კომფორტული.
ჩემი სახელი არის Lucas Freitas.
მე ერთი CS50 უფროსი TFs.
ეს არის Lauren.
>> LAUREN Carvalho: Hi, მე Lauren.
მე ასევე უფროსი TF განთავსების CS50.
>> LUCAS Freitas: დღეს ჩვენ უბრალოდ აპირებს მისცეს მიმოხილვა რა ყველა თქვენ
ბიჭები არ შეიტყო კვირაში ერთი, იმედია რათა თქვენ ბიჭები კარგი
გრძნობა, თუ რა უნდა იცოდეს, პრობლემა მითითებული ერთი.
>> მხოლოდ რამდენიმე განცხადებები.
პირველ რიგში, სამუშაო საათებში.
საათებში ხდება ორშაბათიდან ხუთშაბათი სხვადასხვა სახლები
Annenberg ყოველ დღე.
ისინი ძალიან კარგი რესურსი თქვენ ბიჭები მოდიან და შეკითხვები, და
გაიგო TFs, და კიდევ exchange იდეები სხვა სტუდენტებს.
ასე რომ დარწმუნებული უნდა გამოიყენოთ, რომ რესურსი თქვენს სასარგებლოდ.
>> მეორე ის არის, CS50 ელექტრო მოწყობილობების.
უკანასკნელი [INAUDIBLE]
თქვენ ბიჭები არ აქვს რეალურად აქვს ელექტრო მოწყობილობების.
უბრალოდ ყველაფერი გააკეთა თქვენს პერსონალურ კომპიუტერში.
მაგრამ ეს პრობლემა, თქვენ ნამდვილად აქვს აქვს ვირტუალური მანქანა, ასე რომ
დარწმუნებული ჩამოტვირთოთ CS50 ელექტრო და ვაყენებთ მას up.
>> და მესამე რამ დარწმუნებული უნდა იყოს დაიწყოს პრობლემა კომპლექტი ASAP მხოლოდ
იმიტომ, რომ ეს ბევრად უფრო ადვილია, რათა იპოვოს დაეხმაროს, როდესაც თქვენ
დასაწყისში კვირაში.
იმიტომ, რომ ადამიანი, როგორც წესი, დაველოდოთ ბოლო მეორე დაიწყოს პრობლემა კომპლექტი,
და მაშინ წასვლა საათებში, და იქ ბევრი ადამიანი.
სადაც თუ ორშაბათს, თქვენ აპირებს ვხედავთ, რომ შეგიძლიათ გაიგო TFs
საკმაოდ ბევრი მთელი ღამე, და ისინი აპირებენ უფრო მეტი ვიდრე
მოხარული ვარ, რომ დაგეხმაროთ.
>> LAUREN Carvalho: შემიძლია უბრალოდ შეწყვიტოს თქვენ მხოლოდ ერთი მეორე?
უკვე ყველასთვის შეძლო ჩამოტვირთვა CS50 ელექტრო?
ხალხი ცდილობდა?
>> LUCAS Freitas: ჩამოსატვირთად მიერ გზა, შეგიძლიათ მიიღოთ ინსტრუქცია
cs50.net/appliance.
>> LAUREN Carvalho: Right.
და ეს არ მიიღოს ცოტა ხანს ჩვენს sys admins მისაღებად თქვენ ლიცენზიის
გასაღები, ამიტომ იწერთ უფასო საცდელი პირველი.
ეს გზა, თქვენ გაქვთ ის 30 დღის განმავლობაში, და მაშინ დაველოდოთ თქვენი ლიცენზიის გასაღები
რომელიც უნდა მისცეს მას თქვენ წელიწადში.
>> LUCAS Freitas: პირველ რიგში, მოდით ვისაუბროთ ცოტა
შესახებ CS50 ელექტრო მოწყობილობების.
CS50 ელექტრო რეალურად ვირტუალურ მანქანა, რომ თქვენ აპირებს
აწარმოებს თქვენი კომპიუტერი, რომელიც ძირითადად გაშვებული სხვა კომპიუტერზე
შიგნით თქვენი კომპიუტერი.
რომელიც არის საკმაოდ გრილი.
და რეალურად ის გამოიყენება ყველგან.
ადამიანები, რომლებიც ტექნიკური იქნებოდა ვიცი, რომ ეს გამოიყენება ყველა დროის.
თქვენ?
შეიძლება მქონდეს კომპიუტერები ერთი მოწყობილობა.
>> მოდით რეალურად შევხედოთ იმ მოწყობილობების.
როცა წასვლა ელექტრო შემდეგ რეგისტრაციისას, თქვენ უნდა
განათავსოთ თქვენი სახელი და შეხვიდე Harvard ასე რომ ჩვენ შეგვიძლია თქვენ ყველა არ არის რეგისტრირებული.
თქვენ აპირებს ვხედავ ძირითადად მხოლოდ ფონი და შემდეგ სახლი და Trash,
და შემდეგ ამ პატარა ხატები.
ეს სამი ხატები რეალურად ყველაზე მნიშვნელოვანი რამ, რომ თქვენ შეგიძლიათ აქვს
თქვენი მოწყობილობების.
>> პირველი gedit, რომელიც არის ტექსტი რედაქტორი, ისევე, როგორც Notepad ან მოსწონს
ნებისმიერი სახის ტექსტური რედაქტორი.
ეს არის მხოლოდ ის, რაც ჩვენ ვიყენებთ დაწერა კოდი და შემდეგ გავაკეთოთ პერსონალის იგი.
>> მეორე, რაც ჩვენ აქ არის Chrome.
ასე რომ, თუ თქვენ უნდა გამოვიყენოთ ინტერნეტში ელექტრო, რომ
რა შეგიძლიათ გამოიყენოთ.
>> და მესამე ის არის, ტერმინალი, რომელიც რეალურად ძალიან ტკბილი.
ადამიანი, როგორც წესი, სახის ეშინია ტერმინალი, რადგან ეს არის ძალიან
მოძველებული განცხადება, რომელშიც თქვენ უბრალოდ ძირითადად აკრიფოთ ყველაფერი
თქვენს კლავიატურაზე.
არ არსებობს ბევრი ურთიერთქმედების თქვენი მაუსი.
მაგრამ რეალურად ტერმინალში აკეთებს ძალიან კარგი რამ.
>> პირველ რიგში, მოდით უბრალოდ გავლა ზოგიერთი ბრძანებები,
შეგიძლიათ გამოიყენოთ ტერმინალში.
>> LAUREN Carvalho: და მოგერიდებათ შეწყვიტოს ჩვენთვის, თუ თქვენ გაქვთ რაიმე შეკითხვებს.
>> LUCAS Freitas: ჰო.
ასე რომ, პირველი ბრძანება, რომ ჩვენ განთავსების ტერმინალის ls.
ls ძირითადად იმას ნიშნავს, სიაში ყველაფერს, ყველა ფაილი და ყველა დირექტორებს,
რომ მაქვს ერთი ადგილი, რომ მე ვარ.
ასე რომ, თუ ls აქ, მე ვაპირებ ვხედავ რომ მაქვს რამდენიმე დასტა.
მაქვს desktop, ჩამოტვირთვების, ჟურნალები და VHOSTs.
ეს არის ლურჯი, რადგან ისინი ყველა დასტა.
>> მაშინ თქვენ გაქვთ რაიმე სხვა ფაილი.
თქვენ გაქვთ, როგორიცაა მიესალმები და hello.c, რომელიც უბრალოდ ფაილი, და ისინი
სხვადასხვა ფერის.
ასე რომ, ეს არის ძალიან მნიშვნელოვანი ბრძანება მხოლოდ თქვენ შეგიძლიათ ნახოთ თუ რა ფაილი
და დირექტორიების, რომ თქვენ გაქვთ დირექტორია, რომ
თქვენ ტერმინალში.
როდესაც ხედავთ jharvard @ ელექტრო და მაშინ პატარა სიმბოლო არსებობს,
tilde, რომელიც მხოლოდ იმას ნიშნავს, რომ ის დირექტორია, რომ თქვენ ხართ იმ მომენტში.
>> LAUREN Carvalho: ასე აკრეფით ls თითქმის ისევე როგორც დაწკაპვით საქაღალდეში
რომ არის ჩამოთვლილი უფლება არსებობს, ეს შოუები თქვენ ყველა შინაარსი, რომელიც
შიგნით რომ საქაღალდე.
>> აუდიტორია: არის ტექსტი შემდეგ hello.c?
>> LAUREN Carvalho: Oh, თქვენ არ შეგიძლიათ ვხედავთ, რომ, რადგან ეს არის ლურჯი.
>> LUCAS Freitas: იგი ამბობს ჟურნალი და VHOSTs.
>> LAUREN Carvalho: ეს უბრალოდ სხვა ფოლდერები.
ვწუხვარ, ეს მართლაც რთული ვხედავ.
შესაძლოა თუ ჩვენ გამორთულია შუქი?
COLTON, თქვენ შევეცდები და მოძებნეთ მსუბუქი შეცვლა?
უკაცრავად შესახებ.
მე არ ვფიქრობ ამაზე.
>> LUCAS Freitas მაგრამ ეს ძირითადად -
ჰო, თუ შეიძლება -
>> LAUREN Carvalho: Zoom თქვენს ეკრანზე.
>> LUCAS Freitas: მე არ აქვს, რომ ფუნქცია.
>> LAUREN Carvalho: [INAUDIBLE].
OK.
ისე, არსებობს მხოლოდ ბევრი ბუნებრივი სინათლე ამ ოთახში ასევე.
>> LUCAS Freitas მოდით მხოლოდ ვივარაუდოთ, რომ არსებობს ორი სხვა დირექტორიები არსებობს.
>> LAUREN Carvalho: Just ეკისრება ჩვენთან ერთად.
ეს არის ერთადერთი ნაწილი, რომელიც თქვენ ეძებს ტერმინალში.
>> LUCAS Freitas: მომავალი ბრძანება ძირითადად იქნებ გსურთ ორგანიზება
თქვენი ფაილები -
მაგალითად, ყველა თქვენი C ფაილი ერთი დირექტორია, მაგრამ თქვენ არ გაქვთ
დირექტორია მხოლოდ C ფაილი ამჟამად.
შეგიძლიათ პრაქტიკულად შექმნათ დირექტორია გამოყენებით ტერმინალის ისევე, რომელიც
იგივე, რაც მარჯვენა დაწკაპვით და იტყოდეს: New Folder.
ბრძანება მიიღოს დირექტორია, რომელიც არის mkdir, ასე ძირითადად "მიიღოს" და
"დირექტორია."
>> და მაშინ დააყენა სახელი დირექტორია.
ვთქვათ, რომ მინდოდა ეწოდოს, მე არ ვიცი, ასე ვთქვათ pset1 Doing
ეს, მე უბრალოდ შექმნილი დირექტორია.
მოდით უბრალოდ შეამოწმოს, რომ ის არსებობს.
ასე რომ, თუ ls, ახლა მე ვხედავ მორების, და მაშინ pset1, და შემდეგ VHOSTs.
ასე რომ, მე მაქვს ახალი დირექტორია არ არსებობს.
>> და შემდეგ თქვენ გაქვთ ახალი დირექტორია, იქნებ გსურთ ნავიგაცია
შევიდა, ასე რომ მომდევნო ბრძანება ამ CD, რომელიც უბრალოდ ნიშნავს იმას, წასვლა
კონკრეტული დირექტორია.
ასე რომ, თუ მინდა წასვლა pset1, მე შემიძლია უბრალოდ cd pset1.
>> LAUREN Carvalho: cd დგას ცვლილება დირექტორია, [INAUDIBLE] შეუძლია
გახსოვდეთ, რომ.
>> LUCAS Freitas: და ახლა ხედავთ, რომ ნაცვლად მხოლოდ მქონე jharvard
ელექტრო, მე არ jharvard მოწყობილობების, და შემდეგ pset1, რადგან ეს გვიჩვენებს
მე სად ვარ ამ კომპიუტერი.
>> ახლა თუ მინდა დაბრუნდეს დირექტორია, რომელიც იყო ამ ერთი, მე
შეგვიძლია გავაკეთოთ cd dot dot, რომელიც მხოლოდ იმას ნიშნავს წასვლა დირექტორია, რომ მე ადრე,
ისევე როგორც მშობელს ამ დირექტორია, ძირითადად.
და ახლა ვხედავ, რომ მე ვარ უკან jharvard.
>> შემდეგი რამ, რომ მე შემიძლია ამის გაკეთება არის rm, რომელიც ამოიღონ ფაილი.
მაგალითად, მოდით პირველ გავაკეთოთ ls ვნახოთ, რა მაქვს აქ.
მე არ მიესალმები და hello.c.
ვთქვათ, რომ მე მინდა ამოიღონ მათ.
შემიძლია rm hello.
იგი აპირებს ამბობენ "ამოიღონ რეგულარული ფაილი მიესალმები? "და მე ვთქვა," დიახ. "და ახლა თუ მე
გავაკეთოთ ls, მე ვხედავ, რომ ეს არ უქმნით.
>> თუ მე ცდილობენ გამოიყენონ rm ერთი დირექტორია, თუმცა, ის არ აპირებს
ნება თქვენ არაფერი.
იგი აპირებს ამბობენ, hey, თქვენ ვერ ამოიღონ დირექტორია.
ასე რომ, ჩვენ გვაქვს ამ მეორე მოდის მოუწოდა rmdir, რომელიც უბრალოდ ნიშნავს იმას,
ამოიღონ დირექტორია.
შემიძლია, მაგალითად, ამოიღონ pset1.
და, თუ ls, მე არ აქვს მას აღარ.
>> ნებისმიერი კითხვები შესახებ?
არა?
ჰო?
>> აუდიტორია: ეს მნიშვნელოვანია, რომ თქვენ დატოვეთ ფართი შემდეგ - როცა
დაიწყოს აკრეფით რაღაც?
>> LUCAS Freitas: ჰო.
იმ შემთხვევაში, თუ მე მინდა cd და დირექტორია, მე უნდა დააყენოს სივრცეში.
რა ადგილი ვსაუბრობთ?
>> LAUREN Carvalho: The შორის სივრცე CD და [INAUDIBLE].
>> LUCAS Freitas: Yeah, თქვენ უნდა დააყენა ფართები რადგან cd არის
ბრძანება, ხოლო შემდეგ მომდევნო სტრიქონი თქვენ type ძირითადად დირექტორია.
ასე რომ, როგორც არგუმენტი.
ჰო?
>> აუდიტორია: როცა სიაში, ყველა იმ სხვადასხვა დირექტორიები, არა?
>> LUCAS Freitas: Yeah, ისინი არიან დირექტორია.
>> აუდიტორია: რა არის განსხვავებები შორის დირექტორიები?
>> LUCAS Freitas: ისინი უბრალოდ სხვადასხვა ფოლდერები.
დირექტორია საქაღალდეში თქვენს კომპიუტერში.
>> აუდიტორია: ღია ფოლდერი.
>> LUCAS Freitas: ჰო მხოლოდ ღია ფოლდერი.
>> LAUREN Carvalho: მეტი აქ, ვინც რომ ლურჯი ფაქტობრივი
დირექტორიები, რომ თქვენ შეგიძლიათ მიიღოთ შევიდა და შემდეგ ვხედავთ რამოდენიმე რამ არის
ფარგლებში, რაც სამწუხაროა რადგან ვერ რეალურად წაიკითხა
პირობა ლურჯი ფერით.
და ვინც თეთრი უბრალოდ ფაილი რომ მიმდინარე დირექტორიაში.
>> LUCAS Freitas: So დირექტორიები არის ფოლდერები.
მეორე პირობა არის ფაილი.
>> აუდიტორია: რა არის ბრძანება აღადგინოთ იგი ან გარკვევა ეს?
LUCAS Freitas: გარკვევა?
LAUREN Carvalho: გარკვევა?
LUCAS Freitas: ვფიქრობ ეს "ნათელი". ჰო.
ასე, რომ თქვენ უნდა აკრიფოთ ნათელია, თუ თქვენს ეკრანზე ძალიან ბინძურ.
ნებისმიერი სხვა კითხვები?
და თქვენ შეისწავლით bunch სხვა ბრძანებები უბრალოდ ბუნებრივად დროს
სემესტრის იმიტომ, რომ ისინი ძალიან სასარგებლო.
>> ახლა მოდით ვისაუბროთ შედგენა.
ჩვენ ვისაუბრეთ pseudocode და კოდის და ობიექტის კოდი.
და არსებობს უამრავი კოდები, და, შესაძლოა, თქვენ ბიჭები არიან დაბნეული შესახებ.
მოდით ვისაუბროთ ცოტა შესახებ, თუ რა ხდება, როდესაც თქვენ პროგრამის წერა,
და თქვენ კომპილირება, და ეს ხდება შესრულებად ფაილს.
ეს არის ყველა სიტყვა, რომ თქვენ ბიჭები ალბათ მსმენია, და იქნებ თქვენ არ
მართლაც, რა ხდება.
>> ვთქვათ, მაგალითად, რომ მინდა დაწერეთ პროგრამა, რომელიც ამბობს, რომ "Hello".
პირველი, რაც შეეხება თქვენი აზრით თქვენ სახის ცდილობენ ვფიქრობ, თუ როგორ თქვენ
აპირებს, რომ თქვენი გონება და თქვენ ალბათ ფიქრობს, ინგლისურ ან
ზოგიერთი სხვა ენაზე, როგორც ბუნებრივი ენა, ალბათ.
და მაშინ ვფიქრობ, ასევე, თუ მინდა, მაგალითად, დაწერა პროგრამა, რომელიც
ამბობს "hello," მინდა დაიწყოს პროგრამა, მე ბეჭდვა hello, და მერე
დატოვა პროგრამა.
ეს არის pseudocode.
ეს მხოლოდ ძირითადად თქვენ ცდილობს ამუშავება მოვლენათა
რომ თქვენ ვაპირებთ იყოს შეუძლია დაწეროს პროგრამა.
>> მაშინ თქვენ გაქვთ კოდის და კოდის არ უნდა
კონკრეტულად იყოს C. ჩვენ ვსაუბრობთ შესახებ კოდის in C იმიტომ, რომ
ენა ჩვენ სწავლის, მაგრამ, რა თქმა უნდა კოდი შეიძლება იყოს საკმაოდ ბევრი ნებისმიერი
პროგრამირების ენა, რომელიც თქვენ გაქვთ.
შემდეგ სემესტრში, თქვენ აპირებს ვისწავლოთ სხვა ენებზე.
რომ ასევე კოდის.
>> მაგალითად, აქ, ეს არის ჩემი წყარო კოდი და მაშინ მე მათ შორის,
ბიბლიოთეკა და შემდეგ დავიწყო მთავარი, და მერე ბეჭდვა.
და ლორა აპირებს გაიგო ცოტა ცოტა ყველა ამ.
ასე რომ, ეს არის source code.
>> და რა არის ობიექტის კოდი?
ობიექტი არის bunch of zeros და პირობა, ძირითადად.
რა ხდება თქვენ თავდაპირველად უნდა pseudocode, რომელიც ყველა ინგლისურ ენაზე.
მე ვგულისხმობ, თქვენ გესმით ეს.
ალბათ თქვენი მეგობარი მესმის , და ყველაზე ხალხი
მესმის იდეა.
მაგრამ კომპიუტერი მართლაც dumb, და ისინი არ მესმის, English, ასე რომ თქვენ
არ თარგმნოს რომ შევიდა რაღაც, ჩვეულებრივ თარგმნილი ზოგიერთი
პროგრამირების ენა.
>> და შეგიძლიათ წარმოიდგინოთ, პროგრამირების ენის, როგორც სახის, როგორიცაა ენა
რომ გითხრათ, თქვენს კომპიუტერში, თუ როგორ საუბარი და გაგება.
თქვენ ძირითადად წერილობით რაღაც ენა, რომ თქვენ და თქვენი
კომპიუტერული მესმის.
სწორედ source code.
ასე აპირებს ფორმა pseudocode წყარო კოდი, ეს თქვენზეა.
ეს ძირითადად აკეთებთ თქვენი პროგრამა.
>> მაგრამ პრობლემა ის არის, რომ კომპიუტერი არც კი
მესმის პროგრამირების ენაზე.
მას არ ესმის, კოდის ყველა.
ეს რეალურად მხოლოდ ესმის zeros და პირობა.
ასე რომ, ჩვენ ამ ჯადოსნური რამ მოუწოდა შემდგენელი, რომელიც ძირითადად არის
აპირებს მისაღებად წყარო მოუწოდა, რომ თქვენ წერდა ენაზე, როგორც თქვენ
და თქვენი კომპიუტერის საუბარი, და ახლა თქვენ აპირებს გარდაქმნას, რომ
zeros და პირობა.
ასე რომ, ძირითადად, რა შემდგენელი არ არის იგი იღებს კოდის, ამ შემთხვევაში C,
იგი აპირებს გარდაქმნას იგი zeroes და პირობა, რომ კომპიუტერი
ესმის და შეუძლია შესრულებადი ფაილი გარეთ.
>> ამჯამად რომ აზრი?
შეგიძლიათ უბრალოდ ვფიქრობ შემდგენელი, როგორც გარკვეული სახის თარჯიმანი, რომელიც არის
ეხმარება თქვენ ავუხსნათ კომპიუტერი ზუსტად რა უნდა გააკეთოს.
>> მაგრამ როგორ უნდა შეადგინოს.
მოდით დავუბრუნდეთ ელექტრო და ვთქვათ, რომ მე ვაკეთებ, რომ პროგრამა.
პირველი მე ვაპირებ, რომ შევქმნათ დირექტორია აქ, და მე ვაპირებ მოვუწოდო მას
"პრაქტიკა". ახლა მე ვაპირებ ნავიგაცია დირექტორია, ამიტომ cd პრაქტიკაში.
ახლა მე შიგნით პრაქტიკაში.
>> ახლა მინდა, რომ დაიწყოს gedit, ასე როგორ შემიძლია ამის გაკეთება?
შემიძლია ან დააწკაპუნეთ აქ, ან მე შემიძლია მხოლოდ ფაქტიურად ტიპის "gedit," და ის აპირებს
გახსნა ჩემთვის.
>> ახლა მე ვაპირებ აკრიფოთ ჩემი პროგრამა, ასე რომ, ზუსტად რა დავწერე slide.
მე გამოცხადების ბიბლიოთეკა.
მე ვაკეთებ int, მთავარ ბათილად.
და ახლა მე ვაკეთებ printf, hello.
ახლა მე ვაპირებ გადარჩენა ეს.
ნება მიბოძეთ პრაქტიკაში და მე ვაპირებ მოვუწოდო ამ hello.c.
ახლა ის გადაარჩინა.
>> თუ მინდა კომპილირება, მე რეალურად შეგვიძლია ამის გაკეთება ორ სხვადასხვა ადგილას.
მე შეგიძლიათ ამის გაკეთება ტერმინალის ფანჯარა, ასე რომ, ეს დიდი ერთი, ან შეგიძლიათ
გამოყენება gedit, რომ რეალურად აქვს ტერმინალის ფანჯარაში უფლება აქ.
ასე რომ თქვენ შეგიძლიათ ძალიან მოხერხებულად უბრალოდ თქვენი კოდი და შემდეგ შეგიძლიათ უბრალოდ აკრიფოთ
რასაც აქ, და ცდილობენ კომპილირება.
>> ასე რომ, როგორ შემიძლია კომპილაციის კოდი?
ყველაზე იოლი გზა, რომ ჩვენ გვაქვს გამოყენებით მიიღოს, რომელიც არის ფუნქცია, რომელიც
ძირითადად აპირებს კომპილაციის თქვენი კოდი.
თქვენ უბრალოდ უნდა ვთქვა, მიიღოს hello, ისე "მიიღოს" და პროგრამის სახელი.
>> Oops.
ეს არის უხერხულია.
>> LAUREN Carvalho შეგიძლიათ [INAUDIBLE]?
>> LUCAS Freitas: უკაცრავად.
მე არ გადარჩენა მას მარჯვენა დირექტორია.
მოდით პრაქტიკაში, და ახლა შეინახეთ hello.c.
მე ბოდიში.
ახლა ის გადაარჩინა.
>> ნება მომეცით უბრალოდ ls და დარწმუნებული ვარ, რომ ის აქ.
OK, ახლა აქ.
ახლა თუ გააკეთოს hello, ეს spits ბევრი პერსონალი, მაგრამ ეს მხოლოდ აძლევს
მე ერთი ხაზი ტერმინალში, რომელიც იმას ნიშნავს, რომ წარმატებული იყო.
ახლა, თუ ls ერთხელ, მე რეალურად ვხედავ ამ ფაილის მწვანე, რომელიც
შესრულებად ფაილს.
>> და მაშინ თუ მინდა აწარმოებს, ყველა რომ მე უნდა გააკეთოთ dot slash hello.
ის აპირებს მიესალმები უფლება აქ, ასე რომ, ეს არის ზუსტად ის, რაც მე გეკითხებით მას.
>> არის კიდევ ერთი გზა შედგენა, რომელიც გამოყენებით Clang.
Clang მხოლოდ შემდგენელი რომ ჩვენ, და ეს ცოტა მეტი verbose to
კომპილირება.
მაგრამ მუშაობს ისევე, როგორც კარგად.
ასე რომ, თუ clang, და შემდეგ-o და შემდეგ სახელი, რომ მინდა, რომ
შესრულებადი ფაილი, ასე ვთქვათ, "Hello". და შემდეგ ფაილი, რომელიც მე მინდა
კომპილაციის, hello.c.
ის ასევე აპირებს შეადგინოს.
და თქვენ გაქვთ ფაილი აქ, და მე შემიძლია მხოლოდ შეასრულოს ის, ასევე.
ასე რომ, ორივე მათგანი იმუშავებს.
>> ამჯამად რომ აზრი?
რაიმე შეკითხვა?
>> აუდიტორია: შეგიძლიათ გაადიდოთ ცოტა?
>> LUCAS Freitas: უკაცრავად?
>> აუდიტორია: Zoom in?
>> LAUREN Carvalho: მე ვფიქრობ, თქვენ შეგიძლიათ უბრალოდ ბრძანება plus.
>> LUCAS Freitas: უბრძანე რა?
>> LAUREN Carvalho: Command plus.
>> LUCAS Freitas: არა
>> LAUREN Carvalho: Oh, რომ არ არის იმუშავებს, რადგან -
ეს იმიტომ, რომ ჩვენ დავსახეთ გარჩევადობა ამ რამ.
>> LUCAS Freitas: მე არ ვფიქრობ, ჩვენ შეგვიძლია zoom სისტემაში
ჰო, ჩვენ ვერ გაადიდოთ.
გაქვთ სხვა კითხვები?
უკაცრავად.
>> აუდიტორია: შეგიძლიათ ვიმეორებ clang?
>> LUCAS Freitas: clang?
Clang არის იგივე როგორც მიიღოს, მაგრამ განსხვავება ის არის, რომ პირველი მე ვაპირებ
დაწერა clang, რომელიც არის ბრძანება, მაშინ მე ვაპირებ ამის გაკეთებას -0, ყველა, რომელიც
მხოლოდ ის, რაც ჩვენ ვაპირებთ ვისწავლოთ შემდეგ დროშა.
ასე რომ, უბრალოდ ვფიქრობ, რომ თქვენ ყოველთვის უნდა დააყენოს-o.
>> და მაშინ პირველი, თქვენ უნდა დააყენოს სახელი შესრულებადი ფაილი,
ძირითადად ფაილი, რომელიც თქვენ შექმნას აპირებს.
ასე რომ, შემიძლია ვთქვა, მაგალითად, hello2 და შემდეგ ფაილი, რომელიც მინდა კომპილაციის,
რომელიც არის. c ფაილი.
ასე რომ hello.c.
ამჯამად რომ აზრი?
>> აუდიტორია: Hello რა?
რა არის ეს?
>> LUCAS Freitas: hello.c.
და თუ მე კომპილაციის, და თუ მე ls, მე ასევე აქვს
hello2 რომ მე უბრალოდ შედგენილი.
და თუ მე ვცდილობ, რომ აწარმოებს, ის აპირებს გააკეთოს ზუსტად იგივე როგორც hello,
უბრალოდ ბეჭდვა hello.
>> აუდიტორია: როგორ მოვიდა მარკა თქვენ შეგიძლიათ განათავსოთ hello.c შემდეგ?
>> LUCAS Freitas: In გააკეთოს, თქვენ არ უნდა დააყენოს. გ.
In გააკეთოს, უბრალოდ ამბობენ, რომ პროგრამის დასახელება.
თქვენ არ უნდა ვთქვა. გ.
მაგრამ clang, თქვენ უნდა.
>> აუდიტორია: With clang ასევე თქვენც უნდა დაემატოს [INAUDIBLE]
>> LAUREN Carvalho: ჰო.
ასე, რომ თქვენ ასევე უნდა ბიბლიოთეკაში.
>> LUCAS Freitas: Yeah, რომ რაღაც ჩვენ ვაპირებთ გამოვიყენოთ შემდეგ.
რომ ე.წ. აკავშირებს, და მე ვფიქრობ, რომ ჩვენ ვაპირებთ ვისაუბროთ მოგვიანებით.
კიდევ ერთი შეკითხვა?
>> აუდიტორია: თქვენ დააყენა dot slash clang?
>> LUCAS Freitas: არა
Dot slash მხოლოდ გახსნა შესრულებად ფაილს.
ასე რომ, clang, უბრალოდ წერა "clang" და მაშინ თუ გსურთ გახსნა
შესრულებადი ფაილი, რომ თქვენ მხოლოდ შედგენილი, მაშინ თქვენ dot
სლეში და სახელი.
ამჯამად რომ აზრი?
>> აუდიტორია: თუ იყო მხოლოდ ცვლილება [INAUDIBLE] to Hello World, თქვენ
უნდა recompile იგი?
>> LUCAS Freitas: ჰო.
თუ მე მინდა ვთქვა, რომ, მაგალითად, "Hello იქ, "მე შემიძლია უბრალოდ გადარჩენა მას ახლა, და მე
უბრალოდ კომპილაციის კიდევ ერთხელ.
ნება მომეცით, გავაკეთოთ მიიღოს hello.
და, თუ hello, ის აპირებს ამბობენ, "გამარჯობა". აზრი?
ნებისმიერი სხვა კითხვები?
>> აუდიტორია: თქვენ უნდა შეიცავდეს სტანდარტული I / O კოორდინაციას მუშაობა?
>> LUCAS Freitas: ჰო.
სტანდარტული I / O, ძირითადად, ბიბლიოთეკა, რომელსაც აქვს
განხორციელების printf.
ასე რომ, რაც უფლებას top შედის stdio.
რომ მათ შორის ბიბლიოთეკა, ძირითადად აქვს bunch სხვადასხვა
ინსტრუმენტები, რომ შეგიძლიათ გამოიყენოთ.
ერთი?
მათ შორის printf რომ არის ფუნქცია რომ ძირითადად ბეჭდავს
შეტყობინებები ეკრანზე.
>> ნებისმიერი სხვა კითხვები?
არა?
OK.
ახლა მოდით ვისაუბროთ -
>> LAUREN Carvalho: მოდით უბრალოდ წასვლა სტილის სახელმძღვანელო.
გნებავთ უბრალოდ ვიპოვოთ იგი აქ?
>> LUCAS Freitas: ამიტომ, ჩვენ ვაპირებთ ვისაუბროთ სტილი.
>> LAUREN Carvalho: Oh, დავით არ დასრულდება.
OK.
რატომ არ გვაქვს დაბრუნდება სტილი ბოლომდე?
ეს რეალურად განახლება როგორც ჩვენ ვსაუბრობთ.
>> LUCAS Freitas: ჰო.
მოდით გზა დავით დასრულება რომ.
>> LAUREN Carvalho: Can ჩვენ გადავიდეს რეალურად?
>> ასე რომ, იმედი მაქვს, ყველას უკვე მოსარგებლე Scratch.
სამწუხაროდ, დროა გადაადგილება დაშორებით ამ -
სამწუხაროდ დროა გადავიდეს დაშორებით ამ საკმაოდ პროგრამირების ბლოკები
რომ C. მაგრამ საბედნიეროდ, ყველა პროგრამირების აშენებს, რომ თქვენ
უკვე მუშაობს in Scratch არის პირდაპირ translatable to C, და ჩვენ
აპირებს დაიწყოს შემესწავლა ზოგიერთი მათგანი ახლა.
მოდით პირველი საუბარი პირობები ამ ლოგიკური გამონათქვამები.
>> ეს არის გაშვებული სარეზერვო ბატარეის ძალა.
>> LUCAS Freitas: როგორ არის რომ არ მუშაობს?
OK.
იქ, მე ვაპირებ მისაღებად -
>> LAUREN Carvalho: So პირობები მნიშვნელოვანია, რადგან ისინი საშუალებას მოგვცემს
გააცნობს ლოგიკა ჩვენს პროგრამებს.
აი მაგალითად მდგომარეობის ფარგლებში C პროგრამა.
მოდით აღვნიშნო, თუ როგორ ეს -
ასე რომ, ეს მდგომარეობა ბლოკი უფლება აქ, ამ printf განცხადება არ შეასრულოს
თუ მდგომარეობა ფარგლებში ფრჩხილებში, n მეტია 0,
აფასებს ჭეშმარიტი.
>> ახლა, ყველა პირობების ფარგლებში f განცხადებები ლოგიკური გამონათქვამები,
რაც იმას ნიშნავს, რომ არ არსებობს მხოლოდ ორი ვარიანტი.
მათ შეეძლოთ ან შეაფასოს ჭეშმარიტი, ან მათ შეუძლიათ შეაფასონ ცრუ.
ასე რომ, აქ, ასე რომ ეს აზრი, არა? n უფრო მეტი, ვიდრე 0, ნიშნავს, რომ იგი არის დადებითი
ნომერი, რაც იმას ნიშნავს, რომ ეს იქნება ბეჭდვა out "თქვენ აიყვანეს დადებითი რიცხვი."
>> არსებობს უამრავი ლოგიკური გამონათქვამები რომ შეიძლება შექმნან მდგომარეობაში
init განცხადებაში.
ჩვენ გვაქვს ნაკლები.
ეს არის ნაკლები ან ტოლია.
ეს არის სასაცილო [INAUDIBLE].
თუ გსურთ printf მოხდეს, თუ ეს მეტია ან ტოლია 0, მაშინ
თქვენ უნდა აირჩიოთ ეს.
ასე რომ თანაბარი მხოლოდ appends უფლება მას შემდეგ, რაც მეტია ნიშანი.
>> თანაბარი თანაბარი, რომელიც განსხვავდება მხოლოდ ერთი ტოლობის ნიშანი, თანაბარი თანაბარი
ფაქტიურად ნიშნავს, რომ რასაც ის შესახებ მარცხენა მხარეს, ეს არის იგივე როგორც
რა არის მარჯვენა მხარეს ამ სადაც ერთ თანაბარი ნიშანი არის რა?
რა არის მხოლოდ ერთი ტოლობის ნიშანი?
დავალება.
>> LUCAS Freitas: ვინ თქვა, რომ?
ის არის, რომ candy?
ოჰ, არა.
უკაცრავად.
თქვენ, როგორც მიიღოთ კამფეტი.
ოჰ, OK!
სამი ადამიანი მიიღოთ კამფეტი!
>> LAUREN Carvalho: ასე რომ, ეს ერთი აქ არის bang ოპერატორის წინა
თანაბარი ნიშანი, ასე რომ არ უდრის.
ასე რომ, თუ ეს იყო ჩემს მდგომარეობაში, სხეულის მდგომარეობა იქნებოდა
შეასრულოს მხოლოდ იმ შემთხვევაში, რასაც ის მარცხენა არ არის იგივე, რაც
რა არის უფლება.
>> შემიძლია ასევე აქვს მხოლოდ ძახილის წერტილი.
რეალურად ვნახავთ ფუნქცია ლღობას როგორ ეს იქნება გამოყენებული.
>> LUCAS Freitas: ნებისმიერი კითხვები?
არა?
>> LAUREN Carvalho: ჩვენ შეგვიძლია დააკავშიროთ ამ ლოგიკური გამონათქვამები მშენებლობა მეტი
რთული პირობითი განცხადებები.
ასე რომ აქ, თუ რასაც მიერ მარცხენა მხარეს ორმაგი ბარები ან
რაც მარჯვენა მხარეს ორმაგი ბარები აფასებს ჭეშმარიტი,
მაშინ ჩვენ ამობეჭდოთ არასწორია.
და შემდეგ ქვევით აქ, თუ რასაც მიერ მარცხენა მხარეს ორ
ampersands და რასაც მიერ მარჯვენა მხარეს ორი ampersands
აფასებს მართალია, მაშინ ჩვენ ამობეჭდოთ მოქმედებს.
ორმაგი ბარები უწოდებენ ლოგიკური ან ოპერატორის ორმაგი ampersands არის
მოუწოდა ლოგიკური და ოპერატორს.
დიახ?
>> აუდიტორია: არის იმ უბრალოდ ქვედა l's?
>> LAUREN Carvalho: არა
ისინი რეალურად -
იცით საწინააღმდეგოდ, როგორიცაა ზემოთ თქვენი Return გასაღები?
ხედავთ, რომ?
>> LUCAS Freitas: ეს რეალურად ბარი.
>> LAUREN Carvalho: ეს არის, ფაქტობრივად, მხოლოდ ორი ბარები.
>> აუდიტორია: შეგიძლიათ გამოიყენოთ თანაბარი თანაბარი strings?
>> LUCAS Freitas: არა
ჩვენ ვაპირებთ ვისწავლოთ შემდეგ რაღაც შესახებ, რომ.
>> LAUREN Carvalho: არსებობს ფუნქცია რომ თქვენ შეგიძლიათ გამოიყენოთ.
მაგრამ თქვენ არ უნდა შიშობენ, რომ უბრალოდ არავის გაუკეთებია.
>> რა მოხდება, თუ მე ვაძლევ ამ პროგრამის ნომერი 5?
რა იქნება ამობეჭდოთ?
>> აუდიტორია: [INAUDIBLE]
ძალაშია.
>> LAUREN Carvalho: ძალაშია?
ჰო.
მე არ ვიცი, რომელმაც, რომ.
>> [სიცილის]
>> LAUREN Carvalho: ეს ერთგვარი საშინელი [INAUDIBLE].
>> აუდიტორია: ასე ორმაგი და, რომ მხოლოდ იმას ნიშნავს და?
>> LAUREN Carvalho: ჰო.
ასე რომ 5 არის როგორც დიდი ვიდრე 0 ნაკლები 100.
>> აუდიტორია: რატომ უნდა იყოს ერთი?
>> LAUREN Carvalho: One ampersand არის რეალურად რაღაც განსხვავებული, და ეს
bitwise ოპერატორი, რომელიც თქვენ გაეცნობიან მოგვიანებით.
მაგრამ რაღაც რომ რეალურად მუშაობს ერთად ბიტი მოცემულ ნომერი.
>> LUCAS Freitas: Just ვფიქრობ, რომ ისინი არ უნდა ფიქრი, რომ ახლა.
>> LAUREN Carvalho: ვფიქრობ, ეს, ალბათ, ახლოვდება მომავალ კვირას.
>> LUCAS Freitas: ნებისმიერი სხვა კითხვები?
არა?
>> LAUREN Carvalho: ასე რომ, ჩვენ ვხედავთ, რომ ეს ბლოკირება შეიძლება დადგეს მარტო, მაგრამ მას შეუძლია
ასევე დაწყვილებული და სხვა ბლოკი.
ასე რომ, ამ შემთხვევაში, თუ n მეტია 0, ჩვენ ვაპირებთ ამობეჭდოთ "თქვენ
აიყვანეს დადებითი რიცხვი. "სხვას, რაც იმას ნიშნავს, თუ ის არის 0, თუ ეს ნაკლებად
ვიდრე 0, ჩვენ ვაპირებთ ამობეჭდოთ, "თქვენ აიყვანეს უარყოფითი რიცხვი."
>> საინტერესო ისაა, რომ ამ ექსკლუზიური ერთმანეთს.
იქ არასდროს იქნება საქმე რომელშიც ეს და ეს
შეგიძლიათ ორივე ამობეჭდოთ.
>> დარწმუნებული ვარ, მუშაობდა თუ / სხვა ყუთი Scratch, ასე რომ ეს უნდა იყოს
საკმაოდ ნაცნობი.
დიახ?
>> აუდიტორია: გვჭირდება შორის სივრცე int n შეადგენს GetInt მაშინ სივრცე
თუ განაცხადი?
Like ჩვენ ვიყენებთ ხაზი [INAUDIBLE]
>> LAUREN Carvalho: Oh, სივრცე აქ?
>> აუდიტორია: Like, მაგრამ თქვენ გაორმაგება სივრცეში.
არა, ახვიდეთ.
ახვიდეთ.
>> LUCAS Freitas: Just ხაზი?
>> აუდიტორია: Yeah.
>> LUCAS Freitas: Just ცარიელი ხაზი?
>> აუდიტორია: Yeah.
>> LAUREN Carvalho: Blank ხაზი?
პოსტები
ეს მხოლოდ სტილისტური რამ.
>> LUCAS Freitas: ეს არის, ისევე, როგორც ზოგჯერ თქვენ უბრალოდ გამოტოვოთ ზოგიერთი ხაზები ასე
რომ კოდი არ ჰგავს დიდი ტექსტს.
>> LAUREN Carvalho: ვფიქრობ, თუ რა მოხდა იყო ის, რომ ჩვენ გვქონდა კომენტარი აქ, მაგრამ მე
მას, ასე რომ თქვენ ბიჭები ექნება ვიფიქროთ კოდი საკმაოდ
ვიდრე უბრალოდ წაიკითხა ჩემი კომენტარი.
ზოგადად, ინტერვალი ნამდვილად არ იმოქმედებს თქვენი პროგრამა ეშვება.
ეს უფრო სტილისტური რამ.
და როდესაც ჩვენ გვაქვს სტილის სახელმძღვანელო განახლება და მზად ვართ წავიდეთ ბოლოსთვის
supersection, ჩვენ ვსაუბრობთ ამის შესახებ მეტი.
>> არსებობს რაღაც ამ პროგრამის, უფლება?
იმის გამო, რომ 0 არ არის უარყოფითი რიცხვი.
მოდით ვნახოთ, თუ შევძლებთ დაფიქსირება, რომ.
>> თქვენ ალბათ წარმოიდგინეთ ეს ამბობს, არა?
თუ n მეტია 0, ჩვენ ბეჭდვა "თქვენ აიყვანეს დადებითი რიცხვი. "მაშინ სხვა
თუ n ნაკლებია, ვიდრე 0, "თქვენ აიყვანეს უარყოფითი რიცხვი. "სხვაგან" თქვენ აიყვანეს
0. "
>> ახლა საინტერესო ის არის, რომ ეს ვერ გაგრძელდება სამუდამოდ.
თქვენ შეგიძლიათ, თუ ბლოკი, სხვას თუ ბლოკი, კიდევ სხვაგან, თუ ბლოკი სხვაგან, თუ
სხვაგან, თუ სხვაგან, თუ სხვაგან, ძირითადად, როგორც თქვენ გსურთ.
და როცა აშენდა მოსწონს, ეს არის ყველა იქნება
ექსკლუზიური ერთმანეთს.
დიახ?
>> აუდიტორია: ასე რომ, რატომ არ შეიძლება უბრალოდ გამოიყენოთ სხვა თუ ნაცვლად [INAUDIBLE]?
>> LAUREN Carvalho: ამ შემთხვევაში, დიახ მე შეიძლება გამოიყენოს სხვა, თუ, და ეს იქნება
აბსოლუტურად ჯარიმა, რადგან პირობები თავად
ექსკლუზიური ერთმანეთს.
მაგრამ თუ პირობები არ იყო განსაკუთრებული ერთმანეთს, ამ
აიძულებენ, რომ არასოდეს ორივე შევაფასოთ, თუ ეს აზრი.
>> აუდიტორია: ამ შემთხვევაში, შეიძლება, ჩვენ ბუდე მეორე თუ პირველი თუ?
>> LAUREN Carvalho: თუ - რას ნიშნავს?
>> აუდიტორია: თუ ორი პირობა არ არის ურთიერთგამომრიცხავი?
>> LAUREN Carvalho: თუ პირობები არ არის ურთიერთგამომრიცხავი?
მაგრამ გსურთ მხოლოდ ერთი მათგანი, რომ აწარმოებს?
>> აუდიტორია: თქვენ მინდა უბრალოდ თუ ნაცვლად სხვაგან.
>> LAUREN Carvalho: ჰო.
იქ ყოველთვის იქნება უამრავი გზები, რომ თქვენ შეგიძლიათ ამის გაკეთება.
თქვენ აუცილებლად ბუდე მათ.
და თქვენ ნახავთ მომავალი slide, რომ შეგიძლიათ რამდენიმე IFS, მხოლოდ ერთი
მიყოლებით.
მაგრამ ეს არის გზა ლოგიკურად ორგანიზება ნაკადის თქვენი პროგრამა.
>> LUCAS Freitas: არსებობს კიდევ ერთი რამ, ის არის, რომ თქვენ სთხოვა აყენებს
თუ და მერე მეორე თუ.
რომ იმუშავებს კარგად, მაგრამ ეს ცუდი დიზაინი, რადგან, ძირითადად, იმ შემთხვევაში, თუ
შეამოწმეთ პირველი, თუ თქვენ შეამჩნევთ, რომ რაოდენობის მეტია 0, თქვენ
შეგიძლიათ უბრალოდ დასრულდება პროგრამა.
თქვენ არ უნდა შეამოწმოთ, თუ ეს ნაკლებია, ვიდრე 0, არა?
>> მაგრამ თუ, თუ, თუ ის აპირებს შეამოწმოს როგორც, ხოლო თუ მე, თუ სხვაგან არის,
ის აპირებს შეამოწმოს, თუ ეს არის უფრო მეტი, ვიდრე 0.
თუ ეს არის, ის კი არ ვაპირებთ შევხედოთ მეორე ხაზი კოდი.
ასე რომ თქვენ ძირითადად შემოწმების მას მოსწონს ორჯერ ზედმეტად, ასე რომ რატომ ჩვენ
გავაკეთოთ, თუ სხვაგან თუ.
ნებისმიერი სხვა კითხვები?
>> აუდიტორია: ასე ფუნქციონალური საქართველოს სხვაგან თუ არის იგივე როგორც
თუ ეს იყო უბრალოდ, თუ?
>> LAUREN Carvalho: არა
თქვენ რეალურად აპირებს ვხედავ ჩემს მომავალ ლღობას მაგალითი, რომელიც მას შეუძლია
იყოს განსხვავებული.
ამ შემთხვევაში, ეს არის თითქმის იგივე.
>> ასე რომ აქ, ჩვენ გვაქვს მაგალითი მრავალჯერადი თუ განცხადებებს და
ფუნქციონალური არ არის იგივე თითქოს ვიყავი, რომ თუ
სხვაგან, თუ სხვაგან, თუ სხვაგან.
მოდით უბრალოდ ვიფიქროთ, რა იქნებოდა ბეჭდვა თუ მე შევა რაოდენობა 95
ამ პროგრამაში.
>> აუდიტორია: [INAUDIBLE]
>> LAUREN Carvalho: და მერე?
>> აუდიტორია: [INAUDIBLE]
>> LAUREN Carvalho: ჰო.
ასე რომ, ამ შემთხვევაში, ეს პირობები არ არის ურთიერთგამომრიცხავი ერთმანეთს.
და რადგან არაფერი შეჩერების ამ მდგომარეობის შეფასებისას, თუ ამ
ერთი უკვე აქვს, ისინი უბრალოდ ყველა აპირებს ამობეჭდოთ.
ასე რომ, როგორ შეიძლება მე დაფიქსირება ამ?
>> აუდიტორია: სხვაგან IFS?
>> LAUREN Carvalho: თქვენ შეგიძლიათ გამოიყენოთ სხვაგან IFS.
მე ვერ შეცვლის მიზნით ეს, არა?
იმ შემთხვევაში, თუ მე ამ ერთი პირველი?
ისე, რეალურად, არ.
რომ არ იმუშაოს 95.
>> LUCAS Freitas: არა, უბრალოდ სხვაგან IFS.
>> LAUREN Carvalho: სხვაგან IFS არ დაფიქსირდა ამ.
ამჯამად რომ სასწარფოდ დაბნეულობა შორის IFS და სხვაგან IFS?
>> აუდიტორია: მე უბრალოდ მინდოდა გთხოვოთ, თუ თქვენ არ გამოიყენოს სხვაგან, თუ ეს იქნებოდა შეჩერება?
>> LAUREN Carvalho: Right.
ასე რომ, მხოლოდ ეს პირველი.
თუ შევედი ნომერი 95, მხოლოდ ამ არ იბეჭდება, და მას არასოდეს
არ ვითარდებოდა სხვა.
>> LUCAS Freitas: Just სახის ვფიქრობ მას, როგორც თუ ეს მოხდება, ამის გაკეთება.
სხვაგან ჰგავს თუ არა, შემოწმება ამ, და შემდეგ გავაკეთოთ, რომ.
ასე რომ ისინი ყველა ორმხრივად ექსკლუზიური.
თქვენ არ შეგიძლიათ მიიღოთ ორ იმ.
>> აუდიტორია: შეგიძლიათ გამოიყენოთ ლოგიკური და რომ სიტუაცია?
>> LAUREN Carvalho: ჰო.
ეს არის კიდევ ერთი გზა, რომ ჩვენ შეგვიძლია დაფიქსირდა ეს პრობლემა.
ჩვენ შეიძლება არ განისაზღვრება მერყეობს, არა?
ასე რომ, მე ვერ განაცხადა, რომ თუ n მეტია 90 და ნაკლები -
ასევე, ვფიქრობ, ამ ერთი ნამდვილად არ სულ ერთია, მაგრამ აქ მე ვერ განაცხადა, რომ თუ
n მეტია 80 და ნაკლები 90.
უფრო მეტი, ვიდრე 70, ნაკლები 80.
რომ არ მუშაობდა.
>> [სიცილის]
>> LUCAS Freitas: ის ეშინია.
>> LAUREN Carvalho არ შეგეშინდეთ.
>> LUCAS Freitas: ეს არ არის რომ ეს იქნება არასწორი.
უბრალოდ, რომ ეს ზედმეტად verbose.
Like კომპიუტერულ მეცნიერებაში, უნდა იყოს როგორც მარტივი, როგორც ეს შესაძლებელია, რადგან
თქვენ გაქვთ ფუნქცია.
გსურთ კამფეტი?
>> აუდიტორია: არ სჭირდება.
>> LAUREN Carvalho: თქვენ დაშინება ყველას, Lucas.
>> LUCAS Freitas: უკაცრავად.
>> LAUREN Carvalho: David ასევე აღნიშნა, ამ გადახვიდეთ განაცხადი კლასში.
ძირითადად, რა ხდება არის switch განაცხადი იღებს ცვლადი.
ამ შემთხვევაში, ჩვენ აღების რიცხვი.
>> თუ რიცხვი არის 1, ჩვენ ვაპირებთ ამობეჭდოთ "თქვენ აიყვანეს მცირე
ნომერი. "თუ რიცხვი არის 1," თქვენ აიყვანეს საშუალო ნომერი. "თუ
რიცხვი 3, "თქვენ აიყვანეს მაღალი ნომერი. "და მეც რა შემთხვევაში
ქვემოთ აქ, მაგრამ ეს არ აჩვენებს up, რაც ძალიან ცუდია.
>> ძირითადად, ეს მხოლოდ კიდევ ერთი სინტაქსი.
ჩვენ ვერ განვახორციელეთ ამ ზუსტი იგივე, თუ სხვაგან, თუ
განცხადებები.
მაგრამ, როცა არსებობს უამრავი სხვა პირობები და უამრავი სხვადასხვა
ვარიაციები რა გსურთ გააკეთოთ თითოეული შეყვანის, ეს არის ვარიანტი.
ასე რომ, ეს უბრალოდ კარგი სინტაქსი ვიცი.
დიახ?
>> აუდიტორია: რატომ არის იქ არ backslash n წელს პირველი?
>> LAUREN Carvalho: For არის?
არ არსებობს backslash n up there იმის გამო, რომ GetInt -
თუ თქვენ ცდილობენ, ეს გამოგიგზავნით გადმოგცეთ ეს ზოლზე.
მომეცი რიცხვი შორის 1 და 3.
და თუ მე ზუსტად საწინააღმდეგოდ n, ეს იქნებოდა მიიღოს ჩემთვის მომდევნო ხაზი, მაგრამ მე უბრალოდ
უნდოდა მათ აკრიფოთ რიცხვი მას შემდეგ, რაც მსხვილი ნაწლავის.
თქვენ შეეძლო საწინააღმდეგოდ n.
ეს არ არის დიდი გარიგება.
ჰო?
>> აუდიტორია: ამ კოდი, ეს შემთხვევაში ერთი, ის არის, რომ
ეს არის პირველი შემთხვევა?
გამო -
>> LAUREN Carvalho: არა, არა, არა.
ასე რომ, ეს მომეცი რიცხვი შორის 1 და 3.
თუ n 1, მე ბეჭდვა ეს.
თუ მე სთხოვა წერილებს, მე შეიძლება განაცხადა მომეცი წერილი შორის
და C. შემდეგ ეს იქნება საქმე A.
>> აუდიტორია: [INAUDIBLE].
იმ შემთხვევაში, უბრალოდ [INAUDIBLE]
>> LAUREN Carvalho: Yeah, უფლება.
ჰო?
>> აუდიტორია: რა მოხდება, თუ მინდოდა უფრო relational გამოხატვის?
ასე რომ ნაცვლად ამბობდა n უდრის 1, [INAUDIBLE]
n მეტია 1 პირველ შემთხვევაში?
>> LAUREN Carvalho: სინამდვილეში, თუ არ განსაზღვრა ზოგიერთი ამ შემთხვევაში, ეს იქნებოდა
უნდა განახორციელოს ქვემოთ.
ასე რომ, რეალურად, შესაძლოა, ეს ასე არ არის თუ რას ეკითხება.
>> LUCAS Freitas: მე ვფიქრობ, რომ ის ეკითხება თუ საქმე n მეტია 0, საქმე
ნაკლებია, ვიდრე 0.
>> LAUREN Carvalho: შესაძლოა შეცვლა განცხადება არ არის ის, რაც გსურთ
გამოყენება ამ შემთხვევაში.
>> LUCAS Freitas: შეცვლა განცხადება მხოლოდ ღირებულება, ასე რომ თქვენ შემოწმება
ღირებულება იგივეა, ამა თუ იმ.
ასე რომ თქვენ შეგიძლიათ რეალურად არ მა პირობები.
>> აუდიტორია: რა მოხდება, თუ პირი ტიპი დავუკავშირდეთ [INAUDIBLE]?
>> LAUREN Carvalho: ეს იქნებოდა ჩემი ნაგულისხმებ შემთხვევაში, რომელიც, სამწუხაროდ,
თქვენ ვერ ვხედავ.
>> LUCAS Freitas: [INAUDIBLE] მათ ვხედავ.
>> LAUREN Carvalho: სინამდვილეში, იცით რა?
მოდით უბრალოდ შესწავლა 50, და მე უბრალოდ მიუახლოვდით სლაიდები სასწავლო
50, რადგან ეს არის მხოლოდ შემაშფოთებელი.
ნება მომეცით რეალურად წასვლა მდგომარეობაში.
ეს მხოლოდ აპირებს ცოტა ხნით.
>> ყველა უფლება.
ასე რომ, მე ბოდიში.
მინიმუმ ახლა ჩვენ უნდა ნახოს ყველაფერი მის გარეშე შეწყვეტასთან.
ყველა უფლება.
>> ასე რომ, თუ ისინი წელს 10, ჩვენ რა აქ ჩემი ნაგულისხმებ შემთხვევაში, მე და
უბრალოდ ბეჭდვა არასწორია იმიტომ, რომ მე სთხოვა მიუთითოთ მთელი რიცხვი
შორის 1 და 3.
ნებისმიერი სხვა კითხვები?
ჰო?
>> აუდიტორია: ვთქვათ, საქმის ერთ შემთხვევაში სამი, ამბობენ, რომ თქვენ სურდა, რომ იყოს ყველა
იგივე, ასე რომ თქვენ აიყვანეს ნომერი ეს არ არის საშუალო ნომერი.
ამ შემთხვევაში, უნდა იყოს გადაჭარბებული?
გსურთ თუ უბრალოდ შეცვალოს ტექსტის ორივე მათ, ან იქნებოდა ზოგიერთი
redundancy?
არის თუ არა რაიმე გზა დააკავშიროთ [INAUDIBLE]?
>> LAUREN Carvalho: არსებობს გზები, რათა დააკავშიროთ მათ, მაგრამ მე მჯერა, რომ თქვენ შეგიძლიათ
მხოლოდ დააკავშიროთ მიმდებარე მიიჩნიეს.
ასე რომ, თუ მე არ განსაზღვრავს არაფერს საქმის ორი, ამ
ვრცელდება ორივე შემთხვევაში.
ოჰ, თუ მე არ დააყენა არაფერი საქმე ერთი, ამ შემთხვევაში გამოიყენება როგორც
შემთხვევაში ერთი და ორი.
იმ შემთხვევაში, თუ ეს აზრი.
>> აუდიტორია: შეგიძლიათ გავიმეორო, რომ ერთი?
>> LUCAS Freitas: OK.
თუ გააკეთეს, ძირითადად, ისევე, თქვენ უნდა იგივე, მაგრამ თქვენ არ დააყენა
არაფერს, აქ, თქვენ მინდა იყოს ან შემთხვევაში ერთი ან ორი საქმე, ამის გაკეთება.
უფლება?
და ამ შესვენების იმას ნიშნავს, თუ თქვენ მიიღებთ ამ შემთხვევაში, უბრალოდ დატოვონ.
ასე რომ რა სამუხრუჭე ნიშნავს.
ასე რომ, თუ მე მხოლოდ ეს, გადავხედავთ, ეს შემთხვევაში ერთი, და თქვენ უბრალოდ ამის გაკეთება.
თუ ეს იყო შემთხვევაში ორი, იგი ასევე მხოლოდ აქ და ამის გაკეთება.
>> აუდიტორია: მაგრამ შეგიძლიათ ამის გაკეთება?
იმ შემთხვევაში, თუ არსებობს რაღაც საქმე ორი [INAUDIBLE]
>> LAUREN Carvalho: მე არ მჯერა, თქვენ შეგიძლიათ ამის გაკეთება.
არა მგონია, შეგიძლიათ გამოტოვოთ გარშემო.
შეგიძლიათ გააკეთოთ, რომ Rob?
მე ასე არ ვფიქრობ.
>> აუდიტორია: ასე რომ, მხოლოდ ერთი ნომერი შეგვიძლია წავიდეთ შემდეგ შემთხვევაში, უფლება?
იქ არ შეიძლება იყოს საქმე ერთი, მძიმე, ორი?
>> LUCAS Freitas: არა, თქვენ არ შეგიძლიათ.
თქვენ ნამდვილად არ შეუძლია.
>> LAUREN Carvalho: ვგულისხმობ, საქმე ის არის, ეს არის ვარიანტი, და ეს არ შეიძლება
შეესაბამება თქვენს შემთხვევაში ასეა, მაშინ თქვენ გამოიყენებს თუ პირობები.
>> აუდიტორია: ასე რატომ აკეთებთ ამას?
შეცვლა?
>> LAUREN Carvalho: მე გამოიყენოს ეს თუ თქვენ ძალიან განსაზღვრული -
რეალურად, Lucas, რომელიც თქვენ ბლოკავს.
>> LUCAS Freitas: ოჰ, უკაცრავად.
>> LAUREN Carvalho: თუ თქვენ გაქვთ ძალიან განსაზღვრული ქცევის, რომ გსურთ
ყოველი input, ეს შეიძლება იყოს ცოტა უფრო მოკლე, ვიდრე წერა out
თუ განაცხადი თითოეული ერთი.
>> აუდიტორია: რა break ნიშნავს კიდევ ერთხელ?
>> LAUREN Carvalho: break ნიშნავს შეწყდეს.
გახსოვდეთ, თუ არ მქონდა ამ შესვენების აქ, ჩვენ არ უბრალოდ გადმოვარდა
შევიდა მომავალ შემთხვევაში.
>> LUCAS Freitas: Break ნიშნავს მისაღებად გარეთ შეცვლა განცხადებაში.
იმიტომ, რომ თუ ის 1, მინდა ბეჭდვა და დატოვოს.
მე არ მინდა, რომ შეამოწმოთ არაფერი.
>> აუდიტორია: თქვენ არ მინდა ბეჭდვა არაფერი.
>> LUCAS Freitas: ჰო.
იმიტომ, რომ ეს არის ურთიერთგამომრიცხავი.
>> აუდიტორია: და ჯერ ეს მხოლოდ გაგრძელება მომდევნო შემთხვევაში, თუ პირველ შემთხვევაში
ასე არ არის?
ან იგი შეამოწმოთ ყველა შემთხვევაში ამავე დროს?
>> LUCAS Freitas: არა, ეს ამოწმებს თანამიმდევრულად.
თანამიმდევრულად, yeah.
კიდევ ერთი შეკითხვა, მაშინ ჩვენ მივიღეთ გადაადგილება ასე რომ, ჩვენ შეიძლება დაფაროს ყველაფერი.
ჰო?
>> აუდიტორია: ასე რომ, იმ შემთხვევაში, შეგვეძლო გაკეთდეს რაღაც გარდა მხოლოდ ერთი?
შეგიძლიათ მისცეს მას სპექტრი?
>> LUCAS Freitas: არა
>> LAUREN Carvalho: მე არ ვფიქრობ, თქვენ შეგიძლიათ მისცეს მას სპექტრი.
>> LUCAS Freitas თქვენ არ შეგიძლიათ თქვენ ვერ მისცეს მას სპექტრი.
>> აუდიტორია: საქმე ის არის განსაზღვრული [INAUDIBLE].
>> LUCAS Freitas: Switch არის ერთგვარი ღირებულებებს.
აკეთებთ სხვადასხვა რამ დამოკიდებულია on ღირებულება, კონკრეტული მნიშვნელობა.
თქვენ არ შეგიძლიათ სპექტრი, თქვენ არ შეგიძლიათ გავაკეთოთ არაფერი.
ეს არის კიდევ ერთი ინსტრუმენტი ვხედავ.
>> LAUREN Carvalho: ადამიანების უმეტესობა არ გამოიყენოთ გადახვიდეთ განცხადებები ძალიან CS50,
მაგრამ ეს არ არსებობს.
>> ყველა უფლება.
ასე რომ, შემდეგი რამ ჩვენ ვაპირებთ გაიგო დაახლოებით არის ternary ოპერატორს.
ეს არის კიდევ ერთი ტიპის პირობითი.
ძირითადად, რა ხდება აქ არის მე ვარ ითხოვენ მთელი რიცხვი, და თუ N არის
აღემატება 100, მე ვაპირებ ამობეჭდოთ "მაღალი". თუ ეს არ, მე ვაპირებ
ამობეჭდოთ "დაბალი".
>> ასე რომ, რასაც ის აკეთებს, არის მდგომარეობა უფლება აქ ფრჩხილებში, და თქვენ
შეგიძლიათ სახის ვფიქრობ კითხვა როგორც მე კითხვა
ეს მართლაც ასეა თუ არა.
თუ ეს სიმართლეა, მე ვაპირებ ამ პირველი რამ, და თუ ეს ასე არ არის, მე
ვაპირებთ გავაკეთოთ ეს მეორე რამ.
>> შეკითხვები ternary ოპერატორს?
>> LUCAS Freitas: Just მინდა აღვნიშნო დან დავით არის, რომ როდესაც თქვენ გაქვთ
მდგომარეობა -
>> LAUREN Carvalho: ვფიქრობ, დავითის თვალს მეშვეობით ცოცხალი ნაკადი.
>> LUCAS Freitas: ის აკეთებს ცხოვრების ნაკადი ახლა.
ასე რომ, როდესაც თქვენ გაქვთ პირობით, თქვენ უნდა დააყენოს curly აფრთხილებს,
ისევე, როგორც ჩვენ გვაქვს შეცვლა განცხადება აქ.
ჩვენ curly აფრთხილებს აქ.
რაც პირობებში, თქვენ უნდა ასევე დააყენა, რომ.
>> LAUREN Carvalho: თქვენ ნახავთ ამ სტილის სახელმძღვანელო.
ჩვენ რეალურად არ გვაქვს სტილის სახელმძღვანელო ახლა.
მე ვფიქრობ, რომ დავითის დრომდე მუშაობენ.
>> LUCAS Freitas: მისი თქმით, უბრალოდ მუშაობს.
>> LAUREN Carvalho: Oh, არის ის ამჟამად მუშაობს?
OK.
ასე რომ, როგორც ჩანს, ამ წელს სტილი უხელმძღვანელებს, თუნდაც მხოლოდ ერთი ხაზი,
თქვენ მოხვდით დააყენა იმ curly აფრთხილებს შემოსული
თქვენ არ აუცილებლად უნდა, რომ ფუნქციონალური პროგრამა.
და იქნებ ჩვენ უნდა მხოლოდ მიიღოს შესვენების მას შემდეგ, რაც პირობები და წავიდეთ პირდაპირ
სტილი სახელმძღვანელო გარკვევა up ზოგიერთი რამ?
>> LUCAS Freitas: ჰო.
გაქვთ შეკითხვა?
>> აუდიტორია: არა, მე უბრალოდ დაველოდოთ წლის სტილის სახელმძღვანელო.
>> აუდიტორია: იქნებ დაბრუნდეს რომ ternary ოპერატორს?
>> LAUREN Carvalho: ternary, დიახ.
>> LUCAS Freitas: ternary ოპერატორი ძირითადად თუ სხვაგან განაცხადი, მაგრამ
ნაცვლად, რომელმაც უნდა აქვს ორი ხაზი შემოწმების თუ და მაშინ
სხვაგან, უბრალოდ უნდა ერთი ხაზი.
ასე რომ, ძირითადად თუ მინდა სიმებიანი ღირებულება მაღალი ან დაბალი, და მე
გსურთ მაღალი, თუ n მეტია 100 ან დაბალი, თუ ის ნაკლებად, რა შემიძლია
ეს [INAUDIBLE]
სიმებიანი იქნება, და მერე ვთხოვთ პროგრამის N აღემატება 100?
>> ასე რომ, რატომ მაქვს ეს გამოთქმა ფრჩხილებში და შემდეგ
კითხვის ნიშნის.
მე გეკითხებით არის უფრო მეტი, ვიდრე 100?
იმ შემთხვევაში, თუ არ არის, ეს იქნება მაღალი.
თუ ეს არ არის, ის აპირებს დაბალი იქნება.
>> ასე რომ, ძირითადად რას ფიქრობთ თქვენ არის ითხოვთ კითხვაზე, ასე რომ თქვენ დააყენა ფრჩხილებში
მდგომარეობა.
მაშინ დააყენა კითხვის ნიშნის იმიტომ, რომ თქვენ გეკითხებით ეს.
და თუ ეს მართლაც ასეა, ის იქნება პირველ ღირებულება [INAUDIBLE] აქ.
თუ ეს არ, მე ვაპირებ დააყენა ღირებულება, რომელიც მას შემდეგ, რაც მსხვილი ნაწლავის.
ამჯამად ეს აზრი?
>> ეს არის ასევე რაღაც რომ ჰგავს ინსტრუმენტი C, მაგრამ თქვენ არ გაქვთ
კონკრეტულად გამოიყენოს იგი.
მაგრამ CS ადამიანი, როგორც წესი მინდა, რომ იმიტომ, რომ ეს მხოლოდ ზოგავს ხაზები.
>> LAUREN Carvalho: ეს არის ძალიან ელეგანტური.
ეს იმას ბევრი მხოლოდ ერთი განაცხადი.
>> აუდიტორია: ასე პროცენტი ნიშანი არის უბრალოდ რასაც შედეგები
წინა ხაზი?
>> LAUREN Carvalho: Oh, მე ბოდიში.
ეს პროცენტს ნიშანი ფაქტიურად placeholder ეს s.
ამ printf განაცხადი, თქვენ მოხვდით ამ სიმებიანი აქ, რაც აპირებს
ამობეჭდოთ, მაგრამ თქვენ შეგიძლიათ არა მხოლოდ დააყენოს ამ დრიურის არსებობს.
წინააღმდეგ შემთხვევაში ეს იქნებოდა ბეჭდვა გარეთ s სიტყვასიტყვით.
ამიტომ, ჩვენ დააყენა პროცენტს აქ შენარჩუნება ამ ადგილას გაიმართა სხვადსხვა
მას შემდეგ მძიმით.
>> ისე სიმებიანი, თქვენ მოხვდით პროცენტს s.
განთავსების რიცხვი, პროცენტი i.
იყიდება float, პროცენტი ვ.
თქვენ ნახავთ, ვინც, როგორც ჩვენ იხილეთ მეტი მაგალითები.
მაგრამ იქნებ უნდა ვისაუბროთ სტილის სახელმძღვანელო ცოტა ხნით, ახლა
რომ ეს up.
>> LUCAS Freitas: თუ წასვლა cs50.net/style, თქვენ ვაპირებთ ვხედავ
სტილი სახელმძღვანელო.
პრობლემის კომპლექტი, თქვენი ქულა პრობლემა კომპლექტი შედგება ფარგლებში,
რომელიც ძირითადად იმას ნიშნავს, თუ ყველაფერი ნაწილები პრობლემა მითითებული, ან თუ
სცადა რამე.
მეორე ის არის, სისწორის, რომელიც საშუალებით თქვენი პროგრამა აკეთებს იმას, რაც მას
უნდა იყოს აკეთებს, ან აკეთებს აქვს შეცდომები, ან ის არ აკეთებს რა
ის უნდა გააკეთოს.
>> მესამე კი ის არის, დიზაინი, რაც იმას ნიშნავს, თქვენ ახორციელებს ამ კარგად, ან
თქვენ გამოყენებით არასაჭირო განცხადებებს?
ასე მაგალითად, თუ თქვენ მინდა გავიმეორო ნომერი 10 ჯერ, წერ
მარყუჟის ან უბრალოდ აკეთებს 10 ჯერ ამავე განცხადებაში, უბრალოდ აკეთებს
ასლი და პასტა.
ასე რომ დიზაინი არის, რომ.
>> და ბოლოს, თქვენ გაქვთ სტილი.
სტილი ისევე ვიმსჯელებთ თუ თქვენი კოდი გამოიყურება
იკითხება და სახის ლამაზი.
ეს უბრალოდ ნიშნავს იმას, თქვენი კოდი იკითხება?
ნუთუ ვინმე სხვა ვინც ეძებდა არის თქვენი კოდი უნდა შეეძლოს გაიგოს, თუ რა
ის აკეთებს?
მას აქვს კომენტარები და ასე შემდეგ?
>> მოდით ვისაუბროთ სტილი, რომელიც თქვენ უნდა გამოიყენოთ.
პირველი ის არის კომენტარი.
კომენტარი ძალიან მნიშვნელოვანია თქვენი კოდი რადგან ზოგჯერ თქვენ აკეთებთ
თქვენი პროგრამა, და თქვენ იცით ზუსტად რა გსურთ ამის გაკეთება დავიწყო
კოდირება, აკრიფოთ up bunch of C. მაგრამ თუ ვინმეს ეძებს, რომლებიც თქვენ
კოდი, ისინი არ აპირებენ შეძლებს მესმის იმიტომ, რომ მათ არ იციან,
რამ, რომ თქვენს უფროსს, როგორც pesudocode, იქნებ ისინი
აქვს მძიმე დრო, რომ გავიგოთ რა კოდი აკეთებს.
>> ასე რომ, კომენტარი ნამდვილად სასარგებლო ასახსნელად ვინც ეძებს
თქვენი კოდი, თუ რას აკეთებს, და რეალურად კი თქვენ,
ისინი ძალიან სასარგებლო.
როგორც თქვენ გადადით უფრო რთული და რთული psets, თქვენ ვაპირებთ ვხედავ, რომ კოდი იღებს
აღარ, და შემდეგ კომენტარი ნამდვილად მნიშვნელოვანია, ასე რომ თქვენ გახსოვთ რა თითოეული
თქვენი პროგრამა აკეთებს.
>> იმისათვის, რომ კომენტარი, შეგიძლიათ უბრალოდ slash slash და შემდეგ დაწეროთ კომენტარი.
და მთელი ხაზის ნაწილია კომენტარი, და რაც თქვენ დაწერეთ,
ეს არ იქნება გამოიყენება თქვენი კოდი.
ეს ძირითადად, როგორც შემდგენელი აპირებს იგნორირება, რომ.
ამჯამად რომ აზრი?
>> აუდიტორია: რას აკეთებთ ერთხელ დაწერა კომენტარი?
>> LUCAS Freitas ეს?
Slash slash?
როდესაც თქვენ ჩაწერეთ ხაზი ხაზი, რასაც არის, რომ ხაზი არ აპირებს
to ითვლება C. ჰო?
>> აუდიტორია: ასე შემდეგ კომენტარი, თქვენ უბრალოდ შევა და დაიწყება ახალი ხაზი?
>> LUCAS Freitas: ჰო, ზუსტად.
>> LAUREN Carvalho: slash slash არის ერთი ხაზი კომენტარი.
>> LUCAS Freitas: მაგალითად, აქ გვაქვს -
ნება მომეცით მიუახლოვდით -
მაგალითად, აქ მე გამოცხადების float, მაგრამ იქნებ თუ უბრალოდ დააყენა ამ
თქვენი კოდი, ისევე, როგორც თქვენ არ ვიცი რა ამ ყველაფერს აკეთებს, როგორიც რეალურად
ვინც ეძებს ეს კოდი იქნება, როგორიც, რა
ჯანდაბა ხდება?
>> თუ თქვენ დააყენა კომენტარი რომ "გარდაქმნას Fahrenheit to გრადუსი, ეს ქმნის ბევრად
მეტი გრძნობა.
თქვენ, ისევე როგორც, OK, თქვენ აკეთებს კონვერტაციის.
ამჯამად რომ აზრი?
ასე რომ, ეს უბრალოდ რაღაც, რომელიც ეხმარება ხალხს მზად თქვენი კოდი და ასევე
თქვენ შეძლებთ ორგანიზება თქვენი კოდი უკეთესი.
>> მეორე ის არის, რომ თქვენ შეგიძლიათ ეს გააკეთოთ მრავალ ხაზის კომენტარი, ასე რომ გვაქვს ერთი
კომენტარის რამოდენიმე ხაზი.
იმის მაგივრად, რომ დააყენა ხაზი ხაზი, პირველი ხაზი კომენტარები, ირიბის ხაზი,
მეორე ხაზი, და ასე შემდეგ, თქვენ შეგიძლიათ გამოიყენოთ slash ვარსკვლავი.
ისე, რომ თქვენ ამის გაკეთება, რომ პირველი ხაზი კომენტარი, თქვენ
აპირებს slash ვარსკვლავი ვარსკვლავი, ასე რომ, ისევე, როგორც, რომ.
ისევე როგორც აქ გვაქვს დასაწყისში პროგრამა, თქვენ ჩვეულებრივ დააყენა, რომელიც თქვენ
, რა ეს პროგრამა აკეთებს, და პერსონალის იგრძნობა.
ეს ერთგვარი მოსწონს header პროგრამა.
>> ისევ და ისევ, ეს არ არის რაღაც, რომ შემდგენელი აპირებს აინტერესებს, მაგრამ
ეს მნიშვნელოვანია, რომ თქვენ იცით, რა ამ პროგრამა აკეთებს, ან სხვა ადამიანების
ვიცოდეთ თქვენი პროგრამა აკეთებს.
ასე რომ თქვენ ირიბის ვარსკვლავი ვარსკვლავი, და შემდეგ ბოლო ხაზი თქვენ ვაპირებთ ვარსკვლავი
slash შეძლებს დახურვა რომ კომენტარი.
ასე რომ, ძირითადად ყველა სხვა ხაზები, შეგიძლიათ უბრალოდ წერენ რასაც, და ამ
ყველაფერი იქნება იგნორირებული.
>> ასევე, როგორც წესი, თქვენ ხედავთ, რომ თითოეული ხაზი აქვს ვარსკვლავი, და ყველა
ვარსკვლავები იდეებს.
ეს არის მნიშვნელოვანი რამ ასე რომ თქვენი კოდი გამოიყურება საკმაოდ.
ხმები კარგი?
>> ახლა, პირობები.
რა დავით ამბობდა, რომ ჩვენ უნდა რეალურად დააყენა იმ სლაიდები, არის ის, რომ
როდესაც თქვენ გაქვთ რაიმე თუ განცხადებები ან რაიმე სახის პირობები,
თქვენ უნდა გამოიყენოთ curly აფრთხილებს აჩვენებს, რომ ეს არის ის, რაც მოხდება
როდესაც თქვენ გაქვთ მდგომარეობაში.
ტექნიკურად, როდესაც თქვენ გაქვთ მდგომარეობაში ხოლო შემდეგ მომდევნო ხაზი არის მხოლოდ ერთი
ხაზი, თქვენ არ ტექნიკურად აქვს დააყენა curly აფრთხილებს.
>> ძირითადად შემდგენელი რომ გაიგოს მაინც, როგორც დაფარული.
მაგრამ CS50, ჩვენ ვთხოვთ, რომ თქვენ ბიჭები დააყენა curly აფრთხილებს მხოლოდ ისე, რომ თქვენი
კოდი არის უფრო ორგანიზებულად და უფრო იკითხება.
იმიტომ, რომ კოდი იღებს აღარ თუ არ გაქვთ curly აფრთხილებს და ასეთი.
იგი იღებს ნამდვილად ბინძურ.
>> LAUREN Carvalho: ეს არის ზუსტად რა დავით უბრალოდ აღნიშნა,
ჩემი წინა სლაიდები.
ეს ნამდვილად მუშაობს გარეშე curly აფრთხილებს, მაგრამ სტილისტური მიზეზები
ჩვენ ვაპირებთ, ვთხოვოთ, რომ თქვენ დააყენა იმ შემოსული
>> და როდესაც თქვენ დაიწყოს გაშვებული style50, რომელიც სახის ქვითარი 50
სტილი, შეგახსენებთ, რომ ამის გაკეთება.
>> LUCAS Freitas: და კიდევ ერთი რამ არის მახსოვს დააყენა curly აფრთხილებს ერთად
თითოეული ხაზი.
ასე რომ თქვენ, მაგალითად, l's.
წასვლა მომდევნო ხაზი, გახსნა curly გაუწიოს, მაშინ გადადით მომდევნო ხაზი.
წანაცვლება, რომელიც ოთხი ფართები.
მაშინ წერენ რასაც, მაშინ სხვა ხაზი, და დახურვა curly გაუწიოს.
ასე რომ, დარწმუნებული ვარ, რომ ორივე იმ curly აფრთხილებს სხვადასხვა ხაზები.
>> აუდიტორია: ასე რომ, თუ ამ კოდექსით ჰქონდა მოსწონს 10 სხვაგან IFS, ეს უნდა
იყოს 10 კომპლექტი ფრჩხილებში?
>> LUCAS Freitas: Yeah, თითოეული მათგანი.
ჰო.
ასე რომ, თუ სხვაგან, თუ და ასე შემდეგ.
>> აუდიტორია: შეგიძლიათ არ დააჭირეთ Tab to აბზაცის?
>> LUCAS Freitas: ჩვენ გეკითხებით ბიჭები გამოიყენოთ ოთხი ფართები.
ზოგიერთი ტექსტის რედაქტორები თარგმნა tab ოთხი ფართები ავტომატურად.
gedit არ, ასე რომ თქვენ უნდა გავაკეთოთ ფართი ფართი ფართი სივრცეში.
ეს არის ასევე რაღაც, რომ ზოგიერთი პროგრამისტები მხოლოდ ჩანართების, ზოგიერთი
პროგრამისტები მხოლოდ ოთხი ფართები, და რამდენიმე სხვა ადამიანი კი გააკეთოს
ორი ან სამი ფართები.
უბრალოდ, აქ ჩვენ ითხოვს თქვენ ბიჭები გავაკეთოთ ოთხი ფართები.
>> აუდიტორია: არსებობს თითქმის აუცილებლად რაღაც უნდა იყოს გზა gedit to
ავტომატურად [INAUDIBLE].
ისევე როგორც [INAUDIBLE] აკეთებს, რომ.
>> LUCAS Freitas: ჰო.
მე ვფიქრობ, თქვენ შეგიძლიათ წასვლა პარამეტრები.
>> აუდიტორია: ეს უკვე ყველაფერს აკეთებს, რომ.
>> LUCAS Freitas: ეს უკვე აკეთებს?
OK.
ასე რომ, უბრალოდ დარწმუნებული უნდა იყოს, რომ ოთხი ფართები.
>> აუდიტორია: ნუ ჩვენ დააყენა curly ფრჩხილებში მარყუჟების ისევე?
>> LUCAS Freitas: დიახ.
>> LAUREN Carvalho: როდესაც თქვენი encapsulating კოდის ბლოკი, ისევე,
გთხოვთ გამოიყენოთ curly აფრთხილებს.
და სანამ თქვენ ფიქრობთ, რომ ჩვენ მხოლოდ მიმდინარეობს sticklers ამაზე კარგი
ამიტომ, თუ თქვენ ბიჭები არ წასვლა მისაღებად ტექნიკური სტაჟირება დიდი კომპანიები,
მათ მოგცემთ სტილის სახელმძღვანელო და ისინი გითხრათ, ეს არის ის, რაც თქვენი
კოდი უნდა გამოიყურებოდეს.
და მიუხედავად იმისა, რომ თქვენ ისწავლა კოდი მოსწონს ეს, ალბათ, თქვენს სტაჟირება
თქვენ უნდა გავაკეთოთ რაღაც სრულიად განსხვავებული.
ისინი არ ველით, რომ თქვენ შეესაბამება მათი სტილი.
>> LUCAS Freitas: და კიდევ ერთი რამ არის რომ თქვენ შეამჩნევთ, თუ როგორ მაქვს, როგორიც x,
ფართი, ნაკლებად, სივრცე, 0?
როდესაც თქვენ გაქვთ ოპერატორი -
ეს შეიძლება იყოს, როგორც პლუს, მინუს, ჯერ, ნაკლებად, მეტი, რასაც ოპერატორი -
თქვენ უნდა დააყენოს სივრცეში მარცხენა და მარჯვნივ ოპერატორს.
>> LAUREN Carvalho: ეს მოუწოდა ორობითი operands.
უბრალოდ დარწმუნდით, რომ თქვენ ყოველთვის ფართი თქვენი ორობითი operands.
>> LUCAS Freitas: ეს არის არ ორობითი operand.
>> LAUREN Carvalho: ეს არის რადგან იგი იღებს ორი.
>> LUCAS Freitas: Oh, yeah.
>> OK, კონცენტრატორები.
პირველი, თქვენ უნდა დაინახოს, რომ ისევე, როგორც იმ შემთხვევაში, თუ ანდა განაცხადი, თქვენ უნდა
დააყენა Curly გაუწიოს საკუთარი ხაზი და ქვეშ Curly გაუწიოს აქ.
გაითვალისწინეთ, რომ არსებობს ერთი ფართი მას შემდეგ, შეცვლა, ისევე, როგორც იმ შემთხვევაში, თუ და სხვა
ჩვენ გვქონია შორის სივრცე რომ და ფრჩხილებში.
ასე, რომ თქვენ უნდა დააყენოს, რომ.
>> და არ არსებობს ფართი უფლება ყოველი საქართველოს მრგვალ ან ბოლომდე
საქართველოს ფრჩხილებში.
ასე რომ, თქვენ ხედავთ, რომ ყველა ერთად, და ასევე მინდა აქ.
>> ჰო?
>> LAUREN Carvalho: ვფიქრობ ჩვენ გვჭირდება გადაადგილება.
>> LUCAS Freitas: ასე რომ, ეს არის ნაწილი სტილის სახელმძღვანელო, რომ თქვენ გაქვთ CS50.
დარწმუნდით, რომ წასვლა cs50.net/style და შევხედოთ ამ.
ეს არის ყველა ძალიან მნიშვნელოვანია თქვენი სტილი ანგარიში.
>> ნება მომეცით დაბრუნდეს განცხადებაში.
>> LAUREN Carvalho: მე მირჩევნია უბრალოდ გამოიყენოთ style50.
ჩვენ უბრალოდ აპირებს წავიდეს პირდაპირ მარყუჟების.
ყველა უფლება.
>> მოდით დავუბრუნდეთ შინაარსი, ახლა რომ ჩვენ წავიდა სტილის სახელმძღვანელო.
მარყუჟების, თქვენ ვხედავთ მათ Scratch და ჩვენ ვაპირებთ ვისაუბროთ მათ
C.
>> ამ მარყუჟის, არსებობს სამი ნაწილი, რომელიც
დეკლარაცია ამ loop.
თქვენ მოხვდით თქვენი ინიციალიზაცია in რომელიც თქვენ თქვენი ცვლადები.
თქვენ მოხვდით თქვენი მდგომარეობა, რომლებიც შემოწმების თუ არა რამე
ჭეშმარიტი ან მცდარი და თუ არა loop უნდა გაგრძელდეს.
და თქვენ მოხვდით თქვენი განახლება, რომელიც არის განახლება თქვენი ცვლადები.
>> მოდით უბრალოდ მიიღოს სწრაფი შევხედოთ ზოგიერთი C კოდი ამ for loop in action.
რა ხდება აქ არის ინიციალიზაციისას, ჩვენ შექმნის i 0.
მდგომარეობა ჩვენ შემოწმების თუ არა მე ნაკლებია 10.
და update ჩვენ დამატება i.
ასე რომ, რაც გამოიწვევს ამ loop?
>> LUCAS Freitas: სინამდვილეში, პირველ რიგში, თქვენ ბიჭები ვიცი, რა i + + არის?
>> აუდიტორია: გაიზარდა 1.
>> LUCAS Freitas: გაიზარდა 1, დიახ.
ასე რომ ეს არის იგივე როგორც აკეთებს i შეადგენს i პლუს 1.
და შენიშნავს, რომ ჩვენ არ გვაქვს სივრცე შორის მე და + +.
>> ასე რომ თქვენ ბიჭები ვიცი რა ამ ყველაფერს გააკეთებს?
შეგიძლიათ ვინმეს მითხრათ?
და იქნებ მიიღოთ გარკვეული candy ამის გამო?
>> აუდიტორია: [INAUDIBLE]
>> LUCAS Freitas: OK.
[INAUDIBLE]
ვაჩვენოთ შემდეგ [INAUDIBLE].
ჰო, ის აპირებს ნახოთ "ეს არის CS50 "10 ჯერ.
>> LAUREN Carvalho: ვფიქრობ, ეს იყო ტიტული slide.
>> LUCAS Freitas: Oh, yeah.
>> [სიცილის]
>> LUCAS Freitas: ეს ეხმარება.
>> LAUREN Carvalho: ასე რომ, იმ ამისთვის მარყუჟების.
ჩვენ ვაპირებთ, რომ ნახოთ კიდევ რამდენიმე მაგალითი ამისთვის მარყუჟების მოგვიანებით.
მაგრამ მოდით რეალურად შევხედოთ მეორე ტიპის loop თქვენ ექმნებათ
C, და ეს ე.წ. ხოლო loop.
>> ხოლო loop, თქვენ უბრალოდ მიიღო მდგომარეობაში.
მდგომარეობის შემოწმება დაწყებული და, თუ, რომ მდგომარეობა
აფასებს მართალია, მაშინ კოდი ფარგლებში ორგანოს, ხოლო ბლოკის
განახორციელებს.
და კოდი გაგრძელდება შეასრულოს მანამ, სანამ ამ
მდგომარეობა რჩება ჭეშმარიტი.
>> აი მაგალითი, ხოლო loop in C. ჩვენ ვაპირებთ, რომ მითითებული რაოდენობა, რათა 10
დავიწყოთ.
რადგან რაოდენობა მეტია 0, ჩვენ ვაპირებთ, რომ შევინარჩუნოთ დაბეჭდვისას ამ
ცვლადი აქ.
ჩვენ ვაპირებთ decrement რაოდენობა და შემდეგ შეამოწმოს მდგომარეობა კიდევ ერთხელ.
ბეჭდვა, decrement, შემოწმება მდგომარეობა კიდევ ერთხელ.
>> აქ ჩვენ გვაქვს მაგალითი, რომ ეხება თქვენს კითხვაზე ადრე.
ჩვენ გვქონდა პროცენტს ნანახია როდესაც ჩვენ დაბეჭდვისას სიმებიანი, და ახლა რომ
ჩვენ დაბეჭდვის out int, ჩვენ გვაქვს პროცენტი მე, როგორც ჩვენი placeholder ნაცვლად.
წერილები უნდა იყოს საკმაოდ ინტუიციური, დრიურის სიმებიანი, მე int.
>> ასე რომ, თუ ამ კოდექსით ახორციელებს, თქვენ უნდა ითვლიან ქვემოთ 10 0, დაბეჭდვისას
თითოეული რიცხვი.
>> LUCAS Freitas: თქვენ შეგიძლიათ ვფიქრობ პროცენტი ეს იგრძნობა ცარიელი
სივრცეში, და მაშინ თქვენ აყენებს ამ ცვლადი აქ, რომ ცარიელი სივრცე.
ასე მაგალითად, აქ მე მხოლოდ ცარიელი, და შემდეგ მე სტუმრად
იმედი უფლება არსებობს, ღირებულება რაოდენობა.
ამჯამად რომ აზრი?
>> შეიძლება მე უბრალოდ მოსწონს printf და შემდეგ მოჰყავს, იმედი?
იქნებოდა, რომ მუშაობს?
>> აუდიტორია: არა
>> LUCAS Freitas: არა, იმიტომ, რომ ეს იქნება რეალურად ბეჭდვა სიტყვა "რაოდენობა"
ნაცვლად დაბეჭდვის ღირებულება.
ეს არის, თუ როგორ, რათა ის ბეჭდვა ღირებულებები მიმართ ცვლადი ნაცვლად
მხოლოდ სახელწოდება ცვლადი.
რაიმე შეკითხვა?
>> აუდიტორია: რატომ ვიყენებთ როგორც ეწინააღმდეგებოდა ხოლო?
>> LAUREN Carvalho: მინდა გამოიყენოთ for loop თუ ვიცი ზუსტად რამდენი
iterations მინდა ჩემი loop გასაშვებად.
ამ შემთხვევაში, არ აქვს მნიშვნელობა, რადგან, ვგულისხმობ, მე უბრალოდ ცდილობს
ვფიქრობ ნამდვილად მარტივი მაგალითად ამ slide.
მაგრამ მოდით ვთქვათ, რომ გსურთ რაიმე შენარჩუნება აპირებს, ხოლო -
>> LUCAS Freitas: მაგალითად, თქვენ ითხოვს input სანამ ადამიანი
გაძლევთ უფლებას შეყვანა.
ასე მოსწონს, ხოლო input არ არის OK, შეინახოს ეკითხება მას.
ან მოსწონს, ხოლო თქვენ მშობლებს არ აძლევს თქვენ ფული, შეინახოს ეკითხება მას.
>> [სიცილის]
>> LAUREN Carvalho თქვენ არ იცით, თუ როგორ ბევრი ჯერ თქვენ უნდა გავაკეთოთ.
>> LUCAS Freitas: იმის გამო, რომ თქვენ არ ვიცი რამდენჯერ, რომ
ვაპირებ შენარჩუნება აპირებს.
>> LAUREN Carvalho: მაგრამ ამისთვის მარყუჟის, თქვენ უნდა იცოდეთ, რამდენჯერ.
ჰო?
>> აუდიტორია: Just გარკვევა, პროცენტი ამბობს, რომ ეს არის რაღაც შესახებ
მოხდეს, i ს რიცხვი, და backslash n -
>> LAUREN Carvalho: ნიშნავს?
ვინ იცის, რა backslash n ნიშნავს?
ახალი ხაზი, yeah.
ზუსტად.
>> LUCAS Freitas: შეგიძლიათ წარმოიდგინოთ of n ახალი ხაზი.
>> LAUREN Carvalho: Nice.
>> აუდიტორია: რა არის, რომ რაოდენობა dash dash [INAUDIBLE]?
>> LUCAS Freitas: Count მინუს მინუს არის იგივე როგორც plus plus, მაგრამ
ნაცვლად იზრდება, ის მცირდება 1.
>> LAUREN Carvalho: ნებისმიერი მეტი ხოლო loop კითხვები?
არა?
ოჰ, უნდა გაგვეშვა არ გამოტოვებენ, რომ.
>> ეს არის do ხოლო loop.
ძალიან გავს ხოლო loop გარდა ამ შემთხვევაში ჩვენ შეამოწმოს მდგომარეობა მას შემდეგ, რაც
კოდი ორგანოს loop ახორციელებს ერთხელ.
ასე რომ, ჩვენ შეასრულოს კოდი პირველი არ აქვს მნიშვნელობა რა.
მაშინ ჩვენ შეამოწმოს მდგომარეობა, შეასრულოს კიდევ ერთხელ თუ მდგომარეობა არის ჭეშმარიტი.
>> თქვენ აღმოჩნდეთ გამოყენებით, როდესაც თქვენ ითხოვს მომხმარებლის შეყვანის.
იმიტომ, რომ თქვენ ყოველთვის აპირებს ვთხოვთ ერთხელ, და შემდეგ დამოკიდებულია რა
მომხმარებლის input, თქვენ ალბათ reprompt და ვთხოვ, ისევ და ისევ, თუ
შეყვანის არ იყო ის, რაც თქვენ მოსალოდნელია, რომ იყოს.
>> აუდიტორია: ასე რომ, როგორც ფორმა ხალხს უნდა შეავსონ.
>> LAUREN Carvalho: ჰო, ზუსტად.
ნახავთ, ვფიქრობ, თქვენი პირველივე Pset, თქვენ უნდა
გამოყენება კარგად loop შეაგროვოს შეყვანის შესახებ.
>> აუდიტორია: დამოკიდებულია სიტუაცია, თქვენი ხოლო მარყუჟების ტენდენცია აწარმოებს მეტი
ხშირად, ვიდრე ხოლო მარყუჟების, ისევე როგორც ერთი ან რაღაც?
>> LAUREN Carvalho: თუ ის ზუსტი -
>> LUCAS Freitas: მათ ყოველთვის უნდა აწარმოებს ზუსტი ოდენობა ჯერ, რომ თქვენ
მინდა, რომ ის აწარმოებს.
Like ჩვენ ვიყენებთ გააკეთოს, ხოლო, რადგან ჩვენ ნამდვილად მინდოდა შეყვანის ერთხელ მაინც.
ხოლო მარყუჟების, ზოგჯერ არ გსურთ შეასრულოს ის, თუ ეს ასე არ არის
იმ შემთხვევაში, თუ შეასრულოს.
ასე რომ, ეს დამოკიდებულია დიზაინის.
ვგულისხმობ, შეგიძლიათ გამოყენების გააკეთოს, ხოლო თუ ხოლო რადგან თქვენი კოდი აკეთებს, რომ
ის უნდა გააკეთოს.
>> LAUREN Carvalho: მაგრამ მე ვფიქრობ, პასუხი თქვენს
კითხვაზე, ალბათ, კი.
ვთქვათ, იმ პირობით, იყო ყალბი.
ერთ შემთხვევაში, რომ აწარმოებს ერთხელ და სხვა შემთხვევაში ეს იქნებოდა აწარმოებს ნულოვანი ჯერ.
ასე რომ, yeah.
>> ნებისმიერი უფრო მეტი შეკითხვა?
დიახ?
>> აუდიტორია: შეიძლება loop მდგომარეობაში იყოს მარყუჟის თვალსაზრისით ცვლადი სხვა
გარდა [INAUDIBLE].
>> LAUREN Carvalho: ჰო, ეს შეიძლება იყოს არაფერი.
ალბათ დასაწყისში psets, თქვენ არ უნდა განიცადოს, რომ საქმე, მაგრამ
აუცილებლად ეს შეიძლება იყოს არაფერი.
>> LUCAS Freitas: ვფიქრობ ჩვენ გავაკეთეთ აქ.
>> LAUREN Carvalho: ვართ ჩვენ?
არა?
>> LUCAS Freitas: Loops?
ჰო.
>> LAUREN Carvalho: ჩვენ არ უნდა იყოს.
ოჰ, ჩვენ კეთდება მარყუჟების.
OK.
>> სინამდვილეში, იმის გამო, რომ ჩვენ ვსაუბრობთ ისე ბევრი, მოდით რეალურად ყველა ნავიგაცია
მეტი study.cs50.net/conditions.
და თქვენ ვაპირებთ ნავიგაცია ქვემოთ პრობლემები ვიჯეტის.
ისე, რეალურად, ხოლო ადამიანები იღებენ ამ წყობის, CS50 კვლევა
იქნება ინსტრუმენტი, რომ თქვენი TFs იქნება გამოყენება მომზადება სექციები და რომ
თქვენ ბიჭები შეგიძლიათ გამოიყენოთ თუ გამოტოვებთ სექციები.
ის აპირებს შეიცავდეს bunch of სლაიდები, რჩევები და ხრიკები თითოეული
თემას, და გარკვეული პრაქტიკის პრობლემები გადაწყვეტილებები.
>> რატომ არ ყველას უბრალოდ შევხედოთ ამ პრობლემის უფლება აქ.
>> მე ბოდიში, მე უნდა შეახსენა ადამიანი, რათა ლაპტოპები დღეს.
მაგრამ თუ თქვენ არ გაქვთ ლეპტოპი, რომ OK.
შეგიძლიათ უბრალოდ jot ქვემოთ შესახებ ნაჭერი ქაღალდი ან გამოიყურებოდეს მეტი
თქვენი მეზობლის მხრის.
>> მოდით ცდილობენ და დაწეროთ პროგრამა, რომელიც თხოვს მომხმარებელს მიიღოს ვხვდები,
ბავშვების საშუალო რაოდენობას ოჯახზე ერთეულის შეერთებული შტატები.
ეს რიცხვი 2, სხვათა შორის, როგორც თქვენ ხედავთ ამ მაგალითები.
>> ჩვენ გვინდა, რომ ამობეჭდოთ რაოდენობის საშუალო ბავშვები ოჯახზე აშშ, მაშინ ჩვენ
მინდა რა?
ჩვენ გვინდა, რომ შეაგროვოს input საწყისი მომხმარებელს.
და შემდეგ დამოკიდებულია რა მომხმარებლის ანკეტის შეყვანის არის, თქვენ აპირებს ამობეჭდოთ
არც ეს არის სწორი ან ეს არასწორია.
>> და ძალიან პირველი, რაც თქვენ ვხედავ, თუ თქვენ დააჭირეთ პატარა ისარი
ბოლოში პრობლემა ვიჯეტის არის რაშია jot ქვემოთ ზოგიერთი pseudocode.
ამიტომ თქვენ არ პროგრამირების არავის გაუკეთებია.
თქვენ მხოლოდ მიღების თქვენი იდეები მიზნით.
>> ვინმეს სურს დაეხმაროს Lucas ამუშავება უფლება
pseudocode ამ პრობლემას?
>> LUCAS Freitas: რა არის პირველი რამ, რომ ჩვენ უნდა ალბათ აქ?
რა ბიჭები ვფიქრობ?
>> აუდიტორია: [INAUDIBLE]
>> LUCAS Freitas: Yeah, OK.
ასე რომ, ბეჭდვითი.
უბრალოდ, ვამბობთ ბეჭდური ამ საშუალო რაოდენობის ხალხი?
OK.
Print კითხვა, ვთქვათ.
მას შემდეგ, რაც მე ბეჭდვა ეს კითხვა, რა უნდა გავაკეთო?
>> აუდიტორია: ოჯახის შეყვანა.
>> LUCAS Freitas: ოჯახის შეყვანა.
არაფერი?
>> აუდიტორია: მდგომარეობა.
>> LUCAS Freitas: მდგომარეობა.
>> LAUREN Carvalho: რა არის ის, რომ მდგომარეობა იქნება?
>> აუდიტორია: პუნქტების [INAUDIBLE].
>> LAUREN Carvalho: Right.
>> LUCAS Freitas: რა ვარ მე აპირებს შემოწმება მდგომარეობაში?
>> აუდიტორია: თუ ეს უდრის 2.
>> LAUREN Carvalho: თუ ეს უდრის 2.
ზუსტად.
>> LUCAS Freitas: არის რამე სხვაგან, რომ მე უნდა გავაკეთოთ?
>> აუდიტორია: Count.
>> LUCAS Freitas: ასე რომ, თუ ის უდრის 2, ვთქვათ -
ნება მომეცით უბრალოდ წერენ, თუ input შეადგენს 2, მერე რა მე ვაპირებ
ამის გაკეთება არის ბეჭდვის სწორი.
და მერე სხვას, მე ვაპირებ ბეჭდვა არასწორია.
არაფერი?
არა?
>> LAUREN Carvalho: ასე რომ თქვენ დააკლიკეთ -
ამჯამად ყველას აქვს ეს ყველაფერი?
>> LUCAS Freitas: აქვს აზრი?
ახლა მოდით ცდილობენ კოდექსს.
>> LAUREN Carvalho: თუ თქვენ დააჭირეთ პატარა arrow, ეს ფაქტიურად ზოგავს თქვენს
pseudocode, რომელიც ნამდვილად საინტერესო.
და შეგიძლიათ იმ შევიდა კომენტარი თუ გსურთ უბრალოდ შევახსენო თავს
რა უნდა გააკეთოს.
>> LUCAS Freitas: ასე მაგალითად, პირველი მე ვაპირებ ბეჭდვა კითხვას, ასე
როგორ ვარ მე აპირებს, რომ, რეალურად?
printf.
ამიტომ printf, და კითხვა არის საშუალო ბავშვების პოსტი
ოჯახის ამერიკის შეერთებულ შტატებში.
>> შემდეგ მე ვაპირებ მისაღებად შეყვანის შესახებ.
ასე რომ, როგორ შემიძლია ამის გაკეთება?
>> აუდიტორია: ოჯახის Int.
>> LAUREN Carvalho: GetInt.
>> LUCAS Freitas: OK.
ამიტომ პირველ აცხადებენ, უფლება?
int, მოდით ეძახით n შეადგენს GetInt.
>> და ახლა მდგომარეობაში.
ნება მომეცით ვთქვა, რომ მე ვაპირებ აქ გამშვები პასუხი.
ასე რომ, პირველი, თუ input, რომელიც n, ტოლობის to - როგორ ვარ მე აპირებს დაწეროს, რომ?
>> აუდიტორია: თანაბარი თანაბარი.
>> LUCAS Freitas: Perfect.
ასე რომ, n.
და შეამჩნია, რომ მე სივრცეში, შეადგენს, ტოლობის, სივრცე, ასეა.
და ახლა რა უნდა ვქნა?
რაღაც ძალიან მნიშვნელოვანია სტილი.
Curly აფრთხილებს.
>> და შემდეგ მე ვაპირებ ბეჭდვა.
როგორ შემიძლია ბეჭდვა?
printf.
>> აუდიტორია: შეიძლება იყოს ის, კაპიტალიზაცია?
>> LUCAS Freitas: არა
ის უნდა იყოს ყველა ამას.
ასე რომ, არის სწორი.
>> რომ ეს საკმარისია, რომ printf განაცხადი, ან მე ვერ გავიგე რამე?
>> აუდიტორია: New ონლაინ.
>> LUCAS Freitas: New line, yeah.
და ახლა სხვაგან.
>> აუდიტორია: არის სივრცე მას შემდეგ, რაც printf, თუ არა?
>> LAUREN Carvalho: ჩვენ უნდა შეამოწმეთ სტილის სახელმძღვანელო.
>> აუდიტორია: ეს არ უნდა იყოს.
>> LUCAS Freitas: არ უნდა იყოს, OK.
ასე სხვაგან, printf, "ეს არასწორია."
>> LAUREN Carvalho: Oops, თქვენი quotes.
>> LUCAS Freitas: OK.
არაფერი?
იგი ლამაზად?
>> LAUREN Carvalho: რა ვქნათ, ცდილობენ?
>> LUCAS Freitas: ჰო, მოდით გაუშვით.
ასე რომ, ეს შედგენა, და ეს როგორც ჩანს, ეს სამუშაოები.
მოდით ვეცადოთ და ორი შვილი.
ეს არის სწორი.
და ახლა გავუშვათ ისევ, მაგრამ ახლა ნაცვლად აყენებს ორი შვილი, მოდით
ამბობენ, რომ მე ვაპირებ დააყენა მოსწონს ხუთ.
ეს არასწორია.
ასე რომ, როგორც ჩანს, ეს სამუშაოები.
>> LAUREN Carvalho: რატომ არ ვაჩვენოთ რა მოხდება თუ თქვენ დააყენა რაღაც
უცნაური, ისევე როგორც ზოგიერთი წერილებს.
>> LUCAS Freitas: Oh, yeah.
მოდით შეამოწმოთ, რომ.
რა მოხდება, თუ მომხმარებელი ცდილობს სასადილო თქვენი პროგრამა, და ისინი უბრალოდ
წერენ, არ ვიცი, ორი.
იგი აპირებს ამბობენ გაიმეორეთ.
>> LAUREN Carvalho: So GetInt ეკითხება მათ გაიმეორეთ.
ჩვენ არ უნდა იზრუნოს რომ საკუთარ თავს.
>> LUCAS Freitas: ჰო.
ასე რომ, თუ მე რეალურად დააყენა ნომერი, ეს ვაპირებ შენარჩუნება მთხოვდნენ გაიმეორეთ.
>> აუდიტორია: როგორ ფიქრობთ აწარმოებს?
>> LUCAS Freitas: უბრალოდ დააჭირეთ ეს ვარსკვლავი ღილაკს.
>> LAUREN Carvalho: თქვენ უნდა ახვიდეთ.
აქ თქვენ წასვლა.
>> LUCAS Freitas: ვარსკვლავი button უფლება არსებობს.
ჰო?
>> აუდიტორია: იგი შეეკითხება [INAUDIBLE] ერთად ათობითი რიცხვები ძალიან?
>> LAUREN Carvalho: მე მჯერა, რომ ეს იქნება.
>> LUCAS Freitas: თუ ეს ასეა, რა?
>> LAUREN Carvalho: თუ ისინი აკრიფოთ in ათობითი რიცხვი, ვფიქრობ
ის აპირებს უბიძგონ.
>> LUCAS Freitas ვნახოთ.
>> LAUREN Carvalho: იმის გამო, ეს არ არის int.
>> LUCAS Freitas: ჰო.
>> LAUREN Carvalho: ასე რომ ეს არ არის int, ოჯახის Int მოგთხოვთ გაიმეორეთ.
>> აუდიტორია: ასე რომ, სადაც, რომ კოდი იქნება ათობითი ადგილი რომ თხოვს
შესახებ, რომ ისინი უნდა შევიდეს მთელი კონკრეტულად?
>> LAUREN Carvalho: GetInt ფაქტიურად აკეთებს, რომ ჩვენთვის.
>> აუდიტორია: არა, მე იმას, თუ გვინდოდა შესვლის [INAUDIBLE]
>> LUCAS Freitas: თქვენ შეიძლება ითქვას, როგორიცაა საშუალო ბავშვების ამერიკის შეერთებულ შტატებში.
მე არ ვიცი.
ჩვენ შეგვიძლია ვთქვათ, მაგალითად, "გთხოვთ, input მთელი რიცხვი. "
>> LAUREN Carvalho: მთელი ტოლია საშუალო ნომერი.
ვგულისხმობ, ის, თუ რამდენად თქვენ სიტყვა იგი, არა?
>> LUCAS Freitas: ჰო.
ეს არ არის ნაწილი ფაქტობრივად კოდირების.
ეს უფრო მოსწონს, რასაც თქვენ აპირებს მინდა
წერს თქვენი პროგრამა.
>> აუდიტორია: რა ჩვენ აწარმოებს, თუ იგი იყო რეალურად gedit [INAUDIBLE].
ნაცვლად დაჭერით პიესა?
>> LUCAS Freitas: ჩვენ პირველი კომპილირება.
ჩვენ შეგვიძლია ამის გაკეთება აკეთებს მაკიაჟი და ფაილის სახელს.
და შემდეგ აწარმოებს, ჩვენ ყველაფერს გავაკეთებთ dot slash და სახელი პროგრამა.
>> აუდიტორია: ვფიქრობ, ის, რაც მე იმას ნიშნავდა, იყო თუ გვინდოდა პროგრამა უპასუხოს
მათი არასწორია, არასწორი ჩანაწერი, თქვენ არ უნდა დასვა -
>> LUCAS Freitas: ჩვენ ვერ შეძლებს გავაკეთოთ, რომ რადგან კოდი ამ ამბობს
გაიმეორეთ მოდის Get Int რომელიც ფუნქცია, რომელიც უკვე განხორციელდა
ჩვენთვის მეშვეობით CS50 ბიბლიოთეკა, და რადგან ეს უკვე განხორციელდა, ჩვენ
არ შეუძლიათ უბრალოდ [INAUDIBLE].
>> LAUREN Carvalho: თუ თქვენ არ გამოიყენოთ GetInt, მაშინ ამის გაკეთება.
>> LUCAS Freitas: ჰო.
მაგრამ თუ თქვენ იყენებთ GetInt, თქვენ არ შეგიძლიათ.
ნებისმიერი სხვა კითხვები?
>> აუდიტორია: იქნებ არ წავიდა მოსწონს GetFloat და შემდეგ შეძლებს დააყენოს
ის ათობითი?
>> LUCAS Freitas: ჰო.
>> აუდიტორია: OK.
მაშინ უბრალოდ შეეძლო input ათწილადი შეადგენს -
>> LAUREN Carvalho: ჰო.
ზუსტად იგივე გარდა ათწილადი ნაცვლად int.
>> LUCAS Freitas: Just დააყენა აქ და შემდეგ GetFloat არსებობს.
>> აუდიტორია: როგორც თქვენ ვხედავ ან არ ჩანს -
>> LAUREN Carvalho: ჩვენ არ მიღებული არსებობს ამჟამად.
>> აუდიტორია: - აკეთებს უთანასწორობა ერთად მოძრავი არ [INAUDIBLE]
>> აუდიტორია: რა semicolons ნიშნავს?
>> LAUREN Carvalho: მძიმით მხოლოდ იმას ნიშნავს, რომ ეს განცხადება არის სრული,
და ჩვენ ვაპირებთ წავიდეთ გადატანა მომდევნო slide.
>> აუდიტორია: ასე აუცილებელია ყოველ ჯერზე?
>> LAUREN Carvalho: ჰო.
ასევე, OK, ასე რომ არა ამ პირობებში, იმიტომ, რომ ისინი
encapsulating რაღაც.
ასე რომ, ძირითადად თუ რამე იწვევს თქვენ მაშინ შექმნა Curly გაუწიოს
ბლოკი, არ დააყენოს მძიმით დასასრულს.
>> LUCAS Freitas მაგრამ ყველაფერი სხვაგან, დიახ.
როცა დასრულდება განცხადებაში, დააყენოს მძიმით.
და თუ თქვენ დაგავიწყდებათ semicolons, შემდგენელი აპირებს მიიღოს გაბრაზებული თქვენ,
და თქვენ ვაპირებთ აქვს ცდილობენ გაასწორონ ის.
>> LAUREN Carvalho: თუ მე დააყენოს მძიმით აქ, რომ შეწყვიტოს ეს, და მე
არასოდეს მიიღოთ შეასრულოს რა შიგნით, სხვათა შორის.
ასე რომ, ეს არის ერთ ერთი იმ საერთო შეცდომები.
>> აუდიტორია: Always შესრულებაში.
>> LAUREN Carvalho: ჰო.
ამ შემთხვევაში, ჩვენ ყოველთვის შეასრულოს რა არის შიგნით.
>> აუდიტორია: თქვენი სტილი [INAUDIBLE] ანიჭებენ, რომ თქვენ, ფიქრობდნენ.
>> LAUREN Carvalho: Oh, რომ მართალია.
>> აუდიტორია: [INAUDIBLE] ერთი ონლაინ რამ [INAUDIBLE]
>> აუდიტორია: დიახ?
>> აუდიტორია: შეგიძლიათ მქონდეს საშუალებებით ერთ ხაზზე?
ასე რომ შეგიძლიათ ვთხოვთ მომხმარებლებს ბეჭდვა ორი რამ?
>> LAUREN Carvalho: არ იყენებს -
>> LUCAS Freitas: არა
ვთქვათ, რომ მეც მინდა მიიღოს ამ რიცხვი ტელ.
მე უნდა გავაკეთოთ სხვადასხვა ონლაინ.
>> აუდიტორია: თუ თქვენ აწარმოებს , როგორ [INAUDIBLE]?
ეს იქნებოდა ბეჭდვა prompt არსებობს [INAUDIBLE]
და მერე ნეტავ შევა ერთი და -
>> LAUREN Carvalho: ისე, გაუშვით.
ვგულისხმობ, იქ არაფერი შეჩერების ჩვენ მხოლოდ გაშვებული და ხედავს, თუ რა
მოხდებოდა.
>> LUCAS Freitas: მე ვფიქრობ, რომ აპირებს უჩივის ჩვენთან
იმიტომ, რომ ჩვენ არ იყენებს -
>> LAUREN Carvalho: Oops.
>> LUCAS Freitas: ეს დაიჩივლა ჩვენთან უფლება ახლა, რადგან ჩვენ არ იყენებს ამ
ცვლადი, მაგრამ თუ მე, მაგალითად, n არის უდრის უდრის, და მ უდრის
შეადგენს, მაშინ, რა იქნება მოხდება ამ შემთხვევაში?
რა ამ პროგრამის გაკეთება?
>> აუდიტორია: მე უბრალოდ გაინტერესებთ როგორ იქნებოდა -
>> LAUREN Carvalho: მან უბრალოდ სურს უნდა იცოდეს, როგორ გამოიყურება
ისევე, როგორც, ვფიქრობ, არა?
ასე რომ აიღო ერთი მათგანი, და შემდეგ დასჭირდა მეორე.
>> მე ვფიქრობ, რომ ჩვენ უნდა გადაადგილება, იმიტომ, რომ ჩვენ კიდევ ერთი
სლაიდ შოუ წასვლა ადრე -
გსურთ გაიყვანოს მათემატიკის?
>> LUCAS Freitas: Yeah, math.
>> LAUREN Carvalho: Give მე მხოლოდ ერთი მეორე.
>> არსებობს რამდენიმე სხვადასხვა ციფრული ცვლადები in C. რიცხვითი მონაცემების C
შეიძლება კლასიფიცირებული შევიდა სხვადასხვა სახის, და ეს არის ის, ვინც თქვენ
იხილეთ ყველაზე ხშირად.
>> და int არის მთელი რიცხვი.
შეგიძლიათ არ აქვს არც decimals.
ელექტრო, სჭირდება 32 ბიტი შესანახად int.
>> Float შეიძლება ჰქონდეს decimals.
იგი ასევე იღებს 32 ბიტი შესანახად float ამ მოწყობილობების.
>> ორმაგი არის ნომერი ათობითი წერტილი, რომელიც იღებს 64 ბიტი შეინახოს იგი,
რაც იმას ნიშნავს, რომ თქვენ შეგიძლიათ უბრალოდ დიდი სიზუსტით, რადგან
თქვენ შეგიძლიათ მეტი -
რას ეძახით?
>> LUCAS Freitas: ჰო, მეტი.
>> LAUREN Carvalho: სხვა ადგილები მას შემდეგ, რაც ათობითი წერტილი.
და ხანგრძლივი ხანგრძლივი არის მთელი რიგი რომ იღებს 64 ბიტი
sore ის მოწყობილობების.
>> LUCAS Freitas: ასე რომ, ეს შეიძლება იყოს აღემატება ints შეიძლება იყოს.
>> LAUREN Carvalho: ის მონაცემები სახეები C არის ის, რომ გითხრათ რა
სახის მონაცემები შეგიძლიათ შეინახოთ თქვენი ცვლადი.
ისინი გითხრათ, თუ როგორ შეგიძლიათ გამოიყენოთ ეს ცვლადი თქვენი პროგრამა.
ეს ძალიან მნიშვნელოვანია, რომ უბრალოდ შეინახოს სიმღერა რა ტიპის მონაცემის თქვენ იყენებთ, და თუ
თქვენ უნდა მსახიობი მონაცემები ტიპის სხვა, დარწმუნდით, რომ თქვენ იცით,
ზუსტად რა ხდება, როცა casting ხდება.
და დაინახავთ, მაგალითად შემდეგ on ამ სლაიდები, რომელიც
შეცდომა, რომელიც შეიძლება მოხდეს.
>> მოდით შევხედოთ ზოგიერთი მათემატიკის C და ვფიქრობ, ნამდვილად ფრთხილად, ვფიქრობ,
შესახებ, თუ რა ხდება, როდესაც ამ მათემატიკის ხდება.
პირველივე ხაზი, რა არის მაშინ, როცა ვაცხადებ x?
>> აუდიტორია: თქვენ საშუალებითაც x უნდა იყოს რაღაც?
>> LAUREN Carvalho: ჰო.
კარგად, მე ნამდვილად ითხოვს ოპერაციული სისტემის 32 ბიტი მეხსიერების, არა?
რომელიც მე შეგიძლიათ შეინახოთ int, და მე ვაპირებ მოვუწოდო, რომ int x.
>> LUCAS Freitas: ძირითადად მიმდინარეობს მეხსიერების და მოძიებაში ადგილი რომ აქვს 32
ბიტი და ამბობდა, hey, მინდა ამ სივრცეში, და ის აპირებს ეწოდოს x.
ასე რომ, თქვენ უბრალოდ საკმაოდ ბევრი დასკვნა ყუთი თქვენი მეხსიერება
მაღაზია ღირებულებების x.
>> LAUREN Carvalho: და მერე ინიციალიზაცია x, რაც იმას ნიშნავს, რომ უბრალოდ შეინახოს
ღირებულება 2 იმ ადგილას, რომ ბლოკი მეხსიერება, რომ ჩვენ ვთხოვეთ ოპერაციული
სისტემა.
და ქვემოთ აქ რასაც ვაკეთებთ არის ჩვენ რეალურად გამოცხადების და
ინიციალიზებისას y ერთი ხაზი ნაცვლად ორი ხაზი ისე, როგორც აქ,
რომელიც ასევე შესანიშნავად ჯარიმა, ჩვენ დასძინა, 1 x, და ჩვენ შენახვის, რომ
ღირებულება y.
>> LUCAS Freitas: ასე რომ, ძირითადად რა ეს ონლაინ აკეთებს, იგი აღმოაჩენს ახლა ყუთი y,
და შემდეგ მისი ღირებულება, რაც თქვენ აპირებს დააყენოს შიგნით ყუთი, არის
იქნება ღირებულება x პლუს 1.
ასე რომ ეს ყუთი y.
იგი იღებს ღირებულება x, გამოიყურება აქ, და ვხედავ, რომ ის 2.
ვთქვათ არსებობს, პლუს 1, ასე რომ ეს აყენებს 3 არსებობს.
ამჯამად რომ აზრი?
ასე რომ y იქნება 2 ამ შემთხვევაში.
>> LAUREN Carvalho: ყველა უფლება, cool.
ვნახეთ ასევე, მოდით ახლა ვფიქრობ გაყოფის შესახებ in C. აქ ვარ
ვაცხადებთ და ინიციალიზაციისას float მოუწოდა პასუხი და გამყოფი 1 10,
და შემდეგ მე დაბეჭდვისას პასუხი ორ ათობითი ადგილებში.
და აღნიშნავენ, აქ, ჩემი printf განცხადება, როცა მინდა ბეჭდვა რაღაც ორ
ათობითი ადგილებში,% .2 f არის რა მინდა გამოიყენოს.
ასე რომ, წერტილი 2 უბრალოდ ვამბობ მჭირდება ორ ადგილას შემდეგ
ათობითი იბეჭდება.
>> ახლა, რა მოხდება თუ აწარმოებს ამ კოდი?
ვინმეს აქვს იდეა?
რა ამობეჭდოთ?
>> LUCAS Freitas: რა არის ჩვენ ველოდებით, რომ მიიღოს.
>> LAUREN Carvalho: რა ჩვენ გვინდა, პირველ რიგში?
>> LUCAS Freitas: [INAUDIBLE]
>> LAUREN Carvalho: 0.1, yeah.
მაგრამ რა იქნება ამობეჭდოთ?
>> აუდიტორია: [INAUDIBLE]
>> LAUREN Carvalho: ისე, არა, რეალურად.
ეს არის ის, რაც მე ლაპარაკი, თუ რატომ უნდა შევინარჩუნოთ ძალიან ფრთხილად სიმღერა
თქვენი მონაცემთა ტიპები.
მაშ, რა მონაცემები ტიპის არის ეს?
არის int, არა?
არ არსებობს ათობითი ადგილი.
10 ასევე int.
არ არსებობს ათობითი ადგილი.
>> თუ მე გაყოფა int by int, მივიღებ int, რომელიც არ არის 0.1, რადგან ints
არ შეიძლება ჰქონდეს ათობითი ადგილებში, მაგრამ 0.
იმის გამო, რომ int მხოლოდ truncates off ათობითი ადგილებში.
>> LUCAS Freitas: ასე რომ, როდესაც თქვენ აკეთებთ ოპერაციების ints, თქვენ აპირებს
მიიღოს int როგორც პასუხი.
ასე რომ, ძირითადად, რა კომპიუტერი აკეთებს, ეს ყოფს 1 by
10, და იგი იღებს 0.1.
მაგრამ შემდეგ ის მსგავსად, დაველოდოთ, ეს არის უნდა იყოს მთელი რიცხვი, ასე რომ თქვენ მხოლოდ
იგნორირება 0.1, ამიტომ ახლა მხოლოდ 0.
>> LAUREN Carvalho: ასე რომ, როდესაც მე ბეჭდვა ეს out, მივიღებ 0.00 ვიდრე 0.10.
>> LUCAS Freitas: არა, რომ აზრი?
>> LAUREN Carvalho: ეს ერთგვარი სამწუხარო, არა?
>> LUCAS Freitas: მაშ, როგორ შეგვიძლია დაფიქსირება ამ?
>> LAUREN Carvalho მოდით ცდილობენ და დაფიქსირება, რომ.
აი მაგალითად სადაც მე ვარ რეალურად კასტინგის 1
და 10 მოძრავი.
ახლა, 1 აღარ არის int.
1 არის float.
სხვათა შორის, ეს მხოლოდ სინტაქსი როდესაც გსურთ მიცემული ერთი
მონაცემები ტიპის სხვა.
შეგიძლიათ უბრალოდ დააყენა მონაცემები ტიპის ფრჩხილებში და უნდა, რომ მხოლოდ წინ უძღვის
ღირებულება, რომ თქვენ აძლევენ.
>> ასე რომ, აქ, მე გამყოფი float მიერ float მისაღებად float პასუხი.
და დიახ, ეს საკითხი ფაქტობრივად ბეჭდვა 0.10.
ამჯამად რომ აზრი?
>> LUCAS Freitas: So ტიპის casting მხოლოდ კონვერტაცია ერთი ტიპის სხვა.
ასე რომ float 1 რეალურად 1.000.
არ არის ზუსტად, მაგრამ ეს რაღაც ერთად ათობითი ადგილებში
რომ არის რეალურად 1.
ამჯამად რომ აზრი?
ჰო?
>> აუდიტორია: რა მოხდება, თუ თქვენ არ float პასუხი შეადგენს 1.0 იყოფა 10?
>> LAUREN Carvalho: თქვენ რეალურად აპირებს ვხედავ, რომ მომდევნო slide.
რომ სინამდვილეში ჩვენი მომდევნო slide.
ეს არის რეალურად გავალამაზოთ, ვიდრე ჩაწერეთ casting, ვფიქრობ.
ასე რომ, ეს ორი მოძრავი მხოლოდ ბუნების იმისა, რომ ისინი
აქვს ათობითი ადგილებში.
დიახ?
>> აუდიტორია: რა მოხდება, თუ თქვენ გააკეთეთ [INAUDIBLE]
იყოფა 10?
>> LAUREN Carvalho: სინამდვილეში float იყოფა int რეალურად გაძლევთ
float, ისე, რომ მუშაობა ჯარიმა.
>> დაველოდოთ, ჯერ ყველას კარგად ესმის ეს?
იმიტომ, რომ ეს იქნება მართლაც დიდი გარიგება Pset1, რეალურად.
დიახ?
>> აუდიტორია: იქნებ უბრალოდ სწრაფად წავიდეთ წითელი ნაწილი?
>> LAUREN Carvalho: წითელი ნაწილი, yeah.
Lucas, გინდა?
>> LUCAS Freitas: OK.
ასე მახსოვს, რომ პროცენტიანი არის placeholder.
ეს იგივეა, ცარიელი სივრცე.
მოდით ცდილობენ მესმის ყველაფერი რომ ხდება აქ.
პროცენტი იმას ნიშნავს, რომ ეს placeholder.
მაშინ თქვენ გაქვთ f, რაც იმას ნიშნავს, ამ placeholder არის float.
ბოლო რამ, რომ ჩვენ აქ არის .2, რაც იმას ნიშნავს, მინდა ორ
ათობითი ადგილებში, რომ float.
>> იმ შემთხვევაში, თუ მე უბრალოდ ჰქონდა% f, მათ ეს იქნება დააყენა რამოდენიმე ათობითი ადგილებში.
ასე, რომ შეიძლება უბრალოდ დააყენა .2 ან .1 ან .5, ან რასაც, და ის აპირებს დააყენოს, რომ
ნომერი ათობითი ადგილებში.
მხოლოდ ის არის, რომ თუ თქვენ დააყენა მოსწონს .100 ან .1,000, ეს არ არის რეალურად
აპირებს დააყენოს ყველა იმ ათობითი ადგილებში იმიტომ, რომ მას არ გააჩნია საკმარისი მეხსიერება
აქვს, რომ სიზუსტით.
>> ნებისმიერი სხვა კითხვები?
ჰო?
>> აუდიტორია: ასე რომ float მხოლოდ საშუალებას თქვენ სცილდება რიცხვებით?
>> LUCAS Freitas: დიახ.
>> LAUREN Carvalho: ისე, float მხოლოდ საშუალებას გაძლევთ ათობითი ადგილებში.
>> LUCAS Freitas: ეს უბრალოდ ნიშნავს, რომ თქვენ ახლა შეიძლება ჰქონდეს ათობითი ნომრები.
>> აუდიტორია: რატომ ჩვენ ოდესმე გამოიყენოს რიცხვებით?
>> LUCAS Freitas: რატომ თქვენ იყენებთ რიცხვებით?
იქნებ თუ თქვენ დათვლის 0 დან 10, გსურთ გამოიყენოთ რეალურად რიცხვი.
თქვენ არ უნდა გამოიყენოს float.
ზოგიერთ სიტუაციებში, თქვენ არ უნდა რეალურად -
>> LAUREN Carvalho იქნებ არ მინდა decimals.
>> LUCAS Freitas იქნებ არ გინდათ გამოიყენოთ float.
>> LAUREN Carvalho: სხვა რამ არის, მახსოვს, ორივე დააყენა float და int
მიიღოს 32 ბიტი შესანახად მათ, და იქნებ თქვენ არ მინდა დაგვრჩა ბიტი
ათობითი ადგილებში.
>> LUCAS Freitas: ჰო.
ასე რომ, უბრალოდ ფიქრობთ ამის შესახებ.
თქვენ გაქვთ 32 ბიტი ორივე int და float.
განთავსების int, ყველა იმ 32 ბიტი წასვლა მთელი ნაწილი.
თუ თქვენ იყენებთ float 32 ბიტი, თქვენ უნდა ნაწილი ამ მეხსიერების გამოიყენება
რაოდენობის, მთელი ნომერი, ან, და მეორე ნაწილი, რომელიც გამოიყენება
ათობითი ადგილებში.
ასე რომ, რაც იმას ნიშნავს, რომ თქვენ ვერ ძალიან დიდი რაოდენობით მოძრავი რადგან
float უკვე გამოყენებით უამრავი მეხსიერების ათობითი ადგილებში.
ჰო?
>> აუდიტორია: ეს პირველი პასუხი, რა ზუსტად არის ის აკეთებს?
იგი შექმნის ღირებულება float ტოლია რომ placeholder, რომ თქვენ შეგიძლიათ
გავიხსენოთ, რომ მომდევნო ხაზი?
იგი აცხადებს, რომ float პასუხი.
>> LUCAS Freitas: ჰო.
ასე რომ, float პასუხი იმას ნიშნავს, რომ თქვენ მიღების ახლა პატარა bucket მეხსიერებაში, რომ
აქვს float, და რომ აპირებს ეწოდოს პასუხი.
ასე რომ რა float პასუხი აკეთებს.
>> და მაშინ ვიტყვი, რომ შიგნით ამ, თქვენ აპირებს დააყენოს
შედეგი ამ.
ასე, რომ თქვენ ვაპირებთ 1.0 იყოფა 10.0, თქვენ მიიღებთ 0.1, და მაშინ დააყენა
რომ შიგნით პასუხი.
>> LAUREN Carvalho: ასე რომ ერთი ხაზი, ჩვენ ვაცხადებთ და ინიციალიზაციისას ამ float
მოუწოდა პასუხი.
>> LUCAS Freitas: საინტერესოა, რომ მიუხედავად იმისა, ეს არის მხოლოდ ერთი ხაზი, ის აკეთებს
მრავალი ოპერაციებში.
უბრალოდ გზა C გამოშვება თქვენ გამოიყენოს ნაკლები კოდი.
ეს არის იგივე როგორც ternary ოპერატორი, თუ როგორ შეგიძლიათ უბრალოდ
[INAUDIBLE] ერთ ხაზზე.
ის რეალურად აკეთებს იგივე როგორც აკეთებს float პასუხი, მძიმით, და
მაშინ პასუხი უდრის, მაგრამ ნაცვლად რაც თქვენ აკეთებთ ორი ხაზი, რომ,
ეს როგორც მალსახმობი.
ჰო?
>> აუდიტორია: ასე რომ, თუ თქვენ გაიქცა ეს, ეს იქნება 0.10?
>> LUCAS Freitas: დიახ.
ჰო?
>> აუდიტორია: არის უპასუხოს რეალურად კოდი ან უბრალოდ სახელი?
>> LAUREN Carvalho: ეს რეალურად კოდი.
ეს არის, რასაც ჩვენ ვაპირებთ ასახელებს ჩვენი ცვლადი.
>> აუდიტორია: ასე რომ უბრალოდ სახელი [INAUDIBLE].
>> LAUREN Carvalho: ჰო.
მე ვერ განაცხადა float x უდრის 1.0.
>> LUCAS Freitas: საქმე ისაა, რომ სახელი ცვლადის
რაღაც, რომ თქვენ გამოიყენოთ.
მნიშვნელოვანია თქვენთვის.
ფაქტობრივი პროგრამა, ერთადერთი რომ თემა არის ღირებულება, რომ თქვენ
აქვს შიგნით bucket.
მიზეზი, თუ რატომ უნდა ცვლადები და სახელები ცვლადები არის ასე ნეტავ ვიცი
რა თქვენ საქმე, ისევე როგორც რა სახის მონაცემები, თქვენ
წვდომის დროს.
მაგრამ კოდი თავისთავად, თუ რეკავთ მას უპასუხოს, ან კითხვა ან არაფერი,
საკმაოდ ბევრი, არა აქვს მნიშვნელობა.
არ აქვს მნიშვნელობა.
რადგან თქვენ თანმიმდევრული ყველა კლების და ამიტომ თქვენ ეძახით
რაღაც.
ჰო?
>> აუდიტორია: ნუ ცვლადები გასცდება ფუნქცია?
Like თუ თქვენ შექმნათ bracket [INAUDIBLE], შეიძლება თქვენ უბრალოდ
[INAUDIBLE] პასუხზე ერთხელ?
>> LAUREN Carvalho: არა
>> აუდიტორია: [INAUDIBLE]
>> LAUREN Carvalho: არა
ეს იქნება გარეთ ფარგლებში ამ კონკრეტული ცვლადი.
და რეალურად, რომ სახის საინტერესო, რადგან, როდესაც ჩვენ
რამ, როგორიცაა მარყუჟების ან იმ შემთხვევაში, თუ პირობები, თუ განაცხადოს ცვლადი
ფარგლებში კიდევ ერთი კომპლექტი curly აფრთხილებს, ეს მართლაც მხოლოდ არსებობს
ფარგლებში იმ curly აფრთხილებს.
>> აუდიტორია: ერთი ბოლო შენიშვნა შესახებ [INAUDIBLE] მოძრავი.
რატომ ოდესმე გსურთ გამოიყენოთ ints?
ეს არის კიდევ ერთი მინიშნება, ვიდრე არაფერი, მაგრამ თქვენი კომპიუტერი
მნიშვნელოვნად უკეთესი გატარება ints ვიდრე ეს არის დამუშავება მოძრავი.
ეს იგივეა ბრძანებით მასშტაბები სწრაფად.
ასე რომ, თუ ჩვენ უბრალოდ სიფრთხილით მხოლოდ მოძრავი, რამ იქნება ბევრი ნელა.
>> LAUREN Carvalho: სინამდვილეში, როგორც ჩანს, უნდა იყოს პრობლემა მოძრავი.
>> LUCAS Freitas: კეთილი მიზეზი რომ, შეგიძლიათ წარმოიდგინოთ, თუ რამდენად ორობითი
თქვენ შეგიძლიათ წარმოადგენს რიცხვებით გამოსული 0 და 1 ს.
>> LAUREN Carvalho: ეს შემდეგი რამ.
>> LUCAS Freitas: OK.
გასაოცარია.
>> LAUREN Carvalho: Just ფიქრობს, რომ აზრის.
>> LUCAS Freitas: OK, მე გეტყვით მოგვიანებით.
>> LAUREN Carvalho: სანამ არ მივიღებთ იმას, რაც Lucas იყო უბრალოდ ვამბობ, ოპერატორი
უპირატესობა.
ეს არის საღი აზრი.
თქვენ ბიჭები არ კეთდება ეს საკმარისი.
ასე რომ, მხოლოდ იმ შემთხვევაში, თუ რაღაც ფრჩხილებში, ეს მოხდება პირველი.
ეს გამრავლება ხდება უპირატესი მეტი ამისა,
გამოკლება, რამ, როგორიცაა, რომ.
ასე რომ, რეალურად, მხოლოდ ვინმეს გსურთ მითხრათ რა რაოდენობის ერთი რეალურად
აფასებს?
>> აუდიტორია: 27.
>> LAUREN Carvalho: 27?
ჰო.
>> LUCAS Freitas: ნება მომეცით ტკბილეულს ხალხს.
>> LAUREN Carvalho ყველა უფლება.
რაც შეეხება ნომერი ორი?
>> აუდიტორია: 22.
>> LAUREN Carvalho: 22, yeah.
მე არ ვიცი, ვინ მიიღო, რომ.
ნომერი სამი?
>> აუდიტორია: 10.
>> LAUREN Carvalho: 10, დიახ.
ზემოთ.
ასე modulo.
Lucas, თქვენ მინდა განვმარტო modulo?
>> LUCAS Freitas: Modulo ეს ოპერატორი რომ არის რეალურად ძალიან სასარგებლოა
bunch of პრობლემები.
თუ გავაკეთო 55 modulo 10, რას აკეთებს ამ ვთქვათ, რომ მინდა
გავყოთ 55 10.
რა მივიღო?
იგი გრძნობს, ისევე, როგორც, თუ მე რეალურად მხოლოდ აკეთებს გაყოფა, რა არის
პირველად რომ მე მივიღე რიცხვი?
>> აუდიტორია: 5.
>> LUCAS Freitas: 5.
და შემდეგ დარჩენილი 5, არა?
ასე რომ, ეს იგივეა, 5 ჯერ 10 პლუს 5.
ძირითადად, რა modulo აკეთებს, ის ცდილობს გაყავით ეს რაოდენობა ამ ერთი და
ის ხედავს, რა არის დარჩენილი სამმართველოს.
>> LAUREN Carvalho: ასე რომ უბრალოდ დააბრუნებს დარჩენილი.
ასე რომ, ერთი არის რა?
5.
ნომერი ორი?
>> აუდიტორია: 3.
>> LAUREN Carvalho: 3.
ნომერი სამი?
0.
და ოთხი არის 1.
ზუსტად.
>> LUCAS Freitas: მარტივი, არა?
>> LAUREN Carvalho: რატომ არ გვაქვს გამოტოვოთ ეს მხოლოდ იმიტომ, რომ ჩვენ ნამდვილად არ აქვს
დრო და ადამიანი, როგორც ჩანს გასაგებია.
ასე რომ, აქ არის ის, რაც Lucas იყო უბრალოდ ვსაუბრობთ.
>> LUCAS Freitas: კიდევ ერთი მიზეზი, რის გამოც მე გამოიყენებს ints ნაცვლად მოძრავი არის
რომ მოძრავი ძალიან ბუნდოვანი.
და რატომ არიან ისინი არაზუსტი?
დავითმა თქვა, რომ წარმოადგენს მთელი რიცხვი, მაგალითად, ჩვენ ვიყენებთ 0 და
1 ს, არა?
და მაშინ ძირითადად გაკეთება გამრავლება, ყველაფერი იმ
ოპერაციების ვიცი რა ათობითი რიცხვი თქვენ გაქვთ ნაცვლად ორობითი.
>> რა ხდება ახლა, თუ ვცდილობ დააყენოს ათობითი ქულები?
რეალურად, მაგალითად, თუ მაქვს რაოდენობა, როგორიცაა 3,33333?
ეს იგრძნობა 10 3.
როგორ ვარ მე აპირებს შესანახად ყველა 3 ის, რომ მე ამის შემდეგ?
ეს მართლაც რთულია, არა?
თქვენ არ შეგიძლიათ უბრალოდ ვუთხრა კომპიუტერი, hey, მაქვს 3 და
მაშინ გავაკეთოთ, რომ სამუდამოდ.
რეალურად კომპიუტერში არ არის ჭკვიანი საკმარისი ამისათვის.
>> ასე რომ, ძირითადად ყველა თქვენს კომპიუტერში არ არის რომ ცდილობს დააყენა ბევრი ციფრისგან როგორც
მას შეუძლია მდე მეხსიერების რომ თქვენ გაქვთ.
მოდით ვთქვათ, რომ ის აპირებს ამბობენ, 3,3333, და რომ არის ის.
ასე რომ არ შეუძლია რეალურად გამოხატავენ სწორედ რომ float არის.
>> LAUREN Carvalho: ჩვენ გვაქვს სასრული რაოდენობის ბიტი, რაც იმას ნიშნავს, რომ არ არის
ყველა ათობითი რიცხვი იქნება შეუძლია იყოს წარმოდგენილი ზუსტად.
და ა.შ. ამ მაგალითში, თუ ჩვენ დაბეჭდვისას 0.1, ჩვენ ახლა ბეჭდვა
out 20 ადგილებში.
>> LUCAS Freitas: ისევე როგორც მე ვეუბნებოდი თქვენ ბიჭები, თქვენ შეიძლება დააყენოს ნებისმიერი ნომერი.
მაგრამ თუ უბრალოდ გააკეთა ორ ადგილას, ნეტავ კიდევ 0.10, მაგრამ თუ დააყენა 20
ადგილები, ის აპირებს გაჩვენოთ bunch of 's რადგან ეს არის ის, რაც თქვენ შეგიძლიათ განათავსოთ
მეხსიერებაში, არა?
>> მაგრამ სწორედ აქ, დაახლოებით 0, და შემდეგ უბრალოდ განათავსოთ
bunch of შემთხვევითი რიცხვების.
ეს არის სახის მოსწონს რაღაც -
>> LAUREN Carvalho: ეს არის, რადგან ჩვენ ვერ წარმოადგენს ამ ათობითი
სწორედ ნომერი ბიტი გვაქვს.
>> LUCAS Freitas: და შემდეგ კომპიუტერული ძირითადად
გაწვდით trash ნომერი.
ეს არ არის რეალურად ღირებულება ნომერი.
>> აუდიტორია: ეს არის ახლოს როგორც მას შეუძლია მიიღოს [INAUDIBLE]
გამოყენებით [INAUDIBLE].
>> LAUREN Carvalho: So გავლენა ეს არის ის, რომ ვთქვათ, რომ ნაცვლად
მიმდინარეობს 0.100014, რასაც, რა იყო თუ არა 0,0999 -
ასევე, OK.
მოდით ვიტყვი, რომ ფაქტობრივი პასუხი რომ ეს იყო 0,9999999.
რომ ძალიან ახლოს 1, მაგრამ ეს არ არის ზუსტად 1.
ეს 0,99999.
>> ეს იმას ნიშნავს, რომ თუ მე რომ 0,999, მე და განაგდე to int, მივიღებ 0.
მე არ მიიღოს 1.
>> LUCAS Freitas: იმიტომ, რომ მახსოვს, casting საწყისი float to int, თქვენ უბრალოდ
იგნორირება ყველა ათობითი ადგილებში.
უბრალოდ ყურადღებას არ აქცევენ.
არ არსებობს ასეთი რამ, როგორც დამრგვალება ან გაშვებული ქვემოთ, როდესაც თქვენ typecast.
სინამდვილეში, ეს არის ფუნქცია, რომელიც აკეთებს დამრგვალება, რომელიც ძალიან
მნიშვნელოვანია, მაგრამ უბრალოდ ვფიქრობ, რომ როდესაც თქვენ აკეთებთ typecasting, უბრალოდ
აპირებს წაშლა ყველაფერი.
ისე კი, თუ თქვენ გაქვთ 0,99999, ის აპირებს უბრალოდ მისცეს 0 თუ typecast
[INAUDIBLE] რიცხვი.
>> LAUREN Carvalho: ასე რომ იყოს ნამდვილად იცის მცურავი წერტილი სიზუსტით,
განსაკუთრებით მაშინ, როდესაც თქვენ დავიწყოთ გამოყენება მოძრავი Pset1.
მაგრამ გავლა უნდა გაფრთხილებთ, რომ ისევე.
>> LUCAS Freitas: და რეალურად ეს ნამდვილად რთულია, მაგალითად, თუ მე
float პასუხი 1 უდრის 1.0 მეტი 10 და შემდეგ ათწილადი პასუხი 2
შეადგენს 10.0 მეტი 100.0.
ისინი იმავე რაოდენობის, არა?
0.1, არა?
1 10 ან 10 100.
მაგრამ ახლა, თუ ვცდილობ ვხედავ თანასწორობის, მოსწონს თუ პასუხი 1 ტოლია უპასუხოს 2,
იქნებ ეს არ არის რეალურად აპირებს უნდა იყოს იგივე.
ასე რომ, მოძრავი სახის იგრძნობა.
ისინი მოსწონს აკეთებს თანასწორობა.