>> [მუსიკის დაკვრა]
JASON HIRSCHHORN: OK, ყველას.
მოგესალმებით განყოფილება.
ეს არის CS50, ჩვენი პირველი სუპერ მონაკვეთზე.
როგორც იცით, მომავალ კვირაში რეგულარული სექციები დაიწყება,
მაგრამ ამ კვირაში ჩვენ ყველა ერთად.
>> არ არის თავს.
ჩემი სახელი არის ჯეისონ.
მე ლექტორი კომპიუტერული მეცნიერება.
ჩვენ გვყავს Andi, რომელიც არის ხელმძღვანელი TA CS50.
და Scaz, პროფესორი ბრაიან Scassellati, ის პროფესორი კომპიუტერულ მეცნიერებათა.
>> ჩვენ ვართ CS50 ხელმძღვანელები იელის.
თქვენ ყოველთვის შეგიძლიათ მოგვწეროთ ჩვენს heads@cs50.yale.edu.
ჩვენ იქნება ლექციები.
ჩვენ ვიქნებით საათებში.
თუ არსებობს ოდესმე არაფერი შეგვიძლია, თქვენთვის, არაფერი გჭირდებათ,
მოგერიდებათ დაგვიკავშირდნენ.
>> ასე რომ, რასაც ჩვენ ვაპირებთ, რომ დღეს?
ან მაშინ, რა არის ახლოვდება ამ კვირაში?
ასე რომ, სამუშაო საათებია ორშაბათს, სამშაბათს, ოთხშაბათი, ხუთშაბათი, 8:00 11:00.
არსებობს გრაფიკი ვებგვერდზე.
>> განყოფილებები, როგორც ვთქვი, ვიწყებთ მომავალ კვირას.
და თქვენ იპოვით ამ კვირაში რა დრო თქვენი მონაკვეთი, რა დღეში ეს,
და ვინ არიან თქვენი TA არის.
>> პრობლემა Set 1 გამო ხუთშაბათს ზე შუადღისას, პარასკევი შუადღისას ერთად გვიან დღეში.
დიახ, თქვენ გაქვთ ცხრა გვიან დღე.
და არსებობს ცხრა პრობლემა კომპლექტი.
და შეიძლება მხოლოდ ერთი გვიან დღეში პრობლემა კომპლექტი.
დიახ, ფაქტობრივად, ყველა პრობლემა კომპლექტი გამო პარასკევი შუადღისას.
ეს არის ყველა.
ყველა დეტალი on სილაბუსში.
>> ყოველ პარასკევს, ჩვენ გვაქვს სადილების.
ჩვენ გვსურს, რომ ეს დიდი რა თქმა უნდა, თავს ცოტა პატარა.
ასე რომ, თქვენ მივესალმებით RSVP.
უფასო სადილი თანამემამულე თანაკლასელები და პერსონალი.
cs50.yale.edu/rsvp.
>> ეს ყველაფერი, რომ მაქვს ეკრანზე,
და კიდევ, თქვენ შეგიძლიათ იპოვოთ cs50.yale.edu ან cs50.harvard.edu, თუ ჰარვარდის
და თვალს ამ ონლაინ რეჟიმში.
>> ასევე იმ საიტებზე, არ ტონა რესურსების თქვენთვის.
ყოველი მოხსენების აქვს არა მხოლოდ ვიდეო ლექცია, არამედ აღნიშნავს.
ვიღაც უყურებს ლექცია და მიიღოს შენიშვნები თქვენთვის.
ასე რომ, შეგიძლიათ უბრალოდ გადაიხადოს ყურადღება ლექციების დროს,
ან შეგიძლიათ გამოიყენოთ მათი შენიშვნები / ჩვენი აღნიშნავს, რომ შეავსონ საკუთარი შენიშვნები.
>> არსებობს სლაიდები ონლაინ რეჟიმში.
წყარო code-- ყველაფერი დავით მიდის ლექცია,
ან Scaz მიდის ლექცია, რომელიც კოდის ხელმისაწვდომია ონლაინ
ისევე, როგორც, როგორიც მე, აღნიშნული ვიდეო.
>> განყოფილებები, ასევე, იქნება ყველა გადაიღეს.
ყველა იმ სლაიდები იქნება შესაძლებელი.
ყველა რომ კოდექსი ხელმისაწვდომი იქნება თქვენთვის.
არსებობს შორტები ნახვა, სადაც CS50 პერსონალის წევრები ატარებენ ხუთიდან 10
ე წუთზე გადის თემა თქვენთვის.
ზოგიერთი იმ თქვენ უკვე შეექმნა პრობლემა კომპლექტი.
>> სამუშაო საათები, როგორც აღვნიშნე, ორშაბათს მეშვეობით ხუთშაბათს, 8:00 11:00.
CS50 კვლევა არის ფანტასტიკური რესურსი.
არსებობს პრაქტიკის პრობლემები, ნიმუში სლაიდები, ცნობილი შეცდომები
რომ სტუდენტები მინდა აწარმოებს შევიდა, არსებითად ყოველ თემას ჩვენ
დაფარავს ამ კურსს.
>> და ბოლოს, ამ slide მინიმუმ, Reference50
რომელიც გაძლევთ ინფორმაცია ყოველივე C ფუნქციები
თქვენ ოდესმე შესაძლოა იმედი გამოყენება და მრავალი, მრავალი სხვა.
>> კიდევ ერთხელ, რომ dot dot dot ზე ბოლოში ეკრანზე
მიანიშნებს იმაზე, რომ იქ კი მეტი რესურსი ამ ორ ვებ-გვერდი:
cs50.yale.edu, cs50.harvard.edu.
>> ასე რომ, რას ვაკეთებთ დღეს?
ისე, პირველი მე ვაპირებ მისცეს გადავხედავთ რესურსები.
უკვე გააკეთა, რომ ერთი.
შეხედეთ ჩვენთვის.
>> ახლა, ჩვენ ვაპირებთ წავიდეთ მეტი მონაცემთა ტიპები და ოპერატორები C.
მაშინ Andi მოვა აქ და გადასვლა ზე მეტი ბიბლიოთეკების C, printf (),
ფუნქცია, რომელიც თქვენ უკვე ნაცნობი და სწრაფად გახდა ძალიან
ნაცნობი.
და თქვენ ასევე წავიდეთ მეტი პირობით და მარყუჟების.
>> და ბოლოს, Scaz წავა მეტი CS50 ID.
თუ არ dove in უკვე პრობლემა Set 1,
აგრეთვე, თუ როგორ გამოიყენოთ ტერმინალი და სასარგებლო ბრძანებები
და შემდეგ მოგცემთ რამდენიმე demos და პრაქტიკა კოდირება, CS50 ID.
>> სანამ მე მიცემას, რათა ამ შინაარსი ამ მხარეს,
ვინმეს აქვს რაიმე შეკითხვები აქამდე?
შესანიშნავი.
OK.
იცვლება გადაცემის.
>> [იცვლება გადაცემის]
>> ეს იყო ჩემთვის გადასვლის გადაცემის სახელმძღვანელო მანქანა.
ასე რომ, მონაცემთა ტიპები C, თქვენ არ შეგიძლიათ უბრალოდ ცვლადი x და ეს იქნება on line 10,
რიცხვი, შესაძლოა, ნომერი 1, on line 20, ათობითი რიცხვი 10.5,
და შემდეგ რამდენიმე ხაზები შემდეგ სიმებიანი, მე მიყვარს CS50.
>> In C, ცვლადები შეიძლება იყოს მხოლოდ ერთი რამ, და ერთი რამ მხოლოდ.
ასე რომ, თქვენ უნდა მისცეს მათ ტიპის.
და ამ ფორუმში, ჩვენ გვაქვს ჩამონათვალი ტიპის.
არსებობს სიმბოლო, რომელიც დავდგეთ სიმბოლო.
ასე რომ, ერთი წერილი A, B, C, დ ეს შეიძლება იყოს სივრცეში,
ან, რომ შეიძლება ახალი ხაზი ხასიათი.
>> არსებობს რიცხვებით, რომლებიც მხოლოდ ციფრები, მთელი ნომრებზე ან რიცხვებით
rather-- მაგრამ არ decimals.
>> იყიდება მეათედამდე, ჩვენ გვაქვს მცურავი პუნქტიანი ნომრები.
მცურავი პუნქტიანი ნომრები ციფრები, მეათედამდე.
>> მაშინ არსებობს მიისწრაფვის, რომლებიც არსებითად აღარ რიცხვებით.
თქვენ შეამჩნევთ, რომ დიდი ხნის 8 ხოლო int არის 4.
მე კიდევ, რომ მეორე.
ეს იმიტომ, რომ მიისწრაფვის შეგიძლიათ შეინახოთ კი უფრო რიცხვებით, ვიდრე int შეგიძლიათ შეინახოთ.
ორმაგი დიდი ხნის float.
>> და ბოლოს, ჩვენ გვაქვს ტექსტი, რომელიც არის ტიპის
რომ თქვენ ალბათ გამოიყენება ადრე.
თუ თქვენ მოიცავს hashtag # includeCS50.h თქვენს წყარო ფაილი,
მაშინ შეგიძლიათ გამოიყენოთ string ტიპის.
ეს რეალურად არ ჩაშენებული C.
>> არსებობს რამდენიმე სხვა სახის ასევე.
მაგრამ ეს არის ძირითადი პირობა რომელშიც თქვენ უნდა გამოიყენოთ და ექმნებათ.
C რადგან, კიდევ ერთხელ აღვნიშნე, ყველა ცვლადი ეს
შეიძლება იყოს მხოლოდ ერთი ტიპის და ერთი ტიპის მხოლოდ.
ეს იმიტომ, რომ C არის statically აკრეფილი ენის, როგორც ეწინააღმდეგებოდა
დინამიურად აკრეფილი ენაზე სადაც, თუ თქვენ შექმნით ცვლადი
თქვენ შეგიძლიათ შეცვალოთ რა ინახება მას, როგორც თქვენ გადასვლა თქვენს პროგრამას.
მეტი აქ მარჯვენა მხარე, მაქვს სხვადასხვა ზომის
ამ ტიპის მონაცემების ბაიტი.
ასე რომ ხასიათი არის 1 ბაიტი.
ეს არის 8 ბიტი.
ეს იმას ნიშნავს, რადგან 8 ბიტი იქ რვა 0S და 1s.
ჩვენ ვნახეთ იმ demos პირველი კვირას, რომ ორობითი ნათურებით.
>> 8 ბიტი ან 1 byte, ჩვენ შეგვიძლია წარმოადგენს ნომრები 0 255.
უფლება.
თუ ყველა 8 ბიტი 0 ეს არის 0.
თუ პირველი ცოტა 1, რომ ნომერი ერთ-ერთი, და ასე შემდეგ, ყველა გზა მდე 255.
ამიტომაც არის, რომ გმირები თქვენ შეგიძლიათ არსებითად მდე 255 მათგანი,
მაგრამ, რომ უამრავი დაფარავს ყველა გმირები ჩვენ უნდა გამოვიყენოთ.
>> მთელი რიცხვები, შეგიძლიათ 0 და მაშინ თქვენ გაქვთ 2 დან 32 მინუს 1.
ეს არის, თუ რამდენი ვარიანტი თქვენ გაქვთ რიცხვებით.
>> დიდი ხნის, თქვენ გაქვთ 0 2 დან 64 მინუს 1.
ასე, რომ თქვენ ბევრი, ბევრი, დამატებითი პარამეტრები მიისწრაფვის.
>> Strings, რომ კითხვის ნიშნის იმიტომ რომ cliffhanger მოგვიანებით.
ჰო.
მე ვერ გეტყვით ყველას ზღვარზე მათი ადგილს,
როგორც ის, რაც არის, რომ კითხვის ნიშნის?
ეს არის cliffhanger.
ჩვენ საბოლოოდ მოიცავს ზომა სტრიქონები და გაიგო მეტი სიმები.
იმის გამო, რომ string ფაქტიურად ერთი სასწავლო დისკები
ჩვენ შესახებ ამ რა თქმა უნდა, დასაწყისში
და შემდეგ მიიღოს off შემდეგ , იმიტომ, რომ სტრიქონები C
რეალურად პოინტერები ხასიათი მასივები.
თუმცა ისევ და ისევ, ეს არის ქლიფჰანგერი მოგვიანებით.
სანამ გადავა რაიმე შეკითხვები, კომენტარი, შეშფოთება ამ slide?
>> OK.
მე უნდა ფანტასტიკური explainer.
გარდა ამისა, როდესაც თქვენ პროგრამირების, თქვენ აპირებს გამოიყენოს ეს ოპერატორები.
მართლაც მარტივი ნიშნები, რომ შეგიძლიათ გააკეთოთ მარტივი ოპერაციების, რომელიც თქვენ ალბათ
უკვე ძალიან ნაცნობი.
>> მაგალითად, მარჯვენა მხარეს, ჩვენ ვხედავთ, დაამატოთ.
იმისათვის, რომ დაამატოთ, თქვენ უბრალოდ პლუს ნიშანი.
ასე რომ, ალბათ ორი ცვლადის x და y.
თქვენ შეგიძლიათ ამის x + y თქვენს კოდი.
იქნებ გსურთ, რომელთა მიზანია: ამბობენ, რომ თქვენ აქვს 7 ნომერი და 3,
გსურთ, რომ შესანახად ცვლადში თანხა.
თქვენ შეგიძლიათ ამის გაკეთება int ტიპის, სივრცე ამგვარად, ცვლადის სახელი, = 7 + 3;
>> რა იქნებოდა, რომ მაღაზიის თანხა?
ვინმე?
თუ მქონდა თანხა = 7 + 3.
რა იქნება შენახული თანხა?
შეგიძლიათ უბრალოდ ყვირილი ის.
აუდიტორია: 10.
>> JASON HIRSCHHORN: 10!
ეს არის სწორედ.
რაც შეეხება თანხის = 7 - 3, მე უბრალოდ გამოიყენოთ, რომ ტირე ნიშანი.
რა იქნება შენახული?
აუდიტორია: 4.
JASON HIRSCHHORN: 4.
თანხა, ალბათ, არასწორი სახელი რომ ცვლადი, მაგრამ 4 იქნება შენახული.
>> გამრავლების C, გამოიყენოთ პატარა Star ხასიათი, არ გამოიყენოთ x.
დაყოფა, გამოიყენოთ Forward Slash არ გაყოფის სიმბოლოდ.
და modulo, გამოიყენოთ პროცენტი სიმბოლო.
>> ასე ვთქვათ, მე მინდა, რომ int z = 7% 3, რა იქნება შენახული z?
ასე რომ, არსებითად ეკითხება რას modulo გავაკეთოთ?
ვინმემ იცის რა modulo აკეთებს?
ჰო.
y 4.
დინამიკები 1: ეს არის დარჩენილი.
JASON HIRSCHHORN: ეს არის დანარჩენი როცა თქვენ დაყოფის.
ასე რომ, 7 გაყოფილი 3 2 დარჩენილი 1.
ასე რომ, 1 იქნება შენახული.
>> თქვენ გააკეთა გამოკლება, მაგრამ ეს როგორ მუშაობს.
ეს არის ის, რაც modulo ოპერატორი აკეთებს.
იგი იღებს ნომერი ყოფს მას მეორე ნომერი და დაბრუნდა თქვენ
დარჩენილი.
ასე რომ კიდევ ერთხელ, 7% 3 გაძლევთ 1, იმიტომ, რომ 7 გაყოფილი 3 2 დარჩენილი 1,
და დააბრუნებს დარჩენილი.
>> რაც შეეხება მოდით დავუბრუნდეთ up ერთი ნაბიჯი, რომ სამმართველოს ნიშანი.
თუ მე 7 / იყოფა 3 ჯერ ვინმემ იცის რა, რომ დაბრუნდეს?
>> დინამიკები 2: 2.
>> JASON HIRSCHHORN: რატომ 2 და არა 2,333?
>> დინამიკები 2: მე ვფიქრობ, რომ ის წყვეტს შემდეგ, მთელი რიგი.
JASON HIRSCHHORN: ასე რომ ის, სწორედ.
In C, თუ თქვენ სამმართველოს ორი რიცხვებით 7 იყოფა 3,
იგი იღებს პასუხს, რომელიც ამ შემთხვევაში 2,3333 სამუდამოდ
და აღმოაჩენს, რომ ათობითი წერტილი და chops ყველაფერი off შემდეგ ათობითი
და ეს მხოლოდ ბრუნდება თქვენ 2.
>> ასე რომ, თუ მე 8 გაყოფილი 3-ზე.
რომ რეალურად, ჩვენ ვიცით, რომ დაბრუნდნენ 2,666,
მაგრამ ეს chops ყველაფერი გამორთვას ათწილადის truncates ეს ყველაფერი,
და მხოლოდ დააბრუნებს თქვენ 2.
ასე რომ, 6 იყოფა 3, 7 გაყოფილი 3, 8 იყოფა 3,
ყველა დაბრუნებას აპირებს თუ არა 2.
>> ვინმემ იცის, ან უნდა ვხვდები, ის, თუ როგორ შემეძლო რეალურად მიიღონ
სრული პასუხი, თუ მინდა, რომ ათობითი?
ჰო.
წავიდეთ წინ.
დინამიკები 3: გამოიყენეთ float?
JASON HIRSCHHORN: რას ნიშნავს?
დინამიკები 3: იმის გამო, რომ განაცხადა, float არის ნომრები [INAUDIBLE]
JASON HIRSCHHORN: მარჯვენა.
ასე რომ, სწორედ.
7 არის მთელი რიცხვი.
მაგრამ თუ მინდოდა იქცეს, რომ შევიდა მცურავი პუნქტიანი ნომერი,
მე არ შესანახად, რომ როგორც 7.0, რადგან კომპიუტერის
მართლაც stupid-- ჩვენ ვნახეთ, რომ ერთად PB და J მაგალითად
ეს მხოლოდ ზუსტად რას გეტყვით იგი.
>> ასე რომ, თუ თქვენ წერთ 7, ვფიქრობ, რომ ეს რიცხვი.
თუ წერთ 7.0, მიუხედავად იმისა, რომ ჩვენ ვიცი, ის, რაც ექვივალენტურია,
ეპყრობა, რომ როგორც მცურავი პუნქტიანი ნომერი.
ასე რომ, თუ თქვენ არ 7.0 იყოფა 3, ან იყოფა 3.0,
რომ ვთქვა, OK, ახლა ჩვენ საქმე მოძრავი.
დავბრუნდები თქვენ 2.333333 სამუდამოდ.
მაგრამ ნამდვილად არ სამუდამოდ, რადგან როგორც დავინახეთ, ასევე ლექცია,
ამ მცურავი პუნქტიანი ნომრები არ არის ზუსტად ზუსტი.
>> ასე რომ, თუ გვინდა, რომ ათობითი, ან მისი ნაწილი, რომელიც ათობითი,
მაშინ თქვენ უნდა გამოიყენოს ერთ-ერთი მათგანი უნდა იყოს მცურავი პუნქტიანი ნომერი
კომპიუტერი და უნდა გვესმოდეს, რომ ეს არის მცურავი წერტილი თქვენ
საქმე, არ არის მთელი რიცხვი.
ნებისმიერი კითხვები რომ მაგიდა, მარჯვენა მხარეს, ჯერჯერობით?
ან მარცხენა მხარეს, თქვენი მარცხენა, მარცხენა მხარეს.
ჰო.
დინამიკები 4: მარჯვენა.
ისევე როგორც რეგულარული რიცხვებით, თქვენ აკეთებთ
ჩაწერის, რომ თქვენ უნდა დაწეროთ float?
>> JASON HIRSCHHORN: ჰო ასე.
ისე, თუ გვინდა, რომ შევქმნათ ცვლადი რომ float,
თქვენ უნდა ვთქვა, float z უდრის რაღაც.
>> დინამიკები 4: OK.
>> JASON HIRSCHHORN: მაგრამ თუ მინდოდა ამის 7 გაყოფილი 3 და მიიღოს, რომ ათობითი,
მე ყველაფერს გააკეთებს, float z = 7.0 / 3.0; და რომ მომეცი მცურავი წერტილი
ნომერი.
>> დინამიკები 4: OK.
>> JASON HIRSCHHORN: თუ მე რაღაც int z = 7/3,
რომ მომეცი რიცხვი, იმიტომ, რომ ეს არის ყველა რიცხვებით.
არა, რომ აზრი?
>> დინამიკები 4: დიახ.
>> JASON HIRSCHHORN: OK.
შესანიშნავი.
ნებისმიერი სხვა კითხვები იმის შესახებ, რომ მაგიდასთან?
მართლა?
მე ასე აღელვებს.
OK.
>> ასე რომ, სხვა რამ უნდა გამოიყენოთ, ხშირად პირობებში და მარყუჟების,
არიან ამ ტიპის operators-- ამ ტიპის ლოგიკური გამონათქვამები.
და როგორც გავიგეთ, == არის ის, რაც თქვენ გამოიყენოთ შემოწმება, თუ ორი რამ არის თანაბარი.
>> ასე რომ, აქ მე შემოწმების თუ x == y, მოდით ერთხელ ვივარაუდოთ, რომ x 7 და y არის 3.
ასე რომ, თუ მე დავწერე 7 == 3, თუ რა იქნებოდა, რომ დამიბრუნდება?
ის არის, რომ ჭეშმარიტი ან მცდარი?
>> აუდიტორია: ყალბი.
JASON HIRSCHHORN: OK.
მე ვგრძნობ, რომ ყველას შეუძლია ამ ერთ.
ასე რომ ყველას, რა იქნებოდა, რომ დაბრუნდეს?
აუდიტორია: ყალბი.
JASON HIRSCHHORN: ყალბი.
შესანიშნავი.
7 არ უდრის 3.
ასე რომ, 7 == 3 დაბრუნდნენ ყალბი.
თქვენ გაქვთ არ თანაბარი ნიშანი, ასე რომ, თუ მე შეამოწმეს 7! = 3, რა იქნებოდა, რომ დაბრუნდეს?
აუდიტორია: ჭეშმარიტი.
JASON HIRSCHHORN: ჭეშმარიტი.
შესანიშნავი.
ვიღაცას ძალიან დაბეჯითებით უკან და აფასებენ.
მაშინ თქვენ გაქვთ ნაკლები ოპერატორი, ნაკლები ან ტოლია ოპერატორი,
უფრო მეტი, ვიდრე ოპერატორი, დიდი მეტი ან ტოლია ოპერატორი.
>> ასე რომ, კიდევ ერთი საღი აზრის ქვითარი.
თუ მე 7 დიდი მეტი ან ტოლია 3.
რა, რომ დაბრუნდეს?
>> აუდიტორია: ჭეშმარიტი.
JASON HIRSCHHORN: ჭეშმარიტი.
დიახ.
ეს უკან ოთახი, უკანა მხარეს ოთახი, ფანტასტიური.
თქვენ შეგიძლიათ დააკავშიროთ ამ გამონათქვამები თუ გნებავთ, ასევე,
ლოგიკური და რომელიც && ან ლოგიკური ან რომელიც ||
||.
ასე რომ, ახლა თქვენ შეგიძლიათ შეამოწმოთ ორი რამ together-- არის, რომ სასაცილოა?
რატომ არის, რომ სასაცილოა?
>> ასე რომ, თუ მინდოდა, შემიძლია ვთქვა, არის 7 უფრო მეტი, ვიდრე 3 და 2 4-ზე ნაკლებია?
ისე, თუ 7 დიდი 3-ზე, რომ მართალია.
2 4-ზე ნაკლებია, რომ მართალია.
ასე რომ, ეს მთელი რამ დაბრუნდნენ მართალია.
>> თუ მე გამოცდილი 7 აღემატება 3 and-- მე უბრალოდ კრეფა შემთხვევითი ნომრები აქ
4 2 დღეზე ნაკლები, ისე, რომ ეს სიცრუეა.
ასე რომ, ჭეშმარიტი და ცრუ ცრუ.
და თქვენ შეგიძლიათ წასვლა და აერთიანებს როგორც ბევრი პირობები ერთად, როგორც თქვენ გსურთ.
>> ვინმეს გაქვთ რაიმე შეკითხვები, კომენტარი, შეშფოთება ჯერჯერობით?
და მე ვხედავ ზოგიერთ თქვენგანს აღების სურათები ჩემთვის ეკრანზე, რომელიც მე ვაფასებ.
იმედია, ეს არ აპლიკაციით.
იმედია, ეს თქვენი შენიშვნები.
მაგრამ ყველა ამ ვაპირებთ ხელმისაწვდომი იქნება ონლაინ რეჟიმში.
ასე, რომ თქვენ არ უნდა ვახდენთ ამ.
როგორც ვთქვი, ყველაფერი ხელმისაწვდომი იქნება ონლაინ თქვენთვის.
OK.
მე უნდა მიიღოს offstage, ასე რომ ვინმეს
მინდა ვთქვა, რომ არაფერი სანამ ეს მოხდება?
კითხვები?
>> [INTERPOSING ხმები]
>> JASON HIRSCHHORN: Oh, შეწყვიტოს.
თქვენ ბიჭები არიან ძალიან ლამაზი.
OK.
მე ვაპირებ, რომ მონიშნო out.
მოდით წავიდეთ.
>> Andi Peng: ჩვენ ვაპირებთ, რომ უხერხულ mic ცვლილება ახლა.
>> JASON HIRSCHHORN: მე ვარ ვაპირებ ამ off.
Andi Peng: ვაფასებთ იმ მხარდაჭერას, ბიჭები.
გესმით მე?
კარგია?
სრულყოფილი.
ლამაზი.
ნება მომეცით სთავაზობდნენ, რომ.
OK.
ასე რომ, მე უნდა გააკეთოს, როგორც გიგანტური ინფორმაცია ნაგავსაყრელი, თქვენ ბიჭები ახლა.
და არ აწუხებს განაწილებაზე თუ თქვენ არ შემდეგ ყველა პატარა ხაზი, რაც
მე უნდა გაჩვენოთ.
როგორც ჯეისონ თქმით, ყველაფერი სრულიად ონლაინ რეჟიმში.
უბრალოდ, ჩვენ ვაპირებთ, რომ ცდილობენ დანერგვა ყველას ცნებები დაფარული
ზოგიერთი სლაიდები.
ასე რომ, უბრალოდ მიყევით ერთად.
არ აწუხებს, თუ თქვენ არ იცით, თუ ყველაფერი; თუმცა, თუ ნებისმიერ წერტილში
გრძნობთ დაკარგა, დააყენოს თქვენი მხრივ, ჩვენ შეწყვიტოს, არ აწუხებს.
ზემოთ.
>> ასე რომ, მე ვფიქრობ, რომ ის, რაც დავით აქვს უკვე სახის აღნიშნა ლექციების
და ჯეისონ სახის გააკეთა მინიშნება დღეს არის ის, რაც ბიბლიოთეკა.
ასე რომ, პროგრამირება, ჩვენ გვაქვს ეს რამ მოუწოდა ბიბლიოთეკები.
სად, არსებითად, ყველა ისინი მხოლოდ კომპლექტი
ფუნქციები, რომელიც არის არსებითად მხოლოდ კოდი, რომელიც
უკვე დაწერილი სხვისი რომ ჩვენ შეგვიძლია ყველა
გამოყენება ჩვენს პროგრამებს.
>> ასე როგორ ნორმალური ბიბლიოთეკის სამუშაო, არა?
გადიხარ ბიბლიოთეკის კარი.
თქვენ გაქვთ ყველა ამ წიგნები შეგიძლიათ გაიყვანოს
და თქვენ შეგიძლიათ თქვათ ინფორმაცია ფარგლებში იმ წიგნებს.
იგივე პროგრამირებაში.
>> თქვენ გაქვთ ბიბლიოთეკა, რომელიც უკვე უკვე დაწერილი სხვა ადამიანი.
და ისე, რომ თქვენ შეგიძლიათ, როგორც პროგრამისტი ან სტუდენტი,
შეუძლია მოიპოვოს წვდომა ბიბლიოთეკაში მეშვეობით hashtag მოიცავს.
>> მაგალითად, C ჩვენ აქვს სამი, C ყველაზე
ხშირად გამოყენებული სამი C სტანდარტული ბიბლიოთეკების შემავალი / გამომავალი ბიბლიოთეკა,
სიმებიანი ბიბლიოთეკა, და მათემატიკის ბიბლიოთეკაში.
>> ასე რომ, თქვენი პირველი რამდენიმე პრობლემა კომპლექტი,
ეს იქნება სამ რომ თქვენ პირველ რიგში გამოყენებით.
ასე რომ, როგორც დავით უკვე განმარტა, ლექცია,
სტანდარტული I / O ბიბლიოთეკა, ან სტანდარტული input / output ბიბლიოთეკა
ზუსტად რომ.
ეს გაძლევთ საშუალებას, თქვენი კოდი, შეყვანის არაფერი შესახებ და გამომავალი რომ
ეკრანზე, არსებითად დაბეჭდვის მას ეკრანზე.
>> ასე რომ, როდესაც თქვენ გამოიყენოთ რომელიმე ფუნქცია, მაგალითად ფუნქცია printf (), რომელიც
ჩვენ ვაპირებთ წასვლა მომდევნო slide, დარწმუნდით, რომ მოიცავს სტანდარტული I / O
ბიბლიოთეკა ანდა თქვენ არ ვაპირებთ შეძლებს გამოიყენოს printf () ფუნქცია.
იმიტომ, რომ თქვენ, როგორც პროგრამისტი არასოდეს რეალურად წერდა, რომ ფუნქცია,
თქვენ მხოლოდ გამოყენებით ვინმეს სხვისი კოდი თქვენი საკუთარი კოდი.
>> აკეთებს, რომ აზრი ყველას?
ზემოთ.
>> და მაშინ ჩვენ არსებითად მისაღებად გადატანა string.h ბიბლიოთეკა და math.h
ბიბლიოთეკა, თ უბრალოდ ნიშნავს, ბიბლიოთეკა, სხვა ბიბლიოთეკების, რომ თქვენ საბოლოოდ
გამოყენებით თქვენი კოდი.
>> თუმცა, იმ მიზნით, ამ ბიბლიოთეკაში, ასევე
ფლობის ამ კლასის ჩვენ ასევე გვაქვს რა ჰქვია CS50 ბიბლიოთეკა,
cs50.h, სადაც ჩვენ, თქვენი perusal შექმნეს
ბევრი მნიშვნელოვანი და სასარგებლო ფუნქციები.
ასე, რომ თქვენ, როგორც პროგრამისტი შეიძლება ირიბად off
ის, რაც ჩვენ უკვე დაწერილი ისე, რომ ამ ფუნქციის თქვენთვის ხელმისაწვდომი
თქვენი გამოყენება.
>> მე ვიქნები საფარი რამდენიმე ფუნქციები გამოიყენება,
მაგრამ ვიცი, რომ ეს არის ყველა googleable ონლაინ რეჟიმში.
შეგიძლიათ, დახევის up CS50 ბიბლიოთეკა და მაშინ აქვს ყველა ფუნქცია არსებობს.
ჰო.
>> დინამიკები 5: ასე რომ, თუ არ იყო გამოყენებით პროგრამული უზრუნველყოფა, რომელიც
იმ პირობით, რომ ჩვენს მიერ კლასი, იმას, რომ
ნიშნავს, რომ ჩვენ გვინდა უნდა ჩამოტვირთოთ და იპოვოს ამ header ფაილი თავს და ვუთხრა
კომპიუტერი, სადაც ეს არის?
>> Andi Peng: დიდი კითხვა.
ზუსტად.
ასე რომ, თუ თქვენ არ ფიზიკურად ესწრებოდა ბიბლიოთეკა,
არ არსებობს გზა, რომ თქვენ რეალურად წასვლა და წვდომის იგი.
ასე რომ, იგივე პროგრამირების C, თქვენ
უნდა დავრწმუნდეთ, რომ თქვენ იყენებთ ჩვენი ელექტრო რადგან ბიბლიოთეკაში უკვე
უკვე ნაწილად იგი.
და მაშინ, როდესაც თქვენ ჰეშტეგი მოიცავს, ბიბლიოთეკის არსებობს.
ჰო.
კარგი კითხვაა.
ყველას კარგი?
ზემოთ.
ყველა უფლება.
ამიტომ, ჩვენ ვაპირებთ, რომ მოხვდა, არსებითად, რა არის
პირველი ფუნქცია, რომელიც ჩვენ, როგორც პროგრამისტები
უნდა გამოყენებით ჩვენს კოდი.
ეს ეწოდება printf () ფუნქცია.
ასე რომ, printf () ფუნქცია, როგორც მე უკვე განაცხადა, რომ ბოლო slide,
შედის სტანდარტული I / O, სტანდარტული input / output, ბიბლიოთეკა.
>> ასე რომ დარწმუნდით, რასაც თქვენ using-- ოჰ, ნება მომეცით დაიბრუნოს ლაზერული მაჩვენებელი
როდესაც თქვენ იყენებთ რომ printf () ფუნქცია,
თქვენ უნდა შეიცავდეს სტანდარტული I / O ბიბლიოთეკა და სხვა, როდესაც თქვენ შედგენის,
თქვენ აპირებთ მისაღებად შეცდომა რადგან კომპიუტერის იქნება,
oh მე არ ვიცი სად printf () არის, თქვენ არ მეუბნებოდა, სადაც printf ()
არის.
ისე printf () შედის სტანდარტული I / O, ასე რომ, როდესაც თქვენ გამოიყენოს printf (),
დარწმუნდით, რომ აქვს ხაზის ზემოთ თქვენი კოდი.
>> ასე მაგალითად, printf () აქ არის ფუნქცია.
ყველა ეს იმას არის ბეჭდვის რაღაც შიგნით ფრჩხილებში შესახებ.
არავის სურს, რომ მიიღოს stab რა ეს ხაზი კოდი მარჯვენა
აქ აპირებს ამობეჭდოთ?
აქედან გამომდინარე, პასუხი არის ეკრანზე.
ვინმე?
>> VERDI: ქვედა.
>> Andi Peng: ვერდის, რატომ არ წავიდეთ წინ და აცხადებენ, რომ მთელი განცხადებას?
>> VERDI: Hello, ჩემი სახელია Andi, და მე ვარ 20 წლის.
Andi Peng: Ah, ლამაზი.
ასე რომ, ამ ხაზის ჩვენ ვაპირებთ ბეჭდვა, Hello, ჩემი სახელია Andi,
და მე 20 წლის ვარ, რომელიც სინამდვილეში ჭეშმარიტი განცხადებაში.
>> სინტაქსი.
ასე რომ, ორი სინტაქსური საკითხებზე, რომ თქვენ ბიჭები გვინდა დავრწმუნდეთ, თქვენ იცით.
შეთავაზებები.
ორმაგი შეთავაზებები ვუთხრა კომპიუტერული რომ ყველაფერი
აპირებს დაიბეჭდება.
>> ყველაფერი შიგნით can მხოლოდ იყოს ზუსტად როგორ
თქვენ აკრიფეთ, გარდა საყოველთაოდ ბოლოს,
ჩვენ ვაპირებთ, რომ გსურთ მოიცავს hash-- oh ბოდიში ტირე n.
ასე რომ, მისთვის n.
>> ვინმეს სურს მიიღოს ვხვდები რა, რომ ასეა ჩვენს კოდი?
ჰო.
დინამიკები 6: აყენებს მას ახალი ხაზი.
Andi Peng: ზუსტად.
ასე რომ, ყველა ეს არ არის საშუალებას რაც არ უნდა მოხდეს
ამის შემდეგ, ამ განცხადების შემდეგ, დაიბეჭდება ახალი ხაზი.
ასე რომ, როდესაც თქვენ წერილობით თქვენი კოდი არ შემთხვევით აქვს რამ
tacked წლის ბოლომდე რომ თქვენ არ გსურთ.
ეს ყველაფერი იღებს neatly დაბეჭდილი ერთი ხაზი
და მაშინ ჩვენ დაიწყება შემდეგ ხაზი.
>> ვინმეს გახსოვთ რა, რომ მძიმით აკეთებს, როდესაც ჩვენ კოდირების?
ჰო.
>> დინამიკები 7: განცხადება.
>> Andi Peng: ბოდიში?
>> დინამიკები 7: იგი დასრულდება განცხადებას?
>> Andi Peng: ჰო.
ასე რომ, C, ან რაიმე პროგრამირების ენის, მძიმით
აღნიშნავს ბოლოს პროგრამირების ონლაინ.
ასე მაგალითად, ინგლისურ ვიყენებთ ვადა სათქმელია, რა ეს არის ბოლომდე სასჯელს.
პროგრამირებაში, იგივე, ჩვენ გვაქვს მძიმით აღინიშნოს ბოლოს ხაზი.
ხშირად, როდესაც თქვენ დაწყებული პროგრამა,
თქვენ გააცნობიეროს, რომ თქვენ დაგვავიწყდეს, რომ დაამატოთ მძიმით
და მაშინ ცდილობენ აწარმოებს თქვენი კოდი და ეს არ იმუშავებს.
და თქვენ როგორც ეჰა, მე არ ვიცი, რატომ, ეს უნდა მუშაობა.
>> შანსი თქვენ, ალბათ დაავიწყდა მძიმით ან bracket ან რამე
სადღაც.
ასე რომ, მნიშვნელოვანია გვახსოვდეს.
ზემოთ.
ყველა უფლება, შოუ ხელში, როგორ ბევრი ადამიანი აქ ოდესმე
მიღებული AP კომპიუტერულ მეცნიერებათა ან პროგრამირდება Java ადრე, ოდესმე?
OK.
საყვარელი.
ეს არ იქნება გამოყენებული მაშინ, მაგრამ Java, თქვენ
აქვს რაღაც მოუწოდა System.out.println რომელიც არ არსებობს C.
>> ასე რომ, C, როდესაც თქვენ გსურთ დაამატოთ ცვლადები
შევიდა არაფერი გსურთ ამობეჭდოთ, არსებობს
კონკრეტული სინტაქსის ჩვენ ვაპირებთ გამოვიყენოთ.
რომ ე.წ. placeholding-- არსებითად
ჩვენ დაამატოთ placeholders ადგილი მთელი რიცხვი ან ცვლადი
ჩვენ გვინდა, რომ ბეჭდვა.
>> ასე რომ, როგორც თქვენ ბიჭები ვხედავთ ჩვენ შედის ახალი ბიბლიოთეკა header ფაილი აქ.
CS50 ბიბლიოთეკა.
და შეიცავს, რომ CS50 ბიბლიოთეკა არის საერთო ფუნქცია ჩვენ უნდა გამოყენებით
ჩვენი რა თქმა უნდა მოუწოდა GetInt ().
>> ვინმეს სურს მიიღოს stab at რა GetInt () შესაძლოა იყოს აკეთებს.
>> აუდიტორია: [INAUDIBLE]
>> Andi Peng: ბოდიში.
ვერ მოისმენს თქვენ.
Maddie, არავის.
Maddie: ოჰ, ეს მოთხოვნა თქვენ რიცხვი.
Andi Peng: ზუსტად.
ასე რომ, ეს ფუნქცია, სხვა ფუნქცია, რომელიც უკვე
უკვე დაწერილი სხვისი რომ ჩვენ შეგვიძლია მოვუწოდებთ ახლა.
ყველა ის არის შეეკითხება თქვენ, შესახებ, შეყვანის რაც გაგიხარდებათ, როგორც კოდი
მიმდინარეობს და იგი ინახავს whatever-- ამ შემთხვევაში ჩვენ GetInt () - ing,
ასე რომ, ეს ნიშნავს, რომ ჩვენ მოპოვების რიცხვი.
>> და ჩვენ ვაპირებთ შესანახად რომ კიდევ ერთი რიცხვი
რომ ჩვენ უბრალოდ გააკეთა მოუწოდა ასაკში.
რომ აზრი, რომ ყველას?
ზემოთ.
>> ასე რომ, ახლა რომ ჩვენ ინახება ეს რიცხვი, რომ ჩვენ აიძულა შესახებ,
ამ ცვლადი, ჩვენ ის ტიპის int მოუწოდა ასაკის,
ჩვენ შეგვიძლია წავიდეთ წინ და ადგილი რომ ჩვენი printf () ფუნქცია.
ასე რომ, სინტაქსი, როგორც წესი, printf () არის რომ იქ, სადაც თქვენი ფიზიკური
ონლაინ გსურთ მოიცავს, რომ რიცხვი, თქვენ, რომ სიმბოლო უფლება არსებობს,
პროცენტი სიმბოლო, ერთად ტიპის ცვლადი, რომელიც გსურთ.
>> ასე რომ, ამ შემთხვევაში, ასაკის არის მთელი რიცხვი.
ასე, რომ თქვენ აპირებთ მოიცავს % i იმიტომ, რომ ეს რიცხვი.
და შემდეგ თქვენი განაცხადი, თქვენ აპირებს
უნდა გავაკეთოთ მძიმით და ასახელებს ცვლადი.
>> ასე რომ, ჩვენ ვაპირებთ ბეჭდვა გარეთ, Hello, ჩემი სახელია Andi,
და მე ცარიელი წლის.
Hashta-- ან, ბოდიში, ასაკი რასაც მე შეყვანა.
ასე რომ, თუ მე უნდა შეყვანის 20 ჩემი GetInt () აქ,
ეს იქნებოდა ამობეჭდოთ ზუსტად იგივე რამ.
მაგრამ, თუ მინდოდა შეყვანის რაღაც სხვა, ისევე როგორც ალბათ 40 ან 45,
მაშინ თქვენ დაინახავთ, რომ აისახება შესაბამისად, კოდი.
>> ასე რომ, ეს არის მაგალითი რაღაც, რომელიც
იგი ბეჭდავს out და გამოიყურება თქვენ თითქოს ეს იგივე,
მაგრამ ქვეშ hood კომპიუტერული იქ რეალურად
ძალიან განსხვავებული რამ ხდება.
ზემოთ.
ყველა უფლება.
ასე რომ, თუ ჩვენ გვინდა, მრავალი ცვლადის?
საკმაოდ მარტივია.
იგივე.
ჩვენ ასევე გვაქვს ახალი ფუნქცია აქ მოუწოდა GetString (),
ასევე შედის CS50 ბიბლიოთეკა, რომ ყველა ის არ არის უბიძგონ შესახებ
სიმებიანი, რომელიც მხოლოდ კომპლექტი გმირები,
ისე, როგორც სასჯელის ან მსგავსი სახელი.
>> ასე რომ, ამ შემთხვევაში, ჩვენ გვაქვს ორი placeholders% s სიმებიანი და% i
ამისთვის მთელი რიცხვი.
და ჩვენ ვაპირებთ, რომ დაიცვას რომ ორი ცვლადის
ჩვენ გვინდა, მათ შორის, იმ მიზნით, მათ, როგორც ჩანს, რომელიც სასჯელს.
ასე მაგალითად, ჩემი სახელი არის ცარიელი, მინდა სახელი არ არსებობს,
ასე რომ, მე ვაპირებ აქვს სახელი პირველი.
და მაშინ ამის შემდეგ, მე მინდა, ასაკი, მინდა, რომ ასაკის მეორე.
ასე რომ, თუ მინდოდა input, Hello, ჩემი სახელის Andi, და მე ვარ 20 წლის.
თუ მე inputted Andi და 20 ზუსტად იგივე რამ იქნებოდა ბეჭდვა;
თუმცა, ახლა ჩვენ გვაქვს ორი ინახება ცვლადი სახელი, ისევე როგორც int.
ჰო.
>> დინამიკები 8: უნდა იყოს შეუძლია აწარმოებს თუ შეცვალა
სახელი და ასაკი დასასრულს რომ?
>> Andi Peng: ჰო.
ეს არის კარგი კითხვა.
ასე რომ, მოკლედ, არ არსებობს.
იმის გამო, რომ სახელი და age-- რა ტიპის ცვლადი სახელი?
>> დინამიკები 8: String.
>> Andi Peng: რა ტიპის ცვლადი ასაკში?
>> დინამიკები 8: მთელი.
Andi Peng: ასე რომ, აქ ჩვენ გვაქვს placeholder სიმებიანი და რიცხვი, არა?
ასე რომ, თუ თქვენ უნდა გადავიდეს ეს ყველაფერი, კომპიუტერული არ აპირებს ვიცი.
ის აპირებს შემოწმება სიმებიანი, და თუ ცდილობენ, რათა ეს int,
ეს იქნება, როგორც დაველოდოთ მე ვარ დაბნეული, თქვენ
მითხრა, მე უნდა გამოყოფის მეხსიერების int.
და სწორედ აქ, როდესაც იგი იმედოვნებს, რიცხვი
და თქვენ ეს სახელი და სიმებიანი ნაცვლად,
ის ასევე იქნება ძალიან გაუგებარია, ის არ აწარმოებს ზუსტად ისე, როგორც თქვენ სჭირდება.
ასე რომ, აქ, დასახელებისგან და სინტაქსი არის ძალიან მნიშვნელოვანია გაშვებული კოდი.
ყველას კარგი?
ჰო.
Maddie.
>> Maddie აქ, მე ვიცი, ჩვენ ჩანდა განთავსებულია მაგალითები კლასში, სადაც ისინი ითხოვენ
რა არის თქვენი ასაკი, რა არის შენი სახელი.
აქ, უნდა იყოს, რომ ეს doesn't-- თუ ჩვენ უნდა აწარმოებს ამ კოდი,
ის არ ითხოვენ, რომ?
მაგრამ თქვენ უბრალოდ შეყვანის ორი ნომრები და მაშინ აწარმოებს, რომ?
>> Andi Peng: ჰო, ზუსტად.
ასე რომ, თუ თქვენ სურდა, რომ ეს ჩვენება გთხოვთ შეიყვანოთ თქვენი ასაკი,
შეგიძლიათ უბრალოდ დაამატოთ printf () ფუნქცია რომელიც ამბობს, გთხოვთ მიუთითოთ თქვენი ასაკი,
ზემოთ.
ეს არის კარგი კითხვაა.
ჰო.
>> დინამიკები 9: ასე, რომ უკვე იყოს შედის GetInt () [INAUDIBLE].
Andi Peng: არა, ეს რეალურად არ არის.
ასე რომ, ყველა ეს არ არის მხოლოდ მოთხოვნა ცარიელი ეკრანზე
მომხმარებელს input რაღაც.
თუ გსურთ, რომ, თუ გსურთ, რომ ბეჭდვა რომ რაღაც ეუბნება შესახებ, როგორიცაა,
გთხოვთ, მომეცი თქვენი ასაკი, მაშინ თქვენ უნდა printf (), რომელიც თავს.
იმის გამო, რომ ყველას იყენებს ამ ფუნქცია სხვადასხვა ნივთები,
თქვენ შეიძლება შენახვის ასაკის, თქვენ შეიძლება შენახვის მისამართი,
თქვენ შეიძლება შენახვის ტელეფონის ნომრები.
ასე რომ, ეს მართლაც მდე თქვენი ბიჭები "ინდივიდუალური მიზნებისათვის
რა გსურთ, რომ ვთქვა.
ჰო.
>> დინამიკები 10: ასე, რომ განვმარტო, სადაც თქვენ შეყვანის სახელი და ასაკი
ასე რომ იგი აჩვენებს up ადგილზე% s?
>> Andi Peng: როგორც მომხმარებელი?
>> დინამიკები 10: დიახ, ისევე, როგორ შემიძლია რათა it-- სადაც შემიძლია დააყენა Andi,
და სად მე ამას 20?
>> Andi Peng: ჰო.
ასე რომ, თუ თქვენ უნდა რეალურად აწარმოებს ამ კოდი,
მე რეალურად არ გაშვებული კოდი, ეს მხოლოდ აქ ახლა.
მე რომ აწარმოებს კოდი, მე კომპილაციის კოდი, რათა ფაილი,
აწარმოებს კოდი, და მაშინ არ გვინდა იყოს მხოლოდ ორი ფართები ჩემთვის შეყვანის.
ჰო.
თქვენ ბიჭები ნახავთ, როდესაც თქვენ თამაშობთ გარშემო კოდი თავს.
>> ყველა უფლება ჩვენ ვაპირებთ გადაადგილება მომდევნო მონაკვეთი რა
ჩვენ გააშუქებს დღეს.
ჩვენ ვაპირებთ, რომ წავიდეთ მეტი რა პირობითი არიან.
ასე რომ, თუ ბიჭები გახსოვთ და გავიხსენოთ ლექცია,
პირობითი განცხადებები, ყველა ისინი კომპლექტი
ინსტრუქციების, კომპიუტერი რომელიც, თუ გარკვეული მდგომარეობა არის ჭეშმარიტი,
თქვენ შეასრულოს კოდი შიგნით რომ მდგომარეობა.
>> ასე რომ, ნულიდან არსებითად დიდი თემა დღეს
ის არის, რომ შენ უკვე ყველა ჩანს ლოგიკა ყველაფერი
რომ ჩვენ მოიცავს.
და ყველა ვაკეთებთ თარგმნის რაღაც
რომ იყო ძალიან ინტუიციური Scratch, და მძიმე კოდირების
შევიდა სინტაქსი ჩვენ უნდა გამოყენებით კლასი რომელიც C.
ასე რომ, ლოგიკურად, ყველა ამ ბლოკში იყო ის არის, რომ ნაჭერი კოდი უფლება არსებობს.
ჰო.
OK.
>> ჩვენ ასევე მოხვდნენ თუ ... სხვა განცხადებაში, რომელიც მხოლოდ დამატებითი ფენის
სირთულის, თუ განაცხადი სადაც კომპიუტერული იღებს შევხედოთ ამ
და ხედავს, თუ ეს მდგომარეობა მართალია, ამის რასაც ის შიგნით ამ ორი ფრჩხილებში,
else-- ასე სახის როგორც ნაგულისხმები თუ ის არ აკმაყოფილებს condition-- ამის გაკეთება.
ეს იგივეა, გზის გასაყარი.
თუ წვიმს გარეთ, მე წლის წვიმა ქურთუკი, სხვა არაფერი
სხვა მე არ დააყენა წვიმა ქურთუკი.
>> თუ არა, რომ ლოგიკა აზრი ყველას?
ზემოთ.
ყველა უფლება.
ასე რომ, როგორც მძიმე მაგალითია ეს, რომ ჩვენ ვხედავთ C
თუ მე მინდოდა, რომ შეიქმნას ცვლადში დავალებას საათი.
და თუ დავალებას საათი ნაკლებად ვიდრე ხუთი, მე ვიტყვი, ცხოვრება არის დიდი.
შესანიშნავია.
თუმცა, ამბობენ, ბრძოლა არის real-- რაც ჩვენ ყველა ამ ორშაბათს
დღის მეორე ნახევარში up Science Hill არიან ალბათ ამის უფლება, ახლა
აუდიტორია: [იცინის]
Andi Peng: მათ გზა ჩვენ რომ, დიდი მადლობა, რომ.
გზა ჩვენ hardcode ეს არის C if-- მოდით ვივარაუდოთ,
ჩვენ უკვე გვაქვს ცვლადი ტიპის int მოუწოდა დავალებას საათი უფლება აქ.
თუ დავალებას საათი ნაკლებია, ვიდრე ხუთ printf (), ცხოვრება არის დიდი.
დამახსოვრება შენარჩუნება / n, რადგან გსურთ ახალი ხაზი შემდეგ.
Else ბეჭდვა, ბრძოლა არის რეალური.
>> ამჯამად ყველას გვესმის, თუ როგორ მე გადავიდა ამ ბლოკის
ამ ბლოკის კოდი?
ზემოთ.
ყველა უფლება.
>> ასე რომ, ახლა ჩვენ ვაპირებთ შევხედოთ მრავალჯერადი თუ განცხადებებს საერთოდ.
მოდით ვივარაუდოთ, მიზანი ამ პროგრამის
იყო ჩვენ შეეკითხება მომხმარებელს კლასის.
ჩვენ შეეკითხება გამოყენებით GetInt () დიდი კლასის, და ისინი შემავალი მნიშვნელობა,
და თქვენ გინდათ რომ გამოაჩინოთ რა ტიპის grade მათ.
>> ასე რომ, თუ მე უნდა შეიმუშავონ პროგრამა, მე ნიშნავს, როგორც წესი, ყველა ჩვენი თვალები,
90-100 არის A, 80-90 არის B, და ა.შ. და ასე შემდეგ.
რა არის არასწორი ამ ნაჭერი კოდი, რომ ეს არ
აკეთებს რაც მე მინდა ის უნდა გააკეთოს.
ჰო.
>> დინამიკები 11: მათ აქვთ ქვედა ზღვარი, მაგრამ მათ არ აქვთ ზედა ზღვარი.
>> Andi Peng: ზუსტად.
ხომ ყველას გვესმის რა განაცხადა მან?
არ იქნება ზედა შეზღუდვები, მაგრამ არსებობს ქვედა ზღვარი.
უკაცრავად, პირიქით, ქვედა საზღვრები, არ ზედა ზღვარი.
ასე რომ გსურთ მიიღოს stab განაცხადა,
რა იქნება დაბეჭდილი ეს ეკრანზე, თუ მე აწარმოებს ამ კოდი.
დინამიკები 11: შეცდომა?
Andi Peng: შეცდომა?
დიდი ვხვდები, არ არის სწორი.
ვინმეს აქვს კიდევ stab?
ჰო, Aaron.
>> AARON: თუ თქვენ დააყენა რაღაც უფრო მეტი, ვიდრე 90,
ეს იქნებოდა ნახოთ ყველა შეფასება შენ.
ეს იქნებოდა ნახოთ შენ A, შენ B, შენ C.
>> Andi Peng: ჰო.
ეს არის სწორედ.
ასე, რომ მინდა იყოს მშვენიერი.
თუმცა, ისინი ერთმანეთს ექსკლუზიური, მე ვფიქრობ.
მე რომ აწარმოებს ამ ნაჭერი კოდი.
და მაშინ მოდით უბრალოდ, ვამბობთ, მე inputted კლასის 95.
ასე რომ, 95 არის შენახული int, მოუწოდა კლასის.
>> მაშ ასე, C ენაზე რომელიც ეშვება up ზემოდან,
ასე რომ, ის აპირებს, რომ ყოველთვის აწარმოებს ბოლოში.
ასე რომ, ის აპირებს ჩამოვიდეს აქ, წაიკითხა თუ grade მეტია ან ტოლია 90,
printf () შენ A. დიდი, მე აქვს 95, რომელიც უფრო მეტია, ვიდრე 90-ს.
ის აპირებს ბეჭდვა, მე მივიღე A. იგი აპირებს
უნდა შევხედოთ, თუ, ის აპირებს ამბობენ, კარგად 95 ისიც აღემატება 80,
ის აპირებს ბეჭდვა თქვენ ასევე მივიღე got ბი ძახილის ნიშნის და ასე შემდეგ და ასე
მეოთხე.
>> ასე რომ, როგორც ჩვენ შეგვიძლია ყველა ვხედავთ, ეს არის საერთო bug
რომ შეიძლება მოხდეს, როდესაც ჩვენ წერა კოდი გამოიყურებოდეს out for.
ნებისმიერ მსურველს, რაიმე შეკითხვები რატომ, რომ ხდებოდა?
შესანიშნავი.
OK.
>> ასე რომ, ჩვენ დაფიქსირება ამ, აშკარად ლოგიკური მომდევნო კითხვა.
ისე, ჩვენ ამ ლამაზი რამ მოუწოდა, თუ სხვაგან, თუ სხვაგან
თუ სხვაგან განცხადებებს.
ასე რომ თქვენ ხედავთ, თუ უნდოდა უნდა შეიცვალოს, რომ პრობლემა,
მინდოდა თითოეული პირობები ურთიერთგამომრიცხავი,
თქვენ დაამატოთ სხვაგან ... თუ განცხადებაში.
>> და ეს ერთი course-- ვფიქრობ, რომ მათ კიბეები, ან, როგორც კიბის წლის ladder--
თქვენ შეგიძლიათ დაამატოთ როგორც ბევრი ამ როგორც თქვენ მინდა, როგორც ბევრი პირობებში, როგორც გსურთ.
ასე რომ, თუ მე inputted grade უნდა იყოს 95.
თუ grade უფრო მეტია, ვიდრე 95, printf (), მე მივიღე A. დიდი.
ის აპირებს ვხედავ სხვა ... თუ და ის აპირებს, რომ ვიცი, რა არა,
მე უკვე შესრულებული პირველი სხვაგან.
მე ვიცი და პირველი if-- მე ვიცი, რომ მე არ უნდა შევხედოთ რომელიმე ამ
იმის გამო, რომ ერთ-ერთი მათგანი უკვე ჭეშმარიტი.
ასე რომ, ის აპირებს, ზემოდან ქვემოთ.
როგორც კი პირველი მართალია, მაშინ ის აპირებს გამოტოვოთ ყველა დანარჩენი
საქართველოს სხვა ... IFS.
არა, რომ აზრი?
ასე რომ, ამ გზით თქვენ უნდა სხვადასხვა დონის შემოწმების
და როგორც კი ერთ-ერთი მათგანი არის ყალბი, დანარჩენი, ისინი კი არ ნახოთ.
ზემოთ.
ყველა უფლება.
>> ასე რომ, ეს არის მაგალითი იმისა, სხვადასხვა ერთგვარი პირობითი განაცხადი
ჩვენ ვხედავთ, უფრო ხშირად, მაგრამ ჩვენ დავინახავთ მათ და მათი გამოყენება.
და ისინი ხშირად უფრო ეფექტური გარკვეულ შემთხვევებში.
ასე რომ, ჩვენ გვაქვს რასაც შეცვლა განაცხადი.
ასე რომ, სანამ ჩვენ დაფარული რა არის სხვაგან სიტყვით, თუ ... სხვაგან განცხადებაში.
აქ, ჩვენ გვაქვს რა არის მოუწოდა შეცვლა განცხადებები.
>> ასე რომ, როდესაც ჩვენ ვიყენებთ შეცვლა განცხადებები გასაღები?
ასე რომ, შეცვლა განაცხადი, თქვენ როგორც წესი, როგორც წესი, რეალურად თქვენ
მხოლოდ შეყვანის რიცხვებით თქვენი ცვლადი, რომ თქვენ შემოწმება.
ასე რომ, თუ მინდოდა შეამოწმეთ თუ გარკვეული რიცხვი, მაგალითად,
კლასის, თუ მე მივიღე 90.
მე მინდა, რომ თუ ეს არის A, B, და C მე ვერ აქვს საქმე აქ.
თუმცა, საქმე აქვს კიდევ ერთი მუდმივი.
>> ასე რომ, ამ თვალსაზრისით, შეცვლა განაცხადი შეიძლება მხოლოდ
შეამოწმეთ თანასწორობის ორი ნომერი.
ეს არ ნახოთ არაფერი.
ასე რომ რაღაც უნდა იყოს ძალიან ფრთხილად, როდესაც თქვენ იყენებთ ამ.
ასე რომ, თუ მინდოდა შეამოწმეთ თუ ჩემი კლასის 90 უდრის 90 ან 80
ან 70 ან 60 და შემდეგ ბეჭდვა შესაბამისი კლასის,
მე მინდა შეძლებს დაწერა, რომ შეცვლა განცხადება.
>> ასე რომ, ის აპირებს ჩამოვიდეს აქ, ჩეკი არის ეს რიცხვი უდრის ამ მუდმივი?
თუ არა, ის აპირებს გამოტოვოთ.
ეს არის ტოლი მუდმივი ორი და ასე შემდეგ და ასე შემდეგ,
სანამ არ მოხვდა რა, თუ არც ერთი მათგანი არ არის თანაბარი.
როგორც კი ერთ-ერთი მათგანი მითითებული უნდა იყოს თანასწორი,
ის აპირებს ამის გაკეთება ხაზი კოდი და შესვენება.
რაც იმას ნიშნავს, რომ ის აპირებს მოხვდა, რომ აწარმოებს, შესვენება, და მხოლოდ სრულიად გამოტოვოთ
ბოლოში კოდი.
ასე რომ, ამ თვალსაზრისით, სახის ფუნქციები მოსწონს თუ სხვაგან, თუ სხვაგან თუ განცხადებაში.
>> ასე რომ, აქ კონკრეტული მაგალითად თქვენ ბიჭები.
მოდით ვივარაუდოთ, რომ მინდოდა შევქმნათ ცვლადში წელს დაარსდა.
და მე მინდა შეეკითხება მომხმარებელს input წელს, რომ მათი სკოლა დაარსდა.
ასე, რომ შეიძლება შეიქმნას შეცვლა განცხადება აქ.
და მოდით უბრალოდ, ვამბობთ, მე შეყვანის 1636.
>> ეს კოდი აქ აპირებს ვხედავ შეცვლა წელი დაფუძნდა, რომელიც შეადგენს 1636.
ის აპირებს, რომ ნახოთ შემთხვევაში 1636, oh, ეს არის თანაბარი,
printf () თუ არ შეიძლება იყოს რომ სკოლა up ჩრდილოეთით?
იმიტომ, რომ ჩვენ ვივარაუდოთ, რომ ისინი არ აქ, თუ ისინი ჰარვარდის,
შესვენება და გამოტოვოთ ბოლომდე.
>> მე რომ შეყვანის 1701, რომელიც მე ვფიქრობ, ყველა ჩვენგანისთვის რომ input,
ის გამოტოვოთ ამ შემთხვევაში, მოდის ქვემოთ ორი საქმე, რომელიც 1701 წელს
და ბეჭდვითი კეთილი Yale!
დაარღვიე, გამოტოვოთ ბოლომდე.
Else თქვენ ალბათ აღების ეს კურსი ამჟამად ამ case-- გასაოცარია მისასალმებელი
რომ Yale-- ის აპირებს წავიდეს ძირითადად ბეჭდური, Hello ინტერნეტში!
და შესვენება.
ჰო.
>> დინამიკები 12: შეგიძლიათ გამოიყენოთ სხვა ნაცვლად ძირითადად იქ?
>> Andi Peng: არა, რადგან ისე, რომ მთელი ეს ფუნქცია
შეცვლა აშენდა, სინტაქსი თქვენ უნდა გამოვიყენოთ არის საქმე საქმე იყოს.
ეს იგივეა, რომ იმ შემთხვევაში, თუ სხვაგან, თუ ეს ერთი ის შემთხვევაში საქმე იყოს. ჰო.
დინამიკები 13: თქვენ შესაძლოა უკვე განაცხადა, რომ ეს, მაგრამ შეგიძლიათ უფრო მეტი, ვიდრე ორი შემთხვევა?
Andi Peng: ჰო, თქვენ შეიძლება იმდენი შემთხვევაში, როგორც გსურთ.
ვფიქრობ, რომ ეს უბრალოდ მინდა უსასრულოდ დასძინა.
>> დინამიკები 14: თუ თქვენ შეცვალა 1701 ერთად 1636
ეს ნამდვილად არ განსხვავება უფლება?
უბრალოდ იქნება შემოწმების იგი.
>> Andi Peng: ეს ​​არის კარგი კითხვა.
და ჩვენ შევეხო მოგვიანებით, მაგრამ მხოლოდ
ვიცი, რომ შეცვლა განცხადება უსასრულოდ ეს
უფრო ეფექტურია, ვიდრე ის, თუ სხვაგან, თუ იმიტომ, რომ ეს მუშაობს
გამოყენებით სხვადასხვა ტიპის ფუნქცია, რომელიც საშუალებას გაძლევთ, არსებითად, მხოლოდ
ხტომა პირდაპირ იმ შემთხვევაში თუ თქვენ უნდა იყოს.
ჰო.
დინამიკები 14: ზემოთ.
მადლობა.
Andi Peng: ჰო
>> დინამიკები 14: თქვენ ვერ ამის შემთხვევაში, როგორიცაა, და მეტი.
Andi Peng: No.
ასე რომ, ის, რაც შეზღუდვის შესახებ შეცვლა განცხადება, რომ თქვენ გაქვთ
აქვს მუდმივები მხოლოდ, მხოლოდ რიცხვებით.
ჰო.
OK.
>> ასე რომ, ეს არის ის, რომ თქვენ ბიჭები ექმნებათ ნაკლებად ხშირად,
მაგრამ მე უბრალოდ მინდოდა წარმოგიდგინოთ ის შემთხვევაში.
ჩვენ აქ რა არის უწოდებენ ternary ოპერატორს.
სად არსებითად, უბრალოდ მომწონს თუ განაცხადი შედგენილი ერთ ონლაინ.
აქ, მე წასვლა გადატანა მომდევნო ხაზი, შემდეგი გვერდი, იმიტომ, რომ ეს ადვილია ვხედავ.
>> ასე რომ, ჩვენ ვხედავთ, ეს უფლება?
ეს არის საკმაოდ მარტივი.
თუ მინდოდა ცვლადში სიმებიანი დაასახელა s, თუ გარკვეული რაოდენობის
მე ვაძლევ ეს არის 100-ზე ნაკლები, მე გსურთ დაავალოს დაბალი სიმებიანი,
სხვა მინდა მივანიჭოთ მაღალი.
>> ეს აქ აკეთებს ზუსტად იგივე იმ რვა ხაზების კოდი ვაკეთებთ.
ასე რომ, აქ მინდა, რომ შევქმნათ ცვლად სტრინგს.
და ეს არის იმ პირობით, რომ მე ვარ შემოწმების, თუ ნომერი არის 100-ზე ნაკლები,
მერე დაავალოს ღირებულება დაბალია, სხვა მივანიჭოთ ღირებულების მაღალი.
>> ეს სლაიდები იქნება ონლაინ, არ აწუხებს თუ ბიჭები არ მიიღოს ამ ქვემოთ.
ეს არის მხოლოდ მარტივი გზა, უფრო ეფექტური გზა წერა კოდი.
OK.
>> ასე რომ, ახლა ჩვენ ვაპირებთ შესვლის რა, ყველაზე ხალხი
არიან, ძალიან, ძალიან გაუგებარია რამ ფიქრი, პირველ რიგში.
მარყუჟის განყოფილებაში.
ასე რომ, დღეს, ჩვენ ვაპირებთ, რომ გაიგო დაახლოებით სამი ტიპის მარყუჟების.
ჩვენ ვაპირებთ, რომ დაიწყოს, ხოლო მარყუჟის, მაშინ ვისაუბროთ do ხოლო მარყუჟის,
და მერე ვისაუბროთ ამისთვის მარყუჟების.
>> ასე რომ, არსებითად, უფრო ვიზუალური შემსწავლელთა არსებობს,
ჩვენ, არსებითად, გრაფიკული გამოსახულებებით, რასაც ხოლო loop აკეთებს.
ასე რომ, პროგრამირება, თქვენ დაიწყება და შევა ციკლი გარკვეული თვალსაზრისით.
თქვენ შეამოწმოს მდგომარეობა.
და თუ მდგომარეობა მართალია, თქვენ შეასრულოს კოდი შიგნით.
და თქვენ დავბრუნდებით გარშემო და შემოწმება.
თუ ეს ჯერ კიდევ ასეა თქვენ გაქვთ გაშვებული ეს კოდი ირგვლივ და გარშემო ციკლი.
>> თუმცა, მეორე, რომ მდგომარეობა ხდება ყალბი,
თქვენ აპირებს დაარღვიოს და დასრულდება მარყუჟის.
და ეს არის არსებითად სინტაქსი თქვენ ვაპირებთ გამოვიყენოთ.
მიუხედავად იმისა, რომ გარკვეული მდგომარეობა არის ნამდვილი გაკეთება, თუ ეს ასე არ არის,
თქვენ აპირებს გამოტოვოთ ბოლომდე და წინსვლა თქვენი პროგრამა.
OK.
>> ვინმეს აქვს მაგალითად თუ რა შეიძლება პოტენციურად მოხდეს
თუ მე ვცდილობ გაუშვით ეს კოდი?
სხვათა შორის, SAJ--, რომ Scaz, Andi, Jason-- მოვაწერთ off ჩვენი წერილებს,
სიყვარული, SAJ.
ეს არის ჩვენთვის.
OK.
>> ნებისმიერ მსურველს აქვს, მაგალითად, ან აქვს იდეა რა ეს იქნებოდა ბეჭდვა?
სახის შეასრულა კითხვაზე.
ასე რომ, აქ, მახსოვს მდგომარეობაში ჩვენ შემოწმების არის, ხოლო ჭეშმარიტი.
ასე რომ, როდესაც ეს მართლაც ასეა, ეს აპირებს ბეჭდვა, მე მიყვარს SAJ!
არსებობს თუ არა წერტილი, რომელიც ჩვენ გვინდა შეიცვალოს ეს არაფერი სხვაგვარად?
არა, არა?
>> ასე რომ, აქ, ჩვენ გვაქვს შეექმნა, რაც, ალბათ,
იქნება bugging ბევრი თქვენი პროგრამების, უსასრულო ციკლი.
თქვენ ნახავთ, რომ იმ შემთხვევაში, თუ აწარმოებს ამ ნაჭერი კოდი,
ის უბრალოდ აპირებს შეინარჩუნოს ბეჭდვა, მე მიყვარს SAJ!
მიუხედავად იმისა, რომ ჩვენ ვაფასებთ იმ მხარდაჭერას, ჩვენ არ გვინდა, თქვენი კომპიუტერი
ავარიული იმიტომ, რომ თქვენ შენარჩუნება ბეჭდვა მე მიყვარს SAJ!
>> ასე რომ, გთხოვთ, გთხოვთ, თავიდან აცილების მიზნით, უსასრულო ციკლი
იმიტომ, რომ ის არ აპირებს შეაფასოს ცრუ
და თქვენ არასდროს დატოვება loop.
და თქვენ აპირებს უნდა sucked in სამუდამოდ.
ზემოთ.
OK.
მეორე ტიპის loop ჩვენ ვსაუბრობთ დღეს
არის do ხოლო მარყუჟის, ხოლო loop.
და ეს ე.წ. do ხოლო loop იმიტომ, რომ თქვენ გაქვთ do და ცოტა ხნით.
ასე რომ, ეს არის საკმაოდ მსგავსია, ხოლო მარყუჟის, მაგრამ ცოტა განსხვავებული.
აქ, თქვენ ვაპირებთ გავაკეთოთ რასაც ის შიგნით ამ
ხოლო გარკვეული მდგომარეობა არის ჭეშმარიტი.
ასე რომ მე რომ C და კომპიუტერი მე გაშვებული ქვემოთ ეს კოდი,
მე შევხედოთ დაბრუნება.
მე წასვლა C, ვამბობ, რომ ამის გაკეთება რამ.
და მერე შეამოწმეთ, ხოლო ეს არის ჭეშმარიტი, მე უნდა გავიმეოროთ იგი.
მაგრამ მიუხედავად იმისა, რომ ეს არის ცრუ, მერე წინსვლა
და მე არ დაბრუნდეს, რომ loop ერთხელ.
>> შეიძლება ვინმეს მიიღოს stab რა განსხვავებაა
შორის ამ მარყუჟის და ერთი ჩვენ უბრალოდ შევხედე პრაქტიკულად.
ჰო.
დინამიკები 15: მდგომარეობა მას შემდეგ, რაც ნაცვლად ადრე?
Andi Peng: ზუსტად.
ასე რომ, მან განაცხადა, რომ მდგომარეობა მას შემდეგ, რაც, არა მანამდე.
საბოლოო ჯამში, განსხვავება ამ და ხოლო loop
არის, რომ თქვენ უბრალოდ აპირებს რასაც ის შიგნით, მიუხედავად იმისა,
თუ არა თქვენი მდგომარეობა მართალია, და შემდეგ შეამოწმოს მდგომარეობა.
ასე რომ, ამ შემთხვევაში, თქვენ always-- ამ გზით,
თქვენ ყოველთვის მიღების დარწმუნებული ვარ, რაც არის შიგნით გადის მინიმუმ
ერთხელ ადრე შემოწმების თუ გსურთ, რომ აწარმოებს ერთხელ.
>> აქ არის მაგალითი როდესაც ჩვენ გამოიყენოს იგი.
ასე მაგალითად, თუ მინდოდა ცვლადი ტიპის int დასახელდა ასაკის,
და მე მინდა, რომ შემოგთავაზოთ მომხმარებლის მათი ასაკის,
მე ვაპირებ ამის printf () რა არის თქვენი ასაკი?
ასაკი = GetInt (), რომელიც რითაც შესახებ.
>> და ზოგიერთი ადამიანი იქნება მართლაც შემაშფოთებელი.
თქვენ არ მინდა შეცდომები თქვენს პროგრამა ვინმეს შესაყვანი, როგორიცაა,
oh მე -4 წლის ან რასაც.
ამ შემთხვევაში, თუ ისინი იმაში, რომ ეს აფასებს
მართალია, რაც იმას ნიშნავს, რომ მე ვაპირებ უნდა შევინარჩუნოთ ბრუნდება და ამით.
ასე რომ, ეს აპირებს შენარჩუნება ხელახალი რითაც შესახებ
გადმოგცეთ, როგორც ნამდვილი ასაკი ნომერი და ეს
შენარჩუნება აპირებს უკან და redoing სანამ ისინი მოგცემთ რეალურ ასაკი
უფრო მეტი, ვიდრე ერთი, ან არ არის ნულოვანი.
>> ასე რომ, მინიშნება, მინიშნება.
ეს იქნება ძალიან, ძალიან სასარგებლო ერთი თქვენი PSet პრობლემები.
ჰო.
>> დინამიკები 16: Whoops, ბოდიში.
>> Andi Peng: Yep.
>> დინამიკები 16: არსებობს, არ უნდა იყოს asshole არის, მაგრამ
Andi Peng: არ აწუხებს.
დინამიკები 16: --are არსებობს სხვადასხვა წესები აქ,
ან საერთოდ უბრალოდ დაგავიწყდეთ იმისათვის, რომ ციტატა?
>> Andi Peng: Oh Yeah.
ბოდიში, რომ მთლიანად ჩემი ცუდი.
ეს იყო ნამდვილად უნდა იყოს ციტატა.
კარგი დაჭერა.
ეს იქნებოდა არ აწარმოებს.
OK.
>> ასე რომ, ბოლო ტიპის მარყუჟის ჩვენ ვსაუბრობთ შესახებ და, საბოლოო ჯამში, სახის ყველაზე
კომპლექსი for loop.
არ ინერვიულოთ, თუ თქვენ არ იცით, რას ნიშნავს.
ეს არის საკმაოდ გაუგებარია, პირველ რიგში.
ჩვენ წავიდეთ მაგალითად.
>> ყველა რომ ხდება ამისთვის მარყუჟის არის, რომ თქვენ გაქვთ სამი განცხადებები
რომ თქვენ აპირებთ მოიცავს.
ასე რომ, გარკვეული რამ, თქვენ აპირებს ინიციალიზაცია ცვლადი.
თქვენ ვაპირებთ, რომ დაამატოთ იმ პირობით, რომ რომელიც ამ მარყუჟის იტრიალებს.
და შემდეგ, ბოლოს loop, თქვენ აპირებს განაახლოს იგი.
თქვენ შეგიძლიათ განაახლოთ ცვლადი რომ გსურთ ტრეკზე.
ასე რომ, ჩვენ, როგორც წესი იყენებენ მარყუჟების, როდესაც ჩვენ
გსურთ აწარმოებს loop ამისთვის გარკვეული ჯერ
და უკვე ვიცით, Oh მინდა ამ loop შეასრულოს, როგორც 10-ჯერ,
მაშინ გავაკეთოთ მე წასვლა მეტი მაგალითად, თუ მომდევნო გვერდზე.
>> ასე რომ, აქ მაგალითად, Scratch, თუ უნდოდა რაღაც ვიმეორებ 10 ჯერ,
ყველა თქვენ უნდა ვთქვა, ვიმეორებ 10 ჯერ მე მიყვარს SAJ!
რაც უფრო მისაღებია შოუ მხარდაჭერას ჩვენთვის
ვიდრე უსასრულო ციკლი.
აქ, როგორ გავაკეთეთ გადასვლის C და ჩაწერის
რომ არის გაკეთება int მე ვაპირებ, რომ შევქმნათ ან განაცხადოს ცვლადი ტიპის int დაასახელა i.
მე ვაპირებ ინიციალიზაცია ეს 0, ასე i = 0;
და ეს იქნება ჩემი მდგომარეობა.
ასე რომ, მე ნაკლებია 10.
და მაშინ end-- ბოლო ცნობები თქვენ
აპირებს აქვს არის განახლება რა მოხდება, ცვლადი i
ბოლოს თქვენი for loop.
ასე რომ, ეს სახის დამაბნეველი, რადგან სხვადასხვა კუთხეში ეს ხაზი
ხდება სხვადასხვა სახის ციკლი.
მაგრამ მე წასვლა მეტი pseudocode მაგალითია
და იქნებ ახსნას ეს უბრალოდ ცოტა უკეთესი.
>> ასე რომ, აქ.
სწორედ loop ჩვენ უბრალოდ დაინახა.
არსებითად pseudocode, რა ხდება ამ პროგრამაში,
ეს არის პირველი მე შექმნაში i, ინიციალიზაციისას იგი 0.
მე შემოწმების თუ არის ნაკლებია, ვიდრე 10, ამ შემთხვევაში
პირველად ეს არის რადგან 0 ნაკლებია, ვიდრე 10.
ასე რომ მარყუჟი აპირებს.
და მაშინ მე ვაპირებ ბეჭდვა ეს ხაზი.
და ბოლოს, ამ ხაზის, უფლება აქ, მე ვაპირებ ამის ნამატი i, i ++,
ეს ნიშნავს რომ დამატება იგი ერთ-ერთი.
>> ასე რომ, მე ახლა 1.
იმის გამო, რომ ეს იყო კიდევ 0, თუ მე ნამატი ის, რომ ეს არის 1.
და მაშინ მე ვაპირებ დაბრუნდეს დასაწყისში მარყუჟის
და მე შეამოწმოს მდგომარეობა.
არის მდგომარეობა კვლავ ჭეშმარიტი?
დიახ, 1 დღესაც არანაკლებ 10.
ასე რომ, ის აპირებს ბეჭდვა ეს კიდევ ერთხელ, წასვლა და მაშინ ნამატი i, და შემოწმება
მდგომარეობა მუდმივად, მუდმივად,
სანამ თქვენ საბოლოოდ მისაღებად იმ წერტილში, სადაც მე 10.
>> თქვენ აპირებს ბეჭდვა ეს 10-ჯერ და მერე აპირებს გაუტოლდება 10.
თქვენ აპირებს შეამოწმოს მდგომარეობა.
10 10-ზე ნაკლები?
არა, ეს არ არის ყალბი.
ასე რომ, ამ loop არ აპირებს აწარმოებს, ის აპირებს დაარღვიოს,
და თქვენ აპირებს გაგრძელდება თქვენი კოდი.
>> ასე რომ, როგორც თქვენ ბიჭები ხედავთ, ამ არის ძალიან დიდი მაგალითია
მარყუჟის შეგიძლიათ პროგრამა, რომელიც გადის გარკვეული ჯერ.
ყოველი ნათელი?
ჰო.
>> დინამიკები 17: როგორ შესახებ ნამატი exponentially, ეს არის სხვადასხვა კოდირების?
>> Andi Peng თქვენ can-- გავემგზავრებით მეტი ამ მომდევნო slide.
კარგი კითხვაა.
არის anyone-- სანამ გადავა on-- ვინმეს ყველა დაბნეული,
იმიტომ, რომ ეს არის ძალიან მკაცრი კონცეფცია.
არ აწუხებს, თუ you're-- OK.
ზემოთ.
>> ყველა უფლება.
უბრალოდ ზოგადი slide.
ეს ხოლო მარყუჟის აკეთებს ზუსტად იგივე რამ ამისთვის მარყუჟის იყო.
ეს მხოლოდ წერილობითი განსხვავებულად.
შენ შეიძლება ყურადღებით გაეცნოთ სლაიდები თქვენთვის მოგვიანებით.
მაგრამ ვიცი, რომ არსებობს მრავალი გზები წერა იგივე
უნდა მოხდეს სხვადასხვა მარყუჟების.
OK.
>> ასე რომ, ახლა ჩვენ მიიღონ კითხვაზე, თუ რა თუ ჩვენ გვაქვს loop შიგნით loop.
ჩვენ ვიღებთ რეალურ Inception ტიპის პერსონალის აქ.
როდესაც გსურთ ამის გაკეთება რამ სხვადასხვა ჯერ შიგნით სხვა რამ
რომ არ რამ რამდენჯერმე, თქვენ მინდა რასაც წყობილი for loop.
იმ თქვენ, რომლებიც პირველად ვხედავ და მისაღებად ძალიან დაბნეული, ყველა ვაკეთებთ აქ
აქვს ამისთვის მარყუჟის, სადაც ჩვენ ცვლადი ზედიზედ.
მაგრამ შიგნით, ჩვენ ასევე გვაქვს სხვა ამისთვის loop ცვლადში სვეტი.
და უაღრესად გთავაზობთ ყველა თქვენგანს რომლებიც დაბნეული, რომ შევინარჩუნოთ
track-- მიაპყროს ამ, მიაპყროს ამ out.
ნუ ეცდებით უბრალოდ მიზეზი მეშვეობით, დავხატოთ ის.
>> თქვენი უფროსი, ამ ცალი ქაღალდი, ან რასაც წერენ ზედიზედ,
ტრეკზე რა ზედიზედ უდრის.
დაწერეთ სვეტი, ტრეკზე რა სვეტი უდრის.
და ტრეკზე რა არის დაბეჭდვისას ყველა მცდელობაა.
ყოველ iteration ამ მარყუჟის, ყოველ iteration რომ დიდი მარყუჟის,
უბრალოდ შეინახოს შემდეგ ლოგიკით.
და მე გარანტიას გაძლევთ, თქვენ მიყვარს, რასაც თქვენ ხედავთ,
იმიტომ, რომ ეს არის ასევე ძალიან გამოიყენება თქვენი პრობლემა კომპლექტი.
ზემოთ.
ყველა უფლება.
ასე რომ, რაც ყველაზე მთავარია, რომ თქვენ ბიჭები არიან ალბათ ყველა
ფიქრი ახლა, თქვენი პრობლემა Set 1s,
რომლებიც გამოწვეულია ხუთშაბათი / პარასკევი.
>> თქვენი water.c პროგრამა, მინიშნება ვაპირებთ აქვს
შეეკითხება მომხმარებელს შეყვანის.
თქვენი mario.c პროგრამა თქვენ ვაპირებთ აქვს
გამოიყენოს წყობილი for loop, რომელიც ამისთვის loop შიგნით ამისთვის მარყუჟის,
ბეჭდვა ბლოკი პირამიდის, არსებითად მსგავსი იმისა, რაც მარიო უნდა ხტომა მეშვეობით.
და მაშინ თქვენს greedy-- ან შესაძლოა მიღების შეცვლა, თუ რომელიმე თქვენ ბიჭები
ოდესმე მსმენია that-- თქვენ აპირებს უნდა იყოს ძალიან
ფრთხილად პირველი მცურავი პუნქტიანი ღირებულებებს.
დამახსოვრება მცურავი ათობითებზე და რიცხვებით არ არის იგივე.
ნუ ტრეკზე რომელიც ერთი, რომელიც.
და თქვენ ვაპირებთ გამოვიყენოთ პირობითი, ისევე.
>> ყველა უფლება, ბოლო რამ.
მაქვს რამდენიმე წუთში დატოვა.
სტილი.
ასე რომ, ეს არის ის, რომ არ რეალურად მოქმედებს ეფექტურობის,
ან ფაქტობრივი გაშვებული თქვენი კოდი.
თუმცა, ეს ეფექტი ჩვენთვის, როგორც თქვენი კლასის მოსწავლეები, რადგან თქვენს მკითხველს.
ეს ეფექტი საკუთარ თავს, თუ თქვენ ცდილობს იპოვოს პრობლემა.
ეს ეფექტი readability თქვენი კოდი.
>> ასე რომ, სტილი, როგორც, როდესაც თქვენ ცდილობთ სტილი ესსე ინგლისური, თუ
არ აქვს პუნქტები, თქვენ გაქვთ ყველაფერი სახის
საქართველოს სახელებს ერთად ერთი ხაზი, ის რაც ნამდვილად რთული არავისთვის
წავიკითხე თქვენი ესსე, მაშინაც კი, თუ თქვენი რაოდენობა ლოგიკურად ხმა.
იგივე პროგრამირებაში.
თქვენ შეგიძლიათ horribly ბუნდოვანი კოდი, რომელიც Scaz დაფარავს,
და ეს შეიძლება კვლავ აწარმოებს და ფუნქცია.
მაგრამ ჩვენთვის, როგორც თქვენი საყვარელი TAs, რომელიც იქნება კითხულობს და შეფასების თქვენს psets,
ეს არ არის ძალიან ლამაზი.
>> ასე რომ, გთხოვთ, გულისთვის ჩვენთვის და საკუთარ თავს,
როდესაც თქვენ ცდილობთ დაფიქსირება პრობლემა თქვენი კოდი,
და თქვენ ცდილობთ წავიკითხე თქვენი საკუთარი კოდი, რათა
დარწმუნდით, რომ თქვენ დაიცვას გარკვეული კონვენციების რომ ჩვენ ვაპირებთ წასვლა.
>> ასე რომ, პირველი.
მიეცით თქვენს ცვლადები მნიშვნელოვანი სახელები.
თუ გსურთ შესანახად რიცხვი მოუწოდა ასაკის, გთხოვთ დაარქვით ასაკში.
არ დაარქვით სიმაღლე.
როდესაც თქვენ ცდილობთ შესანახად ასაკის სიმაღლე,
ის ყველაფერს აკეთებს ძალიან გაუგებარია ჩვენთვის.
ჩვენ არ გვსურს იყოს დაბნეული.
თქვენ არ მინდა იყოს დაბნეული.
არავის არ უყვარს იყოს დაბნეული.
თუ თქვენ აპირებთ შექმნა რაღაც, დაარქვით რაღაც მნიშვნელოვანი.
>> თუმცა, ამისთვის მარყუჟის, ერთი ხასიათი ცვლადები, როგორც წესი, ჯარიმა.
და ამისთვის მარყუჟის, თუ გვინდა, მხოლოდ მე, და J, K, შეგიძლიათ უბრალოდ რომ.
>> თანმიმდევრული ინიციალიზაციისას.
ასე რომ, რას ნიშნავს ეს?
ეს იმას ნიშნავს, რომ ტექნიკურად, თეორიულად, თქვენ შეგიძლიათ დაიწყოს და შექმნას
მრავალჯერადი ცვლადები იგივე ხაზი.
ასე მაგალითად, შემიძლია შექმნა მთელი მოუწოდა scaz_age,
და მთელი მოუწოდა andi_age = 20, და მთელი მოუწოდა jason_age
იგივე ხაზი.
და მე ასევე შეგიძლიათ დანიშნოს მხოლოდ ერთი მათ და არა სხვები ღირებულებებს.
ჩვენ ვთხოვთ თქვენ, გთხოვთ, არ გაგვაჩნია.
იმის გამო, რომ აქ თქვენ არსებითად შექმნილი სამი ცვლადის, მაგრამ მხოლოდ ერთი მათგანი
რეალურად აქვს მნიშვნელობა.
და მაშინ, როდესაც ჩვენ ცდილობს წაიკითხა თქვენი კოდი,
ან თუ თქვენ ცდილობს დააფიქსიროს პრობლემა თქვენი კოდი,
ეს ძალიან დამაბნეველი დაიცვას.
ასე რომ, მხოლოდ თქვენი readability, for ჩვენი readability, არ გაგვაჩნია.
>> თანმიმდევრული Curly braces.
ზოგიერთი ადამიანი მინდა, რომ მათი curly აფრთხილებს სხვადასხვა ადგილებში.
ეს ნამდვილად არ აქვს.
უბრალოდ დარწმუნდით, რომ თქვენ თანმიმდევრული თქვენს საკუთარი კოდი, სადაც გსურთ, რომ მათ.
>> თანმიმდევრული ინტერვალი.
თუ თქვენ დააყენა სივრცეში შემდეგ ამისთვის მარყუჟის, ყოველთვის გაგვაჩნია.
ნუ უბრალოდ მინდა სახის გაკეთება ზოგან, არ გავაკეთებთ სხვები.
უბრალოდ იყოს თანმიმდევრული.
>> მეორეც, თუ ვინმეს სურს რომ ყურადღებით გაეცნოთ მათ შორის CS50 სტილის სახელმძღვანელო,
ოფიციალურად აქვს სტილის სახელმძღვანელო, რომ გიჩვენებთ ყველა ამ კონვენციების,
პლუს კიდევ.
ეს არის ონლაინ რეჟიმში.
ეს იგივეა, cs50.net/style ან რამე მაგდაგვარს.
თქვენ შეგიძლიათ google იგი.
>> მდგრადობა არის გასაღები.
ასე რომ არ ინერვიულოთ რა სხვა ხალხი აკეთებს,
უბრალოდ დარწმუნდით, რომ თქვენ ხართ შეესაბამება თქვენი საკუთარი კოდი.
ვინმეს აქვს რაიმე შეკითხვები, რომ?
ჰო.
>> დინამიკები 18: ასე რომ, სათანადო რამ უნდა გავაკეთოთ ინიციალიზაციისას მხოლოდ
მათ ყველა ცალკე ხაზი, არის ის, რომ, თუ რას ამბობდა?
>> Andi Peng: ასე რომ, მე იშვიათად ეს მოხდეს.
მაგრამ თუ სურდა, თუ უნდოდა უნდა იყოს, როგორც გადარჩენის სივრცის თქვენი კოდი,
ან რასაც, თქვენ შეგიძლიათ ამის გაკეთება.
ჩვენ ვთხოვთ, რომ თქვენ უბრალოდ არ ვრთავ ერთი რამ და არა სხვები.
ასე რომ, თუ გსურთ ამის გაკეთება int scaz_age, int andi_age, int jason_age, რომ ჯარიმა.
უბრალოდ არ ვრთავ ერთი და არა სხვები ყველა.
>> კითხვები?
ყველა უფლება.
მე ვაპირებ გაივლის off მიკროფონის და ლაზერული მაჩვენებელი,
და ხელკეტი Scaz ამ ეტაპზე.
ეს არის უხერხულია.
აი, ეს არის.
>> ბრაიან SCASSELLATI: დიდი მადლობა.
როგორ არის, რომ ხმა?
ხმის არის კარგი? .
შესანიშნავი.
OK.
ასე რომ, hi ყველას.
>> მე ვაპირებ ცდილობენ მუშაობას მეშვეობით პრაქტიკული მაგალითი თქვენთან ერთად.
და ჩვენ ვაპირებთ გამოვიყენოთ CS50 ს განვითარების გარემო, რასაც
ინტეგრირებული განვითარება გარემოს დაცვა.
და ვნახე ეს აჩვენა ლექცია.
და პრობლემა Set 1, თქვენ აპირებს აქვს შესაძლებლობა
გამოიყენოს იგი, და ითამაშოს გარშემო მას, და მიეჩვევა მას,
იმიტომ, რომ ჩვენ ვაპირებთ გამოვიყენოთ ეს დანარჩენ სემესტრში.
>> ასე რომ, ამ IDE, თუ რა გამოიყურება როგორც ძალიან ტრადიციული ფაილი ბრაუზერში
მეტი ერთ მხარეს.
თქვენ მოხვდით ნაწილი up დაბრუნება, სადაც თქვენ აპირებს
იმისათვის, რომ ნახოთ თქვენი კოდის, თქვენი Cfile კოდი რომ წერთ.
და ქვემოთ ბოლოში, თქვენ აქვს ტერმინალის ფანჯარაში
რომელშიც თქვენ უნდა გამოყენებით ორივე კომპილაციის თქვენი პროგრამა
და აწარმოებს ან შეასრულოს თქვენი პროგრამა.
OK.
>> ასე რომ, უბრალოდ, რომ მოგვცეს ცოტა ფონდი, რომელიც ტერმინალის ფანჯარა,
თქვენ იქნება გამოყენებით კომპლექტი ბრძანებები
რომ არის სტანდარტული ბრძანებები მთელი ყველაზე Unix და Linux სისტემების.
ასე რომ, თუ თქვენ ოდესმე გამოყენებული ნებისმიერი ფორმით Unix, Ubuntu,
ან რომელიმე სხვა არომატს, ამ ვაპირებთ ნაცნობი.
>> თუ თქვენ არა გაქვთ, არ ინერვიულოთ.
არაფერია რთული მათ შესახებ.
ისინი უბრალოდ გამოყენებით სხვადასხვა სინტაქსი, სხვადასხვა დასახელებისგან
კონვენცია, ვიდრე თქვენ მინახავს ადრე.
>> ასე რომ, სიაში ის ფაილი ფარგლებში კონკრეტული მომსახურება,
ისინი აპირებენ გამოიყენოთ ბრძანება მოუწოდა ls, და სია.
თუ გსურთ, რომ ყველაფერი ყველა დეტალი,
თქვენ გამოიყენოთ ბრძანება ხაზი არგუმენტი ls-l.
და რომ ყველაფერს გაჩვენებთ ყველაფერს უფრო დეტალურად, მათ შორის,
ნებართვების ფაილი.
>> შესაცვლელად დირექტორია, თქვენ გამოიყენოთ cd ბრძანება.
და თქვენ შეძლებთ შეცვალოთ დირექტორია ორივე წასვლა თქვენი სახლის დირექტორია.
ეს მხოლოდ cd ყველა მიერ თავისთავად, cd ორი
წერტილების დაბრუნდება თქვენ ერთი დონე თქვენი წინა დირექტორია.
და ასევე შეგიძლიათ cd, რომ ქვედირექტორიაში აკრეფით cd
და სახელი რომ subdirectory.
>> თქვენ ასევე შეგიძლიათ შექმნათ ახალი დასტა.
და ჩვენ ვაპირებთ ფეხით ამ გზით მხოლოდ ერთი წუთით.
მაგრამ მხოლოდ იმისათვის, რომ ყველაფერი ეკრანზე.
ასე რომ თქვენ ხედავთ მათ.
>> თქვენ ასევე აქვს უნარი მანიპულირება ფაილი პირდაპირ
საწყისი ბრძანებათა სტრიქონიდან.
თქვენ გექნებათ კოპირება, მათ შორის, გადაადგილება მათ, ან ამოიღონ მათ,
რომ არის, ეფექტურად, წაშლა.
>> რომ CS50 IDE გაძლევთ სრულ ძალა ბრძანების არგუმენტები.
ეს ნიშნავს, რომ თქვენ ასევე შეგიძლიათ დიდად სახიფათო რამ.
OK.
მაგალითად, თქვენ შეგიძლიათ ამოიღონ, ან, რომელიც წაშლის,
ფაილი არ მოუთხოვია ერთი დადასტურება.
და თქვენ კი ამოიღონ recursively--, რომ
ტირე r დროშა მთელი ქვედირექტორიაში და ყველა მისი შინაარსი.
OK.
ისინი ჩამოთვლილი წითელი იმიტომ, რომ თქვენ უნდა ვიფიქროთ, რომ "საფრთხე" ყოველ ჯერზე,
ხედავთ იმ რამ.
OK.
ყველა უფლება.
>> ახლა საბოლოოდ, რამ, რომ იქნება მართლაც ღირებული თქვენ,
არსებობს რამდენიმე კარგი tricks ვიცი როგორც თქვენ ნავიგაცია
ამ გზით ტერმინალის ფანჯარაში.
პირველი, თქვენ შეგიძლიათ გარკვევას ეკრანზე ნებისმიერ დროს უბრალოდ აკრეფით ნათელია.
და თქვენ ვაპირებთ ვხედავ მომეცით გავაკეთოთ, რომ საკმაოდ ხშირად.
ასევე შეგიძლიათ მხოლოდ ცარიელია ტექსტი ფაილი
აკრეფით უფრო და შემდეგ ფაილის სახელი.
თქვენ მაშინ შეძლებს გადახვევა უკან და მეოთხე, რომ მხოლოდ ერთად spacebar
და arrow გასაღებები.
>> თუ თქვენ გაქვთ, როგორც ჩვენ გავაკეთეთ დღეს ლექცია, პროგრამა, რომელიც არის გაშვებული უწყვეტად
ამ უსასრულო ციკლი, თქვენ შეუძლია შეწყვიტოს, რომ პროგრამა
შესრულებაში აკრეფით კონტროლი, რომ მართავს down Control-C.
და თქვენ უნდა გავაკეთოთ ეს რამდენჯერმე.
კომპიუტერული იღებს ბევრად უსწრებს თქვენ.
და თქვენ ზოგჯერ უნდა მისცეს მას რამდენიმე ლელო
სანამ ის მოვა მეშვეობით.
>> თქვენ ასევე შეძლებთ დასალაგებლად მეშვეობით ბრძანებები
რომ თქვენ უბრალოდ აკრეფილი გამოყენებით up გასაღები, arrow გასაღები და შემდეგ ქვემოთ arrow გასაღები.
და რაც ყველაზე სასარგებლო ნაცვლად აკრეფით გარეთ ხანგრძლივი სახელები,
თქვენ გექნებათ გამოყენების Tab to თვითდასრულება რამდენიმე მითითებებს.
ახლა ჩვენ ვაპირებთ იმის დემონსტრირება ყველა იმ მხოლოდ მეორე.
ასე რომ, თუ თქვენ არ მახსოვს მათ, არ ინერვიულოთ.
ეს ის საკითხებია, რომ თქვენ შეარჩიო და გამოიყენოთ როგორც ჩვენ წავიდეთ ერთად.
OK.
>> ასე რომ, C განსხვავებით ნულიდან C არის შედგენილი ენაზე.
ეს ნიშნავს, რომ ჩვენ ვაპირებთ, რომ მიიღოს წყარო ფაილი, რომელიც არის ტექსტი, რომ წერთ,
ბრძანებები, წერთ, printf () განცხადებებს, მარყუჟების,
ყველაფერი else-- და ჩვენ ვაპირებთ იმისათვის, რომ ფაილი და გადასცემს მას off
პროგრამა ეწოდება შემდგენელი.
>> შემდგენელი შემდეგ მიიღებს რომ ტექსტი, რომ თქვენ წერილობითი
და თარგმნა ორობითი ინსტრუქციები
რომ თქვენი კომპიუტერი არის რეალურად აპირებს გამოყენება.
რომ ე.წ. ობიექტი ან შესრულებადი ფაილი.
თუ გადავხედავთ ეს ფაილი, თქვენ აპირებს იმისათვის, რომ ნახოთ კოდი, რომ თქვენ წერილობითი.
თუ გადავხედავთ ეს ფაილი, თქვენ აპირებს იმისათვის, რომ ნახოთ შემთხვევითი თანმიმდევრობა გმირები
რომ არ გაუმახვილებიათ.
ეს იმიტომ, რომ ეს არის ორობითი.
ეს არ ნიშნავს, თქვენ უნდა კითხულობს.
>> თუმცა, ნებისმიერ დროს გსურთ აწარმოებს რაღაც, რაც თქვენ ვაპირებთ
გაშვებული არის ამ ობიექტის ფაილი.
ასე რომ, როდესაც ჩვენ ვმუშაობთ ამ ფაილი, ჩვენ წერენ ფაილის C.
ჩვენ მაშინ შედგენა ის გამოყენებით ბრძანება მოსწონს, რომელიც გამოიწვევს
შემდგენელი clang, რომ C ენაზე.
და რომ წარმოების ობიექტი ფაილი, როგორც გარეთ, ან ამ შემთხვევაში,
სახელი, ჩემი ფაილი, რომელიც მე დააყენა.
ყველა უფლება.
>> მოდით რეალურად ცდილობენ.
ასე რომ, მე გამოვიდა მაგალითად რა მინდოდა ცდილობენ.
და კიდევ ერთი რამ, რომ fascinates ჩემთვის ანიმაცია.
ასე რომ, ჩვენ ვაპირებთ, რომ ვცდილობთ გავაკეთოთ ცოტა ანიმაცია
მხოლოდ გამოყენებით ASCII სიმბოლოებს.
პერსონაჯები ჩვენ შეგვიძლია ამობეჭდოთ მარტივად არის.
>> ასე რომ, აქ არის ჩემი საუკეთესო მცდელობა შექმნა თქვენთვის
ანიმაცია კურდღელი გადის მაღალი ბალახის.
აი ისიც.
OK.
ასე რომ, ის არ არის გაშვებული არ არის, მაგრამ ის იქ მდგომი in tall ბალახის.
>> ახლა თუ მე ანიმატორად, ძველი სკოლის
მობილური ანიმაცია, რაც მე ყველაფერს გააკეთებს, მე აწარმოოს
სურათს ამ bunny ბალახის.
და მერე, რომ აწარმოოს სხვა სურათზე
სხვა, რაც მათ მოუწოდა საკანში რომ ჰქონდა bunny მხოლოდ ოდნავ გადავიდა.
და შემდეგ მესამე ერთი რომ ჰქონდა bunny გადავიდა ცოტა უფრო.
>> და მე აწარმოოს მთელი თანმიმდევრობა ეს საკნები.
ზოგიერთი, სადაც bunny დასრულდა გადატანა მარცხენა მხარეს.
და მაშინ მოძრაობს ნელა, ერთი ერთი მიმართ შუა.
და შემდეგ შუა მეტი უფლება.
და თუ იყო მაშინ, ნამდვილად გაუმართლა, მე ვერ დააყენა ერთად
და მე ვერ animate მათ.
და იქ ჩემი bunny გადის ბალახის.
>> ეს არის ჩემი დიდი PowerPoint შეასრულა იმ დღეს.
OK.
ასე რომ, ეს არის როგორც კარგი, როგორც იგი იღებს.
OK.
ასე რომ, აქ კიდევ ერთხელ, აქ არის ჩვენი bunny გადის ბალახის.
>> დინამიკები 19: ისევ და ისევ.
ბრაიან SCASSELLATI: ერთი მეტი დრო, ყველა უფლება.
არსებობს თქვენს bunny.
OK.
>> ასე რომ, დღეს, რასაც ჩვენ ვაპირებთ რომ არის ჩვენ ვაპირებთ
ცდილობენ ავტომატიზირება პროცესში წარმოების ეს საკნები.
ჩვენ არ საკმაოდ მისაღებად წერტილი მიმდინარეობს შეუძლია, რომ მათ ყველა ერთად.
მაგრამ, ჩვენ ვაპირებთ, რომ ცდილობენ ავტომატიზაცია პროცესში გამოიმუშავებს ამ თანმიმდევრობით.
>> და ეს არის ბევრი რამ, რაც ანიმაცია ჰგავს დღეს.
რომ არის, არ გააკეთებს რამ აუცილებლად ხატვის ყველაფერს ხელით.
ჩვენ ვიყენებთ კომპიუტერული ავტომატიზაცია ნაწილები, რომ პროცესი.
OK.
>> ნება მომეცით გადართოთ მეტი ახლა ჩვენი CS50 IDE.
და მე შევქმენით us-- და მოდით მომეცით მიუახლოვდით აქ ცოტა bit-- მე
შეიქმნა ჩვენთვის ამოსავალი წერტილი.
>> ყოველ ჯერზე, რომ ჩვენ ვთხოვთ თქვენ უნდა იჯდეს ქვემოთ და დაწეროთ ნაჭერი კოდი,
ის, რაც ჩვენ ნამდვილად ითხოვს, თქვენ უნდა გავაკეთოთ არის ჩვენ ითხოვს პრობლემის გადაჭრას.
და ისე, რომ თქვენ უნდა ვიფიქროთ აკეთებს, რომ
არის დაწყებული ზოგიერთი მარტივი ნაწილი, რომ გამოსავალი.
და მაშინ ავაშენოთ, რომ ნაწილი.
და რომ ის, რასაც ჩვენ ვაპირებთ, რომ დღეს.
>> ასე რომ, ვიდრე ცდილობს ერთდროულად წერენ მთელი bunch of კოდი, რომელიც
აპირებთ იმ 10 ანიმაცია საკნები,
ჩვენ ვაპირებთ, რომ დაიწყოს ნაცვლად ერთი ნაჭერი, რომელიც მუშაობს.
და მაშინ ჩვენ ავაშენებთ ცოტა გარშემო, რომ
და ცოტა მეტი და ცოტა მეტი.
>> ახლა კარგი რამ შესახებ პრობლემის გადაჭრის ამ გზით
ის არის, რომ ეს საშუალებას გაძლევთ, რათა დაიწყოს ყოველთვის არის რაღაც, რომ თქვენ იცით,
მუშაობს და წარმოგიდგინოთ ერთი ეტაპობრივი ცვლილება.
და ეს არის დიდი გზა ვისწავლოთ თუ როგორ უნდა კოდი,
რადგან ყოველ ჯერზე თქვენ მიიღოს ცვლილება, თქვენ ხედავთ, თუ რა გავლენა აქვს.
OK.
>> ასე რომ, აქ არის ჩვენი ამოსავალი წერტილი.
OK.
ასე რომ, დასაწყისში ჩემი ფაილი, მე hash #included stdio.h.
ეს არის ის, ისე, რომ მე შეუძლია მიიღოს printf () ფუნქცია მუშაობს.
>> მე მაქვს ჩემი მთავარი ფუნქცია.
და ეს მაინც გამოიყურება პატარა arcane ან ბუნდოვანი ზოგიერთ თქვენგანს.
ეს არის ის, OK.
ყველა ის ამბობს, რომ მთავარი ფუნქცია იღებს
არსებობს არგუმენტი ბათილად საშუალებით არაფერი C. ეს
ანაზღაურება კონვენციის მთელი რიცხვი.
მთავარი ყოველთვის ბრუნდება რიცხვი, ჩვეულებრივ კოდი ამბობდა რამ
წავიდა კარგად ან არ წავა კარგად.
OK.
მაგრამ მთავარი უნდა ჰქონდეს, რომ ქმნიან ჩვენთვის ახლავე.
>> მე მაშინ დააყენა სამი ხაზი კოდი.
და ერთად თითოეული ხაზი კოდი, მე დააყენა კომენტარი.
ახლა ერთი რამ, რომ ჩვენ მოვითხოვთ, რომ თქვენ,
და ეს ასეთი მნიშვნელოვანი პროგრამირების პრაქტიკა,
ყოველთვის კომენტარი თქვენი კოდი.
ყოველთვის ჩაწერეთ ქვემოთ ინგლისური კომენტარის რაღაც
რომ ფიქრობთ, კოდი უნდა გააკეთოს.
ასე რომ, მოგვიანებით, როდესაც თქვენ დაბრუნდება მას, შეგიძლიათ შეხედეთ მას და თქვენ შეიძლება ითქვას,
ოჰ, მე მახსოვს რა იყო ცდილობს გააკეთოს ეს.
ან როდესაც TA ზის ქვემოთ თქვენ ცდილობენ, რათა დაგეხმაროთ საათებში,
მათ შეუძლიათ შევხედოთ და წავიდეთ, მე ვხედავ, თუ რას ცდილობს,
მაგრამ ნაცვლად ეს რა ხდება რეალურად.
OK.
>> ასე რომ, მე მაქვს სამი ნაწილისგან ჩემი კოდი, მე ვაპირებ პირველ რიგში ბეჭდვითი
გარკვეული წერტილების სტარტზე.
მე მაშინ ამობეჭდოთ ჩემი ძალიან ლამაზი bunny.
და შემდეგ რამდენიმე ცოტა წერტილები ბოლოს.
>> და ეს სამი ბეჭდვითი განცხადებები უნდა გამოიყურება ნაცნობი თქვენ ამ ეტაპზე.
ყველა მე ვაკეთებ თითოეული მათგანი ვარ
დაბეჭდვისას თანმიმდევრობა სიმბოლო.
არ არსებობს ცვლადები ჩართული.
ყველაფერი მხოლოდ ბინა.
OK.
>> ასე რომ, თუ დაცემას ახლა ჩემს ტერმინალში მოდით ვნახოთ, თუ მე შეუძლია მიიღოს ამ თავში out--
და მე ვაპირებ აკრიფოთ წმინდა ერთხელ.
>> დინამიკები 20: ვიყენებთ ორმაგი სლეში, კომენტარს?
ბრაიან SCASSELLATI: Can გამოიყენოთ ორმაგი დიახ.
არსებობს მრავალი გზა დატოვონ კომენტარი in C. ერთი
გზა არის გამოიყენოს ორმაგი ხაზი.
სხვა გამოიყენოს ხაზი და ვარსკვლავი და შემდეგ ახლოს ვარსკვლავი და ირიბის.
ყველა უფლება.
>> პირველ რიგში, მე ვაპირებ დაიწყოს სანავიგაციო გარშემო აქ.
ასე რომ, თუ მივდივარ ჩემი სახლის დირექტორია, მე შეიცვალა საიტები არსებობს,
მე ვაპირებ თვალი და ვნახოთ, რა არის რომ დირექტორია, ls, მიუთითეთ out.
მე ვაპირებ ვხედავ, რომ მე მიიღო ორი subdirectories.
მოდით, ეს ცოტა დიდია აქ, ასე რომ ჩვენ შეგვიძლია ყველა ვხედავთ მას.
>> მე ვხედავ, რომ მე მიიღო ორი subdirectories.
მე შეცვლის დირექტორია წასვლას სამუშაო გარემოს.
და მე ვაპირებ მხოლოდ აკრიფოთ გარეთ ნაწილი, და შემდეგ უბრალოდ მოხვდა Tab.
და ეს თქვენ დაასრულებს დანარჩენი ჩემთვის.
Fancy.
>> მე შევხედოთ და ვნახოთ გარემოს.
და ახლა, მე მუშაობა წლის supersection
რომ ჩვენ სწავლების ახლავე.
ასე რომ, მე წასვლას, რომ დირექტორია.
და ბოლოს, ენახათ.
და მაქვს, რომ ფაილი bunny.c.
>> ყველა უფლება ნება მომეცით, ნათელი კიდევ ერთხელ.
და მე ვაპირებ, ახლა ისევ მე ჯერ კიდევ რჩებიან, რომ დირექტორია
და ის მეუბნებოდა, რომ მე ვარ რომ supersection დირექტორია.
მე ვაპირებ წავიდეთ წინ და რომ ჩემი პროგრამა bunny.
და რომ ბრძანება, რათა bunny, ხოლო sounding ცოტა უცნაური,
ასევე აღვიძებს clang შემდგენელი.
>> და ის წარმოებული მე გამომავალი, რომელიც არის
შემსრულებელი funny-- შესრულებადი ფაილი მოუწოდა bunny.
OK.
შემიძლია მაშინ, და ეს ხმები კიდევ უფრო უარესი, შეასრულოს bunny.
OK.
მოდით ვნახოთ რას აკეთებს.
OK.
ეს არის ის, ცოტა რა ელოდება.
მე მივიღე ჩემი bunny სურათი იქ, მაგრამ მე სახის მინდოდა ეს ყველაფერი თავისთავად.
რა მენატრება?
>> დინამიკები 21: Slash ლ ან ირიბის n.
ბრაიან SCASSELLATI: Slash n.
OK.
ასე რომ, მოდით დავუბრუნდეთ აქ.
და მე გავიდნენ, რომ.
და მე დაბრუნდეს ამ ერთი.
და მოდით შევხედოთ ახლა ჩემი მთავარი ფუნქცია აქ.
>> ასე რომ, რა უნდა გავაკეთო?
მე მინდა, რომ დამთავრდეს ონლაინ.
ასე რომ, მე ამას კომენტარი.
მე დააყენა printf ().
და რას უნდა ჩაიდოს?
/ n.
OK.
რა უნდა დამთავრდეს ეს?
მძიმით.
ყველა უფლება.
>> ახლა, ერთი ნამდვილად მნიშვნელოვანი რამ არის დარწმუნდით
ყოველ დროს, თქვენ მიიღოს ცვლილება თქვენი კოდი, რომ თქვენ შენახვა.
თუ თქვენ არ გადაარჩინა თქვენი კოდი, რომ თქვენ აპირებს შეამჩნია პატარა ვარსკვლავი არსებობს.
და რომ ვარსკვლავი ამბობს, არ გადაარჩინა ეს კოდი.
>> თუ კომპილირება ახლა, ეს არ არის აპირებს ასახავს იმ ცვლილებებს,
რადგან შემდგენელი უყურებს ფაილი რომ არის დისკზე, არ ფაილი, რომელიც არის
გახსნა თქვენი რედაქტორი.
ყველა უფლება.
>> ასე რომ, მოდით ეს და შემდეგ გავემგზავრებით უფლება ქვემოთ აქ, დავბრუნდები.
ჩამოდი ჩემი ტერმინალში.
და მოდით გარკვევა სივრცეში ერთხელ.
>> და ჩვენ შეგვიძლია წავიდეთ წინ და კიდევ ერთი დრო, რათა ჩვენი bunny პროგრამა.
და შეასრულოს bunny.
ეს არ იმუშავებს არც.
არასწორი ხაზი.
ასე რომ, თუ თქვენ შეხედეთ რა მაქვს, მე დააყენა / n იქ, მაგრამ მე მქონდა არასწორი ხაზი.
>> ყველაფერი, რაც თქვენს კომპიუტერში ამჯამად არის ძალიან ზუსტი.
OK?
ერთი პატარა შეცდომა პუნქტუაციის და მოულოდნელად თქვენ არ რა გსურთ.
ყველა უფლება.
მოდით zoom out უკან კიდევ ერთხელ.
ჩვენ დაბრუნდეს.
ისე მიიღოს, რომ ძალიან სწრაფი შეკეთება.
ჩვენ დააყენა უფლება slash წელს.
ჩვენ გადარჩენა მას.
ჩვენ მასშტაბის უკან.
>> გარკვეული მიზეზების გამო, რომ არ არის ბედნიერი, მაგრამ მოდით წავიდეთ წინ
და ჩვენ წავიდეთ თავში ტერმინალში აქ.
გარკვევა ეს.
ჩვენ მიუახლოვდით.
და კიდევ ერთხელ, ჩვენ გვექნება bunny.
ახლა დარწმუნებული ვარ, რომ მუშაობს.
Hooray.
OK.
>> მოდით ცდილობენ ამ ცოტა უფრო ზოგადად.
მოდით ვნახოთ, თუ ნაცვლად მხოლოდ ბეჭდვის ერთი კონკრეტული ჩარჩო,
მოდით ვნახოთ, თუ შეიძლება, რომ ეს ასე რომ ჩვენ შეგვიძლია მისაღებად ყველა 10
იმ ანიმაციური ფარგლებში რომ გვინდოდა.
ასე რომ კიდევ ერთხელ, ავიღოთ ამ ნაბიჯით იმ დროს.
>> მოდით პირველი განზოგადება ის, არ ისე, რომ მე ყველაფერი ფარგლებში,
მაგრამ ასე რომ რომელიმე ჩარჩო, რომელიც მე დაგვჭირდება.
ასე რომ, რა არის განსხვავება შორის ფარგლებში?
არის bunny იგივე?
აუდიტორია: დიახ.
ბრაიან SCASSELLATI: ჰო.
რა განსხვავებაა?
>> აუდიტორია: პოზიცია.
ბრაიან SCASSELLATI: მისი პოზიცია, არა?
და როგორ შემიძლია კონტროლი მისი პოზიცია?
რამდენი წერტილები ვარ აყენებს დასაწყისში
და რამდენი წერტილები ვარ აყენებს ბოლოს.
ასე რომ, მე ხუთ საათზე დაწყებული და ხუთი ბოლოს.
>> მოდით შეცვლის, რომ ხუთი ამისთვის loop.
OK.
და მე ვაპირებ, რომ შევქმნათ for loop ახლა რომ აპირებს ამბობენ,
მე ვაპირებ ბეჭდვა ზოგიერთი ნომერი წერტილების დასაწყისში.
მე ვაპირებ გამოიყენოთ ცვლადი.
მოდით, ვთქვათ, როგორ მე, როგორც კონტრ ჩემი loop.
და მე ვაპირებ განაცხადოს, up დაბრუნება.
>> და მაშინ ამისთვის მარყუჟის მე უნდა გავაკეთოთ სამი რამ.
პირველი, რაც უნდა გავაკეთოთ, არის მე უნდა ინიციალიზაცია i.
რა უნდა ინიციალიზაცია ეს უნდა დაიწყოს, რომ იყოს?
0.
OK.
>> მაშინ მე უნდა ვთქვა, რა არის შეწყვეტის მდგომარეობა?
როდის უნდა შეწყვიტოს?
ისე რამდენი წერტილები თქვენ გვინდა ბეჭდვა ამ ერთი?
>> აუდიტორია: ხუთი.
ბრაიან SCASSELLATI: ხუთი ერთხელ?
როგორ შესახებ მოდით რაღაც განსხვავებული, ჩვენ გავაკეთეთ ხუთ.
მოდით დავანახოთ, რომ ის განსხვავებულია.
დინამიკები 22: ორი.
ბრაიან SCASSELLATI: ორი.
OK.
ასე რომ, თუ მინდა ორი წერტილი, რა უნდა მე აქ?
>> აუდიტორია: სამი.
>> ბრაიან SCASSELLATI სამი.
OK.
როგორ ბევრჯერ არის, რომ აპირებს გავლა?
რომ აპირებს გავლა სამჯერ, 0, 1, 2, არა?
ყველა უფლება, მოდით დავუბრუნდეთ ქვემოთ ორი.
ამჟამად ჩვენ კიდევ ორი ​​წერტილი.
და რა არ მინდა ყოველ დროს მე გავლა loop?
რა უნდა შეიცვალოს ყოველ ჯერზე მე გავლა?
>> დინამიკები 23: დამატება dot.
>> ბრაიან SCASSELLATI: მე უნდა შევინარჩუნოთ აპირებს.
მე ვაპირებ, რომ დაამატოთ dot.
მე ვაპირებ ბეჭდვა dot, ყოველ ჯერზე მეშვეობით loop.
მაგრამ თუ როგორ ვარ მე შენახვა ტრეკზე თუ როგორ ბევრჯერ მე უკვე მარყუჟის?
მე გამოყენებით, რომელიც ცვლადი, რომელიც counter.
>> ასე რომ, ყოველ ჯერზე მეშვეობით, მე ვაპირებ ნამატი counter ერთი.
ახლა, რომ იგივე ჩემთვის, როგორც დაყრდნობით მე = i + 1.
ეს არის ის, OK.
მე ამას that-- მომწონს სტენოგრამის, ასე რომ მე ვაპირებ ვთქვა i ++.
OK.
>> მოდით გავაკეთოთ იგივე ქვემოთ აქ ბოლოში.
მხოლოდ მე სახის გააკეთა, რომ ერთი.
მე ვაპირებ მოგცემთ ბიჭებს ამისათვის ერთი მთლიანად.
ყველა უფლება.
>> ასე რომ, რა უნდა დავწერო აქ?
აი ჩემი for loop.
მე ვაპირებ გავაკეთოთ printf () და მე ვაპირებ ისე, რომ მე მხოლოდ ბეჭდვა ერთ dot
რომ ბოლოში.
>> რა უნდა დავწერო შიგნით ამ loop ახლა?
ისე, პირველ რიგში, რა ცვლადები უნდა გამოვიყენო?
>> დინამიკები 24: კ.
>> ბრაიან SCASSELLATI: მე ვერ გამოიყენებს კ.
შემიძლია იგივე ერთი?
შემიძლია მე კიდევ ერთხელ?
ჰო.
ეს კარგია, რადგან Is რომ მე გამოყენებით აქ,
მე არ უნდა კიდევ ერთხელ, როდესაც მე მიიღოს ქვემოთ ამ ეტაპზე.
>> ასე რა უნდა ინიციალიზაცია მე უნდა?
დინამიკები 25: 10.
ბრაიან SCASSELLATI: 0.
რა უნდა ნახოთ?
რამდენი წერტილები მჭირდება ახლა ბოლოს თუ მაქვს ორი წერტილი დასაწყისში?
მე უნდა რვა ბოლოს, ასე რომ, მე უნდა ნახოთ, i ნაკლებია, ვიდრე
>> აუდიტორია: შვიდი, რვა, ცხრა.
ბრაიან SCASSELLATI: გავიგე შვიდი.
გავიგე, რვა.
და გავიგე ცხრა.
OK.
ასე რომ, ჩვენ ყველა უფლება ball-- ჯეისონ ამბობს 10.
OK.
>> თუ მე საჭირო ორი წერტილები პირველი, რამდენი
არ მე და მე უნდა რვა წერტილები, რომ ბოლო ერთი მე დააყენა ორი ზემოთ,
რა უნდა დააყენოს ქვემოთ?
>> აუდიტორია: რვა.
>> ბრაიან SCASSELLATI: რვა.
იმის გამო, რომ აპირებს იმედი ნულოვანი მეშვეობით შვიდი.
და რომ ის რვაჯერ მეშვეობით loop.
OK.
და რა უნდა გავაკეთოთ, ბოლოს?
>> აუდიტორია: i ++.
>> ბრაიან SCASSELLATI: i ++.
ყველა უფლება.
ასე რომ, ის ეძებს საკმაოდ კარგი არსებობს.
მოდით ცდილობენ და ვნახოთ რას აკეთებს.
OK.
ამიტომ, ჩვენ ვაპირებთ, რომ გადავარჩინოთ ეს.
ლამაზი და გადაარჩინა.
>> ჩვენ zoom out უკან.
ჩვენ შევეცდებით აქ ტერმინალში.
ჩვენ მიუახლოვდით.
Oops.
ჩვენ გამოგიგზავნით, კიდევ ერთხელ, რათა ჩვენი bunny პროგრამა.
და წავიდეთ წინ და შეასრულოს bunny.
და ეს არის.
>> ასე რომ ჩვენი bunny.
სადაც მას აქვს ორი წერტილი დასაწყისში და რვა წერტილები დასასრულს.
ყველას ისევ ჩემთან ერთად?
OK.
>> ასე რომ, ჩვენ ავაშენეთ ეს.
ჩვენ ავაშენეთ ერთი bunny, ერთი კონკრეტული ჩარჩო.
ახლა ჩვენ შევძელით განზოგადება, რომ ავაშენოთ
მეტი, სხვადასხვა სახის ფარგლებში.
>> ახლა მოდით წავიდეთ წინ, და ეს წარმოქმნის არა მხოლოდ ერთ ჩარჩოში,
მაგრამ მოდით წარმოქმნის 10 ფარგლებში, სადაც ჩვენ ნელ-ნელა
რათა bunny გადავიდეს ყველა გზა მასშტაბით სფეროში.
ყველა უფლება.
>> მოდით დავუბრუნდეთ.
და ჩვენ შევეცდებით ახლა.
ასე რომ, რა მე ნამდვილად აქ უნდა შეიცვალოს?
რა უნდა შეიცვალოს?
>> დინამიკები 26: თქვენ ჯერ უნდა შეცვლა წერტილების რაოდენობა მაქსიმალური
დასაწყისში.
იმიტომ, რომ თუ ჩვენ ვაკეთებთ 10 წერტილები, ის აპირებს უნდა up მასშტაბით.
ბრაიან SCASSELLATI: ჰო.
ასე რომ, ახლა მე მაქვს ეს ერთგვარი სხვებთან ყოველთვის ორ წერტილები დასაწყისში
და ყოველთვის რვა წერტილები ბოლოს.
>> მინდა ავაშენოთ სხვა მარყუჟის, არა?
იმიტომ, რომ მე არ მინდა, რომ აშენება მხოლოდ ერთი bunny სურათი,
მინდა აშენება 10 bunny სურათები.
ასე რომ, მე უნდა ავაშენოთ კიდევ ერთი მარყუჟი, და როგორც მე გაიაროს, რომ მარყუჟი,
მინდა, რომ შეიცვალოს, თუ რამდენი წერტილების მე ბეჭდვა დასაწყისში
და რამდენი წერტილები მე ბეჭდვა ბოლოს, რომლის საფუძველზეც ციკლის მეშვეობით loop
მე ვარ.
ყველა უფლება.
>> მოდით კიდევ ერთი მთვლელი.
ვიღაცის წინაშე განაცხადა, j, ასე რომ, ჩვენ, რათა კიდევ ერთი კ.
და ახლა, ჩვენ ვაპირებთ აშენება სხვა for loop.
>> რა მიდის შიგნით რომ loop?
ამ პერსონალის უნდა წავიდეს შიგნით მარყუჟის, არა?
ამჯამად bunny აქვს წასვლა შიგნით loop?
მჭირდება bunny in თითოეული იმ 10 ფარგლებში?
>> აუდიტორია: Uh-huh.
ბრაიან SCASSELLATI: ჰო.
მე მინდა bunny თითოეულ საქართველოს 10 ფარგლებში, უფლება?
როგორ შესახებ წერტილების ბოლოს და ბოლოს, მჭირდება, რომ?
OK.
>> ამიტომ, მე ვაპირებ აბზაცის ყველა მათგანი.
მე ვაპირებ ხაზი გავუსვა ყველა ეს, და მე ვაპირებ, რომ მოხვდა Tab.
და რომ აპირებს დააყენებს მათ მთელი ცოტა, ისე, რომ ეს ჩემთვის ადვილი
ვნახოთ, რა არის ამ loop.
და მაშინ მე დასრულდება იგი.
მოდით ვთქვათ.
OK?
>> ახლა, ამ მარყუჟის, რომ მე building-- whoops,
იმისათვის, რომ ეს ასე რომ თქვენ შეგიძლიათ see-- მე მივიღე ჩემი counter კ.
მე დაიწყო 0.
რამდენჯერ მინდა გავლა ამ loop?
აუდიტორია: 10 ჯერ.
ბრაიან SCASSELLATI: 10 ჯერ.
ასე რომ, რა ნომერი უნდა მე აქ?
>> აუდიტორია: 9, 10.
>> ბრაიან SCASSELLATI: 9, 10, ვიღაცის მივიღე ვთქვა 11, არა?
მინდოდა ორი წერტილი ადრე და მე ნაკლები 2.
მინდოდა რვა წერტილები, დააყენა i არანაკლებ 8.
ახლა მინდა გავლა 10 ჯერ, ამიტომ დააყენა j ნაკლებია, ვიდრე
>> აუდიტორია: 10.
>> ბრაიან SCASSELLATI: 10.
იქ ჩვენ წავიდეთ.
და რა გავაკეთო ბოლოს j?
++, იყოს იგი.
OK.
ახლა, აქ არის სახიფათო ნაწილი, რა არის მოხდება ახლა, თუ ამის გაკეთება?
მე აპირებს ბეჭდვა 10 ფარგლებში?
დინამიკები 27: ვფიქრობ, ისინი ყველა ერთი და იგივე იყოს.
ბრაიან SCASSELLATI: ისინი იყოს იგივე, არა?
იმიტომ, რომ ყველა მათგანი ჯერ კიდევ აპირებს იმისათვის, რომ ორი წერტილი დასაწყისში.
მაგრამ მე არ მინდა მათ ყველა აქვს ორი წერტილი დასაწყისში.
რამდენი წერტილები შემიძლია გსურთ დასაწყისში?
>> აუდიტორია: შეცვლა.
>> ბრაიან SCASSELLATI: I მინდა, რომ ის შეიცვალოს, არა?
ასე რომ, რა მაქვს აქ რომ იცვლება თითიეულ გადის?
>> აუდიტორია: პუნქტების წერტილები, კ.
ბრაიან SCASSELLATI: j, წერტილების რაოდენობა.
ასე, რომ შეიძლება შეიცვალოს ეს უნდა იყოს კ.
პირველად მეშვეობით loop, რა, რომ იქნება?
რა მითითებული კ პირველ რიგში?
>> აუდიტორია: 0.
>> ბრაიან SCASSELLATI: ასე რომ, რამდენი ჯერ მე ვაპირებ ამის გაკეთება?
0.
მეორედ მეშვეობით loop, კ-ს იქნება 1, რადგან მე ნამატი.
რამდენი წერტილები ვაპირებ ბეჭდვა?
1.
მესამედ მეშვეობით loop, რამდენი წერტილები ვაპირებ ბეჭდვა?
>> აუდიტორია: სამი.
ბრაიან SCASSELLATI: j იქნება 3.
რამდენი წერტილები ვაპირებ ბეჭდვა?
ოჰ, უკაცრავად, j იქნება 2.
რამდენი წერტილები ვაპირებ ბეჭდვა?
>> აუდიტორია: 2.
>> ბრაიან SCASSELLATI: 2.
OK, ასე რომ მე ვაპირებ შენარჩუნება დამატება, რომ, როგორც ჩვენ წავიდეთ ერთად.
როგორ შესახებ ქვემოთ?
რა მიდის ქვემოთ აქ?
მე არ მინდა, 8 ყოველთვის ბოლოს აღარ?
>> დინამიკები 28: 10.
ბრაიან SCASSELLATI: მინდა 10 წერტილებს?
მე მინდა, რომ შეიცვალოს, ძალიან.
ასე რომ, მე მინდა, რომ შეიცვალოს?
>> აუდიტორია: [INAUDIBLE].
ბრაიან SCASSELLATI: ისე, თუ მე აქვს ხუთი წერტილები დასაწყისში,
რამდენი dot ის მივიღო ბოლოს?
>> აუდიტორია: ხუთი.
>> ბრაიან SCASSELLATI: თუ მაქვს ექვსი წერტილები დასაწყისში,
რამდენი მივიღო ბოლოს?
აუდიტორია: ოთხი.
ბრაიან SCASSELLATI: თუ მე მივიღე შვიდი წერტილები დასაწყისში,
რამდენი მივიღო ბოლოს?
აუდიტორია: სამი.
ბრაიან SCASSELLATI: თუ მე მიიღო j წერტილები დასაწყისში,
რამდენი მივიღო ბოლოს?
10-კ.
OK.
მოდით ცდილობენ, რომ.
>> ამიტომ, მე ვაპირებ, რათა გადავარჩინოთ ჩვენი bunny პროგრამა.
კიდევ ერთხელ ჩვენ დააშორებს.
ჩვენ ქვევით რომ ჩვენს ტერმინალში.
ჩვენ გარკვევა იყო.
და მასშტაბის in.
ჩვენ გავაკეთებთ ჩვენი bunny პროგრამა, კიდევ ერთხელ.
და ჩვენ შეასრულოს იგი.
Uh-oh.
>> გამართავს, მოდით დააშორებს.
მივიღებ 10 ფარგლებში?
ისე, რამდენი bunnies ვხედავ იქ?
1, 2, 3, 4, 5, 6, 7, 8, 9, 10.
მე მივიღე 10 ფარგლებში.
არიან ისინი ყველა ერთი და იგივე?
აუდიტორია: Yeah.
No.
>> ბრაიან SCASSELLATI: No.
ეს პირველი, bunny შორს მარცხენა.
და აქ, bunny არის შორს
დინამიკები 29: მარჯვენა.
ბრაიან SCASSELLATI: ასე რომ, რა მოხდა, მე უნდა დაგვავიწყდეს?
დინამიკები 30: დაწყება ახალი ხაზი.
ბრაიან SCASSELLATI: დამავიწყდა დაიწყოს ახალი ხაზი, კიდევ ერთხელ.
იგივე შეცდომას მე მივიღე ადრე.
ყველა უფლება, მოდით წავიდეთ დაფიქსირება, რომ.
ახლა, მე მაინც კოდი იქ, რათა ახალი ხაზი.
რატომ არ მუშაობს?
დინამიკები 31: ეს არ არის შიგნით loop.
ბრაიან SCASSELLATI: Oh, ეს არ არის შიგნით loop.
ეს უფლება.
ის იჯდა აქ.
და ამისთვის loop არის ყველაფერი რომ არის შიგნით, რომ ტექსტი.
>> ამიტომ, მე ვაპირებ გადაადგილება ეს შიგნით ამისთვის loop.
და მე Tab წინაშე, რომ ჩანს, რომ ეს არის სწორი ადგილი.
და ახლა, ჩვენ გადარჩენა მას ერთხელ.
ჩვენ დააშორებს.
ჩვენ გადართოთ მეტი ჩვენს ტერმინალში.
გადიდება.
ჩვენ რიმეიკი ჩვენი bunny პროგრამა.
და ახლა, ახლა ჩვენ მივიღეთ ჩვენი 10 ფარგლებში.
>> [ტაშს]
>> ბრაიან SCASSELLATI: OK.
ასე რომ.
აქ არის ჩვენი წყობილი ამისთვის მარყუჟების.
ჩვენ შევძელით, რომ გენერირება შიდა loop რამდენი წერტილები მინდოდა
ბეჭდვა დასაწყისში, ბოლოს.
და გარე მარყუჟის აკონტროლებს რამდენი ფარგლებში მე მშენებლობაზე.
ჩვენ დავიწყეთ ერთი პატარა kernel პრობლემა,
ჩვენ ავაშენეთ out ამ კუთხით.
ყველა უფლება.
>> მოდით გავაკეთოთ კიდევ ერთი ნაბიჯი.
თქვენ მზად?
არსებობს ერთი რამ აქ, სადაც ჩვენ, ფაქტობრივად, სახის მიიღო
მეტი სირთულის, ვიდრე ჩვენ გვჭირდება.
მოდით შევხედოთ.
ასე რომ, ჩვენი bunny პროგრამა, თუ დააშორებს აქ,
მე რეალურად ერთი და იგივე რამ უსასრულოდ.
რა გავაკეთო, რომ ერთგვარი იგივე განმეორდეს ორჯერ?
>> დინამიკები 32: ბეჭდვა წერტილები.
>> ბრაიან SCASSELLATI: ჰო მე ბეჭდვა იმ წერტილების ორჯერ.
მართლაც, მე უნდა ამ კომენტარის ქვემოთ აქ.
მე ბეჭდვა ზოგიერთი წერტილების იწყება, უფლება მდე აქ.
და მერე ბეჭდვა ზოგიერთი წერტილები ბოლოს.
და მე სახის ზუსტად იგივე.
ის, რასაც ჩვენ ვაპირებთ დავიწყოთ მუშაობა მომდევნო რამდენიმე კვირის განმავლობაში
მიმდინარეობს შეუძლია მიიღოს იმ ბლოკები კოდი, რომ ჩვენ ვიყენებთ უსასრულოდ,
და პროცესის მეშვეობით მოუწოდა აბსტრაქცია,
ჩვენ ვაპირებთ, რომ გაიყვანოს ისინი და წერენ მათ ერთხელ ისე, რომ ჩვენ შეგვიძლია შემდეგ
reuse მათ უსასრულოდ.
მოდით ვეცადოთ, რომ.
მზად?
>> ჩვენ ვაპირებთ, რომ მიიღოს ამ ბლოკი კოდი.
და მე ვაპირებ მას იქ.
და მე ვაპირებ define-- ქვემოთ ბოლოში,
მე ვაპირებ დაწერა ახალი ფუნქცია.
ის არ აპირებს დაბრუნებას არაფერი.
და მე ვაპირებ მოვუწოდო მას printDots.
>> იგი აპირებს მიიღოს ერთი არგუმენტი, მთელი რიცხვი, რომელიც
ამბობს howManyDots მე უნდა ბეჭდვა.
ახლა ნაცვლად დაბეჭდვის j წერტილები, მე ბეჭდვა გითხრათ howManyDots მე უნდა ბეჭდვა.
>> და იქ ერთი პატარა პრობლემა აქ.
ვინმე იცით, რა არის ეს?
რა მაქვს, რომ ჩამოთვლილი აქ რომ არ არის განსაზღვრული?
>> აუდიტორია: [INAUDIBLE]
>> ბრაიან SCASSELLATI: ისე როგორ ბევრი წერტილები განისაზღვრება უფლება
აქ, მაგრამ მე რომ ცვლადი i.
ასე რომ, მე ვაპირებ, რომ ცვლადი i და მე ვაპირებ, რომ განსაზღვროს ის ქვემოთ აქ
ნაცვლად.
>> ასე რომ, ახლა ის აპირებს stay-- oops, მივიღე caps lock on რატომღაც მე
ვაპირებ შენარჩუნება i ქვემოთ აქ.
>> ასე რომ, ახლა აქ არის ჩემი პატარა ფუნქცია ან ქვე-სიტუაციიდან, და ის ამბობს,
რამდენი წერტილები ვაპირებ ბეჭდვა?
და ეს გავლა ამ მარყუჟის და ბეჭდვა მათ უსასრულოდ.
>> მე მაშინ ცვლილებები ჩემი პროგრამა აქ.
და რა მოვუწოდებ, რომ ფუნქცია?
printDots.
ასე რომ, მე მოვუწოდებ printDots.
რამდენი წერტილები არ მინდა ბეჭდვა პირველად ადრე bunny?
აუდიტორია: კ.
ბრაიან SCASSELLATI: კ.
რამდენი წერტილები არ მინდა ბეჭდვა ბოლოს, მას შემდეგ, რაც bunny?
10-კ.
>> და არსებობს ერთი რამ, მე დაკარგული.
როგორც თქვენ ნახეთ ლექცია დღეს, ჩვენ ვაპირებთ, რომ განაცხადოს printDots
ზემოთ, რათა პროტოტიპი.
OK.
>> ასე რომ, რასაც მე ვაკეთებ არის მე სცადა იზოლირებას, რომ reused ნაწილი კოდი
რომ მე ვაკეთებ უსასრულოდ.
და მე შევეცადე გაიყვანოს იგი გარეთ ისე, რომ ყველა, რომელიც შეიცავს ერთ ადგილას.
ასე რომ, თუ მე მაქვს შეცდომა სადღაც, მე მხოლოდ უნდა გაასწორონ ის ერთ ადგილზე.
ყველა უფლება.
>> მოდით გადარჩენა მას.
და მოდით დარწმუნდით, რომ იგი მუშაობს.
მოდით წავიდეთ out.
ჩვენ წავიდეთ ერთხელ ჩვენს ტერმინალში.
ჩვენ მიუახლოვდით.
ჩვენ გავაკეთებთ, რომ bunny პროცესში.
>> Oh.
და ეს მომცა გაფრთხილება.
რა არის ეს მეუბნებოდა?
ისე ნებისმიერ ამ ჯერ, თქვენ ყოველთვის გვინდა
გადახვევა პირველივე შეცდომა ახლა ამ ერთი, მე მხოლოდ ერთი.
>> ეს მითხრა bunny.c, ხაზი 8, სვეტი 9, არსებობს პრობლემა.
იგი აცხადებს, რომ, თქვენ განაცხადა ცვლადი მე და თქვენ არ გამოიყენება იგი.
>> ახლა ჩვეულებრივ, ეს არის არ არის ყველაზე უარესი შეცდომა.
ეს არის ადვილი დაფიქსირება.
და სინამდვილეში, ჩვენ შეგვიძლია წავიდეთ უკან.
ჩვენ შეგვიძლია დაბრუნდეს bunny.
და ამ შემთხვევაში, ჩვენ ყველა უნდა გავაკეთოთ არის მოშორება i,
იმიტომ, რომ ჩვენ არ იყენებს i ფარგლებში ძირითადი აღარ.
ჩვენ უბრალოდ იყენებს ჩვენს sub-სიტუაციიდან.
>> მოდით გადარჩენა, რომ.
ჩვენ დაბრუნდეს.
და მასშტაბის in.
ჩვენ კიდევ ერთხელ მიიღოს bunny.
და ისევ იქ არის ჩვენი 10 ფარგლებში.
OK.
>> ნებისმიერ დროს თქვენ მოცემული procedure-- ჰო.
დინამიკები 33: მე მაქვს a-- დავიბენი.
შეგიძლიათ დაბრუნდეს კოდი?
ბრაიან SCASSELLATI: Yep.
>> დინამიკები 33: ასე რომ, როდესაც თქვენ წერდა თქვენი პროტოტიპი, არგუმენტი
ჰქონდა მას სახელად ეწოდა howMany?
მაგრამ, below--
>> ბრაიან SCASSELLATI: Oh yeah.
>> დინამიკები 33: --called მათ რაღაც განსხვავებული, მე არ მესმის.
>> ბრაიან SCASSELLATI: რატომ არიან ისინი სხვადასხვა.
ასე რომ, დიდი კითხვა.
ასე რომ კითხვა იყო, up აქ, მე დავწერე howMany,
და ქვემოთ, მე დავწერე howManyDots.
>> ამის მიზეზი ის არის, რომ თქვენს პროტოტიპი, ეს რეალურად არ გადამხდელი ყურადღებას
სახელები, რომ თქვენ აყენებს.
ყველა ეს ნამდვილად ზრუნავს არის, რომ ეს რიცხვი.
მას სურს იცოდეს ფორმა რას აყენებს.
>> ახლა stylistically-- oops-- რა უნდა არ არის მე მინდა, რომ ეს მატჩი.
OK.
იმის გამო, რომ უნდა შევინარჩუნოთ ის ადვილია ჩემთვის მახსოვს.
მაგრამ ეს იყო ჩემი შეცდომა ჰო.
>> დინამიკები 34: და ისე პროტოტიპი მუშაობს, უბრალოდ
წერდა, რომ ხაზი, წერილობით პროტოტიპი,
საშუალებას იძლევა, რომ ფუნქცია, რომელიც გააჩნია უფლება ქვემოთ წასვლა ბოლოს
და ახლიდან რას ნიშნავს ეს?
>> ბრაიან SCASSELLATI: რას ნიშნავს არის როდესაც შემდგენელი გადის,
იგი მიდის ზევით თქვენი კოდი ბოლოში.
და რა ეს პროტოტიპი, არის ეს, ძირითადად, დაპირება.
>> იგი აცხადებს, რომ, არ იქნება ფუნქცია განსაზღვრულია სადღაც.
ეს იქნება ე.წ. printDots.
და ის აპირებს მიიღოს ერთი არგუმენტი რომ იქნება მთელი რიცხვი
და ის აპირებს დაბრუნებას არაფერი, ბათილად ტიპის.
OK.
გპირდებით, რომ ეს იქნება განსაზღვრული სადღაც ქვემოთ გზა.
მაგრამ ნებისმიერ დროს ხედავთ რომ, როგორც თქვენ დაცემას
დანარჩენ ჩემი მთავარი ფუნქცია, მინდა
თქვენ მკურნალობა, რომ როგორც ფუნქცია რომელიც იღებს ერთი რიცხვი შეყვანა.
>> ასე რომ, როდესაც შემდგენელი მიდის ქვემოთ ამ გზით, ის ხედავს, რომ დაპირება.
და როდესაც იგი იღებს ქვემოთ, გრძელდება, გრძელდება,
იგი მიიჩნევს, პირველად printDots არის ნახსენები.
ის ამბობს, ო, თქვენ მიცემა ჩემთვის ეს კ. j არის მთელი რიცხვი.
>> ისე თქვენ დამპირდა, რომ იყოს რიცხვი და ეს უფლება.
ეს არის ის, OK.
და ბოლოს, ქვემოთ ძალიან ბოლოში,
სანამ მე ბოლომდე ჩემი ფაილი, მე კარგი ჩემი დაპირება
მე და განსაზღვრავს მას.
OK?
>> დინამიკები 35: ასე რომ, ეს saves-- პროგრამის გადაარჩენს ცარიელი ფართები
რომ მიდის უკან და ავსებს ბოლოს?
>> ბრაიან SCASSELLATI: ეს არ არის მეხსიერების გამოყოფა.
ეს, ფაქტობრივად, მხოლოდ იმაზე, თუ რა ტიპი ელით ვხედავ.
თუ ეს ის ერთ-ერთი არგუმენტი, ან ხუთი არგუმენტები?
უნდა ჰქონდეს რიცხვებით იქნება მიეცეს მას, და სიმები?
ეს არის ყველა ის ეძებს უნდა გააკეთოთ, რათა შეამოწმოს,
თქვენ მაძლევს უფლება სახის არგუმენტი.
OK?
ყველა უფლება.
>> ნება მომეცით დატოვება თქვენ ერთი სხვა ცოტა შევხედოთ.
ASCII art არ არის დიდი მოდელი ანიმაცია, როგორც ეს დღეს არის.
მაგრამ ზოგიერთი ადამიანი, რა თქმა უნდა მიიღოს რამ და ისინი დააყენებს მათი უკიდურესი.
>> ეს არის, როგორც დავით აჩვენა ლექცია, ნაჭერი კოდი
რომ არავითარ შემთხვევაში არ ცდილობენ დუბლიკატი თავი.
იმიტომ, რომ ეს არის საშინელი სტილისტურად.
ფაქტობრივად, ეს მიზანია იყოს როგორც რთული, რაც შეიძლება წაიკითხა.
OK.
>> ასე რომ, ისევ, მოდით მიუახლოვდით აქ.
მე ვაპირებ წავიდეთ ახლა, შეცვლის დირექტორია.
მე ვაპირებ წავიდეთ ერთ დონეზე, უკან ჩემი სამუშაო.
მე მაშინ შეცვალოს დირექტორია ამ სხვა მომსახურება, რომელიც მე შეიქმნა.
>> და ეს არის საერთაშორისო Obfuscated C პროგრამირების კონკურსი.
Obfuscated საშუალებებით, როგორიცაა მძიმე რაც შეიძლება იმის გაგება.
ასე რომ, გთხოვთ, არ უნდა გვეშინოდეს თუ გადავხედავთ ამ და წავიდეთ, მე ვერ წავიკითხე, რომ.
ეს არის წერტილი იგი.
OK?
>> მაგრამ, ჩვენ გვაქვს შესანიშნავი პროგრამა, რომელიც მე
ვაპირებთ შევხედოთ მხოლოდ აკრეფით მეტი.
მოდით ვნახოთ, თუ შემიძლია დააშორებს უბრალოდ ცოტა, ასე რომ თქვენ ხედავთ, რომ ეს
>> და ეს არის პროგრამა.
ეს დაასახელა endo.c.
და როგორც ჩანს, ამ bucket ერთად სახის ასო F-L-U-I-D ეს.
>> ეს არის რეალურად პროგრამა.
წერია ყველაზე ბუნდოვანი ისე, რომ ავტორები, შესაძლოა
დაწერა.
თუმცა, ეს არის მშვენიერი პატარა ნაჭერი, რომ ქმნის მოდელს სითხის დინამიკა.
>> ასე რომ, ჩვენ ვაპირებთ მისცეს რომ მოდელი შეყვანის რომ
ასე გამოიყურება, ერთი staired მითითებული კონტეინერების
ზოგიერთი სითხის, ზოგიერთი თხევადი, ზედა.
და გვექნება ეს სიმულაცია რა ხდება მას.
>> ასე რომ, მე მოვუწოდებ, რომ ფუნქცია, ენდო.
და მე მივცემ, რომ შეყვანის ფაილი, რომელიც მე მქონდა.
და არ არის ჩვენი განსახიერებაა ASCII art.
სრული სითხის დინამიკა სიმულატორი გაშვებული რამდენიმე ხაზი კოდი.
>> ახლა რა რეალურად საოცარი ეს პატარა პროგრამა
ის არის, რომ მე მინდა შეჩერება ახლა, ამიტომ მე ვაპირებ გამოიყენოთ, რა ბრძანება?
>> აუდიტორია: Control-C.
>> ბრაიან SCASSELLATI: Control-C. OK.
ასე რომ, მე გამოიყენოს საკონტროლო-C. C ეს შეწყვიტოს იგი.
მე გარკვევა ერთხელ.
და ახლა მე ვაპირებ მოიყვანონ პროგრამა, შეასრულოს პროგრამა,
გამოყენებით თავად როგორც შეყვანის.
>> ჩვენ დავინახავთ, სითხის დინამიკა სიმულაციური ის დნობის.
OK.
გთხოვთ, არ დავუშვებთ, რომ პროგრამა რამ რომ დაიბენით.
უბრალოდ ისე, რომ ჩვენ შეგვიძლია დასრულდება რაღაც მაგარი და საინტერესო.
OK.
>> საუკეთესო გისურვებთ თქვენი პრობლემა კომპლექტი.
ჩვენ მოხარული იქნება უპასუხოს კითხვები შემდეგ კლასი.
მადლობა ბევრი, ბიჭები.