>> JASON HIRSCHHORN: კეთილი CS50 მონაკვეთის, ყველას.
ჩემი სახელი ჯეისონ Hirschhorn.
მე ვარ ბევრი თქვენი TFS, მაგრამ ბევრი ხალხი იმედია შეუერთდება us
ამჟამად, გაგრძელების სტუდენტებს ან სტუდენტები ცდილობს გაეცნონ მონაკვეთზე, თუ ისინი
ხელიდან გაუშვა მათი მონაკვეთზე, რომ კვირას ან უბრალოდ დაწევას თუ უნდოდათ
გადახედოს ზოგიერთ მასალას.
>> ასე რომ, როგორც თითო სილაბუსში, რომელიც ყველა თქვენგანს წავიკითხე, სწორი?
მე ვხედავ ბევრი ხელმძღვანელი nods.
განყოფილებები მოგაწვდით შესაძლებლობების შეისწავლონ კურსის
მასალის უფრო ინტიმური გარემო, ისევე როგორც dive შევიდა
პრაქტიკული საქმიანობა.
>> ასე რომ, ძირითადად, რასაც ჩვენ უნდა აკეთებს ყოველ კვირას.
ჩვენ ვაპირებთ გაიაროს რაც გვაქვს განისაზღვრება ყველაზე მნიშვნელოვანი
განხილული თემები ლექცია და პირობა ალბათ, ასევე სასარგებლო და
სავარაუდოდ ამუშავება პრობლემების კომპლექტი და ვიქტორინებში, და თქვენს კოდირების
ცხოვრების გარეთ CS50.
ასე რომ, ჩვენ ვაპირებთ წასვლას ამ თემებზე, განიხილავს მათ, წავიდეთ მათზე,
უპასუხოს ნებისმიერ შეკითხვებს ბიჭებს და მაშინ ჩვენ ვაპირებთ ბევრი
პრაქტიკის პრობლემები კოდირების.
>> თქვენ მოუტანა ლაპტოპები, რაც სიმბოლო.
ეს არის კომპიუტერული მეცნიერების კლასის.
თუმცა, ბევრი წვრთნები ჩვენ გავაკეთებთ, თქვენ არ გვჭირდება თქვენი ლაპტოპები.
ამის გაკეთება შეგიძლიათ მათ ფურცელზე.
ეს არის ის, თუ როგორ ვაპირებთ ამის გაკეთება მათ ტესტები.
მართლაც, რომ არის დიდი გზა ვიცი, რომ თუ როგორ უნდა გავაკეთოთ
რაღაც თუ არ აქვს შემოწმება 50 დაეყრდნოს ან დაეყრდნონ, ვეუბნებოდი
გააკეთეთ ნებისმიერი შეცდომები.
>> ასე რომ, მობრძანდით, კოდი მოწყობილობების ან run.cs50.net, რომელიც
კიდევ ერთი ინსტრუმენტი, რომელიც საშუალებას გაძლევთ კოდი შემოსული, მაგრამ ასევე რეკომენდაციას, თუ
თქვენ არ სცადა ის გამოყენებით ფურცელი ქაღალდისა და ცდილობს ეს პრაქტიკა
პრობლემები ფურცელზე.
იმის გამო, რომ კიდევ ერთხელ, რომ საბოლოო ჯამში თუ რას აპირებს
სთხოვეს გავაკეთოთ ვიქტორინებში.
>> მოდით დავიწყოთ ჩვენი დღის წესრიგში დღეს.
ჩვენ ვაპირებთ წავიდეთ მეტი რამდენიმე ნორმები ჩვენს განყოფილებაში, მაშინ ჩვენ ვაპირებთ ჩაყვინთვის
შევიდა მასივების, ფუნქციები, და ბრძანება ხაზი არგუმენტები, რაც თქვენ ბიჭები
არ დაფარული გასულ კვირას ლექცია და შემდეგ ორშაბათს, და რა თქვენ დაფარავს
მეტი ხვალ.
შემდეგ კი, საბოლოოდ, ჩვენ ვაპირებთ ვისაუბროთ pset2.
თუ მე ვერ შოუ ხელში თუ არ უყურებდნენ პრობლემა ნაკრები ორი
დაზუსტება.
ჩვენ ამას ამბობენ ყველას.
ფორმები.
>> ჩვენ ამას ლაპარაკი პრობლემა კომპლექტი ცოტა, მაგრამ თუ წაიკითხა პრობლემა ნაკრები
დაზუსტება, რომ ყველა თქვენ უნდა გავაკეთოთ.
თუკი, რომ თქვენ მოვიდა კლასის და მონაკვეთის სამშაბათს, გნებავთ
დიდი პოზიცია.
ჩვენ შეგვიძლია გაიაროს პრობლემა კომპლექტი, რაც ჩვენ ვაპირებთ
ამის გაკეთება ბოლოს.
ჩვენ ვაპირებთ გავლა ლოგიკა, დარწმუნდით
ყველას იმავე გვერდზე.
>> მინდა დატოვება შეუძლიათ სამშაბათი შეგრძნება ძალიან კომფორტული, რაც თქვენ
უნდა გავაკეთოთ ამ კვირაში პრობლემა კომპლექტი, და თუ ასე არ მოხდა, მე სიხარულით
დარჩენა შემდეგ და მუშაობა თქვენთან ერთად.
თუმცა, ეს კიდევ ერთი რამ, რომ თქვენ უნდა ამის გაკეთება, მაგრამ, ვფიქრობ იქნება ვებზე
მხოლოდ წაკითხვის პრობლემა ნაკრები დაზუსტება კლასის მიხედვით სამშაბათს,
რომელიც მას ჟღერს ბევრი ბიჭებს გააკეთა.
>> დავიწყებ დღის წესრიგში თითოეული კლასის ასე რომ თქვენ იცით, სადაც ჩვენ ვაპირებთ.
ეს ასევე სასარგებლოა მათთვის, თვალს ონლაინ რადგან ყოველ სექციაში
არის ფერადი კოდირებული ასე რომ, თუ გსურთ მოვა უკან და მხოლოდ უყურებს 10 წუთი საკმაოდ
ვიდრე მთელი 90 წუთიანი განყოფილებაში თქვენ შეიძლება უბრალოდ წასვლა ფერი კოდირებული სექციაში
და შევხედოთ იმ ნაწილს.
ასე რომ, მე სცადა მოხსნა მათ დაყოფილია ლამაზი მოდულები, რომლის საშუალებითაც შეგიძლიათ to -
თუ გვინდა, რომ დავბრუნდებით და განიხილავს, ან სხვა სტუდენტები, რომლებიც მხოლოდ
თვალს განყოფილება მიმოხილვა -
იპოვონ კონკრეტული რაც მათ მინდა ყურადღება მიაქციოს
და გაიგეთ მეტი.
Sweet.
>> ნორმები.
მე ფოთის რეგიონალური ოფისის ლიდერის კამპუსში.
არ ვიცი, თუ ვინმეს გააკეთა ფოთის რეგიონალური ოფისის.
ნუთუ ვინმე გააკეთებს ფოთის რეგიონალური ოფისის?
ერთი ადამიანი გააკეთა ფოთის რეგიონალური ოფისის.
ორი ადამიანებს ფოთის რეგიონალური ოფისის.
გასაოცარია.
ასე რომ, ფოთის რეგიონალური ოფისის არის პირველი წელი გარე ორიენტაცია პროგრამა.
ჩვენ სტუდენტებთან ტყეში და მიიღოს ყველაზე ჯადოსნური გამოცდილება
მათი ცხოვრება, სწორი?
ჰო.
ხმები იმის შესახებ, უფლება.
>> ასე რომ, მე უბრალოდ მინდოდა, რომ დაიწყოს ჩვენი პირველი სექცია მიერ განხილვისას გარკვეული ნორმები
ამისთვის კლასის და ჩვენი ურთიერთობა რადგან ვფიქრობ,
ისინი ძალიან მნიშვნელოვანია.
პირველ რიგში, როგორც ვინც ჩემი მონაკვეთზე მიიღეს და
განხილულ იქნა ამ ელ, მე მიყვარს ეს.
ეს არის ჩემი საყვარელი ნაწილია წელს.
მე იმდენად აღფრთოვანებული.
მე უკვე აქ საათში იგეგმება.
მე არ დაუტოვებიათ ამ შენობის გარდა წავიდეთ საჭმელად იმიტომ, რომ მე მიყვარს CS50 მონაკვეთზე, I
მიყვარს სწავლების, მე მიყვარს სამუშაო თქვენთან ერთად ბიჭები.
>> ერთი ჩემი ყველაზე მაღალი პრიორიტეტებს, თუ არა ჩემი ნომერ პირველი პრიორიტეტი, არა მხოლოდ
ამ კლასის, მაგრამ მათ შორის ჩემი სხვა კლასების და extracurriculars, არის
მხარდაჭერა ბიჭები, და დაგეხმაროთ ბიჭები, და გავაკეთებ იმისათვის, რომ დავრწმუნდეთ, რომ თქვენ
ბიჭებს მშვენიერი, სიყვარული, პროდუქტიული, ჩართვა, საინტერესო
გამოცდილება ამ კლასში.
ეს არის ის, რაც მე ერთგული.
ამიტომ მე მიყვარს ამის გაკეთება.
ეს არის ჩემი ნომერ პირველი რამ, მხარს ბიჭები.
თუ თქვენ გაქვთ რაიმე შეკითხვები ლექცია, პრობლემა კომპლექტი, მონაკვეთის,
ცხოვრება, მაშინაც კი, თუ გვინდა, რომ ვისაუბროთ ცხოვრება, შეგიძლიათ დავკავშირებოდით.
>> თქვენ გაქვთ ჩემი ტელეფონის ნომერი, თქვენ გაქვთ ჩემი ელ
მისამართი, თქვენ გაქვთ ჩემი GChat.
შეგიძლიათ ჩემთან ნებისმიერ ან ყველა იმ შემთხვევაში, როდესაც, მაგრამ ალბათ ვერ მიიღებენ
საპასუხოდ, როცა კი.
ვცდილობ და დავუბრუნდეთ 24 საათის განმავლობაში.
ხშირ შემთხვევაში ეს იქნება ფარგლებში 20 წუთი ან 24 წუთი.
მე უნდა ითქვას, რომ რათა ის პარალელურად.
მაგრამ თქვენ პასუხს საკმაოდ სწრაფად.
>> თუ თქვენ ტექსტში me საათით ადრე პრობლემა ნაკრები ის გამო, მე დასამშვიდებლად თქვენ
ქვემოთ და გააკეთებს ღრმა სუნთქვის წვრთნები თქვენთან ერთად, მაგრამ თუ არ დაიწყო,
თქვენ ალბათ არ აპირებს დაასრულოს და მე ნამდვილად ვერ დაგეხმაროთ არსებობს
მიუხედავად იმისა, რომ ვეცდები ჩემი საუკეთესო.
ასე რომ, ყველაფერს გავაკეთებ შემიძლია მხარდაჭერას გპირდებით.
შეგიძლიათ მიღწევა თუ არა ეს ნაწილში ერთხელ, ერთი სამუშაო საათები
თუ ხედავთ მე, ან თუნდაც გარეთ.
მოხარული ვარ, რომ შეიქმნას შეხვედრის დრო და მუშაობის გზით პრობლემების
ერთად ან მეტი მასალა.
ასე რომ, ნომერ მხარდაჭერა.
გავაკეთებ ყველაფერს, რაც მე შეიძლება მხარდაჭერას გპირდებით.
>> ხმების ორი, შეხვედრის ცენტრიდან.
ისევე როგორც მე მინდა რომ იყოს, მე ვარ არ ყოვლისშემძლე ან ყველა ძლიერი ან
ყველა იცის, ასე რომ არ ვიცი ყველა დრო თუ რა მე ვაკეთებ დღითიდღე
მასშტაბით, თუ გზა მე ასწავლის თემის ეხმარება იცით, ან თუ
მათ დაბნეული თემაზე მაგრამ არ ამაღლება თქვენი ხელი ან მკითხოთ
ან გამომიგზავნოთ ელ.
ან კიდევ თუ, კიდევ ერთხელ, მათ დაბნეული რაღაც პრობლემაზე ნაკრები.
თუ არ მივაწვდინოთ me, მე ვერ ვიცი, რომ დარწმუნებული ვარ.
მე ვაპირებ გავაკეთებ შემოწმება წლის თქვენ ბიჭები, დარწმუნდით, ყველაფერი არის
კარგად, ცდილობენ ასწავლონ რამ გზა რომ ხელს ყველაზე მეტად
თქვენი სწავლის სტილი, მაგრამ თუ იქ რამე შემიძლია, ნება მომეცით ვიცი.
>> გარდა იმ ხაზების, თუ გსურთ გარკვეული დახმარება პრობლემას კომპლექტი, მე უფრო
ვიდრე ბედნიერი დაგეხმაროთ პრობლემას ნაკრები.
ჩვენ ვაპირებთ ბევრი რომ მიმართ მეორე
ნახევარი ამ სექციაში.
მაგრამ თუ არ წაუკითხავს პრობლემა ადგენს უკან და არ უყურებს ფეხით
მეშვეობით და არ უყურებს შორტები და ელოდება ჩემთვის გასწავლით
ყველაფერი, რაც უკვე videotaped ამჟამად ან რომ შეგიძლიათ at CS50
სასწავლო, ეს არ არის ნამდვილად სამართლიანი მე ან თქვენს სხვა თანატოლებს.
>> ასე რომ, გთხოვთ, მე ვარ ზე მეტი ბედნიერი, რათა დაეხმაროს თქვენ, მაგრამ თქვენ ბიჭები ჩემთან შეხვედრა in
ცენტრიდან.
ჩვენ გვყავს ტონა რესურსი თქვენ ხელმისაწვდომია CS50.
აღვნიშნე ზოგიერთი მათგანი.
გთხოვთ ისარგებლოს მათ.
თუ თქვენ დაბნეული ვარ, უფრო მეტია, ვიდრე ბედნიერი რათა დაგეხმაროთ აუხსნას მათ
სხვა გზა, მაგრამ ეს არ არის სამართლიანი, თუ სტუდენტები გამოჩნდება ოფისში საათის განმავლობაში,
არ დაწყებულა არაფერი და ეს ხუთშაბათს ღამით და ისინი ელოდება
TF ფეხით მეშვეობით თითოეული რამ პრობლემა მითითებული გამო
შუადღისას მეორე დღეს.
აზრი?
კიდევ ერთხელ, გთხოვთ, ჩვენთან შეხვედრის ცენტრიდან.
>> და ბოლოს, მაღალი მოლოდინი.
მე ვაპირებ, რომ იყოს შეფასების ყველას, ვინც არის ჩემს განყოფილებაში ან გაიტანა თქვენი
პრობლემა კომპლექტი.
თქვენ არ წავიდა უკან პრობლემა მითითებული ნულოვანი ან ერთი ჯერ.
ჩვენ ვწუხვართ, რომ.
დაგვჭირდა awhile საბოლოოდ მოაგვაროს სექციები და ახლა
ჩვენ შეგვიძლია დავიწყოთ შეფასების.
>> მე მიიღოს მათ უკან თქვენ რაც შეიძლება მალე.
ესენი ჩემს რამდენიმე advisees არსებობს.
მე მიიღოს მათ უკან თქვენ რაც შეიძლება მალე.
ხოლო პრობლემის ნაკრები ორი, ჩვენ უნდა გრაფიკით და დავიწყებთ მისაღებად მათ
თქვენ, საკმაოდ სწრაფად შემდეგ თქვენ გახდეს მათ შემოსული
>> როდესაც თქვენ თქვენი პრობლემა დაუბრუნდნენ, თქვენ მიიღებს ქულა, როგორც თქვენ იცით ეხლა
კითხულობს სილაბუსი - სისწორე, დიზაინი, შინაარსით და სტილი ქულით.
თქვენ ასევე კომენტარი.
კომენტარი უფრო მნიშვნელოვანია ვიდრე ქულით.
მე ვფიქრობ, შეიძლება ითქვას, რომ.
>> ქულა მხოლოდ ნომერი ერთი ხუთ.
ძნელი წაიკითხა იმ ძალიან.
ძნელი გაუმჯობესება იმ.
მაგრამ კომენტარი იქნება აღვნიშნო კონკრეტული რამ, რაც კარგად ან სფეროებში
შეგიძლიათ გაუმჯობესება და გადმოგცეთ გარკვეული იდეები სამომავლოდ ან ალტერნატიული
გზები აკეთებს რამ.
>> ასე რომ, გთხოვთ, გთხოვთ, წაიკითხეთ მეშვეობით კომენტარი.
მე ბევრი დრო შევიდა იმ კომენტარი.
გთხოვთ მათ და არა მარტო გადაფურცლეთ ქვემოთ ბოლოში
PDF, ვეძებთ თქვენი ანგარიშით, ან შემოსული და იპოვოს თქვენი ანგარიში და შემდეგ იგნორირება
კომენტარი.
ასე არ ხართ აპირებს უკეთ.
ასე არ ვაპირებთ გავზარდოთ თქვენი ქულა, საბოლოო ჯამში, მხოლოდ
ეძებს ქულით.
გთხოვთ შევხედოთ იმ კომენტარი.
>> და ხაზის გასწვრივ მაღალი მოლოდინი, კიდევ ერთხელ, ისევე როგორც მე ვუთხარი, თქვენ
შეიძლება მა ზუსტად ერთი მეშვეობით ხუთი.
Twos, threes და fours არის დიდი უმრავლესობა ქულით
თქვენ აპირებს, თუ.
პირობა და fives ორივე მართლაც იშვიათია.
იქ ყოველთვის რამ ჩვენ შეგვიძლია გავაკეთოთ უკეთესი.
როცა კოდექსის პროგრამა, არ არსებობს ყოველთვის რაღაც
შეეძლო უკეთესი.
>> ასე რომ, ვიდრე ამბობდა თქვენ გაქვთ ხუთ ყველა დროის ყველაფერზე და გააკეთა
ყველაფერი სრულყოფილი, არა მგონია, რაიმე ჩვენგანს ნამდვილად მჯერა, რომ ჩვენ - ან
იმედია, ჩვენ არ გავაკეთოთ ყველაფერი სრულყოფის ყველა დროის.
ასე რომ არ აწუხებს, თუ ვერ ხუთ.
ხუთ არ რუკაზე გადატანა, ოთხი არ რუკაზე გადატანა B, სამი აკეთებს
არ რუკის გადატანა C. ეს არ არის როგორ ქულით მუშაობს.
>> მსგავსად დავით განაცხადა არაერთხელ, ზე სემესტრის ბოლოს ყველა თქვენი ქულა და
შეიტანენ ჩემთვის, თქვენი TF, გავერთიანდეთ და განსაზღვრავს საბოლოო შეფასება თქვენთვის.
თუმცა ისევ და ისევ, ეს არ არის ხუთი, , ოთხი, B, et ა.შ..
ამიტომ, მე ვაპირებ, რომ აქვს მაღალი მოლოდინი თქვენ ბიჭები.
მე ვაპირებ ველით კარგი პრობლემა კომპლექტი და მე აპირებენ
თქვენთვის, როგორც ასეთი.
და ეს არ ნიშნავს, რომ თქვენ აპირებდა უარესი კლასის.
თქვენ ფასდება თვალსაზრისით თქვენი პროგრესის ეხლა კვირას
ნულიდან კურსის ბოლოს.
>> და ბოლოს, იმ თვალსაზრისით, მაღალი მოლოდინი კლასში, მე მიყვარს, როცა
ადამიანი მონაწილეობს.
მე მესმის, ზოგიერთი ადამიანი გრძნობს, მეტ ნაკლებად კომფორტული მონაწილე.
სხვა ადამიანები მონაწილეობენ არა ამაღლების ხელში და
ვსაუბრობთ ყველა დროის.
მაგრამ ჩვენ ამ კლასში იქნება აკეთებს ბევრი პატარა პრობლემები, ბევრი
სამარშრუტო შეკითხვა, და შემდეგ რამდენიმე უფრო დიდი კოდირების პრობლემები.
ასე რომ ნამდვილად მუშაობა ამ წვრთნების გარეთ როდესაც ჩვენ მათ თქვენს კომპიუტერში ან
ფურცელზე.
>> მაგრამ მე ასევე გაძლევთ რამდენიმე ხნით ადრე ოდესმე ვინმე უნდა უპასუხოს რამდენიმე
კითხვას ვთხოვ.
ასე რომ, იმიტომ, რომ მე მოგცემთ გარკვეული დრო დაფიქრდით, რადგან ჩვენ ვაპირებთ
ამის გაკეთება რამ პარტნიორები ზოგჯერ, მე ველოდებით ყველას
დაკავდნენ გარკვეულწილად.
და გამო უკეთესი ტერმინი, იქ სავარაუდოდ ცივი ნომრებზე, რომელიც
არის, სადაც ყველას ექნება საშუალება ვიფიქროთ პასუხი, შემდეგ კი
მე მოგიწოდებთ, შემდეგ კი თქვენ ვთქვა პასუხი.
>> არ ინერვიულოთ ან ეშინია, რომ.
მე ვაკეთებ ამას წარსულში და ჩვენ აღმოვაჩინეთ რომ ეს ბევრად უფრო წარმატებული,
ასევე წაიკითხა საგანმანათლებლო კვლევების მას განსაზღვრავენ თუ არა, რომ ეს იყო
კარგი ტაქტიკას.
ეს არის ძალიან სასარგებლო, განსაკუთრებით თუ აძლევენ სტუდენტებს დროს ფიქრი
პასუხები და არ მათ მხოლოდ მოდის გარეთ და აცხადებენ, რომ ეს უფლება off bat.
მაგრამ თუ არ კომფორტისთვის პასუხობდა, მე ასევე საკმაოდ კარგად
იგრძნო, რომ, და ჩვენ არ ვაპირებთ დააყენა თქვენ ადგილზევე, განსაკუთრებით
კამერა, მიუხედავად იმისა, რომ არც ერთი თქვენ კამერების ახლა.
>> ასე რომ, ეს ის ნორმები მაქვს.
კიდევ ერთი რამ გასწვრივ ხაზები შეხვედრის ცენტრიდან.
მე ვაპირებ გაძლევთ ბიჭები ბევრი კავშირი.
გთხოვთ მაძლევს კავშირი ასევე.
აქ ნახვა, sayat.me/cs50.
ასე რომ, ეს პატიოსანი კავშირი.
თუ გსურთ, რათა განმავლობაში მონაკვეთის, მივიღებ ელ როდესაც იგი ხდება.
ჩვენ მიიღოს შესვენების ცოტა, ასე რომ მე გაეცნონ კავშირი შემდეგ.
თუ თქვენ ოდესმე რაიმე კავშირი, გთხოვთ, მისთვის ჩემთვის არსებობს.
>> თუ თქვენ მაძლევს კავშირი Q, ეს არის ის, მშვენიერი, მაგრამ ეს სახელმძღვანელო
რომ თქვენ ბოლოს.
მაგრამ ეს იქნება სემესტრის ბოლომდე ასე მე ვერ შეძლებს მიიღოს ნებისმიერი, რომ
კავშირი და გადაქცევას სწავლების თქვენ ბიჭები უკეთესი.
ასე რომ, გთხოვთ, თუ თქვენ გაქვთ რაიმე კავშირი, მისთვის ჩემთვის.
მე მიყვარს კავშირი.
თავში ფოთის რეგიონალური ოფისის, მივიღებთ კავშირი ყველა დროის.
>> შეგიძლიათ მაძლევს pluses, კარგი რამ, deltas, რამ შეიძლება გაუმჯობესდეს საფუძველზე.
შეგიძლიათ კომენტარის გაკეთება ჩემს კოსტიუმები.
რომ არ იქნება, როგორც სასარგებლო, მაგრამ თქვენ მისასალმებელი დაკავშირებით კომენტარს არ ნებისმიერი და
ყველაფერი.
გთხოვთ, გთხოვთ, მომეცი კავშირი.
მე ვაფასებ მას ბევრი და ეს ბევრს ნიშნავს ჩემთვის.
>> კიდევ ერთი ნორმა, სახალისო.
ჩვენ ვაპირებთ აქვს ბევრი გართობა.
იმედია ამ კურსში, თქვენ ბევრი სახალისო.
ჩვენ გვექნება candy ზე მონაკვეთზე.
ჩვენ გვექნება მუსიკა.
ჩვენ იმედი გვაქვს, გავიცნოთ ერთი კიდევ ერთი გარკვეულწილად კარგად, ამიტომ მე მინდა
ეს უნდა იყოს სახალისო, ჩართვით გამოცდილება.
>> მე ვიცი, ზოგიერთ თქვენგანს არ დაეცა ეძინა ლექციები გქონდათ დღეს,
ისე იმედია, რომ არ იმ შემთხვევაში ახლა.
და თუ ეს არის იმ შემთხვევაში, ახლა, უბრალოდ არ snore იმიტომ, რომ შესაძლოა
უნდა დააფიქსირეს ადგილზე.
Sweet.
რაიმე შეკითხვები, კომენტარები, ან შეშფოთება სანამ გადაადგილება შესახებ არაფერი ჩვენ
ვისაუბრეთ?
დიდი.
>> ასე რომ, ჩვენ ვაპირებთ წავიდეთ შევიდა მასივების პირველი.
ეს არის, თუ როგორ გავხადოთ მასივი.
ჩვენ ვნახეთ ეს ადრე.
თქვენ გაქვთ მონაცემების ტიპის, თქვენ გაქვთ სახელი და მაშინ აქვს ზომა.
სწორედ აქ, შევქმნა ორი მასივები.
პირველი რიგი პერსონაჟი, და მას აქვს 26 ფართები.
მეორე მასივი ქულით, და მას აქვს სამი
ფართების სამი რიცხვებით.
დიახ?
>> სტუდენტი: არის თუ არა ყველა ეს სლაიდები ხელმისაწვდომი სადმე ჩვენთვის?
>> JASON HIRSCHHORN: დიდი კითხვაზე.
კითხვა იყო, არის ყველა ეს სლაიდები ხელმისაწვდომი?
დიახ.
ყველა ეს სლაიდები იქნება შესაძლებელი, და მომავალშიც, მე ელ მათ
თქვენ წინაშე განყოფილებაში.
მაგრამ დღეს, რადგან ეს არის პირველი კვირას, ჩვენ გვქონდა გვიან დაიწყეს.
ასე რომ, როგორც წესი, თქვენ შეძლებთ ეს სლაიდები, მაგრამ ისინი ხელმისაწვდომი იქნება ონლაინ და
მე ელ ისინი თქვენთან მას შემდეგ, რაც კლასის.
ნებისმიერი სხვა კითხვები?
>> ასე რომ, კიდევ ერთხელ, მასივების არიან ყუთები, გამო უკეთესი სიტყვა, რომ გამართავს მრავალჯერადი
ელემენტები ერთი მონაცემების ტიპის და ისინი მომდევნო ერთმანეთს მეხსიერებაში.
ასე რომ, კიდევ ერთხელ, ეს არის, თუ როგორ შეგიძლიათ მიიღოს ორი სახის მასივები.
>> ასე რომ, მას შემდეგ, რაც თქვენ გააკეთა თქვენი მასივში რომ პირველი ხაზი - int ქულა, bracket
სამი, ახლო bracket - თქვენ მინდა ინიციალიზაცია იგი.
გსურთ დააყენა რამდენიმე ღირებულებების არსებობს.
ეს არის, თუ როგორ დააყენა რამდენიმე ღირებულებების იქ, უბრალოდ არჩევის indice და
წერა ნომერი.
დავხატოთ ამ ფორუმში.
შეიძლება თუ ყველას?
ყველას შეუძლია დაინახოს.
Sweet.
>> ასე რომ, იქნება ჩემი მასივი მოუწოდა ქულა.
როგორც ხედავთ, ეს ზომა სამი.
არსებობს სამი ყუთი იქ.
თითოეული ეტევა რა ტიპის მონაცემების ტიპის?
>> სტუდენტი: რიცხვი.
>> JASON HIRSCHHORN: მთელი ამ ერთი.
მივწერეთ int ქულით, და პირველი სიტყვა არის მონაცემთა ტიპის, რომ აპირებს
წავიდეს ყუთები, რომ მასივი.
ასე, რომ შეიძლება შეესაბამება სამი.
რატომ უნდა ნულოვანი up არსებობს ფორუმში?
რატომ ამბობენ ანგარიშია ნულოვანი შეადგენს 1?
შეგახსენებთ, მე თქვენი სახელი.
>> სტუდენტი: კურტ.
>> JASON HIRSCHHORN: კურტ.
>> სტუდენტი: დიახ.
>> JASON HIRSCHHORN: რატომ?
>> სტუდენტი: იმის გამო, რომ პირველი ინდექსი ნულოვანი, ჩვენ ვიწყებთ დამთვლელი ზე ნულოვანი.
>> JASON HIRSCHHORN: ასე იწყება დამთვლელი ზე ნულოვანი.
სწორედ უფლება.
ეს არის დამაბნეველი ნაწილი და სოხუმში გაემგზავრება თქვენ მდე, განსაკუთრებით, როდესაც თქვენ
ცდილობს iterate მეშვეობით მასივები, რომელსაც ჩვენ გავაკეთებთ ცოტა.
ვიწყებთ დამთვლელი ზე ნულოვანი.
ასე რომ, თუ მინდა, ეხება პირველი ყუთში, ეს არ არის ყუთში ერთი.
სამწუხაროდ, ეს ყუთი ნულოვანი.
მეორე ყუთი ერთი, და ამ შემთხვევაში, მესამე არის ყუთი ორი.
>> რაც შეეხება ყუთი სამი?
სად არის ყუთში სამი?
ან თუ მინდა ქულა, bracket სამი, ახლო bracket, რა რომ?
ასე, რომ თქვენ განაცხადა null ხასიათი.
ნებისმიერი სხვა აზრები?
რა არის ანგარიშია bracket სამი bracket?
>> სტუდენტი: ეს ნამდვილად არ არსებობს, რადგან თქვენ მხოლოდ განისაზღვრება, როგორც ქულა,
bracket სამი.
>> JASON HIRSCHHORN: ასე ვთქვათ, ეს ნამდვილად არ არსებობს.
ზოგიერთ შემთხვევაში, როდესაც ჩვენ საქმე გვაქვს სიმები, ზოგადად ჩვენ დააყენა null
ხასიათი ბოლოს.
მივიღებთ, რომ ამ მეორე.
მაგრამ ამ შემთხვევაში, არ არსებობს არის მესამე ყუთი აქ.
ასე რომ, ბოლო ყუთში ნებისმიერ მასივი არის ზომა მინუს 1.
ასე რომ, თუ ჩვენ გვაქვს მასივი ზომა n, პირველი ყუთი ზე ნულოვანი, ბოლო ერთი
ის N მინუს 1.
ამ შემთხვევაში, ის არ არსებობს.
რაღაც აქ მეხსიერება მაგრამ ეს არ არის ჩვენი.
ჩვენ არ საკუთრებაა.
ჩვენ არ ვთხოვთ მას.
ასე რომ, თუ ჩვენ ვცდილობთ ვებგვერდზე, რომელსაც ჩვენ გამოგიგზავნით გავაკეთოთ ცოტა, ჩვენ, ალბათ აპირებს
მოხვდნენ უბედურება.
>> ამ შემთხვევაში, მე ინიციალიზაციისას ჩემი მასივში სამი ცვლადი.
ჩვენ სტუმრად ერთი ყუთი ნულოვანი, ორი ამ ყუთში ერთი, და სამი ყუთი ორი.
ვინმეს აქვს რაიმე კითხვა შესახებ ინიციალიზაციისას მასივი?
>> ასე რომ, ჩვენ გადავიდა ამ ახლა.
ნოტები, bracket სამი, ახლო bracket, რომ არ არსებობს.
ჩვენ ნულოვანი ინდექსირებული კომპიუტერული მეცნიერების, ამიტომ ჩვენ დავიწყებთ დამთვლელი ზე ნულოვანი.
ბოლო ყუთი ჩვენს ხელთ არსებული, ეს მესამე ყუთი, მაგრამ ეს ე.წ. ყუთი
ნომერი ორი.
>> ქვემოთ ქვემოთ, ეს არის ალტერნატიული გზა ინიციალიზაციისას მასივები.
ასე რომ, ნაცვლად მასივის შექმნის ერთ ხაზი, შევსების პირველ ყუთი, მაშინ
მეორე ყუთი, მაშინ მესამე ყუთი, შეგიძლიათ ამის გაკეთება ყველა ერთ ხაზზე.
ასე რომ, რომ ხაზი, როგორც მასივები.
ეს ქმნის იგივე ზუსტი წყობის რაც ჩვენ შევქმენით სწორედ აქ, მაგრამ ეს
უბრალოდ აკეთებს ერთ ხაზი.
>> ახლა ჩვენ შევქმენით ჩვენი მასივი.
როგორც წესი ერთხელ თქვენ შექმნით მასივი, თქვენ მინდა, რომ რამე მას, თუ არა
რომ შეავსოთ იგი ან მიიღოს რამ გარეთ და ბეჭდვა მათ ეკრანზე.
ამ შემთხვევაში, ჩვენ ვაპირებთ ჩვენი ქულების მასივი, რომელიც ჩვენ ინიციალიზაცია წლის
პირველი ხაზი აქ რუხი.
და მერე მეორე ხაზი, ჩვენ ვიწყებთ iterating მეშვეობით მასივი.
ვინმეს აქვს რაიმე კითხვა შესახებ სტრუქტურა for loop?
>> ასე რომ, ეს შეეხება ციკლი.
ჩვენ გვაქვს ჩვენი საწყის მდგომარეობას, შემდეგ კი ჩვენი საბოლოო მდგომარეობა, და შემდეგ ჩვენ
iterate, i, თითოეული ციკლი.
ხოლო curly აფრთხილებს წინააღმდეგ ეს მარყუჟის, რა მოხდება თუ მე გასაშვებად
ამ პროგრამაში?
შეიძლება თუ ვინმეს მეუბნებოდა, რაც ჩვენ კიდევ?
[? MATU? ?]
>> MATU ბეჭდვა ყველა ქულის თითოეულ ხაზზე.
კარგი იქნებოდა ბეჭდვა ყოველ ანგარიშია ცალკე ხაზი.
>> JASON HIRSCHHORN: რა უნდა ბეჭდვა?
>> სტუდენტი: ეს იქნებოდა ბეჭდვა ერთი, შემდეგ ორი, შემდეგ სამი.
>> JASON HIRSCHHORN: ზუსტად.
კარგი იქნებოდა ბეჭდვა ერთი, შემდეგ ორი, შემდეგ სამი, თითოეულ ცალკე ხაზი, რადგან
ჩვენ ვაპირებთ მეშვეობით მასივი და თქვენ ვხედავთ, რომ მეორე, printf
განაცხადი, ნოტები i.
ასე რომ, პირველ ტურში ჩვენი for მარყუჟის i ნულის ტოლი, რაც ნიშნავს ჩვენ
მიღების ღირებულება ანგარიშია ნულოვანი -
რომელიც, თუ ჩვენ დაბრუნდეს ჩვენი დაჭერა, ერთ -
და შევსების -
oh, იგი აცხადებს, გ.
ეს უნდა იყოს% d.
მე დავაფიქსირებთ, რომ ცოტა როდესაც I მხრივ, რომ თქვენ, ბიჭები.
მაგრამ ჩვენ წარდგენის რიცხვი ასე რომ უნდა იყოს% d სწორედ აქ, არ% გ.
რა არის% C for?
>> სტუდენტი: ხასიათი.
>> JASON HIRSCHHORN: პერსონაჟი, ზუსტად.
რა არის მეორე?
თუ არ გსურთ% d for მთელი რიცხვი, რა შეგიძლიათ გააკეთოთ?
>> სტუდენტი: i.
>> JASON HIRSCHHORN:% i, ზუსტად.
ასე რომ, რაიმე შეკითხვები iterating მეშვეობით მასივი?
ასე რომ, რა მოხდება, თუ ჩვენ ამის გაკეთება?
იმის ნაცვლად, რომ აკეთებს i ნაკლებია, ვიდრე სამი, ჩვენ i ნაკლებია,
მეტი ან ტოლია სამი.
რა ხდება, როდესაც ჩვენ აწარმოებს ეს კოდი?
დიახ, ენი?
>> სტუდენტი: ისინი აპირებენ ამობეჭდოთ უცნაური პერსონალის მეოთხე ხაზი.
>> JASON HIRSCHHORN: ასე რომ თქვენ თქვით, არის ეს აპირებს ამობეჭდოთ უცნაური პერსონალის შესახებ
მეოთხე ხაზი?
ვინმეს აქვს ჰქონდეს პასუხი მისი კითხვა?
ასე რომ, შანსი, რომ როდესაც ჩვენ მისაღებად -
ასე მეოთხე რაუნდის ჩვენი for მარყუჟის, ისევე, როგორც ეგონა, ენი,
ეს იქნება ქულით bracket სამი, რომელიც ჩვენ უკვე figured, არ
არსებობს, და ჩვენ ვაპირებთ შევეცადოთ და ხელმისაწვდომობის, რომ დაბეჭდეთ
out, გამოიყენოს იგი გარკვეულწილად.
ასე რომ, კომპიუტერში სავარაუდოდ მიიღოს mad ჩვენთან.
თქვენ სწორედ.
>> შესაძლოა დატოვა პროგრამა საერთოდ.
ეს შეიძლება ამობეჭდოთ რაღაც მართლაც უცნაურია.
თქვენ არ ვთქვა.
შანსი რომ თქვენ ალბათ მისაღებად mad at თქვენ და მხოლოდ დატოვა დაუყოვნებლივ.
>> მაგრამ ეს ჩვეულებრივი შეცდომა თქვენ სადაც თქვენ უბრალოდ ეცხოვრათ ერთი
ბოლოს და ეს bug რომ ხელი დამაბრკოლებელი თქვენ მთელი თქვენი კოდირებას.
ერთი გზა მე მიყვარს ამის გაკეთება არის მხოლოდ whiteboard, გაიაროს ყოველი iteration
საქართველოს მარყუჟის მხრივ ან ქაღალდზე სანახავად რა ხდება, და მაშინ
ზოგადად გააცნობიეროს, რა დაველოდოთ, მე არ უნდა წავიდა ნაკლებია ან
თანაბარი სამ.
მე უნდა გაჩერდნენ ორი, რომელიც რა მოხდება თუ თქვენი მდგომარეობა ნაკლებად
სამ.
ნებისმიერი კითხვებით აქამდე?
Sweet.
>> ასე რომ ყველას გვაქვს თქვენი კომპიუტერი ღიაა.
ჩვენ ვაპირებთ გადმოგცეთ ორი სამი წუთში დაწერა პროგრამა, რომელიც
ქმნის მასივს მთელი რიცხვები ერთი მეშვეობით ხუთი და შემდეგ ბეჭდავს out ყოველ
მთელი ახალ ხაზზე.
და თუ თქვენ გაქვთ რაიმე შეკითხვები, დააყენებს თქვენს ხელში.
ძალიან მიხარია, მოდის.
მომწონს განაცხადა, ავიღოთ სამი წუთის დაწერა ეს.
ყველას OK, თუ მივდივარ ახალი ფანჯარა და დახურვა?
>> მე ბოდიში თუ არ ჰქონდა შანსი დასრულება, მაგრამ ჩვენ ვაპირებთ ამის გაკეთებას
ერთად ახლა.
ასე up ეკრანზე, მე # მოიცავს cs50.h, # მოიცავს stdio.h.
შეიძლება თუ ვინმე მეტყვით რა იმ ორ ხაზს გაკეთება?
მაიკლ?
>> სტუდენტი: ეს მოიცავს ბიბლიოთეკების რომ CS50 განხორციელდა და სტივ აქვს
გადაარჩინა, რომ გამოიყენოთ to თქვენი ცხოვრება უფრო ადვილია.
>> JASON HIRSCHHORN: ასე განაცხადა, რომ ისინი მოიცავს ბიბლიოთეკების, რომელიც CS50
გააკეთა, cs50.h და რომელიც მხოლოდ სტანდარტული, გააჩნია
C პაკეტი, stdio.h.
რას ნიშნავს შედის ბიბლიოთეკების, თუმცა?
შეგიძლიათ ცოტა უფრო კონკრეტული?
>> სტუდენტი: ეს ხდის, ასე რომ შეგიძლიათ გამოყენება გარკვეულ კოდი სიტყვები აქვს
ფუნქციონირებს მოხდეს გარეშე წასვლა და მიიღოს ფუნქცია გ თავს.
>> JASON HIRSCHHORN: შეგიძლიათ მომეცი მაგალითად?
>> სტუდენტი: მსგავსად printf არის ერთი შეგიძლიათ გამოიყენოთ.
>> JASON HIRSCHHORN: Printf.
ასე, რომ თქვენ განაცხადა printf ერთ იმ ფუნქციების სადაც ვიდრე მქონე
წერენ printf საკუთარ, printf არის შედის ფაქტიურად stdio.h, ასე რომ თქვენ
უბრალოდ გამოიყენოს იგი და თავის თავზე იღებს რომ ის იმუშავებს.
In stdio.h, თუ გახსნეს, რომ ფაილი, უნდა შეიცავდეს როგორ printf
სამუშაოები, ყველა კოდი printf?
რატომ იმუქრება თქვენი უფროსი?
>> სტუდენტი: იმის გამო, რომ თავით ფაილი მხოლოდ მოიცავს ფუნქციის დეკლარაცია.
>> JASON HIRSCHHORN: სწორედ.
Header ფაილი უბრალოდ მოიცავს ფუნქციის დეკლარაცია.
ასე რომ, ძირითადად, მაშინ, როდესაც შეადგინოს ამ, მოხვდა სასტარტედ რაოდენობა, რომელიც ჩვენ გავაკეთებთ
მეორე, შემდგენელი იცის, რომ თუ თქვენ იყენებთ printf, printf არსებობს.
ეს იქნება განსაზღვრული სადღაც.
ეს არ არის პრობლემა თქვენთვის გამოყენება.
და მაშინ მოგვიანებით, რომ თქვენ მოიცავს პირობა და zeros რომ რეალურად შეიცავს
printf განხორციელებას და შერწყმა მათ თქვენი კოდი.
როგორ დარწმუნდით, რომ იგი მოიცავს პირობა და zeros ამისთვის, ამბობენ, მიიღოს სიმებიანი?
>> სტუდენტური: ოჯახის სიმებიანი არის cs50.h.
>> JASON HIRSCHHORN: Right.
ასე რომ, რომელიც ამბობს, მიიღოს სიმებიანი არსებობს, ფუნქციის დეკლარაცია.
მაგრამ პირობა და zeros, ორობითი ფაილი, რომელიც რეალურად შედის
განხორციელების Get სიმებიანი?
როგორ დავრწმუნდეთ, რომ მიდის თქვენი პროგრამა?
>> სტუდენტური: სასწრაფოდ Linker in ბრძანების ხაზი არგუმენტი.
>> JASON HIRSCHHORN: სასწრაფოდ Linker ბრძანების ხაზი არგუმენტი.
როგორ ეს?
>> სტუდენტი: ეს-l ხაზი clang
>> JASON HIRSCHHORN: სწორედ.
თქვენ თქვით-l cs50, არა?
რომელიც მოიცავს პირობა და zeros.
>> სტუდენტი: მაგრამ არ რომ თქვენ, არა?
>> JASON HIRSCHHORN: ზუსტად.
სასტარტედ აკეთებს, რომ თქვენ, მაგრამ საბოლოოდ, თქვენ არ გააკეთოს, ან
თქვენ უნდა მიიღოს სასტარტედ საკუთარ, ისე, რომ ის
კარგია უნდა გვახსოვდეს.
თუ თქვენ აპირებთ გამოიყენოთ ერთი ასეთი სხვა ბიბლიოთეკების, არა მხოლოდ გაქვთ
დაწერა # მოიცავს და მერე ბიბლიოთეკაში.
თქვენ ასევე უნდა უკავშირებენ მას შემოსული
და ის ორი რამ არის განსხვავებული. -L cs50 განსხვავდება
ვიდრე # მოიცავს cs50.h.
>> შემდეგ უნდა int მთავარი ბათილად curly აფრთხილებს, და ახლა ჩვენ ვაპირებთ კოდი
შიგნით ძირითადი.
პირველი რიგის მე მაქვს აქ კომენტარი რომელიც ამბობს, შექმნა მასივი
ერთად ints ერთი მეშვეობით ხუთი.
რა არის კარგი სიტყვა აღწერს, რაც მე აქვს ახლა ეკრანზე, უბრალოდ
კომენტარები შიგნით ძირითადი?
რას მოვუწოდებთ, რომ?
>> სტუდენტი: Pseudocode.
>> JASON HIRSCHHORN: Pseudocode.
დიდი მადლობა, ჯეფრი.
სწორედ უფლება.
Pseudocode.
თქვენ ბიჭები მინახავს pseudocode ადრე?
ამაღლება თქვენი მხრივ, თუ თქვენ გამოყენებული pseudocode ადრე პრობლემა მითითებული ერთი.
დაახლოებით ნახევარი თქვენ.
>> მე მაღალ რეკომენდაციას გამოყენებით pseudocode ნგრევა პრობლემების შევიდა
პატარა, უფრო მარტივი bite off ცალი.
ასევე, თუ pseudocode, თქვენ გაქვთ თქვენი კომენტარი უკვე დიდწილად
აშენდა, ასე რომ თქვენ არ უნდა დაბრუნდეს და ცდილობენ გაერკვნენ
რას აკეთებს.
ასე რომ, შეიძლება ვინმეს მომეცით ამ პირველი ხაზი შექმნა მასივში ints ერთი
მეშვეობით ხუთი?
თქვენ?
>> სტუდენტი: Int და მაშინ მოვუწოდებთ რაც არ უნდა ნომერზე, შემდეგ კი მოედანზე
bracket ხუთ.
>> JASON HIRSCHHORN: ასე int ნომრები, კვადრატული ფრჩხილი ხუთ.
>> სტუდენტი: უდრის და შემდეგ curly აფრთხილებს.
>> JASON HIRSCHHORN: უდრის, curly აფრთხილებს.
>> სტუდენტი: ერთი, ორი, სამი, ოთხი.
>> JASON HIRSCHHORN: ერთი, ორი, სამი, ოთხი, ხუთი.
>> სტუდენტი: და მერე curly აფრთხილებს და შემდეგ მძიმით.
>> JASON HIRSCHHORN: და curly აფრთხილებს და მძიმით.
შესანიშნავი.
ამობეჭდვა ყოველ int ახალ ხაზზე.
შეიძლება თუ არა სხვისი მისცეს ჩემთვის, რომ კოდის?
[? MATU? ?]
მე წინ.
>> სტუდენტური: იყიდება (
>> JASON HIRSCHHORN: იყიდება (
>> სტუდენტი: Int i = 0
>> JASON HIRSCHHORN: Int i = 0
>> სტუდენტი: მძიმით i ზე ნაკლები აღმოჩნდა.
>> JASON HIRSCHHORN: მძიმით, i არანაკლებ 5.
>> სტუდენტი: მძიმით, i + +.
>> JASON HIRSCHHORN: მძიმით, i + +.
>> სტუდენტური: დასრულებული ფრჩხილებში, შემდეგ ღია მუდმივი წინააღმდეგობა გაუწიოს.
>> JASON HIRSCHHORN: დასრულებული ფრჩხილებში და ორი აფრთხილებს.
Inside აფრთხილებს?
>> სტუდენტი: და მერე printf "% d / n"
>> JASON HIRSCHHORN: უკაცრავად, ჩატარების შესახებ.
Printf "% d / ნ, დახურული გაცემა.
>> სტუდენტი: და მერე დახურულ გაცემა, მძიმე, რაოდენობა, bracket i.
>> JASON HIRSCHHORN: მძიმე, რაოდენობა, bracket i.
>> სტუდენტი: სამწუხაროდ, ნომრები bracket i.
>> JASON HIRSCHHORN: ნომრები, bracket i.
>> სტუდენტი: ბოდიში.
შემდეგ კი დაიხურა ფრჩხილებში, მძიმით.
>> JASON HIRSCHHORN: დასრულებული ფრჩხილებში, მძიმით.
მე ვაპირებ გადარჩენა, რომ.
ჩვენ ვაპირებთ, რათა რაოდენობა.
და როგორ უნდა აწარმოებს რაოდენობა?
>> სტუდენტი: წარმატებული.
>> სტუდენტი: Dot ნაბიჯია Slash -
>> JASON HIRSCHHORN:. / ითვლიან, ზუსტად.
დიდი მადლობა. . / ითვლიან.
ერთი, ორი, სამი, ოთხი, ხუთ ახალი ხაზები.
როგორც ჩანს, იგი მუშაობდა.
დიახ, ნოე?
>> სტუდენტი: თქვენ შეიძლება გააკეთოს ნაკლები ან ტოლია ოთხი, როგორიც მე ნაკლებია, ვიდრე
ან ტოლია ოთხი?
არსებობს თუ არა უპირატესობა კეთების ნაკლები ხუთ, ან უბრალოდ განსხვავებული გზა
წერის ეს?
>> JASON HIRSCHHORN: ასე რომ კითხვა არის თუ არა შეეძლო i ნაკლებია ან
ტოლია ოთხი ნაცვლად i ზე ნაკლები.
თუ რომ არ მუშაობდა იგივე?
>> სტუდენტი: ეს უნდა.
>> JASON HIRSCHHORN: დიახ.
იგი მთლიანად იქნებოდა მუშაობა იგივე.
სტილისტურად, ეს ზოგადად ნაკლებ, და დაინახავთ მეორე, როდესაც
ჩვენ სიმები, შეგიძლიათ გამოიყენოთ რაღაც მოუწოდა strlen, რომელიც ვნახე
ადრე, მიიღოს სიგრძეზე საქართველოს სიმებიანი.
და ვერ გააკეთებს ნაკლები ან ტოლია strlen.
თქვენ შეიძლება ნაკლები ან გაუტოლდება strlen მინუს ერთი.
ასე რომ, ეს უბრალოდ ლამაზი to ამის გაკეთება ნაკლები strlen.
დიახ?
>> სტუდენტი: და ფაქტობრივი ტესტები, გაკეთება ჩვენ უნდა უზრუნველვყოთ კომენტარი ჩვენს
კოდი ასევე?
>> JASON HIRSCHHORN: კითხვა იყო ტესტები, თუ
უნდა უზრუნველყოს კომენტარი?
ასე რომ, ჩვენ გაიგო უფრო მეტი ტესტები როდესაც ისინი ამუშავება, მაგრამ ზოგადად, კარგია
წესი thumb არის მაშინ, როდესაც თქვენ წერა კოდი, უზრუნველყოს კომენტარი.
თუ თქვენ გაქვთ კოდი, მაგრამ მცდარი კომენტარის უფლება, შეიძლება რაღაც
საკრედიტო, როგორც მე თუ იყო შეფასების თქვენ პრობლემა კომპლექტი ან ინტელექტუალური.
ასე რომ, კომენტარი ყოველთვის კარგი უზრუნველყოს.
Sweet.
ითვლიან.
შესანიშნავი სამუშაო.
მოდით გადაადგილება.
>> Strings.
Strings.
ჩვენ ვნახეთ ამ მანამდე ლექცია.
ეს ააფეთქეს ჩემი აზრით, როცა პირველად ამ out.
როგორც ჩანს, იგი არ აფეთქება არავის ძალაუნებურად, მაგრამ ეს არის ის, OK.
>> Strings არიან მასივების პერსონაჟების, და ისინი დამთავრდება, როგორც თქვენ ცოტა ხნის წინ განაცხადა,
null terminator, რომელიც ეს / 0 ხასიათი.
თუ ჩვენ ვაპირებთ მიაპყროს სიმებიანი წლის გამგეობის, ჩვენ შევაჩერო, რომ მეტი აქ.
ასე რომ, რამდენ ხანს არის ეს კონტექსტი?
ბოდიში.
რა ეს კონტექსტი?
>> სტუდენტი: [inaudible].
>> JASON HIRSCHHORN: ოთხი?
რატომ არის ოთხი?
>> სტუდენტი: იმის გამო, რომ მეხუთე ადგილზე არის null ხასიათი.
>> JASON HIRSCHHORN: ასე რომ მეხუთე ადგილზე არის null ხასიათი.
ასე რომ, თუ მე რომ აწარმოებს strlen წლის ამ, ეს იქნებოდა მომეცი ოთხი.
სწორი.
ხოლო მასივი, თუმცა, თუ იყო ვრთავ ამ მასივი, რამდენი ფართები
უნდა ვითხოვოთ?
>> სტუდენტი: ხუთი.
>> JASON HIRSCHHORN: ხუთი.
მე უნდა ვთხოვო ხუთი, მაგრამ შემიძლია მხოლოდ დააყენა ოთხი სიმბოლო აქ
იმიტომ, რომ მე უნდა დააყენოს, რომ null terminator წლის ბოლომდე.
ასე რომ, ჩვენ ვაპირებთ წერენ "ohai" და დააყენა null terminator ამ ბოლოს.
ჩვენ ყველაფერს ვიტყვი, რომ ეს სიმებიანი s უდრის ამას.
რა არის s bracket ნულოვანი?
s bracket ნულოვანი, ენი?
>> სტუდენტი: ო
>> JASON HIRSCHHORN: O, ზუსტად. s bracket ერთი?
s bracket ხუთ?
>> სტუდენტი: არ არსებობს.
>> JASON HIRSCHHORN: არ არსებობს.
სწორედ.
ზემოთ.
შეკითხვები გაგება strings როგორც მასივების პერსონაჟების?
OK, მაშინ.
კიდევ ერთი პროგრამა ბიჭებს.
დაწერეთ პროგრამა, რომელიც სთხოვს შესახებ for სიმებიანი შემდეგ ბეჭდავს out ყოველ
ხასიათი ახალ ხაზზე.
მოდით სამი წუთის დაწერა ამ პროგრამის და შემდეგ ჩვენ კოდი,
როგორც ჯგუფი.
>> ბოდიში.
თუ საჭიროა, რომ ეს?
>> სტუდენტი: არა
>> JASON HIRSCHHORN: OK.
ავიღოთ ერთი წუთით კოდექსს, ან, როგორც მინიმუმ უნდა დაიწყო მასზე.
>> ასე რომ შეგიძლიათ გავაგრძელოთ მუშაობა, მაგრამ მე ვაპირებ უნდა დაიწყოს გადის იგი.
ასე რომ, მინდა ადრე მაქვს ეკრანზე # მოიცავს cs50.h, # მოიცავს stdio.h.
int მთავარი ბათილად.
შიგნით ძირითადი ნახვა curly აფრთხილებს, მაქვს ორი კომენტარი, pseudocode.
ერთი ითხოვენ ნახატზე შესახებ.
მეორე ამობეჭდოთ თითოეული ხასიათი ახალ ხაზზე.
ასე რომ, ანა, შეგიძლიათ მაძლევს ვთხოვთ ამისთვის ნახატზე ხარ?
>> სტუდენტი: Printf.
>> JASON HIRSCHHORN: Printf?
>> სტუდენტი: დიახ.
(
>> JASON HIRSCHHORN: (
>> სტუდენტი: "მომეცი სიმებიანი.
>> JASON HIRSCHHORN: "მისცეს ჩემთვის ქ - oops -
სიმებიანი.
>> სტუდენტი: / ნ ") მძიმით.
>> JASON HIRSCHHORN: ბოლო სიმებიანი, დახურულ ფრჩხილებში, მძიმით.
>> სტუდენტი: დიახ.
და მაშინ მეორე ხაზზე, სიმებიანი s = მიიღოს სიმებიანი.
>> JASON HIRSCHHORN: სიმებიანი s = მიიღოს სიმებიანი.
>> სტუდენტი: დიახ.
და მაშინ ()
>> JASON HIRSCHHORN: ()
>> სტუდენტი: მძიმით.
>> JASON HIRSCHHORN: მძიმით.
ფორმები.
ამიტომ, მე ვაპირებ მისაღებად სიმებიანი და მე ვაპირებ შეინახეთ ის, თუ რა?
რა არის ცვლადში რომ თქვენ შექმნილი?
>> სტუდენტი: სიმებიანი s.
>> JASON HIRSCHHORN: ცვლადი ეწოდება s.
ეს პირობა მხოლოდ.
ზუსტად.
შემდეგი, რაც ჩვენ გვინდა, რომ არის ამობეჭდოთ ყოველ სიმბოლოს ახალი ხაზი.
ვის შეუძლია მაძლევს, რომ კოდი?
[Inaudible]?
შეგიძლიათ ის მე?
>> სტუდენტი: რა თქმა უნდა.
>> JASON HIRSCHHORN: მოდით, გავაკეთოთ.
და ვწუხვარ.
მე არ მიყვარს გავიმეორო რას ამბობენ იმიტომ, რომ თქვენ მისაღებად სწორად, მაგრამ მე
უნდა გავიმეოროთ ისე, რომ როდესაც ისინი transcribe ამისა, მათ შეუძლიათ მიიღონ ყველა
ტექსტის გარეთ ტრანსკრიფცია.
ასე რომ შეგიძლიათ უბრალოდ შეინახოს საუბარი.
სამწუხაროდ, მე არ მაქვს იმის თქმა, რომ მეტი თქვენ.
მე ბოდიში, მაგრამ -
>> სტუდენტი: კიდევ კარგი.
იყიდება int i = 0
>> JASON HIRSCHHORN: იყიდება int i = 0
>> სტუდენტი: მე ნაკლები -
>> JASON HIRSCHHORN: მძიმით.
>> სტუდენტი: მანამდე კი შეგვიძლია დააყენა ცვლადი ასე რომ თქვენ int სახელი სიგრძეზე?
>> JASON HIRSCHHORN: Oh, თქვენ არ ფულის მძიმით?
OK.
ასე რომ, რა გინდათ ამის გაკეთება მას შემდეგ ნულოვანი?
>> სტუდენტი: მე მინდა სიმებიანი ხანგრძლივობა და
მითითებული, რომ ცვლადის?
>> JASON HIRSCHHORN: კარგი, ასე რომ, როგორ გავაკეთო ეს?
>> სტუდენტი: იმისთვის, რომ int სიგრძის =
>> JASON HIRSCHHORN: Int სიგრძის =
>> სტუდენტი: S-T-R-L-E-N.
>> JASON HIRSCHHORN: S-T-R-L-E-N -
>> სტუდენტი: რა s.
ფრჩხილებში.
>> JASON HIRSCHHORN: (s).
>> სტუდენტი: და მე ვფიქრობ, თქვენ უნდა დააყენა მძიმით ორ ints.
>> JASON HIRSCHHORN: მძიმით მას შემდეგ, რაც ნულოვანი?
>> სტუდენტური: ჰო.
შემდეგ დააყენა მძიმით ამის შემდეგ, და ამბობენ, i ნაკლები სიგრძის.
i ნაკლები სიგრძის, რომელიც არის განსხვავებულია.
>> სტუდენტი: და მერე მძიმით.
>> JASON HIRSCHHORN: მძიმით.
>> სტუდენტი: i + +.
>> JASON HIRSCHHORN: i + +.
აქ არის ჩვენი for ციკლი.
OK, შიგნით for ციკლი.
>> სტუდენტი: და მერე printf.
>> JASON HIRSCHHORN: Printf.
>> სტუდენტი: ფრჩხილებში.
>> JASON HIRSCHHORN: ფრჩხილებში, შეთავაზებებს.
>> სტუდენტი: ფრჩხილებში, ციტატებით,% გ / ნ.
>> JASON HIRSCHHORN:% გ, OK.
>> სტუდენტი: / ნ.
>> JASON HIRSCHHORN: / ნ.
>> სტუდენტური: დასრულებული შეთავაზებებს.
>> JASON HIRSCHHORN: დასრულებული შეთავაზებებს.
>> სტუდენტი: Comma.
>> JASON HIRSCHHORN: Comma.
>> სტუდენტი: ს
>> JASON HIRSCHHORN: ს
>> სტუდენტი: Bracket i.
>> JASON HIRSCHHORN: Bracket i.
>> სტუდენტი: და შემდეგ დაიხურა ფრჩხილებში.
>> JASON HIRSCHHORN: დასრულებული ფრჩხილებში.
>> სტუდენტი: და მერე მძიმით.
>> JASON HIRSCHHORN: მძიმით.
ფორმები.
მოდით გადარჩენა ეს.
სასტარტედ სიტყვიერად.
Oh ბიჭი.
მაქვს რამოდენიმე შეცდომები.
პირველი შეცდომა ხაზი 11, იგი აცხადებს, მოსალოდნელია, გამოხატვის და ეს აძლევდა
მე შეცდომა, რომ მეორე int, აქ არის შეცდომა.
არსებობს რაიმე შეცდომა გარშემო არსებობს.
ვინმეს აქვს იცოდეს, თუ რა შეცდომა, რომ არის?
კურტ?
>> სტუდენტი: მე ვფიქრობ, ეს უნდა იყოს მძიმე და არა მძიმით.
>> JASON HIRSCHHORN: კარგი, მძიმე ნაცვლად მძიმით.
ასე რომ, ის არის, რომ ყველა ჩვენ უნდა დააფიქსიროს?
>> სტუდენტი: არა
>> JASON HIRSCHHORN: რა გვჭირდება დაფიქსირება?
>> სტუდენტური: ჩვენ უნდა შეიცავდეს string.h.
>> JASON HIRSCHHORN: მოიცავს string.h.
სად უნდა უნდა შეიცავდეს, რომ?
>> სტუდენტი: იგივე ადგილზე თქვენ ჩათვლით სხვა პერსონალი, მარჯვენა
მას შემდეგ, რაც მოიცავს stdio.h.
>> JASON HIRSCHHORN: ვნახოთ, თუ ეს ეშვება პირველი იმიტომ, რომ ზოგადად, მომწონს
დაფიქსირება ერთი რამ პირველი და შემდეგ აწარმოებს ეს, და შემდეგ დაინახავთ შეცდომები მივიღებთ.
ასე რომ, ჩვენ ვაპირებთ, რომ ნათელი ტერმინალში კონტროლის ო, მოდით მიიღოს მართლწერის.
ასე რომ, კიდევ ერთი შეცდომა ხაზი 11.
მოსალოდნელი მძიმით.
და მე ჯერ კიდევ მიღების შეცდომები ამ ხაზი.
ასე რომ, ეს არ მომცა შეცდომა რომ გაუგებარია რა strlen არის,
მაგრამ მაძლევს შეცდომას ამ ხაზი, ასე რომ რა არის მიზეზი?
მოვნიშნოთ?
მარკუს.
>> სტუდენტი: გაქვთ ამოიღონ მეორე int დეკლარაციის?
>> JASON HIRSCHHORN: ამოღება მეორე int.
მოდით ცდილობენ ამ.
ახლა ნათელია ტერმინალში.
სასტარტედ სიტყვიერად.
შეცდომა.
ირიბად გამოცხადების ბიბლიოთეკა ფუნქციის strlen.
ასე რომ, ახლა ჩვენ ვხედავთ, რომ შეცდომა.
რას უნდა შეიცავდეს?
>> სტუდენტი: String.h.
>> JASON HIRSCHHORN: მოიცავს string.h, ჩვენ ყველაფერს გავაკეთებთ # მოიცავს string.h ზედა
ეკრანზე.
გადავარჩინოთ, მიიღოს სიტყვიერად.
ახლა შედგენილი.
ასე რომ, კიდევ ერთხელ, რამ გვჭირდებოდა გვახსოვს ხაზი 12 ჩვენი for loop როდესაც
ჩვენ განსაზღვრავს ის, int i = 0, სიგრძის = strlen (s).
>> ეს არის ფანტასტიკური სტრატეგია.
სტილი ეს არის დიდი, დიზაინი ამ დიდი.
ჩვენ შეგვიძლია წასვლას იმ მიზეზებზე შემდეგ, მაგრამ ამ გზით თქვენ მხოლოდ უნდა მოვუწოდებთ
strlen ერთხელ ნაცვლად თითოეული დროის აწარმოებს მეშვეობით ციკლი.
თუმცა, თქვენ უნდა გამოვიყენოთ მძიმე არსებობს და არ არის საჭირო int ერთხელ.
თუ თქვენ გამოცხადების როგორც იმ ცვლადები ერთად, თქვენ
არ არის საჭირო int ერთხელ.
და მაშინ თუ ვაპირებთ გამოვიყენოთ strlen, რომელიც კიდევ ერთი ბიბლიოთეკა
ფუნქცია არ შედის stdio.h ან cs50.h, მიიღოს
დარწმუნდით, რომ თქვენ მოიცავს string.h.
კურტ?
>> სტუდენტი: ასე შემდეგ თუ არ უნდა რა ტიპის სიგრძე, აკეთებს, რომ
რაც იმას ნიშნავს რომ უნდა იყოს int?
ვერ გვაქვს ორი სხვადასხვა სახის იქ?
>> JASON HIRSCHHORN: ასე შეიძლება აქვს ორი სხვადასხვა სახის.
სიგრძე არის int აქ, თუმცა.
სიგრძე არის int იმიტომ, რომ მძიმე შემდეგ კი იგივე.
>> სტუდენტი: ასე რომ, ეს გულისხმობს, რომ იგი აპირებს უნდა იყოს იგივე, რაც პირველი?
>> JASON HIRSCHHORN: ზუსტად.
ჩვენ არ ვაპირებთ ამის გაკეთებას, მაგრამ თქვენ შეიძლება შეიცავდეს ორი ცვლადის წლის
ანალოგიური პოზიცია გამოყენებით მონაცემების ტიპის.
ასე int x, y შექმნის ორი ცვლადი.
ასე int x, y, თუ გავაკეთებთ, რომ ეს აძლევს მე გამოუყენებელი ცვლადი x და y, რადგან
ჩვენ არ ვიყენებთ მათ.
ასე აყენებს ბათილად ადრე მხოლოდ მიეცით შეასრულა თუ არ გამოიყენებს
რაღაც, გამოიყენოს იგი.
მაგრამ, როგორც ხედავთ, შევქმნა x და y იმავე ხაზის მძიმით.
ეს ქმნის ორ რიცხვებით უფლება არსებობს.
ასე რომ, დიახ, სრულიად შესაძლებელია, რომ შევქმნათ ორი რამ იმავე ხაზი
გამოყოფილი მძიმით.
მოდით, თავი დაეღწია იმ, თუმცა.
>> ასე რომ მართლწერის.
დიდი მადლობა ბიჭებს ამისთვის კოდირების ეს ჩვენთვის.
მოდით ეს კიდევ ერთხელ, რომ აწარმოებს.
მომეცი სიმებიანი.
[Inaudible], გააკეთეთ საუკეთესო აღმოჩნდა.
რა არის სიმებიანი?
>> სტუდენტი: Hello.
>> JASON HIRSCHHORN: Hello.
H-E-L-L-O, თითოეული ხასიათი ერთ ხაზს.
გამოიყურება დიდი.
მოდით აწარმოებს კიდევ ერთხელ.
ყოველთვის აპირებს შეამოწმოს ამისთვის კუთხეში შემთხვევაში.
რა არის კარგი კუთხეში შემთხვევაში, რათა შეამოწმოს?
>> სტუდენტი: ნომერი?
>> JASON HIRSCHHORN: ნომერი.
ასე რომ მე დასვა 1, და ეს ბეჭდავს out 1.
ეს არ ითხოვს წერილები, ისე როგორც ჩანს, ნომრები მუშაობა.
კარგი კუთხეში შემთხვევაში, რათა შეამოწმოს.
რა არის კიდევ ერთი კარგი კუთხეში საქმე შეამოწმოს?
>> სტუდენტი: ცარიელი სტრიქონი.
>> JASON HIRSCHHORN: Hm?
>> სტუდენტი: მსგავსად ცარიელი.
>> JASON HIRSCHHORN: ცარიელი.
მოდით არ დააყენა არაფერი.
და რა ხდება იბეჭდება?
>> სტუდენტი: არაფერი.
>> JASON HIRSCHHORN: არაფერი.
როგორც ჩანს, მუშაობს.
თქვენ შეიძლება ვცდილობთ უფრო კუთხეში შემთხვევა, არამედ ზოგადად ნომრები, სხვადასხვა მონაცემები
დიდი ცდილობენ, ასევე არაფერია.
არაფერს, ნულოვანი, უარყოფით შედეგებს ყოველთვის დიდი რამ ცდილობენ და რამ
უნდა გამოცდა, რამ, რა თქმა უნდა, ჩვენ შესამოწმებლად და შემოწმება 50 იქნება შეამოწმოთ ამისთვის.
შეკითხვები spell.c?
>> კარგი, მოდით უფროსი უკან.
მე კიდევ ერთი პროგრამა თქვენ ბიჭები დაწერა.
ეს მოუწოდა students.c.
ეს არის პროგრამა, რომელიც სთხოვს შესახებ for ხუთ სახელები, მაშინ შემთხვევით ირჩევს
და ბეჭდავს out ერთი სახელები.
ეს პროგრამა ცოტა მეტი ჩართული, ვიდრე ბოლო ორი ჩვენ წერს
რატომ არ ვიღებთ ხუთი წუთით, კოდი, ინდივიდუალურად, შემდეგ კი ჩვენ გამოგიგზავნით
კოდი, როგორც ჯგუფს.
>> ეს პროგრამა ასევე ჩართვას ზოგი რამ შეიძლება არ მინახავს ადრე, ასე რომ, თუ
თქვენ გაქვთ შეკითხვა, როგორ მე გავაკეთოთ, რომ ამაღლება შენი ხელი.
მე გადმოდიოდნენ და აღვნიშნო თქვენ სწორი მიმართულებით.
მაგრამ ჩვენ ასევე ვაკეთებთ, რადგან ამ იქნება კარგი გზა დანერგვა რამოდენიმე
თემა, რომელიც სახიფათო.
>> ასე რომ, ეს მუშაობს, არა?
>> სტუდენტური: ჰო.
>> JASON HIRSCHHORN: როდესაც თქვენ აქციოს პრობლემა კომპლექტი, არსებობს მრავალი გზა
, მაგრამ ზოგი მეტი დახვეწილი ვიდრე სხვები.
მოდით, dive სისტემაში
# მოიცავს cs50.h.
# მოიცავს stdio.h.
int მთავარი ბათილად, curly აფრთხილებს.
Inside curly აფრთხილებს, მე ორი კომენტარი.
პირველი, ვთხოვთ მომხმარებლის ხუთ სახელები.
მეორე, შემთხვევით აირჩიოს და ამობეჭდოთ ერთი სახელები.
მოდით გავაკეთოთ პირველი, ვთხოვთ მომხმარებლის ხუთ სახელები.
ვინ სთხოვა შესახებ ხუთ სახელები და შეიძლება მეუბნებოდა, როგორ უნდა ამის გაკეთება?
მხოლოდ ორ ადამიანს გააკეთა პირველი ნაწილი.
სამი ადამიანი გააკეთა პირველი ნაწილი.
ოთხი, ხუთი.
ტომ, როგორ ამის გაკეთება?
>> სტუდენტი: თქვენ განაცხადოს სიმებიანი და შემდეგ სახელი, bracket ხუთ.
>> JASON HIRSCHHORN: სიმებიანი ასახელებს bracket ხუთ.
რა არის ამ ხაზის აკეთებს, სიმებიანი სახელი bracket ხუთ?
>> სტუდენტი: თქვენ გამოაცხადოს მასივი strings.
>> JASON HIRSCHHORN: ეს არის მასივი strings.
რამდენი strings ვაპირებთ შეესაბამება აქ?
>> სტუდენტი: ხუთი.
>> JASON HIRSCHHORN: ხუთი.
შესანიშნავი.
ჩვენ ვაპირებთ ეძახით სახელები, რადგან ჩვენ ვაპირებთ, რომ მიიღოთ მრავალი პირობა.
OK, შემდეგ?
>> სტუდენტი: და მერე აქვს for loop -
>> JASON HIRSCHHORN: იყიდება ციკლი.
>> სტუდენტი: - for i = 0.
>> JASON HIRSCHHORN: იყიდება (int i = 0.
>> სტუდენტი: მძიმით.
>> JASON HIRSCHHORN: მძიმით.
>> სტუდენტი: I ზე ნაკლები აღმოჩნდა.
>> JASON HIRSCHHORN: I ზე ნაკლები აღმოჩნდა.
>> სტუდენტი: მძიმით.
>> JASON HIRSCHHORN: მძიმით.
>> სტუდენტი: i + +.
>> JASON HIRSCHHORN: i + +.
>> სტუდენტი: და შემდეგ დაიხურა ფრჩხილებში.
>> JASON HIRSCHHORN: დასრულებული ფრჩხილებში, და შემდეგ რამდენიმე curly აფრთხილებს.
Inside curly აფრთხილებს?
>> სტუდენტი: და მერე printf.
>> JASON HIRSCHHORN: Printf.
>> სტუდენტი: ღია ფრჩხილებში, სახელი% d.
>> JASON HIRSCHHORN: უკაცრავად?
>> სტუდენტი: სახელი.
>> JASON HIRSCHHORN: სახელი.
>> სტუდენტი: და მერე სივრცე, შემდეგ კი% d.
>> JASON HIRSCHHORN: სახელი, სივრცე,% d.
>> სტუდენტი: და შემდეგ / ნ, შემდეგ კი დაიხურა.
>> JASON HIRSCHHORN: ასე რომ სახელი, სივრცე, % D / ნ, დახურული ფრჩხილებში.
>> სტუდენტი: მძიმე, i + 1.
მე ბოდიში.
დახურული გაცემა, შემდეგ კი მძიმე, i +1.
>> JASON HIRSCHHORN: დასრულებული გაცემა, მძიმე, i +1.
>> სტუდენტი: დიახ.
და მაშინ მეორე ხაზზე -
>> JASON HIRSCHHORN: i + 1.
>> სტუდენტი: დიახ.
და მაშინ მომავალი slide არის სახელების bracket i.
>> JASON HIRSCHHORN: შემდეგი ხაზი არის სახელების bracket i.
>> სტუდენტური = მიიღოს სიმებიანი.
>> JASON HIRSCHHORN = მიღება -
კაპიტალის G-E-თი -
სიმებიანი.
ვაი, ბოდიში.
>> სტუდენტი: ღია, დახურული ფრჩხილებში ხოლო შემდეგ -
>> JASON HIRSCHHORN: ღია, დახურული paren.
>> სტუდენტი: მძიმით.
>> JASON HIRSCHHORN: მძიმით.
OK, ასე რომ თქვენ ინიციალიზაცია მასივი სიმები, სახელები და შემდეგ გაიაროს
ამისთვის მარყუჟის და ხუთჯერ ბეჭდვა გარკვეული შეგახსენებთ, რომ შესახებ და შემდეგ შესანახად
ხუთ strings.
ვინმეს აქვს რაიმე კორექტირებას ეს?
ტომ, მე ვფიქრობ, ყველას ეთანხმება თქვენ.
როგორც ჩანს საკმაოდ კარგი.
OK.
რატომ შემიძლია +1, თუმცა?
>> სტუდენტი: მე ვგულისხმობ, არ გააჩნია უნდა იყოს, მაგრამ მე +1 ისე, რომ ეს
სახელი ერთ დაასახელებს ხუთი.
წინააღმდეგ შემთხვევაში, ეს იქნება სახელი ნულოვანი დაასახელებს ოთხი.
>> JASON HIRSCHHORN: ასე გააკეთეთ i +1 რადგან, წინააღმდეგ შემთხვევაში ეს იქნებოდა
იბეჭდება ნულოვანი ოთხ რადგან ასე კომპიუტერების ვფიქრობ, მაგრამ ადამიანები
ნამდვილად არ წაიკითხა, რომ.
ეს არის კიდევ ერთი რამ თქვენ ექმნებათ.
ზოგჯერ, როდესაც თქვენ ამობეჭდოთ რაღაც მომხმარებელს, თქვენ გინდათ ის
ცოტა გალამაზებაში და აკეთებს i +1 ამ შემთხვევაში არის
გზა, რათა ის გალამაზებაში.
>> მეც ვხედავ ხუთ ორჯერ, სიმებიანი სახელი არის ხუთი, i ზე ნაკლები.
მე ვიცი, სად შენ ხუთ.
თქვენ მიიღო იგი მე ვეუბნებოდი თქვენ ხუთ სახელები.
მაგრამ თუ გვინდოდა, რათა კოდი ცოტა უფრო მტკიცე, ერთი რამ ჩვენ
შეიძლება არის აქ, გარეთ int, ჩვენ შეგვიძლია გავაკეთოთ მსგავსი რამ,
# განსაზღვრა და მოვახერხეთ სახელების 5.
>> ასე რომ, ძირითადად, სადაც არ უნდა ვწერ კაპიტალი N, კაპიტალი, კაპიტალის M, დედაქალაქის E,
კაპიტალის S, რომ ტექსტი, იგი ჩაანაცვლებს რომ 5 კოდი.
ან მოდით, უბრალოდ მას - ჩვენ მხოლოდ მას რაოდენობა.
ასე რომ, მე განსაზღვრის ყველა caps ნომერი იყოს 5.
>> ასე რომ, ახლა იქ, სადაც მე მაქვს 5, I შეიძლება შეცვალოს ეს ყველა caps ნომერი.
ახლა კი, თუ მინდა, რომ შეიცვალოს ნომერი სახელები, ყველა მე უნდა გავაკეთოთ არის
ეს ერთი ხაზი, ხაზი ოთხი, სადაც მე მაქვს # განისაზღვროს 5, შეცვლა, რომ 10,
ან შეცვალოს, რომ 4.
როდესაც თქვენი კოდი იღებს აღარ, თქვენ არ აპირებს გვახსოვს ყველა ადგილას
დააყენა რამდენი სახელები უნდოდა, ხოლო იმისათვის, რომ არ გამოგრჩეთ ერთი, ეს
კარგი გზა ამის გასაკეთებლად, რომ რაღაც up დაბრუნება და შემდეგ უბრალოდ გამოიყენოთ, რომ ფრაზა
ყველგან მთელი თქვენი კოდი.
მარკუს?
>> სტუდენტი: ის არის, რომ სტილისტურად სასურველი ვიდრე გლობალურად განსაზღვრის
მუდმივი N?
>> JASON HIRSCHHORN: ასე არის, რომ სტილისტურად ამჯობინა, ვიდრე გლობალურად
განსაზღვრის მუდმივი N?
ასე რომ თქვენ ამბობდა შეიძლება გააკეთოს, int ნომერზე = 5?
>> სტუდენტი: აქვთ თანხმოვანი in C ან არ?
>> JASON HIRSCHHORN: ან const - თანაბარი.
ასე რომ თქვენ ამბობდა მხოლოდ გლობალური ცვლადი?
>> სტუდენტური: ჰო.
>> JASON HIRSCHHORN: ასე სტილისტურად, არ არსებობს აუცილებლად ერთი უფლება
პასუხის გაცემა, მაგრამ ორივე უკეთესი ვიდრე უბრალოდ სროლა ეს შემთხვევითი
ციფრები, მთელი თქვენი კოდი.
ჩვენ მოვუწოდებთ მათ ჯადოსნური ნომრები.
როდესაც ვუყურებ თქვენი კოდი ან როდესაც არავის კითხულობს მეშვეობით, ისინი
არ მინდა უბრალოდ ეს შემთხვევითი ნომრები რომ არ აქვს აზრი.
მაშინაც კი, ნომერი 26, რომელიც ზოგადად არის რიგი ასო ანბანი,
უმჯობესია, განვსაზღვროთ ანბანი up დაბრუნება და გადარჩენა ნომერი 26, რომ ტექსტი,
თუ ეს აზრი.
>> ან პრობლემა მითითებული ერთი, ვიდრე - კიდევ ერთხელ, ჩვენ არ ვსაუბრობთ ამ დროს
დრო, მაგრამ ნაცვლად მხოლოდ სროლა in 25 ყველგან ან 10, შეგიძლიათ
გადავარჩინოთ ნომერი 25 როგორც კვარტალი ან 10 როგორც Dime და ხდის უფრო ადვილად
ვინც ის კითხულობს საშუალებით თქვენი კოდს მესმის, რატომ აირჩია, რომ ნომერი.
ასევე თქვენთვის, თუ თქვენ ოდესმე გვინდა განახლება თქვენი კოდი, ეს ქმნის ცოტა
გაძლიერება.
ჰო?
>> სტუდენტი: არის თუ არა ეს კოდი ასევე აპირებს უნდა იყოს ხელმისაწვდომი ჩვენთვის შემდეგ?
>> JASON HIRSCHHORN: ყველა აღნიშნული კოდებით რომ ჩვენ წერილობით ერთად არიან
უნდა ელექტრონული ფოსტით, რომ თქვენ ბიჭები და არ არის შესაძლებელი.
დიახ.
ამიტომ ვთხოვთ შესახებ ხუთ სახელები.
შემთხვევით აირჩიოს და ბეჭდვა ერთი სახელები.
ვინ გააკეთა ეს ხაზი?
ეს არის საინტერესო ხაზი აქ.
სამწუხაროდ, ტომ.
გააკეთეთ თქვენ მართლაც კარგად იმუშავა, მაგრამ ეს ცოტა trickier.
მარკუს, წავიდეთ წინ.
>> სტუდენტი: ისე პირველი, თქვენ აპირებს უნდა შეიცავდეს stdlib.h და time.h.
>> JASON HIRSCHHORN: ასე რომ თქვენ ამბობდა ზე დასაწყისში, მოიცავს ორი ბიბლიოთეკების.
გსურთ ჩემთვის მოიცავს S-T-D-L-I-B dot H, სტანდარტული ბიბლიოთეკა, და რა
იყო მეორე?
>> სტუდენტი: Time.h.
>> JASON HIRSCHHORN: # მოიცავს time.h.
ასე რომ, ეს არის კიდევ ორი ​​ბიბლიოთეკების.
მე ვივარაუდოთ, ახლა ჩვენ ვაპირებთ გამოყენებით ფუნქციებს, რომლებიც შეიცავს ამ
ორი, რის გამოც თქვენ საჭირო კერძოდ, შეიტანონ მათ?
>> სტუდენტი: ასე შემდეგ, პირველი თქვენ აპირებს მინდა დაწერა srand.
>> JASON HIRSCHHORN: Srand.
>> სტუდენტი: (დრო (0)
>> JASON HIRSCHHORN: უკაცრავად.
Srand (დრო (
>> სტუდენტი: 0.
>> JASON HIRSCHHORN: 0.
>> სტუდენტი:)), მძიმით.
>> JASON HIRSCHHORN: სხვა დახურულ paren?
მძიმით.
მე ვაპირებ მხოლოდ შეცვლის თქვენი ნულოვანი ერთად null.
ეს გავაკეთებ დაახლოებით იგივე რამ, მაგრამ ზოგადად, დაინახავთ, NULL, რომელიც
ჩვენ ვსაუბრობთ ამ ხაზი მეორე.
>> სტუდენტი: სტილისტურად უკეთესი?
>> JASON HIRSCHHORN: საერთოდ, მარჯვენა NULL, მაგრამ იგივე.
>> სტუდენტი: და მაშინ int სახელი.
>> JASON HIRSCHHORN: Int სახელი.
>> სტუდენტური =
>> JASON HIRSCHHORN =
>> სტუდენტი: Rand.
>> JASON HIRSCHHORN: Rand.
>> სტუდენტი: ()
>> JASON HIRSCHHORN: ()
>> სტუდენტი: Modulo ნომერი.
>> JASON HIRSCHHORN: რა არის modulo?
ხასიათი?
პროცენტი ხასიათი?
>> სტუდენტი: პროცენტი ხასიათი.
Modulo ნომერი, რომელიც თქვენ განსაზღვრული up დასაწყისში.
>> JASON HIRSCHHORN: Modulo ნომერი.
>> სტუდენტი: და მერე მძიმით.
>> JASON HIRSCHHORN: მძიმით.
>> სტუდენტი: და მერე ახალი ხაზი, printf.
>> JASON HIRSCHHORN: Printf.
>> სტუდენტი: (
>> JASON HIRSCHHORN: (
>> სტუდენტი: "
>> JASON HIRSCHHORN: "
>> სტუდენტი:% s / n
>> JASON HIRSCHHORN:% s / n
>> სტუდენტი: "
>> JASON HIRSCHHORN:% s / n "
>> სტუდენტი: მძიმე, ინტერვალი სახელები.
>> JASON HIRSCHHORN: სივრცე -
>> სტუდენტი: Oh, ვფიქრობ, რა საერთოდ ჩვენ მას აქ?
>> JASON HIRSCHHORN: ჩვენ მას სახელები.
>> სტუდენტი: ღია bracket, სახელი.
>> JASON HIRSCHHORN: ღია bracket, სახელი.
>> სტუდენტური: დასრულებული bracket.
>> JASON HIRSCHHORN: დასრულებული bracket.
>> სტუდენტი:)
>> JASON HIRSCHHORN:)
>> სტუდენტი: მძიმით.
>> JASON HIRSCHHORN: მძიმით.
OK, გადავარჩინოთ.
მოდით ეს კოდი.
სტუდენტები.
მოდით აწარმოებს ამ კოდი.
სტუდენტები.
არ. / სტუდენტი. . / სტუდენტებს.
სახელი ერთი.
ჩვენ ამის თქმა, დავით.
სახელი ორი, RJ.
სახელი სამი, Rob.
სახელი ოთხი, ლუკასი.
სახელი ხუთ, იოსებ.
და მერე ბეჭდავს out ჯოზეფ ერთხელ.
>> ნება მომეცით, აწარმოებს ამ ერთხელ.
ნება მომეცით იგივეს სახელები.
დავით, RJ, ძარცვა, Lucas, იოსებ.
და ეს მომცა დავით ამ დროს.
ასე რომ, მე იგივე, მაგრამ ეს მისცა მე სულ სხვა რამ, და ეს
იმიტომ, რომ, რა თქმა უნდა, ჩვენ ითხოვს შემთხვევითი სახელი.
ასე რომ, ვფიქრობ, გამომდინარე off ჩემზე მოხეტიალე ოთახში, რომ ადამიანთა უმრავლესობამ
ალბათ მივიღე პირველი ნაწილი, მარჯვენა შექმნის, რომ მასივი, შემდეგ კი მიღების
ყველა სახელები.
მე ვსაუბრობ ხაზები 10 გზით 16.
მაგრამ ხაზები 18 გზით 21 ალბათ ზოგიერთი რამ, რაც არ მინახავს ადრე,
მოდით გაიაროს იმ.
>> ეს ხაზი, srand დრო NULL არსებითად -
ვწუხვარ, მოდით გაფართოებული ქვემოთ ხაზი, RAND ().
რომელიც გაძლევთ შემთხვევითი ნომერი, შემთხვევითი რიცხვი.
და თუ მოხვდა ადამიანი RAND, რომელიც ბევრი გააკეთეთ -
M-A-N სივრცეში R-A-N-D -
ტერმინალურ მსგავსი, M-A-N სივრცე R-A-N-D, დააჭიროთ.
თქვენ ამუშავება სახელმძღვანელოს და შეძლებს წავიკითხე, რომ RAND
ბრძანება შედეგები num ფსევდო შემთხვევითი bytes მას შემდეგ, სათესლე შემთხვევითი რიცხვების
გენერატორი ერთხელ.
>> ასე რომ, აღწერა.
სწორედ ეს RAND არ აძლევს თქვენ შემთხვევით, როცა
თქვენ მოვუწოდებთ, რომ ფუნქცია.
სამწუხაროდ, ეს არ არის ნამდვილად შემთხვევითი იმიტომ, რომ თუ მხოლოდ მოვუწოდებთ შემთხვევითი
მიღების გარეშე მას თესლი, ზოგიერთი ამოსავალი წერტილი, ის ყოველთვის აირჩიოს
იგივე ერთი და იგი იყენებს ფორმულა რათა დადგინდეს მომდევნო ერთი.
ასე რომ, თუ დარეკვა RAND, რომ თქვენ მხოლოდ გადმოგცეთ იგივე.
ეს იქნება ძალიან პროგნოზირებადია.
ის რეალურად არ იქნება შემთხვევითი.
>> ასე რომ, ის, რაც ჩვენ უნდა გავაკეთოთ, ერთ მარკუს ნახვა მითითებები ჩემთვის, იყო სათესლე RAND
რაღაც სხვა, რაც srand ფუნქცია აკეთებს.
ეს თესლი RAND რაღაც უფრო მეტი შემთხვევითი ვიდრე იგივე, და
ის სათესლე ეს დრო NULL, რომელიც არის, მხოლოდ კონვენციის, მიმდინარე
დრო წამებში.
>> ასე რომ თქვენ თუ გავითვალისწინებთ, რომ ყველას არ აპირებს კოდი ზუსტი
იგივე მეორე, ამიტომ უსაფრთხო დადებს, რომ დრო NULL იქნება სხვადასხვა
ყოველ ჯერზე ეს კოდი მართავენ.
უსაფრთხო დადებს, რომ ამით srand იქნება სათესლე RAND რაღაც განსხვავებული ყველა
ერთ დროს.
ამიტომ მიერ კონვენციის, როდესაც ჩვენ გავაკეთებთ მინდა შემთხვევითი ნომერი, ჩვენ წერენ ეს ხაზი,
srand დრო NULL, რომ მოგვცეს გაცილებით უფრო შემთხვევითი თესლი, და შემდეგ ჩვენ აწარმოებს
RAND, რომელიც გვაძლევს შემთხვევითი ნომერი.
ჰო?
>> სტუდენტი: იტყვით რა ნიშნავს სათესლე?
>> JASON HIRSCHHORN: Seed როგორც -
ასე RAND აპირებს პიკაპის ზოგიერთ ნომერი და ეს ხდება გამოვიყენოთ
ფორმულა მისაღებად არსებობს.
ამიტომ დაწყებას აპირებს რაღაც და შემდეგ აქციოს რაღაც საფუძველზე
გამორთვა რომ ფორმულა.
თუ თქვენ ყოველთვის მისთვის იგივე, ის ყოველთვის აპირებს გადაქცევას
იგივე.
ასე რომ, პირველი, რაც თქვენ მისთვის არის თესლი.
ასე რომ გსურთ, რათა იგი რაღაც სხვადასხვა დაიწყოს out, და ა.შ. ეს
გახდება ის რაღაც განსხვავებული.
>> და მაშინ საბოლოოდ, ხაზის 20, ამ% ეწოდება
modulo, და რომ გაუგებარია.
ეს არის ის, რაც არის ცოტა სხვადასხვა აქ, რომ თქვენ ნამდვილად არ
აქვს რეალურ ცხოვრებაში მათემატიკის.
მაგრამ არსებითად, როდესაც თქვენ მიიღოს გიგანტური ნომერი და თქვენ დაყოფის in C, რა
მოხდება დარჩენილი?
>> სტუდენტი: იგი იღებს truncated.
>> JASON HIRSCHHORN: იგი იღებს truncated.
ასე რომ, 20 იყოფა 3 რა?
რას დაბრუნდნენ თქვენ, 20 იყოფა 3.
სამწუხაროდ, 10 იყოფა 3.
რას დაბრუნებას თქვენ?
>> სტუდენტი: [inaudible].
>> JASON HIRSCHHORN: 10 იყოფა 3 მხოლოდ ბრუნდება 3, არა 3 დარჩენილი 1.
მერე რა 10 modulo 3 ბრუნდება მხოლოდ დარჩენილი, 1.
ასე რომ, თუ აინტერესებდათ, თუ რა 10 იყოფა 3 რეალურად იყო, თქვენ
გავაკეთოთ 10 იყოფა 3, ნეტავ მიიღოთ თქვენი 3, და მაშინ ნეტავ გაკეთება 10 modulo 3, და
ნეტავ მისაღებად 1.
ასე რომ, ნეტავ გააცნობიეროს, რომ 10 იყოფა 3 არის 3, დარჩენილი 1.
>> და ამ მხრივაც, RAND შეიძლება იყოს ნებისმიერი რიცხვი, არსებითად.
ასე რომ modulo ამბობს, ყოფს მას მიერ ნომერი, რომელიც ამ შემთხვევაში 5.
და თუ ოდესმე დაყოს რიგი, რიცხვი ყოველთვის უნდა იყოს ნაკლები
რომ ნომერი.
ასე რომ, თუ თქვენ გამყოფი რიგი 5, დანარჩენი ყოველთვის იქნება
ნულოვანი ოთხ.
ეს არის ის, თუ რამდენად მათემატიკის შეიმუშავებს.
>> ასე რომ, დიდი რაოდენობით moduloed მიერ მცირე ნომერი ყოველთვის დაბრუნდნენ
ნაშთი და ყოველთვის დააბრუნებს ნომერი, რომელიც არის ნაკლები ნომერი
იყოფა.
ვინმეს აქვს რაიმე კითხვა შესახებ modulo, რადგან ეს მოვა ძალიან,
ძალიან მოსახერხებელი, ამიტომ გვინდა დავრწმუნდეთ ყველას ესმის?
ზემოთ.
და ჩვენ ვხედავთ, რომ ეს პროგრამა მუშაობდა.
კარგი, მოძრავი.
>> ასე რომ, მომდევნო, ჩვენ ვაპირებთ წასვლას ფუნქციები, და ჩვენ ვაპირებთ წავიდეთ
მეშვეობით დანარჩენი ამ პერსონალის ნამდვილად სწრაფად იმიტომ, რომ გვინდა
ბრძანების ხაზი არგუმენტები.
ასე რომ, ფუნქციები არსებითად, როგორც ვნახე, შავი ყუთები.
ისინი რამ მოუწოდა პარამეტრები, რაიმეს აკეთებენ, რომ მათ, ან
მათი შეცვლა ან შექმნა გვერდითი მოვლენები, და ბოლოს, ისინი Spit
რაღაც, რაც დაბრუნებული მნიშვნელობა.
შეიძლება თუ ვინმეს მომეცი ერთი მიზეზი, ამიტომ ჩვენ ხელთ ფუნქციები?
ვინმეს?
ერთი მიზეზი, რის გამოც ჩვენ მინდა გამოიყენოთ ფუნქციები?
ნებისმიერ მსურველს?
ვნახე ორი ხელში.
რა არის კარგი მიზეზი?
მარკუს?
>> სტუდენტი: თუ თქვენ გაქვთ დარეკვა იგივე ბლოკი კოდი რამდენჯერმე.
>> JASON HIRSCHHORN: კარგი, თუ საჭიროა მოვუწოდებთ იგივე ბლოკი
კოდი რამდენჯერმე.
ჯეფ, გქონდათ სხვა მიზეზი?
>> სტუდენტი: უბრალოდ ისე, რომ შეგიძლიათ კოდექსში ნაკლები.
>> JASON HIRSCHHORN: შეგიძლიათ კოდექსში ნაკლები.
Right.
თუ გსურთ, რომ რამე ლოტი -
წინა კოდექსი, მე ვერ აქვს წერილობითი მიიღოს სიმებიანი ხუთჯერ, მაგრამ
for loop ხდის გამოიყურებოდეს ლამაზი და თქვენ უნდა დაწეროს ნაკლებად კოდი.
ფუნქციები მსგავსი იდეა.
თუ მინდა იგივე ბევრი, გადატანა, რათა ფუნქცია და მოვუწოდებთ, რომ
ფუნქციონირებს ყოველ ჯერზე.
რომ ყველაფერს გააკეთებს, რომ რაც თქვენ.
ეს არის ის, დიდი მიზეზი გამოყენება ფუნქციები.
>> ასე რომ, ანატომია ფუნქცია.
ფუნქცია საერთოდ გამოიყურება ასე.
ეს თქვენ იწყება დაბრუნების ტიპის, შემდეგ თქვენ შეძლებთ სახელი.
იგი წავა არგუმენტები, წინააღმდეგ შემთხვევაში ცნობილია, როგორც პარამეტრი და შიგნით
იმ curly აფრთხილებს, თქვენ დაწერეთ კოდი.
>> ჩვენ ვნახეთ ერთი ფუნქცია ბევრი.
სწორედ მთავარი.
აქ მთავარი superimposed გადატანა რომ ანატომია მქონდა ადრე.
რას int უფლება აქ ნიშნავდეს?
რას int ნიშნავს?
როცა ვწერ int მთავარი (ბათილად).
>> სტუდენტი: დაბრუნება ტიპის?
>> JASON HIRSCHHORN: უკაცრავად?
>> სტუდენტი: დაბრუნების ტიპის.
>> JASON HIRSCHHORN: Int არის დაბრუნების ტიპის, სწორედ.
მთავარი ბრუნდება int.
რა არის მთავარი?
>> სტუდენტი: ფუნქციის სახელი.
>> JASON HIRSCHHORN: მთავარი არის სახელი ფუნქცია.
სწორედ.
და ბათილად?
რა არის ბათილად შიგნით ფრჩხილებში?
>> სტუდენტი: იგი არ იღებს ნებისმიერი გარე ღირებულება.
>> JASON HIRSCHHORN: ასე ბათილად -
უფლება.
შიგნით ფრჩხილებში, ჩვენ პარამეტრების ან არგუმენტები
ფუნქცია იღებს, რა მიდის შიგნით შავი ყუთი.
როდესაც ვწერთ ბათილად, თქვენ ამბობდა ეს მაშინ არაფერი სისტემაში
ასე int მთავარი ბათილად ნიშნავს მთავარ ნახვა არ იღებენ არაფერი სისტემაში
>> Inside curly აფრთხილებს, ჩვენ გვაქვს კოდი, შემდეგ კი ჩვენ ვხედავთ, წლის ბოლოს
დაბრუნების ნულოვანი.
რას დაბრუნების ნულოვანი ნიშნავს?
ასევე, ჩვენ ვისაუბრეთ დაბრუნების ტიპის.
მთავარი სჭირდება დაბრუნებას int.
ეს არის ის რაც ამ ხაზის აკეთებს.
ის დააბრუნებს int, ნულოვანი.
>> რა თქმა უნდა, არ მინახავს, ​​რომ ბევრი იმის გამო, რომ პროგრამირების ვაკეთებთ ერთად
მანქანები ვაკეთებთ და compilers ჩვენ ვიყენებთ დღეს, თქვენ
არ არის საჭირო, რომ ხაზი.
მთავარი არის სპეციალური საკმარისი, რომ იგი დარწმუნებულია, როდესაც თქვენ მიღწევა ბოლომდე მთავარი, უბრალოდ
დაბრუნების ნულოვანი თუ ყველაფერი კარგად ჩაიარა.
რეალურად, თუ რამე არ მიდის კარგად, მთავარ ხშირად დაბრუნდნენ სხვადასხვა
ნომერი ფიქსირდება, რომ რაღაც გაფუჭდა თქვენი პროგრამა.
>> ასე რომ, ზოგადად, როდესაც ხედავთ კოდს, არ წერენ დაბრუნების ნულოვანი, მაგრამ კარგია
იცოდეს, რომ ეს ხდება უკან სცენები, რადგან, როცა წერენ
სხვა ტიპის ფუნქცია, თქვენ უნდა
მოიცავს დაბრუნების ხაზი.
თუ თქვენ ვამბობ მე ვაპირებ დაბრუნების int, თქვენ უნდა
წერა დაბრუნების რაღაც.
თუ თქვენ აცხადებენ, ბათილად up აქ დასაწყისში, ბათილად მთავარი ბათილად, ამისთვის
მაგალითად, მაშინ ეს არ ბრუნდებიან არაფერი - ბათილად არაფერს ნიშნავს -
ასე რომ თქვენ არ გვჭირდება, რომ დაბრუნების ხაზი.
მაგრამ ოდესმე დაწერა ის, რაც არ არის ძალადაკარგულად დასაბრუნებლად ტიპის, საჭიროა
ხაზი, რომელიც ამბობს, დაბრუნებისა და თქვენ უნდა დააყენოს რაღაც არსებობს
რომ შეესაბამება ტიპის.
რაიმე კითხვა ეს?
Sweet.
>> სფერო.
ეს არის რაღაც ჩვენ შეეხო ასევე.
ყველა ცვლადი, როგორც ვიცით, აქვს გარკვეული მასშტაბის, და ეს, ძირითადად,
ვსაუბრობთ, სადაც ცვლადი შეიძლება ან არ შეიძლება მითითებული.
და მე მინდა ვთქვა, თუ რა ხდება in curly აფრთხილებს რჩება
შიგნით curly აფრთხილებს.
ასე მაგალითად, თუ დავაკვირდებით ამ კოდექსის ჩვენ განსაზღვრის გლობალური ცვლადი
გარეთ, მთავარ int, აქ ზედა.
ჩვენ მოუწოდებენ სხვა int შიგნით ძირითადი.
ჩვენ გვაქვს უფრო curly აფრთხილებს, და ჩვენ მოუწოდებენ სხვა int.
>> ჩვენ გვყავს სამი ის კოდი.
ეს არ არის იგივე.
მე შეიქმნა სამი განსხვავებული ცვლადი.
მაშინ შიგნით ეს შიდა curly აფრთხილებს, მე ვამბობ = 4.
რა არის, რომ ვსაუბრობთ, პირველი, მეორე,
ან მესამე?
>> სტუდენტი: მესამე.
>> JASON HIRSCHHORN: ეს ის საუბარი დაახლოებით მესამე.
ყველა იმ მართლაც შეიძლება იყოს ისაუბრა ამ კონკრეტულ
მაგალითად, რადგან მისი მოცულობის ყველაფერი , ამ innermost curly აფრთხილებს.
თუმცა, როცა რეკავთ რამ იგივე სახელი და გვარი, რაღაც მოუწოდა იმალებიან.
ასე, რომ თქვენ მხოლოდ გაუმკლავდეთ ან დაფიქსირება ან გამოიყენონ უახლესი ცვლადი, ან ერთი
ყველაზე ახლოს თქვენ.
ასე რომ შიგნით აქ, ამ მესამე უახლოეს რომ ხაზი, = 4, ასე
გავლენას ახდენს მესამე.
და ბოლოს ხაზი, = 2, რომელიც არის რომ ვსაუბრობთ, პირველი, მეორე,
ან მესამე?
>> სტუდენტი: მეორე.
>> JASON HIRSCHHORN: ეს ის საუბარი დაახლოებით მეორე.
რა თქმა უნდა, მესამე უახლოეს ეს კოდექსი, მაგრამ მესამე
არ არსებობს გარეთ იმ curly აფრთხილებს.
მას შემდეგ, რაც თქვენ, რომ დახურულ curly მუდმივი წინააღმდეგობა გაუწიოს, ეს როგორც ის წავიდა,
არსებითად.
ასე რომ, მხოლოდ ორი თქვენ არ დაუტოვებიათ არიან ისეთებიც პირველი ორი, და რა თქმა უნდა, ახლა
ეს ყველაზე ახლოს მეორე.
>> ასე რომ, კარგია, რომ ახსოვდეს ფარგლებში.
მაგალითად, დარწმუნებული ვარ, თქვენ შეექმნა ეს გააკეთოს, ხოლო ციკლი.
თუ თქვენ ინიციალიზაცია ცვლადი შიგნით ნუ ხოლო მარყუჟის და შემდეგ ცდილობენ
ვებგვერდზე გარეთ, ალბათ, რაღაც გაფრთხილება ისევე, როგორც ეს
ცვლადი არ არსებობს.
ეს იმიტომ, რომ საქართველოს ფარგლებს იდეა, რომ ყველაფერი არსებობდეს
შიგნით იმ curly აფრთხილებს.
Curly აფრთხილებს, ისევე როგორც გიგანტური hug, რომ თქვენ ვაძლევთ თქვენი კოდი, კიდევ ერთი
გზა ფიქრობთ ამის შესახებ.
>> ასე რომ, ეს არის კიდევ ერთი ფუნქცია, რაღაც თქვენ ბიჭები რომ კოდი, hellofunction.c.
ჩვენ ვაპირებთ გაფართოებული, რომ არის, მაგრამ ეს არის ის, მე მოგიწოდებთ თქვენ
პრაქტიკაში საკუთარი.
დაწერეთ პროგრამა, რომელშიც მთავარ ზარები კიდევ ერთი ფუნქცია, ბეჭდავს out
მისალოცი მომხმარებელს.
ეს არსებითად მიღების Hello World და abstracting რომ printf შევიდა
კიდევ ერთი ფუნქცია.
მაგრამ ჩვენ არ ვაპირებთ, რომ ახლა იმიტომ, რომ ჩვენ არ გვაქვს, როგორც ბევრი დრო
დატოვა, როგორც მე არ მომეწონა.
>> ასე რომ, ფუნქცია დეკლარაცია.
ჩვენ ვნახეთ ეს ადრე იყო.
თუ გსურთ წერა კიდევ ერთი ფუნქცია, თქვენ უნდა მისცეს კომპიუტერული ვიცი და
მთავარი იციან, რომ ის არსებობს.
ასე რომ, რას ვაკეთებთ მაღლა მთავარი ჩვენ წერენ დაბრუნების ტიპის, სახელი და
პარამეტრები, და შემდეგ ქვემოთ ქვემოთ, მთავარ ქვემოთ, ჩვენ, ფაქტობრივად, კოპირება რომ ხაზი
შემდეგ კი წერენ აქტუალურ კოდი.
ასე რომ, ამ გზით, თუ რეკავთ ფუნქცია მთავარ ზედა, მთავარ იცის, რომ
კომენტარი პირველმა არსებობს, მაგალითად, მე რომ მოვუწოდებთ hello, და მერე ცდილობს
შესრულების ქვემოთ ქვემოთ.
რა მოხდება, თუ არ შეიცავს ამ ხაზის დასაწყისშივე, ცნოს მიესალმები (ბათილად)?
>> თუ მე არ შეიცავს ამ ხაზის და მთავარი ზარები hello, მე ვარ
აპირებდა შეცდომა.
მე ვაპირებ გაქვთ შეცდომა, რადგან შემდგენელი არ იცის
რომ ეს საგანი არსებობს.
ეს არის მსგავსი ამიტომ ჩვენ ნუ # მოიცავს cs50.h.
რა არსებითად cs50.h აკეთებს აყენებს მიიღოს სიმებიანი აქ.
ეს აყენებს მისაღებად Int აქ.
ეს აყენებს ყველა იმ ფუნქცია პროტოტიპები წინაშე მთავარ ისე, რომ როდესაც
თქვენ მოვუწოდებთ მათ მთავარ, მთავარ იცის რომ ეს ყველაფერი არსებობს.
სწორედ იმ. თ ფაილი გააკეთოს.
ასე რომ, თუ ვაპირებთ, რათა საკუთარი ფუნქცია, თქვენ გაქვთ რომ დავრწმუნდეთ
დააყენა, რომ პროტოტიპი აქ.
შეკითხვები ჯერჯერობით?
>> სარდლობის ხაზი არგუმენტები.
ეს არის ის, რაც ჩვენ ვაპირებთ დასრულდება მე და შემდეგ იმედია, ჩვენ გამოგიგზავნით
შესუსტებას ზოგიერთ pset.
მე არ ვიცი, თუ ჩვენ შევძლებთ შესუსტებას რომ რადგან დრო, მაგრამ
თქვენთან ერთად ბიჭები, რომლებიც აქ, და თუ ბიჭები მინდა ვთქვა, შემდეგ ცოტა ჩვენ
შეიძლება მას გარეთ.
მაგრამ ჩვენ ვაპირებთ დასრულდება ბრძანების ხაზი არგუმენტები
რომ ბოლო 15 წუთის განმავლობაში.
ჩვენ Awake, მაიკლ?
თქვენ Awake?
კარგი.
არ ვიცი, თუ ძილის შენი თვალით დახურულია.
კარგი იქნებოდა სახიფათო.
>> სარდლობის ხაზი არგუმენტები.
ესენი ერთი გზა, რათა ინფორმაცია გადავცეთ შევიდა პროგრამა.
საბოლოოდ, ჩვენ ვაწყდებით სხვები.
მაგრამ არსებითად, ჩვენ შევწყვეტთ წერა int მთავარი (ბათილად) თუ გვინდა
გარკვეული ბრძანება ხაზი არგუმენტები.
ჩვენ ვაპირებთ დაწერა ეს საგანი მოუწოდა int მთავარი (int argc,
სიმებიანი argv, ფრჩხილებში.
ეს გაუგებარია.
ეს არის ის, ბევრი ასო, რომლებიც არ ადამიანის ინგლისური, ამიტომ ჩვენ ვაპირებთ
ამოაარქივეთ იმიჯი და დაამაუნტეთ მათ ახლა.
>> Argc დგას არგუმენტი რაოდენობა -
და ისევ, ყველა ეს იქნება ხელმისაწვდომი იქნება ონლაინ -
და ეს რიცხვი არგუმენტები.
Argv დგას არგუმენტი ვექტორი, და ეს ის არგუმენტები თავს.
ეს მასივი strings.
ჩვენ რეალურად დავინახეთ მასივი საქართველოს strings ადრე დატოვა.
ჩვენ შევქმენით ერთი ბოლო პროგრამის კოდირებული.
>> ასე რომ, აქ არის მაგალითი.
ვწერ. / Ohai cs50 სექციაში ჩემი ბრძანების მითითებით.
Argc ამ ​​შემთხვევაში შეადგენს 3.
Argv bracket 0 არის ohai, argv bracket 1 არის cs50, argv bracket 2 სექციაში.
ისევ, argc არის რიგი არგუმენტები, და მონახულებას თქვენ ოდნავ
ცოტა, ჩვენ ყოველთვის ითვლიან სახელი ფუნქციის პირველი არგუმენტი.
ასე რომ, ამ შემთხვევაში, არსებობს სამი არგუმენტები, სახელით ფუნქცია
და შემდეგ ეს ორი რომ მე აკრეფილი შემოსული
>> შემდეგი, ჩვენ ვაპირებთ, რათა გადავარჩინოთ იმ არგუმენტები თავი argv.
და ისევ, როგორც ვნახეთ ადრე, ჩვენ გავაკეთეთ ეს უკანასკნელი პროგრამის კოდირებული.
შეგიძლიათ გადაადგილება მეშვეობით მასივი argv და მიიღოს იმ strings.
ეს არის ის, არსებითად, რა გავაკეთეთ ზე ბოლოს ჩვენი პროგრამა.
ჩვენ აიყვანეს შემთხვევითი სახელით და წავიდა სახელები bracket რაც არ უნდა და ნაბეჭდი
out სიმებიანი არის განლაგებული.
>> თავზე მხოლოდ ერთი მასივი, რადგან strings თავად მასივები, როგორც
ვისაუბრეთ, შეგიძლიათ მასივების მასივი, რომელიც
არსებითად რა argv არის.
ერთი გზა შეგიძლიათ ვიფიქროთ ეს რიგები და სვეტები.
მე შემიძლია შევაჩერო, რომ ახლა.
ასე რომ argv -
ეს არ არის erasing.
დავხატოთ ქვეშ ohai.
>> ასე რომ, თუ დავწერე, ohai cs50 მონაკვეთის, მე ვაპირებ truncate
სექცია: მაგალითი.
მაგრამ არსებითად, ჩემი მრავალ განზომილებიანი მასივი, ohai cs50,
ჩვენ ვაპირებთ სექტის.
ასე რომ, აქ, მე შეუძლია -
თუ უბრალოდ მისცეს argv ერთი ნომერი -
ეს არასწორია.
რა არის არასწორი ამ დაჭერა?
>> სტუდენტი: დაწყება ზე ნულოვანი.
>> JASON HIRSCHHORN: უნდა იწყება ნულოვანი.
მე უნდა ალბათ ასევე როტაცია იგი, მაგრამ მას შემდეგ, რაც მე უკვე შედგენილი იგი, მე ვარ
დატოვებს მას იქ არის.
მაგრამ ეს იწყება ნულოვანი.
ეს უფლება.
მე ვწუხვარ, თუ ეს არის პატარა.
შეგიძლიათ ბიჭები სახის ვხედავ?
ასე რომ, თუ argv 0, მე მიიღონ ყველა ohai.
თუ გავაკეთო argv 1, მე მისაღებად ყველა cs50.
თუ გავაკეთო argv 2, მე მისაღებად ყველა სექტის.
>> მაგრამ ახლა, როგორც ჩვენ ვთქვით, strings არის მასივების თავს.
ასე რომ, რა შემიძლია არის შემიძლია მკურნალობა ამ როგორც მრავალ განზომილებიანი მასივი, და მე
შეგვიძლია გავაკეთოთ რაღაც გასწვრივ ხაზი argv 0, 0, რომელიც მაძლევს მხოლოდ
ხასიათი 0.
Argv 0, 1, რომელიც მაძლევს მხოლოდ თ.
Argv 1, 3, რომელიც მაძლევს მხოლოდ ამ 0 ქვემოთ აქ cs50.
>> ასე რომ, რადგან strings თავს მათ მასივების, ჩვენ აყენებს
რომ კიდევ ერთი მასივი.
ჩვენ ახლა მასივი მასივი, და ჩვენ შეიძლება ინდექსი ჩვენს პირველ მასივი და
მაშინ ინდექსი ჩვენს მეორე მასივში.
და როგორც თქვენ მოელოდა, ჩვენ გავაკეთოთ, რომ მხოლოდ აყენებს იმ ორ -
ჩვენ გავაკეთებთ კვადრატულ ფრჩხილებში მხოლოდ უფლება შემდეგ ერთმანეთს.
ასე რომ, ამ მაგალითად, argv 1 cs50 და argv 1, 2, ისევე როგორც ჩვენ ვთქვით, მხოლოდ 5.
ვინმეს აქვს რაიმე კითხვა შესახებ მრავალ განზომილებიანი მასივი?
თქვენ ბიჭები აკეთებენ რა.
Sweet.
>> ასე რომ, ჩვენ გვაქვს სხვა პროგრამა სწორედ აქ, და ეს არის საბოლოო რამ ჩვენ
ვაპირებთ ახლა.
ასე რომ, მინდა დაწერა პროგრამა, რომელიც იღებს შესახებ სრული სახელი, ორი და მხოლოდ
ორი ბრძანება ხაზი არგუმენტები და ბოლოს, ამობეჭდოთ მისალოცი to
შესახებ, რომელიც მოიცავს მათი სახელი.
ასე რომ, რატომ არ ჩაიტანა წუთში ამის გაკეთება და შემდეგ გავემგზავრებით
მას, როგორც ჯგუფის და მაშინ ჩვენ გადაიტანოთ up?
>> ისევ და ისევ, აქ, როცა ჩვენ ვამბობთ, მიიღოს მომხმარებლის სრული სახელი თითო აღწერა
ამ პრობლემის, ეს უნდა იყოს ბრძანება ხაზი არგუმენტები, არ იყენებს მიიღოს სიმებიანი.
ჰო, მარკუს?
>> სტუდენტი: ასე რომ, როცა ამბობენ, რომ ორი ბრძანება ხაზი არგუმენტები, ის არის, რომ გარდა
. / აწარმოებს, ან -
>> JASON HIRSCHHORN: კარგი კითხვა.
ნუ, მათ შორის. / პერსპექტივაში სამ ბრძანების ხაზი არგუმენტები.
ან მათ შორის. / პერსონალურად, ხოლო ამ შემთხვევაში, რადგან ისინი
სახელი ამ ფაილი.
ასე რომ argc იქნება სამი.
მაგრამ მე მინდა მხოლოდ ორი არგუმენტები მიცემულ პროგრამა.
მე უნდა დააკონკრეტა, რომ.
გავაკეთებ, რომ ცვლილება ადრე თუ არა ამ და აგზავნიან ბიჭებს.
>> სტუდენტი: რა მოხდება, თუ თქვენ აქვს შუა სახელი?
>> JASON HIRSCHHORN: თუ თქვენ გაქვთ შუა სახელი და გვარი, თქვენ out of luck.
მე ბოდიში.
ან თუ მხოლოდ ხელიდან Shakira, თქვენ ასევე გარეთ წარმატებას.
ჰო?
>> სტუდენტი: ასე რომ, როდესაც ადამიანს არ აქვს cs50.h, ისინი განსაზღვრავს argv
როგორც char ვარსკვლავი argv?
თუ ეს მაინც მოუწოდა სიმებიანი argv?
>> JASON HIRSCHHORN: დიახ.
ასე რომ, სიმებიანი, კიდევ ერთხელ, ჩვენ ნიღაბი რა ზუსტად ხდება.
რომ აპირებს გაიხსნას შესაძლოა, ოთხშაბათს, მაგრამ მალე.
ეს იგივეა სასწავლო დისკები.
იმის გამო, რომ ძირითადად, ეს იგივე.
>> მოდით მიიღოს სხვა წუთს პროგრამა ამ და შემდეგ წავალთ მეტი
ის, როგორც ჯგუფის, შემდეგ კი ისევე, როგორც მე ვთქვი, გადაიტანოთ up.
და ვფიქრობ, ისინი მაინც ზედმეტი Candy, ასე რომ თქვენ ბიჭები უნდა იმედია მიიღოს
, თუ გთხოვთ, რომ.
>> ვწუხვარ, თუ თქვენ ჯერ კიდევ წერის, მაგრამ მე მინდა dive და ჩვენ
შეიძლება დასრულებას ერთად.
ასე რომ, მე არ წერია, # მოიცავს cs50.h, # მოიცავს stdio.h.
int მთავარი (ბათილად), curly მუდმივი წინააღმდეგობა გაუწიოს, curly მუდმივი წინააღმდეგობა გაუწიოს, შიგნით სამი ხაზი
pseudocode, მიიღოს მომხმარებლის სახელი, გვარი, ორი და მხოლოდ ორი ბრძანება ხაზი
არგუმენტები, ამობეჭდოთ მისალოცი to შესახებ, რომელიც მოიცავს მათი სახელი.
>> ასე რომ, პირველი, მიიღოს მომხმარებლის სრული სახელი.
ვის შეუძლია დამეხმაროს მიიღოს მომხმარებლის სრული სახელი?
როგორ შემიძლია ამის გაკეთება ნაწილი?
ხომ არ ბიჭებს, რომ პირველი ნაწილი?
მიიღეთ შესახებ სრული სახელი.
ისე, რომ ერთი ბრძანება ხაზი არგუმენტი, რა უნდა დაწერონ?
რა უნდა შეიცვალოს შესახებ ჩემი ფუნქცია დეკლარაციის?
>> სტუდენტი: თქვენ არ სურს რომ ეს ბათილად აღარ.
>> JASON HIRSCHHORN: ზუსტად.
მე არ მინდა, რომ ეს გარიგება.
რა გვსურს?
>> სტუდენტი: Int argc.
>> JASON HIRSCHHORN: Int argc.
>> სტუდენტი: სიმებიანი argv.
>> JASON HIRSCHHORN: სიმებიანი argv.
>> სტუდენტი: Bracket, bracket.
>> JASON HIRSCHHORN: Bracket, bracket.
აი სწორედ, და ეს რეალურად, როგორ მე ვაპირებ მისაღებად
მომხმარებლის სრული სახელი.
ისინი აპირებენ ამას არსებობს.
ასე, რომ ერთი კეთდება.
ასე რომ, ახლა მინდა ორი და მხოლოდ ორი ბრძანების ხაზი არგუმენტები.
ასე რომ, ნოე, რა არის ერთი გზა არ შემიძლია შეამოწმოს რაოდენობის ბრძანება
ხაზი არგუმენტები მაქვს?
>> სტუდენტი: თქვენ თუ განცხადებაში.
>> JASON HIRSCHHORN: თუ განცხადებაში, ზუსტად.
რა გვინდა, როგორც მდგომარეობაში?
>> სტუდენტი: თუ argc მეტია 3.
>> JASON HIRSCHHORN: თუ argc მეტია 3.
თუ argc მეტია 3, რა გავაკეთო?
>> სტუდენტი: დაბრუნება 1.
>> JASON HIRSCHHORN: დაბრუნება 1.
იქნება, რომლებიც უზრუნველყოფს მაქვს ორი და მხოლოდ ორი?
>> სტუდენტი: არა
თუ argc მეტია 3 და ნაკლები 2.
>> JASON HIRSCHHORN: თუ argc მეტია ვიდრე 3 და argc ნაკლებია, ვიდრე 2.
რა არის ერთი გზა მე შემიძლია წერა ამ რაღაც ერთი ხაზი, ან გამოყენების გარეშე, რომ
და ლოგიკური ოპერატორი?
>> სტუდენტი: ეს არ უდრის 2.
>> JASON HIRSCHHORN: თუ argc არ არის ტოლი 2.
ზუსტად.
ასე რომ, თუ argc არ არის ტოლი 2, რომელიც მისცემს ჩემთვის ეს პროგრამა,
პერსონალურად, როცა აწარმოებს და რაც ხელს მაძლევს, რამდენი
ბრძანების ხაზი არგუმენტები?
რამდენი მე შემოწმება?
>> ბოდიში.
ნება მომეცით reword რომ.
თუ argc = 2, რამდენი რამ გააკეთა შესახებ წერენ შევიდა ხაზი?
>> სტუდენტი: ერთი.
>> JASON HIRSCHHORN: მხოლოდ ერთი.
ასე რომ, ადრე, თქვენ უფლება, ნოე.
რა რეალურად უნდა დააყენოს იქ?
>> სტუდენტი: ეს უდრის 3.
>> JASON HIRSCHHORN: Argc არ თანასწორი 3.
მინდა გაუტოლდება 3 იმიტომ, რომ მინდა პერსონალურად პლუს დანარჩენი ორი.
ასე რომ, თუ argc არ თანასწორი 3, დაბრუნება 1.
რატომ ამბობენ დაბრუნებას 1?
>> სტუდენტი: იმის გამო, რომ ნიშნავს ეს არასწორია.
>> JASON HIRSCHHORN: ეს იმას ნიშნავს, რომ ეს არასწორია, და რა, რომ აპირებს?
>> სტუდენტი: ხელახალი შეეკითხება მომხმარებელს.
>> JASON HIRSCHHORN: ეს აპირებს დატოვა პროგრამა, ასე რომ არ აწარმოებს
ერთხელ, მაგრამ ჩვენ არ გვაქვს არაფერი აქ ვთხოვო მათ.
მე არ ვთხოვ, რომ.
ასე რომ, სწორედ.
დაბრუნება 1 ახალი ტოვებს პროგრამა.
დიდი.
>> და ამობეჭდოთ მისალოცი to შესახებ რომელიც მოიცავს მათი სახელი.
როგორ შემიძლია ამის გაკეთება?
ანა?
>> სტუდენტი: Printf.
>> JASON HIRSCHHORN: Printf.
>> სტუდენტი: ("
>> JASON HIRSCHHORN: (
>> სტუდენტი: "Hello
>> JASON HIRSCHHORN: "Hello
>> სტუდენტი:% s
>> JASON HIRSCHHORN:% s
>> სტუდენტი: / ნ
>> JASON HIRSCHHORN: / ნ
>> სტუდენტი: ",
>> JASON HIRSCHHORN: ",
>> სტუდენტი: Argv
>> JASON HIRSCHHORN: უკაცრავად?
>> სტუდენტი: Argv
>> JASON HIRSCHHORN: Argv
>> სტუდენტი: კვადრატული ფრჩხილები 1.
>> JASON HIRSCHHORN: კვადრატული ფრჩხილები?
>> სტუდენტი: 1.
>> JASON HIRSCHHORN: 1.
>> სტუდენტი: And) მძიმით.
>> JASON HIRSCHHORN:) მძიმით.
მოდით აწარმოებს ამ.
სასტარტედ პერსონალურად.
. / პერსონალურად.
უბრალოდ დატოვა.
რატომ დატოვა?
>> სტუდენტი: თქვენ არ დააყენოს ნებისმიერი არგუმენტები.
>> JASON HIRSCHHORN: მე არ დააყენა ნებისმიერი არგუმენტები სისტემაში
გამოიყურება დიდი.
თქვენ ბიჭები nailed იგი.
ასე რომ, კიდევ ერთხელ, თქვენ შევიდა argv და თქვენ შემოწმდება დასაწყისში argc.
ეს ის ორი მნიშვნელოვანი რამ უნდა გვახსოვდეს.
ასე, რომ ჩვენს ბოლო ორი წუთით ადრე ჩვენ დატოვონ, ჩვენ არ მიიღოს, რათა pset ორი, მაგრამ
ისევე, როგორც მე ვთქვი, თუ გინდა დარჩენა შემდეგ 10 წუთით, მინდა მას ბედნიერი წასვლა
მეტი თქვენ ბიჭები ლოგიკა ამ პრობლემის კომპლექტი.
ჩვენ გვქონდა ბევრი დასაფარავად დღეს მე არ მიიღოს მათ.
საერთოდ, მე მიყვარს მოიცავს რომ ბოლოს.
ასე რომ, თუ გვინდა, რომ გამყარებაში გარშემო, გამყარებაში გარშემო 10 წუთით.
ჩვენ ყველაფერს გავაკეთებთ, რომ.
>> ამის შემდეგ, როგორც აღვნიშნე დასაწყისში, pset ნულოვანი და ერთი, მივიღებთ, რომ
კავშირი უკან თქვენ, როგორც რაც შეიძლება მალე.
მიზანია, რომ pset ერთი კავშირი, კომენტარები მხრივ,
ადრე pset ორი გამო.
ასე რომ, თუ გარკვეული შეცდომები ან სტილისტურად, რამ შეიძლება იყოს უკეთესი,
თქვენ, რომ ინფორმაცია, ასე რომ თქვენ ამას არ გააკეთებს იგივე რამ pset ორი.
და მაშინ მომავალში, თქვენ შეძლებთ ყველა თქვენი pset კავშირი და კომენტარები
უკან მომდევნო ერთი გამო.
>> და ბოლოს, თუ შეიძლება ჩაიდოს სხვა დანამატის for კავშირი.
ეს არის თქვენი პირველი განყოფილებაში.
ეს იყო ჩემი პირველი ნაწილი სწავლების წელს.
წასასვლელად.
დაწერეთ პერსონალი, კარგი და ცუდი, მე და გამოიყენოს იგი, რათა
სექცია უკეთესი მომავალი დრო.
და ბოლოს, კიდევ ერთხელ, თუ საჭიროა არაფერი, ნება მომეცით ვიცი.
მე უფრო მეტი ბედნიერი, რათა დაგეხმაროთ ბიჭები.
თუ გსურთ Candy, I ექნება დამატებითი Candy.
მოხარული ვარ, რათა ეს თქვენ.
>> ეს იქნება საოცარი, რა თქმა უნდა.
ეს არის ერთ ერთი, თუ არა ჩემი საყვარელი რა თქმა უნდა, მე მიღებული ჩემი მთელი ცხოვრება,
და იმედი მაქვს, ეს იქნება, რომ მშვენიერი თქვენთვის.
ასე რომ, მინდა ყველაფერი ჩემი ძალა რათა ის, რომ გასაოცარია თქვენთვის.
მე ვაპირებ გაგზავნის out ელ, თუ თქვენ ჩემს სექციაში ნოე, და
აპირებს ცდილობენ და დანიშნოს თითოეული თქვენ ბიჭები დრო შემოწმება მეტი
მომდევნო რამდენიმე კვირის ამიტომ მე შეუძლია მიიღოს გრძნობა, რაც თქვენი CS ფონზე,
და ეს ასევე დაეხმარება ჩემს მკერავი ეს სექციები უკეთ ვარიანტს თქვენს საჭიროებებს.
ასე რომ, ის, რაც მაქვს გაფორმებულია.
ისევ და ისევ, მე თქვენ გარეთ თუ გვინდა, რომ იყოს იქ.
ეს იყო კვირაში ორი განყოფილება.
დიდი მადლობა ბიჭებს იმდენად.