[Powered by Google Translate] დევიდ ჯ Malan: ყველა უფლება, ეს არის CS50, და ეს არის
დაწყებას კვირაში ორი.
დიდი მადლობა.
მოდით დავიწყოთ აქ სატელეფონო ზარი.
მე უნდა აკრიფოს 617-bug-CS50.
CS50: ეს არის CS50.
იყიდება Shuttle ბიჭი, დააჭირეთ 1.
დაიწყონ ზე, დააჭირეთ 9.
დევიდ ჯ Malan: მან განაცხადა, Shuttle ბიჭი, პრესის 1.
ამიტომ, ჩვენ ვაპირებთ დააჭირეთ 1.
CS50: როგორია თქვენი წარმოშობის?
For Quad, პრესის 1.
Mather, პრესა 2.
Boylston, პრესის 3.
Lamont, პრესა 4.
Mem დარბაზი, პრეს 5.
დაიწყონ ზე, დააჭირეთ 0.
დევიდ ჯ Malan: ჩვენ დააჭირეთ 1 ამისთვის Quad.
CS50: შემდეგი Shuttle ტოვებს ამ ძალიან წუთით 1:10 PM, და
შემდეგ 1:20 PM, 1:30 PM, 1:40 PM.
ეს არის CS50.
>> დევიდ ჯ Malan: ასე რომ, ეს CS50 ხმა.
და ეს მაგალითი სახის საბოლოო პროექტების
მაგალითად, შეგიძლიათ Bite off მიმართ
ბოლოს სემესტრში.
მაგალითად, რომ shuttleboy.cs50.net არსებობს -
რეალურად პროექტი, რომელიც მე პირველად დაწერა მიღების შემდეგ CS51
უკან, როდესაც მე ვიყავი ბაკალავრიატის.
და შთაგონების აქ იყო მაშინ, ყველა მათ ჰქონდათ იყო
ნაბეჭდი Shuttle ავტობუსი გრაფიკების, და არ არსებობს
ცნება ეძებს რამ up ხაზზე.
და მე სახის dove ერთ კვირას, გადაისხა მეშვეობით
ნაბეჭდი გრაფიკი და ported მას კომპიუტერული პროგრამით.
იმ დროს, კომპიუტერული პროგრამა მოხდა უნდა ჩაიწეროს
in C. და თქვენ ნამდვილად გაიქცა ის აკრეფით Shuttle Boy ზე
მოციმციმე შეეკითხება როგორც ჩვენ უკვე აკეთებს დღემდე.
მაგრამ წლების განმავლობაში, ის განვითარდა შევიდა მყისიერი
შეტყობინებათა Bot.
ის განვითარდა მეტი ხნის წინ შევიდა ამ ნახვა, შევიდა
SMS-ზე დაფუძნებული ინსტრუმენტი, ისევე როგორც ამ ხმა დაფუძნებული ინსტრუმენტი.
და ეს არის მინიშნება იმ სახის რამ, რომ თქვენ შეგიძლიათ
გააკეთოს თავის მიერ სემესტრის ბოლოს.
>> მაგალითად, იქ, SMS ვერსია Shuttle ბიჭი ხდება
მუშაობას შემდეგნაირად.
თუ, თქვენს მობილურ ტელეფონზე, თქვენ გააგზავნით ტექსტი შეტყობინება 41411 და
შემდეგ სპეციალური სიმბოლო sboy, ამისთვის Shuttle ბიჭი,
მოჰყვა და B, სადაც არის წარმოშობის და B არის
დანიშნულების -
მაგალითად, Boylston ფართი Quad -
რა უნდა დავუბრუნდეთ ფარგლებში რამოდენიმე წამში არის ტექსტი
შეტყობინება Shuttle Boy გეუბნებოდით ზუსტად მაშინ, როდესაც
მომდევნო რამდენიმე shuttles არიან, ამ კუთხით აპირებს, რომ
ქულა ბ
და ეს არის უფრო ზოგადი მაგალითი რა ცნობილია, როგორც
გამოყენებით API.
>> ასე მაგალითად, ეს აქ არის მხოლოდ shuttleboy.cs50.net,
ფაქტობრივი ვებ დაფუძნებული განსახიერება ამ.
მაგრამ მონაცემები, რომ ხაზს უსვამს ამ და სხვა apps რომ CS50
შეიმუშავა ყველა დაუცველებს ყველას აქ ფორმა
საქართველოს APIs, განაცხადის პროგრამირების ინტერფეისები.
და ეს მხოლოდ ლამაზი გზა და განაცხადეს, რომ ადამიანი როგორც ჩვენ შესახებ
ინტერნეტი და სხვები არ გაატარა გარკვეული დროის შექმნა
პროგრამული უზრუნველყოფა, რომ თქვენ შეგიძლიათ გამოიყენოთ, რათა დაიბრუნოს მონაცემები ჩვენგან და
შემდეგ ავაშენოთ თქვენი საკუთარი განაცხადების დაბრუნება
ამ მონაცემების კომპლექტი.
ასე მაგალითად, ამ Shuttle Boy API გვერდზე აქ, რომელიც
ხდება იყოს CS50 მექანიკური, არსებითად დოკუმენტების
როგორ შეგიძლიათ გადასვლა შესახებ ეკითხება CS50 სერვერებზე მონაცემები.
მაგალითად, თუ თქვენ იცნობს CSV ფაილი მძიმით
გამოყოფილი ღირებულებები, ეს არის უბრალოდ სახის სწრაფ და ბინძური
Excel-ის მსგავსი ფაილი.
ასე რომ თქვენ შეგიძლიათ ვთხოვო Shuttle Boy ყველა მონაცემები ყველა
სახლები და მათი GPS კოორდინატები, და თქვენ მიიღებთ
უკან, არსებითად, ცხრილების მსგავსად, რომ
შეგიძლიათ შემდეგ წაიკითხა შევიდა პროგრამის საკუთარი და შემდეგ
გენერირება შედეგი, როგორიც Shuttle ბიჭი თავად
ხდება უნდა აკეთებს.
მათთვის უფრო ნაცნობია, უფრო თანამედროვე მონაცემები წარმომადგენლობების
მოიცავს JSON, JavaScript Object ნოტაცია.
რაღაც დავბრუნდებით თქვენ მიმართ
ბოლოს სემესტრში.
>> თუმცა ისევ და ისევ, ეს მხოლოდ ერთი რამდენიმე CS50 საკუთარი APIs.
და ამაღელვებელი რამ არის, ამ დღეებში, Facebook და
Twitter და Google და საკმაოდ ბევრი ყველა პოპულარულ ვებ გარეთ
იქ აქვს გარკვეული API, რაც იმას ნიშნავს, თუ წაიკითხავთ
დოკუმენტაცია მათი ნახვა, თქვენ იწერთ
ანგარიში, თქვენ შეგიძლიათ შემდეგ დაიწყოს წერა პროგრამული თავზე
რასაც ინსტრუმენტები ან მონაცემები, რომ კომპანია უზრუნველყოფს არსებობს.
და ა.შ. ერთი ჩვენი საკუთარი სწავლების პრაქტიკის რამდენიმე წლის უკან
წერდა Mac ვერსია ამ.
ამრიგად, ლინკები სახელწოდებით Mac აქ ზედა მარცხენა, შეგიძლიათ რეალურად
ჩამოტვირთვა Mac OS ვიჯეტის, რომელიც ეშვება თქვენი Mac გავაკეთოთ
იგივე სახის ნივთები.
ასე რომ ეს ყველაფერი შენობის ზევით მონაცემები კომპლექტი მოსწონს ეს.
მაგრამ უფრო რომ მიმართ ბოლომდე სემესტრში.
>> მოდით ჩაყვინთვის რეალურ სწრაფად bug, მხოლოდ სახის მისაღებად
რამ warmed დღემდე, და ვფიქრობ უკან ზოგიერთ
რამ ჩვენ შევხედეთ გასულ კვირას.
კერძოდ, მინდა წავიდეთ წინ და გაიყვანოს up, ამბობენ,
ეს მაგალითი აქ.
Buggy1.c, ეს არის შესაძლებელი რა თქმა უნდა ნახვა თუ მინდა
მინდა მისი ჩამოტვირთვა და poke გარშემო თავს.
მაგრამ მოდით მიუახლოვდით აქ ამ საკმაოდ მოკლე პროგრამა, და მხოლოდ
სუპერ სწრაფი recap ზოგიერთი ძირითადი შენობა ბლოკების რომ
ჩვენ ნამდვილად ვაპირებთ დავიწყო აღების თავისთავად.
>> ასე ლურჯი პერსონალის, სტრიქონები 1 მეშვეობით 9, უბრალოდ
softball კითხვები.
ასე რომ ეს არის მხოლოდ კომენტარი.
მათ არ აქვთ ფუნქციური მნიშვნელობა.
მაგრამ ისინი კომენტარი იმ გაგებით, რომ ისინი აღნიშნავს, რომ
მე, ადამიანის, გააკეთა, რომ პირადად ასე რომ ლექცია და შემდეგ
ლექცია, შემიძლია რეალურად გახსოვთ რა ამ პროგრამის
ს გარეშე წაკითხვის საშუალება ხაზს და
recreating ისტორია ჩემი აზრით.
უფრო მეტიც, თუ მე მხრივ, ეს პროგრამა, რათა ვინმე მოსწონს
თქვენ, გაცილებით ნათელი თქვენ, რადგან კომენტარი მოსწონს,
რა პროგრამის რეალურად აკეთებს, ან თუნდაც რა
პროგრამის უნდა აკეთებს.
თუ არა სწორი, ეს სხვა საკითხია საერთოდ.
ახლა კი, C, მრავალწლიანი ხაზი კომენტარები, გავიხსენოთ, რომ ზემოთ
აქ არის ჯადოსნური სიმბოლო, / *.
ეს იმას ნიშნავს, აქ მოდის დაწყების კომენტარი.
და სხვა არაფერი მნიშვნელოვანი, სანამ მიაღწევთ ბოლომდე Terminator,
რაც * /, საპირისპირო.
ასე რომ ის ფაქტი, რომ მე მაქვს 80-რამდენიმე უცნაური ვარსკვლავს აქ
მარცხნიდან მართლაც მხოლოდ ესთეტიკურ დეტალურად.
მას არ აქვს ფუნქციონალური მნიშვნელობა.
>> ახლა როგორ შესახებ ხაზი 11?
რას გავაკეთებთ ერისკაცად წარმოგვიდგება მისი თვალსაზრისით?
რა არის ეს?
აუდიტორია: გაერთიანებულია სტანდარტული.
დევიდ ჯ Malan: OK, კარგი.
ამიტომ იგი მოიცავს stdio.h ბიბლიოთეკაში.
ასე რომ რას ნიშნავს ეს?
ისე, შიგნით, რომ ფაილი, stdio.h, არის მთელი bunch of
ფუნქციის დეკლარაციების -
რომ არის, კოდი, რომელიც სხვისი დაწერა.
და სრულყოფილი მაგალითი ფუნქცია რომ დეკლარირებული
stdio.h არის -
რაც საყვარელი მიერ არის?
ამიტომ printf, ყველაზე საერთო პირობა გამოიყენოს, რა თქმა უნდა
დილით, რომ ბიბლიოთეკაში არსებობს.
თუ გამოვრიცხავ, რომ ხაზი კოდი, Clang აპირებს დაწეროთ
at me რაღაც გამოყენების შესახებ გამოუცხადებელ სიმბოლო.
რაღაც გამოუცხადებელ ალბათ სიტყვით, რადგან
ჩვენ არ აცნობა შემდგენელი რა printf გამოიყურება
მინდა თუ არ შედის, რომ ხაზი.
და უფრო ქვემოთ დედამიწაზე, მართლაც, რა, რომ ხაზი ამბობს არის
გახსენით, რომ ფაილი, stdio.h, სადაც არ არის სერვერის
ხისტ დისკზე, ან ელექტრო მყარ დისკზე, და ასლი პასტა ეს
უფლება არსებობს ჩემს ფაილის გარეშე ჩემი
მქონე გავაკეთოთ, რომ ხელით.
>> ახლა, როდესაც ჩვენ კიდევ ქვევით აქ მთავარი, სანამ ხანგრძლივი დავიწყებთ
teasing გარდა რა int და რა ბათილად არის.
მაგრამ ახლა, მოდით შევხედოთ სამი ხაზები
ფარგლებში 15 გზით 17.
ეს აქ აცხადებენ, როგორც buggy.
Line 7 ჩემი კომენტარები ამბობს "ამობეჭდავ 10
asterisks მაგრამ არ. "რატომ არა ბეჭდვა, ფაქტობრივად,
10 ასეთი ვარსკვლავები?
აუდიტორია: [INAUDIBLE].
დევიდ ჯ Malan: ზუსტად.
ასე რომ ჩვენ ვიწყებთ ითვლიან საწყისი 0.
და ეს არის რეალურად კონვენციის პროგრამირების და
კომპიუტერულ მეცნიერებათა ზოგადად, დაწყებული დათვლა
საწყისი 0 ნაცვლად 1.
და ეს მართლაც მხოლოდ გამომდინარეობს ფაქტი, რომ
მაგალითად, როდესაც ჩვენ გვქონდა რვა ადამიანი up სცენაზე, როდესაც
არავინ ამაღლების მათი მხრივ, ისინი
ყველა ეფექტურად zeros.
და ა.შ. ეს მხოლოდ სახის კომპიუტერულ კონვენციის ისე,
ამიტომ, უნდა დაიწყოს დათვლის საწყისი 0.
თუ ეს ყველაზე დაბალი ნომერი შეგიძლიათ წარმოადგენენ ორობითი.
>> ასე რომ აქ დავიწყეთ ინიციალიზაციისას I დან 0.
ჩვენ მითითებული მე ტოლია 0.
მაგრამ შემდეგ მე მივიღე ეს შეცდომა აქ და განაცხადა, რომ მე ნაკლებია ან
ტოლია 10.
მაგრამ თუ თქვენ ფიქრობთ, რომ მეშვეობით, თუ დაიწყება 0 და მერე წასვლა
მდე 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, მე რეალურად აპირებს
ამობეჭდოთ 11 ვარსკვლავს რომ ეკრანზე, რადგან მე გაიზარდა
და ტოლია 10.
ასე ადვილად სარემონტო აქ მაშინ არის, თუ რა?
აუდიტორია: [INAUDIBLE].
დევიდ ჯ Malan: უბრალოდ შეცვალეთ მას ნაკლები.
თუ თქვენ ნამდვილად გსურთ, თქვენ შეიძლება ამის გაკეთება.
მაგრამ ზოგადად, რომ frowned საფუძველზე.
და ასე იწყება ითვლიან საწყისი 0 მხოლოდ რაღაც თქვენ უნდა
ჩვეულებრივ შეეგუება.
ახლა, რაც შეეხება ამ მთელი შენება და თავისთავად?
ეს ხაზი 15 demarks ამისთვის loop.
ასე რომ არ არის ფუნქცია.
უბრალოდ განცხადებაში.
ეს looping შენება, როგორიც ვნახეთ Scratch.
და მას სამ ნაწილად.
შევნიშნოთ, რომ ეს არის პირველი ნაწილი
მარცხენა მძიმით.
აქ ახლო მონაწილეობა შორის ორი semicolons.
და მერე იქ მარჯვენა ნაწილი მარჯვნივ
მეორე მძიმით.
ახლა, პირველი ასეთი ჯერ რა?
აუდიტორია: [INAUDIBLE].
დევიდ ჯ Malan: თავში იქ?
ჰო?
აუდიტორია: ინიციალიზაციისას.
>> დევიდ ჯ Malan: ინიციალიზაციისას.
ასე რომ რას ნიშნავს ეს?
ჩვენ გამოცხადებული ცვლადში მე.
ეს ტიპის int, რადგან მე მითითებული int i.
და მე ინიციალიზაციისას მე რომ მნიშვნელობა 0.
ასე რომ რა არის ეს მართლაც ამბობდა?
ის ეფექტურად ამბობდა კომპიუტერს hey, მომეცი საკმარისი
მეხსიერება, საკმარისი RAM, რათა შეწყობოდა ნომერი, და შემდეგ დააყენოს
ნომერი 0 ამ ბლოკი RAM.
და როგორც განზე, რამდენად დიდი არის int როგორც წესი, მინიმუმ შიგნით
მოწყობილობის?
აუდიტორია: 32 bit.
დევიდ ჯ Malan: 32 ბიტი.
ასე რომ, რაც იმას ნიშნავს მომეცი 32 ​​ბიტი, სხვაგვარად ცნობილია როგორც 4 ბაიტი,
და დააყენა ღირებულების 0 მასში, რომელიც საკმაოდ ადვილი, რადგან
უბრალოდ ნიშნავს მითითებული ყველა ბიტი უნდა 0.
>> ახლა, მეორე ნაწილი აქ არის მდგომარეობა.
და მდგომარეობა, როგორც სახელი ვარაუდობს, არის ის, რაც შემოწმდება
ისევ და ისევ და ისევ იმის შესახებ თუ რამდენად მართალია ან ცრუ.
ასე რომ, ეს უბრალოდ ვამბობ, გავაკეთოთ შემდეგი ხაზი კოდი -
კერძოდ ხაზი 16, რადგან ისინი მხოლოდ ერთი indented
ქვევმოთ -
ცოტა ხნის როგორც მე ნაკლებია 10.
და ყოველი iteration მეშვეობით ამ მარყუჟის, გააკეთეთ
incrementation, რომელიც ამ შემთხვევაში არის i + +.
ახლა, ეს არ უნდა იყოს მე + +.
ეს შეიძლება იყოს I -.
მაგრამ მე რომ ამ, რა ქცევა აპირებს
იყოს ამ პროგრამის?
აუდიტორია: ეს იქნება უსასრულო ციკლი.
დევიდ ჯ Malan: ეს იქნება ერთგვარი უსასრულო ციკლი,
თუ არ მივიღებთ გაუმართლა შემდეგ უარყოფითი 2 მილიარდ ან იმდენად.
იქნებ რამ გადაიტანოთ გარშემო, მხოლოდ ბუნების სასრულ
პუნქტების ბიტი, რომ ჩვენ გამოყოფილი int.
მაგრამ, რა თქმა უნდა აპირებს iterate ბევრად უფრო მეტია, ვიდრე 10 და
რა თქმა უნდა, უფრო მეტი ვიდრე 11 ჯერ აქ.
>> და ახლა, როგორც განზე, გააცნობიეროს, რომ მე + + და მე -
მართლაც მხოლოდ სინტაქსური შაქარი.
უბრალოდ სტენოგრამის ნოტაცია, რასაც ცოტა მეტი
მკაფიოდ წერია შემდეგნაირად:
i = i + 1.
რომ იდენტურია i + +.
უბრალოდ სახის გამოიყურება გალამაზებაში ვთქვა მე + +.
უფრო ლაკონური, უფრო იკითხება.
და ა.შ. საუკეთესო ხალხი, რომ ნაცვლად.
მაგრამ ეს არის იდენტური ფუნქციურად to
რაც ჩვენ უბრალოდ დაინახა.
ასე მოკლედ, გადავწყვიტოთ აქ მხოლოდ იმის თქმა iterate მე
საწყისი 0 ყველა გზა მდე არანაკლებ 10.
და მაშინ საბოლოოდ დავრწმუნდებით მართლაც კიდევ 10 ვარსკვლავს.
>> მოდით ცდილობენ ამ.
ნება მომეცით გახსენით ტერმინალი ბოლოში.
ნება მომეცით წასვლას დირექტორია, რომ ეს არის შემოსული
და მე ვაპირებ კომპილირება ხელით Clang ახლა.
და მე ვაპირებ ამ კომპილაციის როგორც buggy1.c, შეიყვანეთ.
და ახლა buggy1, რატომ არის იქ ასეთი ფაილი ან დირექტორია
მოუწოდა buggy1?
აუდიტორია: [INAUDIBLE].
დევიდ ჯ Malan: ჰო.
ამიტომ რეალურად მოუწოდა a.out.
ასე რომ გავიხსენოთ, თუ თქვენ მხოლოდ აწარმოებს Clang, სადაც Clang არის
შემდგენელი, და თქვენ არ დააკონკრეტა სახელი გსურთ
მისცეს თქვენი პროგრამა, იგი აპირებს ნაგულისხმევია რომ a.out.
ასე რომ მართლაც თუ ls -
oops.
მე didn't - შავი და თეთრი საკითხი ზოგიერთი
თქვენ წინაშე მდგარი დაფიქსირდა.
მაგრამ ნება მიბოძეთ ამის გაკეთება.
იქ ჩვენ გვყავს a.out წლის მარცხენა მხარეს.
ამიტომ, ჩვენ უნდა აწარმოებს a.out ნაცვლად buggy1.
>> ნება მომეცით, წავიდეთ წინ და ამის გაკეთება.
. / A.out, შეიყვანეთ.
მე აშკარად არ რა?
აუდიტორია: შენახვა.
დევიდ ჯ Malan: Save ჩემი ფაილი.
ასე რომ ადვილად მოგვარდება მიერ hitting კონტროლის S, ან აპირებს
ფაილი, შენახვა, ისევე როგორც საუკეთესო პროგრამები.
ნება მომეცით დაცემას აქ, ნათელი ეკრანზე, გაუშვით ერთხელ.
და იქ მაინც bug.
ასე რომ, რა ხდება -
აუდიტორია: თქვენ არ კომპილირდება.
დევიდ ჯ Malan: Ah, კარგი.
მე არ კომპილირება.
მომწონს იდიოტი, მე ეძებს კოდი რა არასწორი.
ამიტომ clang buggy1.c, ახლა a.out.
და phew, გადაარჩინა.
>> ასე გამოიყურება პატარა მახინჯი რადგან იქ არ არის ახალი ხაზი
ნებისმიერ პროგრამას.
თუმცა ისევ და ისევ, ეს მხოლოდ ესთეტიკური დეტალურად.
და მინიმუმ თუ ჩვენ ითვლიან იმ გარეთ, ჩვენ უნდა
ახლა ვხედავთ 10 ასეთი ვარსკვლავი.
ისე, რაც შეეხება ამ მეორე გახურების მაგალითად?
ასე რომ buggy2, მე აცხადებენ, რომ ეს ვერსია, ძალიან, იქნება ბეჭდვა
10 ვარსკვლავი, ერთი თითო ხაზზე.
ასე რომ, ეს დრო, მაქვს სტრიქონების გადატანით ხასიათი, უბრალოდ, რათა
რამ პატარა გალამაზებაში.
მაგრამ ნაცვლად რა მივიღო ეს.
ნება მომეცით გავაკეთოთ clang buggy2.c, შეიყვანეთ.
ახლა კი კიდევ ერთხელ მოუწოდა a.out.
შეიყვანეთ.
მე მხოლოდ ერთი ახალი ხაზი, მხოლოდ ძალიან ბოლო ახალი ხაზი, რომ
მოძრაობს ჩემი სწრაფი მომდევნო ხაზი.
და მაინც ნათლად მე დაბეჭდვის *, მაშინ ახალი ხაზი,
*, მაშინ ახალი ხაზი.
მაგრამ რა bug აქ?
ჰო?
აუდიტორია: [INAUDIBLE].
>> დევიდ ჯ Malan: ზუსტად.
ასე რომ, განსხვავებით ზოგიერთი ენებზე, როგორიცაა Python, სადაც წანაცვლება
რეალურად აქვს ფუნქციონალური მნიშვნელობა, წელს
ენის მსგავსად C -
როგორც ვნახავთ, PHP, JavaScript -
წანაცვლება მართლაც მხოლოდ ადამიანის სასარგებლოდ.
ასე რომ ის ფაქტი, რომ მე indented ხაზის 16 და 17 გამოიყურება დიდი,
მაგრამ მას არ აქვს ფუნქციონალური მნიშვნელობა აქ.
თუკი მინდა ორივე ხაზები შეასრულოს როგორც ნაწილი იმ
მარყუჟის, მაშინ მე უნდა დაურთოს მათ Curly braces ამით.
თქვენ შეგიძლიათ მხოლოდ გაჭრა კუთხეში და გამომრჩეს Curly braces თუ
რა შემთხვევაში?
აუდიტორია: Just ერთ ხაზს.
დევიდ ჯ Malan: Just ერთ ხაზს.
ასე რომ ეს მხოლოდ ერთგვარი ლამაზი სახის სინტაქსური დეტალურად ისე, რომ
თქვენ არ დახარჯონ დრო წერილობით სამი ხაზი, რომელთაგან ორი არის
Curly braces, უბრალოდ დაწერა ერთი ხაზი კოდი.
მაგრამ თუ თქვენ გაქვთ ორი ან მეტი ხაზი, ჩვენ
მართლაც უნდა გავაკეთოთ ეს.
>> ახლა ნება მომეცით გადარჩენა ამ.
ნება მომეცით წავიდეთ წინ და ხელახლა აწარმოებს Clang.
მაშინ ნება მომეცით გამეორება a.out, და ახლა კიდევ ერთი თითო ხაზზე.
ახლა, a.out ერთხელ არის სახის dumb სახელი პროგრამა.
როგორ შემიძლია გითხრათ Clang რეალურად მომეცი ფაილის სახელი
რომ უფრო მოსახერხებელი, როგორიცაა buggy2 თავად?
ცოტა უფრო ნათლად?
აუდიტორია: [INAUDIBLE].
დევიდ ჯ Malan: OK, ასე, რომ შეიძლება პრაქტიკულად ძალიან
მოსახერხებელი კომბინაცია და მხოლოდ წერენ მიიღოს buggy2.
მე არ დააკონკრეტა. გ ამ შემთხვევაში, და დააჭიროთ.
და რა გააკეთოს არ არის ის ადგენს buggy2.c ჩემთვის მიერ
გეკითხებით Clang ამის გაკეთება.
კერძოდ, ის მოუწოდებს Clang, ის მუშაობს Clang გამოყენებით გზა მეტი
ბრძანება ხაზი არგუმენტები ან კონცენტრატორები ვიდრე რეალურად სჭირდება.
დროულად, ჩვენ დავბრუნდებით, თუ რა ყველა ამ სხვადასხვა
cryptic hyphenated გამონათქვამები ნიშნავს.
მაგრამ ახლა, ეს მხოლოდ გადარჩენის ჩემთვის trouble of
მქონე მახსოვს და რომელმაც უნდა აკრიფოთ ყველა იმ
სხვადასხვა hyphenated გამონათქვამები.
და Upside ის საბოლოოდ არის
რომ ახლა მაქვს buggy2.
თუ მინდა ამის გაკეთება ხელით, თუმცა, მე
შეიძლება ნაცვლად ამის გაკეთება -
clang-o buggy2 და შემდეგ buggy2.c.
და რომელიც ერთნაირად მომეცი ფაილი სახელად buggy2.
>> ასე მოკლედ, Clang არის შემდგენელი.
ჩადება მხოლოდ მოსახერხებელი ინსტრუმენტი, რომელიც ჩვენ უნდა გამოყენებით მეტი
და მეტი, რადგან ის მხოლოდ იწყებს
გაამარტივებს რამ ჩვენთვის.
და ვბრუნდებით 0, ბოლოს.
ახლა მხოლოდ იმიტომ, მაგრამ ჩვენ დავიწყებთ teasing რომ ნაწილი
დღეს და ოთხშაბათს.
ნებისმიერი კითხვები ნებისმიერ ამ?
ჰო?
აუდიტორია: [INAUDIBLE]
LS წელს შეთავაზებები იქ?
დევიდ ჯ Malan: OK.
როდესაც მე აკრეფილი ls წელს შეთავაზებები, რომელიც ჩემთვის აკეთებს ზოგიერთი Magic
კულუარებში დაფიქსირება bug.
დამავიწყდა, ისევე როგორც ჩვენ ვეუბნებით ბევრ თქვენგანს შესახებ
ფორუმი, ჩეთი, გავაკეთოთ -
ჩვენ ეს ახლა - sudo yum-y განახლება appliance50.
Whoops, რომ ეს ჩაწერეთ უფლება.
ასე რომ ელექტრო მოწყობილობების ჰგავს ოპერაციული სისტემა.
იგი კანდიდატად ამ ოპერაციული სისტემის მოუწოდა Fedora.
და ახლა გამო ჩემი ნელი ინტერნეტის, მე
მართლაც hosed იგი.
ასე გაშვებული sudo yum update, როგორც ჩვენ გეტყვით, რომ გავაკეთოთ
პრობლემა კომპლექტი, არსებითად like გაშვებული ავტომატური განახლება
in Mac OS ან Windows.
და მიზეზი გაშვებული ამ დროს ძალიან დაწყების
პრობლემა კომპლექტი არის, რადგან, როდესაც ჩვენ შევქმენით ელექტრო მოწყობილობების, მე
არევა, და მე შემთხვევით გააკეთა ყველა თქვენი პროგრამების გამოიყურებოდეს
შავი შავი ეკრანზე, რის გამოც თქვენ არ ხედავს მათ
იყოს.
მაგრამ უახლესი ვერსია ელექტრო აფიქსირებს ამ.
მე კი დაფიქსირება, რომ შესვენების ერთხელ მაქვს ინტერნეტ
დაკავშირებადობა.
>> ამიტომ შეთავაზებები უბრალოდ მალავს ჩემი შეცდომა, ძალიან discreetly,
როგორც ჩანს.
გაქვთ სხვა კითხვები?
დიახ?
აუდიტორია: სად მიიღოს მოდის?
[INAUDIBLE]
დევიდ ჯ Malan: კარგი კითხვაა.
სად მიიღოს მოდის?
ეს არის ლინუქსის პროგრამა, რომელიც არსებობს მრავალი წლის განმავლობაში, ხანგრძლივი
ადრე CS50.
და მას გააჩნია ოპერაციული სისტემის მსგავსად Fedora.
იგი არ მოდის CS50 ბიბლიოთეკაში.
ფაქტობრივად, მხოლოდ რამ მოდის CS50 ბიბლიოთეკა
ჯერჯერობით, რომ ჩვენ ვხედავთ, არის GetString, GetInt, ყველა
იმ Get ფუნქციები, და სიტყვა სიმებიანი და ზოგიერთ
იმდენად, რამდენადაც, სიტყვა bool.
მაგრამ ამას აჯავრებენ, რომ გარდა, როდესაც ჩვენ ჩაყვინთვის შევიდა CS50
ელექტრო თვით.
>> ასე რომ დიახ, კიდევ ერთი შეკითხვა აქ.
აუდიტორია: როცა განაცხადა მიიღოს და შემდეგ buggy, რამდენად შეესაბამება
კომპიუტერი ვიცი [INAUDIBLE]?
დევიდ ჯ Malan: კარგი კითხვაა.
ასე რომ, როდესაც თქვენ უბრალოდ აწარმოებს მიიღოს buggy1 ან buggy2, თუ როგორ
ამჯამად მიიღოს ვიცი?
ასე რომ იყოს, თუ აკრიფოთ მიიღოს buggy1, მიიღოს ეძებს
ფაილი სახელად buggy1.c.
და მერე ახორციელებს შესაბამისი Clang ბრძანებები,
ამით მნიშვნელოვანი ნაგულისხმევი გამომავალი ფაილი სახელად a.out.
რეალურად, თუ დავაკვირდებით, რა გააკეთოს, რა -
მოდით დატოვა ამ.
თუ დავაკვირდებით, რა გააკეთოს სინამდვილეში აკეთებს, გააკეთოს buggy2,
უკვე დღემდე.
ნება მომეცით, ამოიღონ rm ბრძანება,
პროგრამა დავწერე ადრე.
Typing Y-E-S დავადასტურო, რომ მე მინდა ამოიღონ იგი.
თუ მე ახლა გააკეთოს, რომ ამ ძალიან დიდი ხაზი,
არსებობს ამ ბოლო რამ აქ,-o buggy2.
ყველა მარკა აკეთებს არის ავლით, რომ არგუმენტი, ასე ვთქვათ, რომ
Clang, ისე, რომ მე არ უნდა აკრიფოთ იგი თავს.
>> ყველა უფლება, ასე სწრაფი რამდენიმე ადმინისტრაციული
განცხადებები.
ასე რომ სექციები, რომელიც ოფიციალურად დაიწყო ამ მოდის
კვირა, თქვენ ყოველთვის გვინდა, რათა, თუ
თქვენ გაქვთ ერთი, ლეპტოპი.
თუ არ აქვს ლეპტოპი, ნუ დავკავშირებოდით ჩემს მიერ
ჩაშვების me ელ.
და ჩვენ გაერკვნენ workflow.
რა ზოგადად თქვენ იპოვით ნაწილში ის არის, რომ ისინი ნაწილი
კონცეპტუალური, ნაწილი პრაქტიკული.
ჩვენ კონკრეტულად გამოიყენოთ მონაკვეთზე კითხვები, ნაწილი
კვირის პრობლემა კომპლექტი, ფეხით მეშვეობით ზოგიერთი
კონცეპტუალური მასალა ლექცია.
და ეს ყველაფერი აქტუალური პრობლემა კომპლექტი.
და ჩვენ ასევე ჩაყვინთვის შევიდა ზოგიერთი პრაქტიკული საქმიანობა, ზოგჯერ
რომლის საჭირო იქნება წარსადგენი, ზოგჯერ of
რომელიც არ.
მაგალითად, ამ პირველ კვირას, ისინი ნიშნავდა, ისევე როგორც
გახურების exercise.
და თქვენ ნახავთ, რომ ის პრობლემები მართლაც მხოლოდ, რომ.
ისინი ნიშნავს, რომ საკმაოდ პატარა, მაგრამ არა აუცილებლად
ტრივიალური პროგრამების დაწერა, რომ არ ემთხვეოდეს
ამაღელვებელი და თავს მაგრამ კარგი შანსი
პრაქტიკის სინტაქსი, ახალი ფუნქციები, წელს კომფორტი
სექცია, სადაც თქვენ რამდენიმე თქვენს თანაკლასელებს წარმოადგინოს როგორც
ისევე როგორც თქვენი TF.
>> და ჩვენ ყველაფერს გავაკეთებთ, დროთა განმავლობაში არის გამოიყენოს ინსტრუმენტი მოუწოდა CS50 სივრცეები,
რის ნაცვლად მხოლოდ გამოყენებით CS50 ელექტრო მოწყობილობების, თქვენ
ნაცვლად წასვლა ვებ გვერდი ბრაუზერის, სადაც თქვენ გექნებათ
დაწერა კოდი ბრაუზერის ფანჯარაში დროს მონაკვეთზე.
ხოლო შემდეგ, თუ თქვენ აირჩიონ წელს, თქვენი სწავლების თანამემამულე შეიძლება მაშინ ნახოთ
რაც არ არის თქვენ აკრეფით თქვენს ეკრანზე თქვენი ბრაუზერის
ფანჯრის up at წინაშე კლასის, თუ არა ანონიმურად ან
საჯაროდ, ისე, რომ მას შეუძლია შემდეგ გავლა ერთად
თქვენი თანაკლასელები თუ რა გააკეთეთ თქვენ კარგად, რაც თქვენ არ კარგად.
ისევ და ისევ, დანარჩენი დავრწმუნდი, რომ ყველაფერი ეს შეიძლება ლამაზად anonymized.
მაგრამ ეს იქნება ლამაზი შესაძლებლობა გაცილებით უფრო
interactivity ვიდრე რაღაც ლექცია საშუალებას აძლევს.
>> იმავდროულად, ჩვენ გვექნება ეს ყველაფერი მოუწოდა super
სექციები, რომლებიც სურვილისამებრ, მაგრამ ღიაა ყველასთვის
კლასი, ასე რომ თქვენ შეგიძლიათ ამის გაკეთება უფრო კოლექტიურად ამისთვის
პრობლემა მითითებული ერთი.
აქ გრაფიკი.
ეს ასევე გამოქვეყნდება მთავარი საათზე cs50.net.
გაითვალისწინეთ, რომ იქ იყოს ჰაკერი სპეციფიკური
ერთი ხვალ შუადღისას.
და ჩვენ გადაღება ერთ დღეს და ერთი ხვალ და გამოაქვეყნოთ იმ
ონლაინ 24 საათის განმავლობაში.
ასე რომ, თუ თქვენ ვერ ამ ჯერ, არ ინერვიულოთ.
ისევ და ისევ, გრაფიკი არაა ახლა cs50.net.
>> თვალსაზრისით sectioning თავად, თქვენ უნდა მიღებული
ელ ავალებს თქვენ წასვლა რა თქმა უნდა ვებგვერდი იპოვოს
თქვენი მონაკვეთზე.
თუ ცხოვრების შეიცვალა და თქვენ უნდა შეცვალოთ თქვენი მონაკვეთზე,
პრობლემას არ წარმოადგენს.
დაბრუნება იმავე URL, cs50.net/section, სინგულარული,
და თქვენ შეავსოთ მსგავსი ფორმით ასე რომ თქვენ შეგიძლიათ
მაშინ მოგვცეს თქვენი პრეფერენციები.
და ჩვენ მოჰყვება მიერ კვირის ბოლოს, თუ რა შეგვიძლია
განსახლება.
გასულ კვირას, გავიხსენოთ, რომ ჩვენ შეთავაზებული გამოყენებით CS50 საუბარი,
კურსის დისკუსია ინსტრუმენტი, ლექციების.
ამიტომ ჩვენ გვქონდა 40 კითხვა, რომელიც დაისვა და
უპასუხა დროს ლექციას.
ასე რომ, როგორც ჩანს, კარგად მუშაობს, ამიტომ ჩვენ გავაგრძელებთ
ცდილობს ამის გაკეთება.
თუ დროს ლექცია, თქვენ არა მარტო კომფორტისთვის ამაღლება
თქვენი მხრივ, პრობლემას არ წარმოადგენს.
გადავიდეთ cs50.net/discuss, პოსტ არსებობს, და ჩვენი ერთი სწავლების
პროგრამის ყველა მონაწილე არც პასუხის გაცემა ელექტრონულად ან აიმაღლონ
მხრივ თქვენი სახელით ანონიმურად ვთხოვო, რაც დამოკიდებულია
on ბუნების საკითხია.
და კუთხით კავშირი, ზოგადად psets იქნება
დაბრუნდა ერთი კვირის ვადაში.
იმის გამო, რომ იგი იღებს პატარა ხოლო სექციები, რათა მივაღწიოთ
წონასწორობა, პირველი pset, 0 და 1, იქნება ცოტა
შეფერხდა როგორც რამ დასახლდნენ.
მაგრამ ადევნეთ თვალყური, რომ კვირის მოსვლა.
>> ყველა უფლება, ამიტომ ნება მიბოძეთ, ჩემი სერიოზული
ხმა მხოლოდ მომენტში.
ასე რომ, ეს არის რეალურად საინტერესო კლიმატის იქნება
მქონე ამ დისკუსიის, რა ყველა სხვა რამ
მიმდინარეობს წლის კამპუსში მასთან დაკავშირებული.
მაგრამ CS50 აქვს, რა თქმა უნდა თავისი ისტორიის ამ კონკრეტულ
თემის წელს, ისევე როგორც ყოველ წელს, ამ თქმა უნდა, მრავალი
წლის, Ad-დაფა უხეშად 3% კლასი.
ეს უახლესი წელი, 2011, CS50 Ad-Boarded 35 სტუდენტი.
ეს არ არის, ვფიქრობ, იმის გამო, არსაკმარისად ნათელი.
გააცნობიეროს, რომ საგნის სილაბუსში, არსებობს გვერდზე
განაცხადი ხსნიდა სადაც ხაზები.
იმავე განაცხადი მეორდება ყოველ ერთ
პრობლემა ადგენს გვერდზე ერთი.
>> ასე, რომ აღარაფერი ვთქვათ ამ დღეს მართლაც მხოლოდ რათა
FOLKS მავიწყდება ამ.
და ჩვენ შევეცადეთ სხვადასხვა რამ.
და რა ვიფიქრე ჩვენ ყველაფერს გააკეთებს დღეს მხოლოდ მიიღოს მომენტში
რეალურად შევხედოთ ზოგიერთი წარსული შემთხვევები, რომ არ ამუშავება.
იმის ნაცვლად, რომ შევინარჩუნოთ ეს როგორც ბინძური პატარა საიდუმლოებას, რეალურად
აღნიშნავენ რა სტუდენტები გავაკეთეთ და როგორ არ გამოვლინდა
და მართლაც, რა ყოვლისმომცველი მოტივაცია არის
თუნდაც მქონე ამ საუბრის.
ამრიგად, რომ განაცხადა, ხაზის არსებითად არის ამ -
პოსტი სილაბუსი, მობრძანდით, თქვენ წახალისება, რათა
ესაუბროს თანაკლასელები.
სწორედ მთელი მიზნით მქონე ამ ერთობლივი
ოფისში საათი Annenberg და წამახალისებელი ხალხს
საბოლოო პროექტი დავიწყეთ მუშაობა.
მაგრამ ხაზი დგება, როდესაც საქმე დროის რეალურად წერენ
თქვენი საბოლოო გადაწყვეტა.
ვსაუბრობ ინგლისურ, მთლიანად ჯარიმა, საუბრისას ფსევდო კოდი,
მთლიანად ჯარიმა.
Emailing თანაკლასელი თქვენი pset, გაქირავების მათ გამოიყურებოდეს მეტი
ეკრანზე როგორც ხელში აგრძელებენ აკრეფით,
მეტი ხაზი ასევე.
ნუ ვუყურებთ სილაბუსები კერძოდ ხაზები.
>> მაგრამ ხატვა სურათს როგორ ეს სამწუხაროდ
სინამდვილეში, გააცნობიეროს, რომ არსებობს საიტებზე არსებობს, რომ
აქვს გადაწყვეტილებების ამ კლასში და მრავალი სხვა კლასებს.
ის ფაქტი, რომ თქვენ ან 3% თქვენ იცით, რომ ეს არსებობს
იმას ნიშნავს, რომ ჩვენ ვიცით, რომ ეს არსებობს.
იმისა, რომ არსებობს საიტების მოსწონს ეს სადაც თქვენ
შეგიძლიათ გადაიხადოთ ვინმე მართლაც თქვენი პრობლემა კომპლექტი - ეს იყო
ფაქტობრივი შემთხვევაში გამოვიდა შარშან.
ეს არის ნახვა მოუწოდა odesk.com.
და ტიმ იყო სახელით პირი აქ რომელიც გასაკრავი შესახებ
ამ ნახვა და სთხოვა ვინმე გააკეთებს pset 7 ში
ამ კონკრეტულ შემთხვევაში.
ისე, odesk.com ძალიან Google-შეეძლოს, და ჩვენც ვართ
ძალიან კარგად Googling.
აქაც არსებობს საიტები - და ეს ერთი საკმაოდ
ბარბაროსულ, გულწრფელად.
[სიცილი]
დევიდ ჯ Malan: სასაცილო რამ შესახებ ეს საიტი არის თუ
წაიკითხოთ შესახებ გვერდზე, ისინი საუბრობენ თავიანთი კორპორატიული
კულტურისა და როგორ სამსახური მათი ნომერ
პრიორიტეტი, რომ დავრწმუნდეთ, რომ თქვენი დავალებები მისაღებად
ქცეული დროულად.
>> მაგრამ ყველა სერიოზულობა, კიდევ ერთხელ, იმ ფაქტს, რომ ამ საიტებზე
არსებობს, გააცნობიეროს ჩვენ, ძალიან, are cognizant of
ასეთი საიტები.
და გადმოგცეთ გრძნობა რა ქმნის ამ ზოგადად
იღებს, ჩვენ ზოგადად არ გვაქვს დიდი სკანდალები, სადაც ადამიანებს
მათ თანამშრომლობს ნებისმიერ სახის მასიურ, არამედ
ეს ამ ღამით მომენტები სისუსტე, სადაც თქვენ ასე
გასაკეთებელი, ეს 4:00 AM, თქვენ ამოწურა, და თქვენ
ვფიქრობ საკუთარ თავს, ისე, ნება მომეცით უბრალოდ შეხედეთ ჩემი
roommate ან ჩემი მეგობრის კოდი ან მოსწონს.
და მანიფესტაციების ამ სამწუხაროდ ჩართვა სტუდენტური
წარდგენის მსგავსი რამ და სტუდენტური B წარდგენის
მსგავსი რამ, რაც, რა თქმა უნდა, ამ კომპიუტერში
მეცნიერების კლასის, არის საოცრად მარტივი კომპიუტერული მეცნიერები
შესამჩნევია, პროგრამული.
ეს არის კიდევ ერთი საერთო პარადიგმა, სადაც თქვენ სახის
მუშაობს ერთად ვინმე, იქნებ საუბარს წელს
ინგლისური, მხოლოდ ჯარიმა, pseudocode.
მაგრამ შემდეგ საქმე ახლა რეალურად წარმოადგინოს და psets
უბრალოდ გაცვალეს ფოსტით, ან Dropbox ან მოსწონს.
მაგრამ მცდელობა, რათა ის ნაკლებად აშკარა, რომ ეს არის
რა მოხდა, მაშინ ეს არის რა წარმოდგენილი.
ეს, ძალიან, არ მოგზაურობის up კარგად წერილობითი ცალი
პროგრამული უზრუნველყოფა როგორც ჩვენ რეალურად აღმოაჩინოს
ასეთი რამ.
და მართლაც, რას ვაკეთებთ არის პერსპექტივაში პროგრამული უზრუნველყოფა, რომ ადარებს ყველა
წლევანდელი წარდგინება წინააღმდეგ ყველა წარსული წლის
წარდგინება, წინააღმდეგ ყველაფერი ჩვენ ნაპოვნი
ინტერნეტი, წინააღმდეგ თითოეული ვაკანსიისთვის ნახვა out არსებობს.
ეს ყველაფერი ძალიან ავტომატური.
ასე რომ, ჩვენ ამის გაკეთება ნამდვილად დიდი სამართლიანობისა to 97%, რომლებიც
ნამდვილად მუშაობს მათი ვირები off ამ და სხვა
კლასები და აყენებს ყველა იმ ძალისხმევას, რათა მუშაობა
ისინი საბოლოოდ წარუდგინოს არის საკუთარი.
მე შეიძლება ადამიანმა საუკუნოვანი.
>> ეს არის მხოლოდ ერთი მუჭა შარშანდელი შემთხვევა.
რამდენიმე სტუდენტი წარმოდგენილი ამ ფაილების იდენტურად ამისთვის pset 2,
pset 3, 4 pset, pset 5, 6 pset, pset 9.
ამ შემთხვევაში, ეს იყო ინტელექტუალური 0 და გასულ წელს, სადაც ორი
სტუდენტები წარმოდგენილი იდენტურად წაიკითხავს შორის ბევრი
სხვები, "მოთხოვნით ტიპის -" dot, dot, dot.
ასე კი კლასი 600 საერთოდ ამოვიცნობთ ამ
on წარმოდგენილი ვიქტორინებში.
ასე მოკლედ, ამ - გულწრფელად, I Hate მქონე ამ სახის
საუბარი - მაგრამ ეს მართლაც მიზანმიმართული ძალისხმევით
ამ წელიწადში ცდილობენ შეწყობას ქვემოთ რომ ნომერი.
იმის გამო, რომ მიუხედავად იმისა, რომ ჩვენ ვამბობთ, ასეთი რამ ყველა
წელს, ვფიქრობ, რეალობა, რომელმაც სახლობდნენ მასზე რამდენიმე
მეტი წამი ვიდრე ჩვეულებრივი და რეალურად მხოლოდ მიუთითებს
რომ ის, რაც ალბათ მოსწონს, eh, არ ასეთი დიდი გარიგება, მინიმუმ
ვფიქრობ თავში ამ კონკრეტულ მომენტში, როგორც სამართლიანობისა to
თავის და თქვენი თანაკლასელები აქ.
ასე რომ, თუ ოდესმე აქვს რაიმე შეკითხვები, სადაც ხაზი
არის, გთხოვთ მხოლოდ მივაწვდინოთ პირადად ჩემთვის.
მაგრამ პასუხი ყოველთვის, სრულიად ხაზგასმით ზე
ბოლო წუთს, ნაღდი ფულის გვიან დღეში.
ან თუ ეს საკითხი არ მქონე ნებისმიერი გვიან დღით,
პატიოსნად, ელ პირადად ჩემთვის.
ჩვენ გაერკვნენ რაღაც გარეთ.
გთხოვთ არ დააყენოს თქვენი დრო აქ ჰარვარდის რისკის ქვეშ.
>> ახლა ვფიქრობდი, ჩვენ უნდა lighten განწყობა, ამიტომ
შედის ამ როგორც შემდეგი slide.
[სიცილი]
დევიდ ჯ Malan: ვებგვერდი დიდი.
მე რეალურად მიიღო პატარა სცილდება.
არსებობს ეს ერთი.
და მაშინ ეს იყო საოცარი.
Okay, ასე ვფიქრობ, რომ kitten გვიან ღამით მიღებისას
იმ გადაწყვეტილებებს.
ყველა უფლება, ასე რომ თავში მეტი გართობა და ნაკლებად მძიმე პერსონალის, ისევე როგორც
პირობები.
>> ყველა უფლება, ასე რომ ჩვენ ვისაუბრეთ მოკლედ ამ.
ეს არის ის, რასაც ალბათ საკმაოდ ნაცნობი საწყისი
სამყაროში Scratch.
და სამყაროში Scratch, ჩვენ გვაქვს ამ საჭიროებას ხან
წასვლა მიიღოს ჩანგლები საგზაო.
ან გავაკეთოთ ამა თუ იმ ან ამ სხვა რამ აქ.
და როდესაც ჩვენ გვინდა ამის გაკეთება, ჩვენ შეგვიძლია გამოვიყენოთ, დო ახლა, ამ შემთხვევაში
სხვაგან აშენება.
და მერე აქ გვაქვს ლოგიკური გამონათქვამები.
მაგალითად, ლოგიკური გამონათქვამები, ჩვენ შეუძლია
მათ ერთად, იმ გაგებით, რომ ჩვენ გვაქვს ეს მდგომარეობა ან
რომ მდგომარეობა.
ჩვენ შეგვიძლია და მათი ერთად, იმ გაგებით, რომ ჩვენ გვინდა
შეამოწმოს ამ მდგომარეობაში და რომ მდგომარეობა.
და აქ ჩვენ გვაქვს შეცვლა განაცხადი არის, რაც ასე არ არის
მსგავსი syntactically იმ სახის პირობები, მაგრამ ეს
საშუალებას გვაძლევს გავაკეთოთ ეკვივალენტს, თუ სხვაგან, თუ სხვაგან, თუ სხვაგან
თუ, და მოსწონს უბრალოდ enumerating მათ კონკრეტულ შემთხვევაში
მიერ კონკრეტულ შემთხვევაში.
ამიტომ, ჩვენ ვნახეთ იმ ბოლო დროს.
და შემდეგ ჩვენ დავიწყეთ ეხება რამ, როგორიცაა მარყუჟების.
ჩვენ ვნახეთ ერთი ასეთი მხოლოდ მომენტში წინ.
მაგრამ არსებობს ამ სხვა looping აშენებს.
>> მაგალითად, ამ ერთი აქ.
ასე რომ სანამ (მდგომარეობა), ამის გაკეთება რამ ისევ და ისევ.
ასე რომ ფუნდამენტურად, რა ჩანს სხვადასხვა შორის ამ
ამისთვის მარყუჟის და ამ ხოლო loop აქ?
ამ მარყუჟის და ამ ხოლო loop.
ჰო?
რა არის ეს?
აუდიტორია: [INAUDIBLE].
დევიდ ჯ Malan: კარგი.
ასე ხოლო ამისთვის loop მდგომარეობა, არსებობს ნათლად
უფრო სინტაქსს.
არსებობს ამ ინიციალიზაციისას, არსებობს ამ განახლება.
In ხოლო მარყუჟის, არსებობს მხოლოდ ამ მდგომარეობაში.
ასე რომ, როგორც ჩანს, ეს პატარა pared ქვემოთ წინააღმდეგ ამისთვის
მარყუჟის, რაც იმას ნიშნავს, თუ ჩვენ გვინდა ცვლადები და გვინდა
ჰქონდეს incrementation, ჩვენ რეალურად უნდა
ამის გაკეთება რამ საკუთარ თავს.
>> ნება მომეცით, წავიდეთ წინ და ქმნის gedit.
ნება მომეცით გადართოთ მეტი ელექტრო მოწყობილობების.
და მოდით უბრალოდ სწრაფი პატარა მაგალითი, რომ
განასხვავებს ერთი ამ მეორე.
და უკან ჩემი აზრით აქ, რაც მინდა აღვნიშნო ერთი რამ.
მე კონკრეტულად აღნიშნულ სახელი ტიმ.
ტიმ იყო რეალურად ვინმე რომ სტუდენტი შეეცადა გავაკეთოთ
მათი საშინაო დავალება მათთვის.
ჩვენ არ გვქონდა ტიმ ამ კონკრეტულ მონაკვეთზე.
ასე რომ გააცნობიეროს, მცირეოდენ მე გამხელა სტუდენტი, ეს არ იყო სტუდენტი.
ეს იყო შემთხვევითი პირი ინტერნეტში საქმეს აკეთებენ
მარიონეტული შარშან.
ამიტომ ჩვენ, რომ, ძალიან.
ასე რომ, ამ შემთხვევაში აქ, ნება მომეცით წავიდეთ წინ და
გახსენით ახალი ფაილი.
ფაილი, ახალი.
ეს მაძლევს tab აქ.
ნება მომეცით წავიდეთ წინ და შეინახეთ loop.c.
ნება მომეცით წასვლა და დააჭირეთ Save.
და შემდეგ ქვევით აქ, მოდით წავიდეთ წინ და დავიწყოთ წერა
# Include .
ნება მომეცით zoom სისტემაში
ახლა ჩვენ გავაკეთებთ int ძირითადი (void).
ახლა ნება მომეცით წავიდეთ წინ და გააკეთოს (int i = 0; i <
OH, 10; i + +).
და ახლა მე ვაპირებ წავიდეთ წინ და ბეჭდვა ვარსკვლავი, რომ მე
გააკეთეთ ადრე.
და შემდეგ დასასრულს ამ პროგრამის ჩვენ უბრალოდ აპირებს
ბეჭდვა ახალი ხაზი, უბრალოდ, ისე, რომ ჩემი სწრაფი
არ გამოიყურება ყველა ბინძურ.
დაბრუნებას 0.
როგორც ჩანს syntactically სწორი?
ჯერჯერობით.
ასე რომ ვნახოთ.
>> ნება მომეცით, zoom out, წასვლას ჩემი ტერმინალის ფანჯარაში.
და ნება მომეცით წავიდეთ წინ და აწარმოებს მარყუჟის, რადგან მე უწოდა
რამ loop.c.
ასე რომ მარყუჟი.
როგორც ჩანს, კომპილაციის OK.
ნება მომეცით აწარმოებს მარყუჟის და ახლა შეიყვანეთ.
და როგორც ჩანს, არ დაბეჭდილი 10 ვარსკვლავს.
მოდით უბრალოდ კონვერტირება ეს ხოლო მარყუჟი და ვნახოთ რა
სახის საკითხებზე ჩვენ მოგზაურობა დასრულდა.
ასე რომ ნაცვლად ამისა, ნება მომეცით წავიდეს აქ და ამბობენ, ხოლო მე არის
არანაკლებ 10 -
ნება მომეცით დავაღწიოთ ამისთვის loop.
OK, ასე რომ ჩვენ გვაქვს რამდენიმე პრობლემები უკვე.
ასე რომ მდგომარეობა იგივეა, მაგრამ მე აშკარად აკლია
ინიციალიზაციისას.
მე დაკარგული incrementation.
მერე რა უნდა შემდგენელი სავარაუდოდ მითხრათ როცა ცდილობენ
შეადგინონ ამ პროგრამის?
ჰო?
აუდიტორია: [INAUDIBLE].
>> დევიდ ჯ Malan: კარგი.
ამიტომ აპირებს ამბობენ რაღაც გამოუცხადებელ - ამ
შემთხვევაში, ცვლადი მე.
მართლაც, გამოიყენოთ გამოუცხადებელი იდენტიფიკატორი მე.
და ა.შ. ეს არის განსხვავებით ენებს, როგორიცაა PHP და
Python და Ruby, რომელთანაც ზოგიერთ თქვენგანს შეიძლება იყოს ნაცნობი,
სადაც შეგიძლიათ მხოლოდ სახის დაწყება გამოყენებით ცვლადები
willy-nilly და არ ინერვიულოთ შესახებ გამოცხადების მათ
ცალსახად ყოველთვის.
In C და ენებს, როგორიცაა Java და C + +, თქვენ უნდა იყოს
სუპერ სიცოცხლისუნარიანობა.
და თუ გინდათ ცვლადში i, თქვენ უნდა მითხრათ
რა სახის ცვლადი ეს.
ამიტომ, ჩვენ ვაპირებთ აქვს დაფიქსირება ამ შემდეგნაირად.
მე ვაპირებ უნდა ახვიდეთ აქ და ტიპი int i; ამიტომ,
მე განაცხადა ცვლადში მე.
ახლა, მე გამოტოვებენ ერთი ნაბიჯია.
მე აშკარად არ ინიციალიზდება, მაგრამ ვნახოთ, თუ რომ
მაინც მარკისა Clang გაჩერება პრეტენზიებს.
ნება მომეცით, რიმეიკი ამ პროგრამის.
>> ყველა უფლება, ახლა კი მხოლოდ უკმაყოფილო
სხვა მიზეზით.
"Variable" მე ", რომელიც uninitialized როდესაც გამოიყენება აქ." ყველა უფლება, ისე
რომ საკმაოდ ცხადი.
ინიციალიზაცია მხოლოდ იმას ნიშნავს, თუ მითითებული ტოლი ღირებულების.
და ჩვენ არ კეთდება, რომ, ნება მომეცით, ვცდილობთ შეადგენს 0.
ახლა მოდით ვეცადოთ ეს კიდევ ერთხელ და ხელახლა აწარმოებს Clang.
შედგენილი ამ დროს.
და მე უნდა გაუშვათ.
მაგრამ დიდი წლის უსასრულო ციკლი, რადგან მე ვაკეთებ
ინიციალიზაციისას, მე ვაკეთებ მდგომარეობა, მაგრამ მე არასოდეს კეთდება
ნებისმიერი სახის incrementation.
ასე როგორ გავაკეთო incrementation?
ისე, წელს, ხოლო მარყუჟის, ეს იგრძნობა მე ვაპირებ აქვს
ამის შიგნით მარყუჟის, რადგან ჰგავს პირველი
კვირის მაგალითები კეთების looping აშენებს, ისევე, როგორც
წინდები და თვითმმართველობის დათვლა, ჩვენ უნდა გაეკეთებინათ
რაღაც ეტაპზე ბოლომდე, ისევე როგორც დაბრუნდეს შემდეგი ხაზი.
რა მოხდება, თუ წავიდეთ წინ და ამისათვის მე + + აქ?
მოდით კი არ კომპილირდება ამ.
Catch me უკვე.
რა არის არასწორი აქ?
აუდიტორია: [INAUDIBLE].
>> დევიდ ჯ Malan: ასე რომ ნამდვილად არ int.
ეს მე.
და curly braces, ისევე როგორც ადრე,
წანაცვლება არ არის საკმარისი.
ახლა მე ამ მშენებლობას.
რადგან მე ნაკლებია 10, ბეჭდვა ვარსკვლავი,
მაშინ ნამატი მე.
და გზა ხოლო loop იმაშიც მდგომარეობს, რომ, როგორც კი თქვენ მოხვდა
ბოლოში loop, რომელიც ამ შემთხვევაში ჰგავს ხაზი 10,
იგი აპირებს დაბრუნდეს ხაზის 6, სადაც წერტილი
მდგომარეობა მოწმდება ერთხელ.
და თუ ჯერ კიდევ არანაკლებ 10, ჩვენ ყველაფერს გავაკეთებთ ხაზები 8 და
შემდეგ 9, შემდეგ ჩვენ მოხვდა 10 და დაბრუნდეს 6, ერთხელ და
ისევ და ისევ და ისევ, ასე რომ სანამ მე ნაკლებია 10.
მოდით ხელახლა აწარმოებს გააკეთოს აქ.
>> Okay, ჩვენ შედგენილი okay.
ნება მომეცით ხელახლა პერსპექტივაში loop.
ახლა უკვე რეალურად ჩანს მუშაობა.
ამიტომ pluses და minuses აქ?
ისე, ჯერჯერობით იქ რეალურად არ მთელი plo -
ასე cute.
ყველა უფლება, რომ იყო - ah, რომ იყო უბედური შემთხვევა.
ყველა უფლება, მოდით დავუბრუნდეთ ამისთვის loop.
ასე რომ მარყუჟების კი კარგია რადგან ისინი super სიცოცხლისუნარიანობა.
და მიუხედავად იმისა, ისინი პატარა clunky დაწერა, ეს
ძალიან ძლიერი და ის საშუალებას გაძლევთ ამის გაკეთება
მრავალჯერადი რამ ერთბაშად.
მიუხედავად იმისა, მარყუჟების ვერ ვიტყვით აქვს უზარმაზარი ღირებულების მხოლოდ
ჯერჯერობით, რადგან ეს იგრძნობა ჩვენ უბრალოდ უნდა გავაკეთოთ უფრო მეტი მუშაობა.
ჩვენ უნდა დააყენოს ინიციალიზაციისას აქ,
განაახლოთ ქვემოთ აქ, და ჩვენ უნდა გვახსოვდეს, რომ ყველაფერი, რომ.
ამიტომ, ჩვენ დავინახავთ, დროულად რომ სანამ მარყუჟების რეალურად lend
საკუთარ თავს მხოლოდ სხვადასხვა კონტექსტში, სხვადასხვა მონაცემები
სტრუქტურები, როგორიცაა სიები და hash მაგიდები, რამ ჩვენ მისაღებად
შუა რიცხვებში სემესტრში.
მაგრამ ახლა, ვიცით, რომ არსებობს ამ მესამე ტიპის ცნობილია, როგორც do-
ხოლო loop.
ჩვენ ვხედავთ ამ მოკლედ.
და ეს შეიძლება იყოს სუპერ გამოსადეგი ერთად pset 1.
ნებისმიერ დროს გსურთ რაღაც და შემდეგ შეამოწმეთ თუ
მომხმარებლის თანამშრომლობდა, და თუ არ, ამას კიდევ ერთხელ, do-
ხოლო loop lends თავად ისეთი ლოგიკა.
რადგან შეკვეთით ზემოდან ქვედა აქ ვარაუდობს,
არ სიტყვასიტყვით ნიშნავს ამის გაკეთება.
და ეს კიდევ ერთხელ და ისევ, თუ რა შეიძლება, რომ იყოს?
შესაძლოა ეს იმას ნიშნავს მოუწოდებდა GetInt ან GetString და შემდეგ
შემოწმების ღირებულება GetInt ან GetString და შემდეგ yelling
ზე მომხმარებლის თუ ისინი არ თანამშრომლობდა მიერ სთხოვს
ისევ და ისევ და ისევ.
სადაც გსურთ რაიმეს ერთხელ,
შემდეგ შეამოწმეთ ზოგიერთი მდგომარეობა.
>> მოდით ცდილობენ ამ.
ნება მომეცით რეალურად შეცვალოს ეს ახლა do-ხოლო loop.
და მე ვაპირებ წავიდეთ წინ და ნუ შემდეგ.
ასე რომ შემდეგ.
მოდით int i = GetInt (), მაგრამ მოდით პირველ გითხრათ მომხმარებლის
რა უნდა გააკეთოს.
ასე რომ ცოტა განსხვავებული ამ დროს.
"მომეცი int".
ამიტომ მე გამოიყენოთ printf რომ.
და ახლა მე ვაპირებ დაცემას აქ, და მე ვაპირებ ამის გაკეთებას
ხოლო მე არის, ასე ვთქვათ, მეტი -
ვნახოთ, მე არის, ვთქვათ, ნაკლები 0, ან მე არის
მეტი 10.
სხვა სიტყვებით, მინდა ნომერი 1 დან 9, უბრალოდ
თვითნებურად.
ამიტომ მე გამოყენებით კომბინირებული ლოგიკური გამოხატვის აქ
დარწმუნდით, რომ მე ნაკლებია, ვიდრე 0 ან მეტი 10, რომელშიც
შემთხვევაში გავაკეთებ ამ loop აქ ერთხელ.
ასე რომ კიდევ ერთხელ, ამის გაკეთება -
ხოლო მე ნაკლებია, ვიდრე 0 ან მე მეტია 10.
>> ახლა მოდით წავიდეთ წინ და ამისათვის კიდევ ერთხელ ჩვენ გავაკეთეთ, რომ.
მოდით უბრალოდ სწრაფი საღი აზრის ქვითარი.
printf ("მადლობა, მე% d", მე).
ასე რომ, ეს მარტივი პროგრამა სთხოვს მომხმარებლის ამისთვის int,
ხდის დარწმუნებული ის ფარგლებში გარკვეული სპექტრი, 1 დან 9 ინკლუზიური,
და მაშინ მადლობას უხდის მომხმარებლის მიერ ახსენებს მათ, რაც მათ მხოლოდ
აკრეფილი, ისევე როგორც პატარა საღი აზრის ქვითარი.
მაგრამ ვნახოთ, თუ ამ მუშაობს განკუთვნილი.
ნება მომეცით წასვლა ხელმძღვანელი ქვემოთ აქ და ხელახლა აწარმოებს გააკეთოს მარყუჟი.
Hmm.
"გამოიყენე გამოუცხადებელი იდენტიფიკატორი 'i'". რომ უცნაურია.
ვფიქრობდი, ჩვენ გადაწყდეს, რომ.
იგივე სიმპტომი არამედ სხვადასხვა კოდი.
ჰო?
აუდიტორია: [INAUDIBLE] შიგნით ორი, ჩვენ უნდა
[INAUDIBLE].
>> დევიდ ჯ Malan: ზუსტად.
ასე რომ, ეს ფაქტობრივად მივყავართ თემის ცნობილია როგორც ფარგლებს.
თურმე C, კიდევ ერთხელ, მართლაც მოგაწვდით სიტყვასიტყვით.
და თუ მსგავსი რამ სადაც თქვენ განაცხადოს int
და შემდეგ მივანიჭოთ მას გარკვეული მნიშვნელობა, მაგრამ თქვენ რომ შიგნით
წყვილი Curly braces, რა C არ არის ის ვარაუდობს, რომ თქვენ
მხოლოდ სურვილია, 32 ბიტი ცნობილია როგორც მე არსებობა ფარგლებში
კონტექსტში იმ Curly braces, ფარგლებში ხაზები
6 გავლით 9. ასე რომ ცხადდება და მას ენიჭება
ღირებულების ხაზი 8, მაგრამ, როგორც კი თქვენ მიიღოს გარეთ
ხაზის ქვემოთ 9 Curly გაუწიოს, მე აღარ
ფარგლებს, ასე ვთქვათ.
S-C-O-P-E. ეს აღარ სწორ კონტექსტში.
ახლა არ არსებობს მე, ამიტომ, თითქოს ჩვენ არც კი
განაცხადა საერთოდ.
>> რა არის სარემონტო მაშინ მსგავსი რამ, თუ
მიზეზი ის არის, რომ მე ცხადდება ფარგლებში Curly braces, რომელიც
აშკარად ცუდი?
აქ?
აუდიტორია: [INAUDIBLE].
დევიდ ჯ Malan: ჰო.
ასე რომ ჩვენ შეგვიძლია ინიციალიზაცია მას გარეთ.
ნება მომეცით, წავიდეთ წინ და წაშლა დეკლარაციის ნაწილები რის
მე მიუთითებს, და ნება მომეცით ამის გაკეთება აქ.
ასე რომ ხაზი 5, ეს არის ამბობს "მომეცი int." ზარის ეს მე.
ცნობა, ხაზის 9, მე არ მინდა ამის გაკეთება, რადგან მე
უკვე გვაქვს 32 ბიტი.
მე არ მინდა ვთხოვო კომპიუტერში
სხვადასხვა 32 ბიტი.
მინდა იმ იმავე 32 ბიტი.
და ახლა რადგან მე ცხადდება შეესაბამება 5, მაინც legit
გამოიყენოს იგი ხაზის 11 და ხაზი 12.
>> ნება მომეცით, ცდილობენ recompile ამ და ვხედავ
თუ Clang აჩერებს yelling.
გააკეთეთ მარყუჟი.
ასე რომ ახლა ეს "დაფარული დეკლარაცია ფუნქცია
'GetInt "არასწორია წელს c99." რა არის ეს?
ჰო?
აუდიტორია: [INAUDIBLE].
დევიდ ჯ Malan: ჰო.
ახლა რომ მე რეალურად გამოყენებით GetInt, ეს არ არის რაღაც
რომ მხოლოდ მოდის C. ეს მოდის CS50.
ამიტომ, ჩვენ გვჭირდება ეს აქ.
და ნება მომეცით დაბრუნდეს სწრაფი ქვემოთ
აქ და ხელახლა აწარმოებს მიიღოს.
Okay, საბოლოოდ.
ახლა ჩვენ გადაწყდეს, რომ და სხვა შეცდომა.
ნება მიბოძეთ ახლა აწარმოებს მარყუჟი და ვნახოთ, რა მოხდება.
"მომეცი int." მე მივცემ მას 11.
მე მივცემ მას -1.
მე მივცემ მას foo.
მე მივცემ მას 5.
და ახლა მართლაც მუშაობს.
მაგრამ სწრაფი შეიცვალა მიზეზი აქ.
რატომ ამბობენ გაიმეორეთ ერთი ამ ჯერ მაგრამ მომეცი
int სხვა სამჯერ?
რატომ არის, რომ ქცევის განსხვავებული?
აუდიტორია: მისცა სიმებიანი.
დევიდ ჯ Malan: უკაცრავად?
აუდიტორია: თქვენ მისცა სიმებიანი.
დევიდ ჯ Malan: ჰო.
ამიტომ, ჩვენ მივეცით მას სიმებიანი ამ მესამე მცდელობა,
როდესაც მე აკრეფილი foo.
Foo არის სიმებიანი.
ეს აშკარად არ int.
და ისე, რომ CS50 განახორციელა GetInt არის, რომ ჩვენ
არ შეამოწმოთ თუ რაღაც არის ნაკლები ვიდრე 0 ან მეტი 10
თქვენთვის, რადგან როგორ უნდა იცოდეს წინასწარ, თუ რა სახის
int გსურთ?
მაგრამ ჩვენ შეგვიძლია მინიმალურად შევამოწმოთ თქვენ, საერთოდ მომხმარებლის მინიმუმ
აკრიფოთ რიცხვი?
და თუ არ, ჩვენ დაწეროთ ზე მომხმარებლის აკრეფით "გაიმეორეთ" შესახებ
ეკრანზე.
>> ახლა ჩვენ გვაქვს პროგრამა, რომელიც looping. Okay.
ახლა, რაც ამ არის ერთგვარი უკეთ შენება?
ასე რომ, ეს, რა დაიწყება მიიღოს პატარა ბინძურ,
ის ფაქტი, რომ თქვენ უნდა გვახსოვდეს, განაცხადოს ცვლადი აქ
თუ გსურთ გამოიყენოთ იგი შიგნით ზოგიერთი
Curly braces და გარეთ.
მაგრამ მაშინაც კი, თუ ეს გამოიყურება პატარა cryptic თავდაპირველად
ერთი შეხედვით, მხოლოდ ერთხელ, მახსოვს მარტივი ლოგიკაა.
რათა არაფერი C, თუ არა ეს ფუნქცია ან
ეს ცვლადი, თქვენ უნდა შეიცავდეს იგი, თუ ის ფუნქცია
ზოგიერთ ბიბლიოთეკაში, ან თქვენ უნდა გამოაცხადოს ის.
მაგრამ ახლა თქვენ უნდა ზედმეტი მავიწყდება იმ ფაქტს, რომ
თქვენ გამოცხადების მას უფლება ფარგლებს.
თქვენ არ აყენებს ეს ძალიან მჭიდროდ შიგნით ფრჩხილებში.
>> ნება მომეცით, ფაქტობრივად გააფართოვოს უკან.
თუ ჩვენ დავუბრუნდებით ჩვენი მაგალითად საწყისი ადრე, და მე
თავში ამისთვის int, int i = 0; i <10; მე + +, და მე
გავაკეთოთ printf ვარსკვლავი, ასე, შემდეგ კი ახლო PAREN და ახლა
printf მე არის -
ამავე ლოგიკით, თუ რა მოხდება მაშინ, როდესაც მე ვცდილობ
შეადგინონ ამ პროგრამის?
აუდიტორია: არასწორი იდენტიფიკატორი.
დევიდ ჯ Malan: ასე რომ კიდევ ერთი არასწორი იდენტიფიკატორი,
გამოუცხადებელ იდენტიფიკატორი.
ახლა, მიზეზი არის პატარა სხვადასხვა.
აქ აშკარად არ Curly braces აქ, მაგრამ იგივე
იდეა, იგივე ამბავი ფარგლებს ვრცელდება.
თუ თქვენ არ განაცხადა ცვლადი როგორიც მე შიგნით
ამისთვის მარყუჟის, მაშინაც კი თუ თქვენ არ არის მკაფიოდ წერილობითი Curly
braces, ვფიქრობ მათგანი გონებრივად როგორც ჯერ კიდევ არსებობს, რომელშიც
შემთხვევაში მე ძალაშია მხოლოდ შიგნით ამისთვის loop.
ეს არ არის სწორი ერთხელ თქვენ მიიღებთ შემდეგი ხაზი, რომელიც
ამ შემთხვევაში არის 10.
ასე რომ მხოლოდ რამდენიმე საკითხები ფარგლებს და მოსწონს.
ყველა უფლება, რაიმე კითხვა?
>> ყველა უფლება, ასე რომ, ეს სახის ტრივიალური პატარა პროგრამა,
ბეჭდვა მხოლოდ პატარა ვარსკვლავები.
მაგრამ ვნახოთ, თუ გახსოვთ ეს სიმღერა აქ.
ეს არის წარმოუდგენლად შემაშფოთებელი სიმღერა ბავშვები რომ მღერიან შესახებ
სასკოლო ავტობუსი და მოსწონს.
მაგრამ რა ლამაზი ამის შესახებ არის, რომ მას ამ cyclicity,
რომლითაც ეს "99 ბოთლი ლუდი კედელზე,
99 ბოთლი ლუდი.
მიიღეთ ერთი ქვემოთ, გაივლის ირგვლივ, 98 ბოთლი ლუდი შესახებ
კედელი. "და შემდეგ სიმღერა იმეორებს 97, შემდეგ 96, მაშინ
95, შემდეგ 94, ყველა გზა ქვემოთ 0 თუ თქვენ ნამდვილად გაქვთ, რომ
შორს ავტობუსი.
ასე რომ, ეს არის კარგი პროგრამა დასალაგებლად of განახორციელოს, რადგან ჩემი
ღმერთი, თუ შეიძლება მხოლოდ განახორციელონ ამ რამდენიმე
ხაზების კოდი, შეგიძლიათ Spit out მთელი სიმღერები ამ
სიმღერა საკმაოდ სწრაფად.
მაგრამ გზაზე, ჩვენ შეგვიძლია დავიწყოთ ახლა აჯავრებენ გარდა ზოგიერთი
ამ საბაზისო looping აშენებს და ახლა მას
შემოიღონ ფუნქციებს, რომ ჩვენ წერენ თავს, დაბრუნდნენ ღირებულებები
რომ ჩვენ გაიაროს გარშემო.
მაგრამ პირველი, რატომ არ ვართ წავიდეთ წინ და მიიღოს ჩვენი ხუთი წუთი
შესვენება აქ?
და როდესაც ჩვენ დავუბრუნდეთ, ჩვენ იმღერებს ამ სიმღერას.
>> ყველა უფლება, ასე რომ, ჩვენ უკან.
და როდესაც ვამბობ, რომ ჩვენ ახლა მღერიან ამ სიმღერას, ვგულისხმობ
პროგრამულად, არ სიტყვიერი შეურაცხყოფა მიაყენეს.
ასე რომ აქ გვაქვს beer1.c, რომელიც ერთ განხორციელების
კერძოდ სიმღერა.
და უბრალოდ უნდა იყოს მკაფიო, მათთვის, იციან რა
ეს საგანი ჰგავს, ნება მომეცით წავიდეთ წინ
და მიიღოს beer1, შეიყვანეთ.
ახლა ნება მომეცით აწარმოებს beer1, და რასაც ჩვენ დავინახავთ - რამდენი ბოთლი
ლუდის იქნება?
მე აკრიფოთ 99, როგორიცაა სიმღერა ამბობს.
შეიყვანეთ.
და ახლა თუ ჩვენ გადახვევა მეშვეობით -
oops - თუ ჩვენ გადახვევა მეშვეობით ყველა ამ, ჩვენ დავინახავთ, რომ
ამ მართლაც მღერიან მთელი სიმღერა.
დაელოდეთ წუთი.
ჩემი გადახვევა ბარი ცოტა არევა.
მოდით გამოიყენოთ უფრო დიდი ფანჯარა.
ამიტომ beer1, 99, იქ წასვლა.
ასე რომ აქ გვაქვს მთელი სიმღერა, სენი უფრო სწრაფად მიერ
კომპიუტერი, ვიდრე ეს იქნებოდა ჩვენს მიერ.
ასე რომ შეამჩნია, თუმცა, ციკლური ბუნება აქ.
განცხადებაში ნათქვამია, 99, 99 შემდეგ, მაშინ "ერთ down, მსგავ
გარშემო ", მაშინ 98.
და ახლა იგი იმეორებს ისევ და ისევ.
>> ასე რომ, ეს არის რეალურად შესანიშნავი შესაძლებლობა, გარკვეული სახის
looping მშენებლობა.
გაითვალისწინეთ, რომ მე სახის ჭრის კუთხეში აქ.
გაითვალისწინეთ, რომ მე რომ "98 ბოთლი ლუდი კედელზე,
97 ბოთლი ლუდი კედელზე, "და რომ მხოლოდ ასე
რომ როდესაც მივიღებთ ერთ ბოთლი ლუდი, მე არ მაქვს
ფიქრი English გრამატიკა.
თუმცა ისიც დაფიქსირება ამ ცოტა თუ
მდგომარეობა, ალბათ.
თუ ეს რიცხვი არის სინგულარული, წავიდეთ წინ და ვთქვათ "ბოთლი",
სხვაგვარად, თუ ის მრავლობითი, რომ "ბოთლი".
მაგრამ ახლა, მე მთლიანად მოჭრა რომ კუთხეში.
მოდით ვნახოთ, რა გვაქვს აქ.
ამიტომ, ჩვენ მივიღეთ რამდენიმე კომენტარი ზედა.
მე მათ შორის, ამ ორ ბიბლიოთეკა, როგორც
ჩვენ ხშირად ყოფილა.
და ახლა ნება მომეცით გადახვევა ქვემოთ პირველი
ფაქტობრივი ხაზების კოდი.
Line 17 ჩათვლით ძირითადი.
Line 21 და 20 აქვს რამდენი ბოთლი ლუდი იქნება?
და მაშინ მე მოვუწოდებ GetInt.
და ახლა აქვს ცოტა საღი აზრის ქვითარი.
>> ასე რომ, ეს კონვენცია, რომ ჩვენ ახლა დავიწყოთ მიღებით, რათა
უფრო მკაცრად ამოწმებენ მომხმარებლის შეყვანის.
ზოგჯერ უბრალოდ არ მინდა უბიძგონ მათ ხელახლა
და ისევ და ისევ.
თუ მომხმარებლის ხრახნები მდე და არ ითანამშრომლებს, ჯარიმა.
Quit და უბრალოდ არ გაუმკლავდეთ მათ.
და ისე, რომ ის, რასაც მე ვაკეთებ აქ.
თუ n ნაკლებია, ვიდრე 1, მე უბრალოდ აპირებს დაწეროთ დროს მომხმარებელი,
"ბოდიში, რომ აზრი არა აქვს." და შემდეგ მე ვაპირებ
თვითნებურად დაბრუნების 1.
ასე რომ კიდევ ერთხელ, ეს მხოლოდ კონვენციის მისაღებად გამოიყენება.
ახლა მიიღოს ეს რწმენა.
მაგრამ დღემდე, ჩვენ ყოველთვის ბრუნდებიან 0, რადგან
ჩვენ განაცხადა დაბრუნების 0 აღნიშნავს რა?
აუდიტორია: წარმატება.
დევიდ ჯ Malan: წარმატება, ეს იყო.
ახლა, რომ ჩვენ საბოლოოდ დაწყებული ფიქრი
არასამთავრობო წარმატებები -
სხვა სიტყვებით, კუთხეში შემთხვევაში, შეცდომა პირობები -
ახლა კი ისეთი უსასრულო მიწოდება, ან თუნდაც ოთხი მილიარდი
შესაძლებელია რამ, რაც შეიძლება წავიდეთ არასწორი ჩემი პროგრამები.
და შემიძლია დაიწყოს მინიჭება მათ ინდივიდუალური ნომრები.
ახლა, ზოგადად suffices უბრალოდ დააბრუნოს
რაღაც სხვა ვიდრე 0.
ამიტომ, ჩვენ ვაპირებთ, უბრალოდ დააბრუნოს 1 ახლა.
მაგრამ მიზეზი დაბრუნების 1 ის არის, რომ როგორც კი დაბრუნდებიან
1, გამოიცანით რა ხდება დანარჩენ პროგრამაში?
იგი აჩერებს.
ეს არის ის.
ასე რომ ის ფაქტი, რომ მე დაბრუნების 1 არის ეფექტურად
მოკლე circuiting ამ პროგრამის შესრულების ისე, რომ
არაფერი ქვემოთ ხაზის 27 გაგრძელდება შესრულებაში.
როგორც კი მთავარ ანაზღაურება, რომელიც მას.
>> ყველა უფლება ასე რომ, თუ მომხმარებელს არ ითანამშრომლონ და მივაღწევთ ხაზი 30
იმიტომ, რომ ისინი აკრეფილი ლეგიტიმური ნომერი, აქ არის ჩემი
განხორციელების ეს სიმღერა.
ასე რომ პირველი ამობეჭდოთ სტრიქონების გადატანით ხასიათი, მხოლოდ
ესთეტიკას.
მე ახლა ამისთვის loop.
და შენიშნავს, მე ვაკეთებ რამ bit
საქართველოს სხვადასხვა მიმართულებით.
მე არ უნდა გავაკეთოთ ნაკლები, მე არ უნდა გავაკეთოთ + +.
მე შემიძლია ვთქვა, ნაცვლად ინიციალიზაცია ცვლადი i, ვაყენებთ მას ტოლი
N, ხმების მომხმარებლის აკრეფილი, მაშინ ნუ შემდეგ, ისე
სანამ მე მეტია 0, მაშინ მე -
ერთხელ თქვენ დასრულდა ერთი iteration ამ loop.
ასე რომ ჩვენ შეგვიძლია ითვლიან ქვემოთ გამოყენებით ამისთვის loop ისევე.
ახლა, ეს არის საკმაოდ ბევრი კვირაში ერთი პერსონალის ახლა, printf.
ამიტომ ბეჭდვითი "% d ბოთლი ლუდი კედელზე." ბეჭდვის "% d
ბოთლი ლუდი. "" Take ერთი ქვემოთ, გაივლის ირგვლივ. "ბეჭდვის
"% D ბოთლი ლუდი კედელზე." ასე რომ ჯერ კიდევ% d, მაგრამ
შეამჩნევთ, რომ არგუმენტი printf იცვლება.
შემდეგ მძიმე, მაქვს მე, რადგან მე მინდა ვთქვა, 99.
ამის შემდეგ მძიმე, მაქვს მე, რადგან მე მინდა ვთქვა, 99.
ამის შემდეგ მძიმე, მაქვს მე - 1, რადგან მე მინდა ვთქვა, 98 ში
ამ პირველი iteration და სხვ.
და ახლა ქვემოთ აქ, უბრალოდ გარკვეული სულელური პატარა შენიშვნა.
და შემდეგ ხაზი 42, მე დაბრუნებას 0 მიერ კონვენციის signifying რომ
ყველაფერი okay.
>> მერე რა რომ goofed?
რა შეიძლება ჩვეულებრივი შეცდომა აქ იყოს?
ისე, მე ვფიქრობ შემთხვევით განაცხადა კარგად, მეც მინდა დათვლა
ქვემოთ 0, მინდა 0 ბოთლი ლუდი კედელზე?
ასე რომ ვთქვა, მე მეტია ან ტოლია 0.
რა იქნება სიმპტომია, რომ მე ახლა ვხედავ, თუ recompile
beer1 და გაუშვით?
აუდიტორია: უარყოფითი.
დევიდ ჯ Malan: ჰო gonna go უარყოფითი.
ეს არის Off-by-ერთი შეცდომა, წარმოუდგენლად
ჩვეულებრივი შეცდომა, რათა.
მოდით რეალურად დავუბრუნდეთ ტერმინალის ფანჯარაში და გავაკეთებთ
აქ, ასე ვხედავთ მეტი დროს.
შეიყვანეთ, 99 ბოთლი ლუდი.
დახურვა, მაგრამ წავედით ოდესმე ისე ოდნავ შორს.
ჩვენ იმღერა სიმღერა ძალიან შორს ქვემოთ, ასეთი, რომ ჩვენ ახლა მოხვდა
უარყოფითი რიცხვი.
ასე რომ ეს არ საკმაოდ მუშაობა.
>> ყველა უფლება, ასე რომ ჩვენ შეგვიძლია ადვილად დაფიქსირება, რომ ბრუნდება
გზა, როგორიც ადრე იყო.
მაგრამ რა შესაძლებლობები ახლავე
გაუმჯობესება?
ისე, ნება მომეცით გახსნა beer2.c და გადახვევა ქვემოთ აქ და მიიღოს
შეხედეთ ამ ვერსიას.
რა არის პირველი რაც jumps out at თქვენ, როგორც სხვადასხვა
ამ ვერსიაში აქ?
აუდიტორია: [INAUDIBLE].
დევიდ ჯ Malan: ჰო, ასე აღარ ვარ, რადგან ეს მოხდა, რათა
ჩემთვის იცით, რა, მე გეკითხებით მომხმარებლის ამისთვის N, და შემდეგ მე
შექმნის მე ტოლია n, და შემდეგ მე იცვლება მე, მაგრამ მე არასოდეს
ეხება n ერთხელ.
მერე რა heck იყო წერტილი თქვენ გამოყოფის სხვა 32
ბიტი მოუწოდა მე მხოლოდ ისე, რომ შემიძლია აქვს სხვადასხვა ცვლადი?
ასე რომ, ამ შემთხვევაში, მე სახის აღიარა, რომ ზედმეტი
დიზაინის ფუნქცია.
და მე ახლა მიმდინარეობს იმის თქმა ხოლო n მეტია 0, წასვლა
წინ და ბეჭდვა იგივე სიმღერა, ჩაბარების n to printf როგორც
მეორე არგუმენტი, და N - 1 როგორც მეორე არგუმენტი ქვემოთ აქ.
და შემდეგ თითოეულ iteration ამ მარყუჟის, წავიდეთ წინ და მხოლოდ
decrement n თავად.
ახლა, ფუნქციურად, ამ პროგრამის
იქნება იდენტურია.
თუ მე აკრიფოთ 99, N იწყება 99.
მე decrement, decrement, decrement, decrement.
მე ვაპირებ მისაღებად ყველა გზა ქვემოთ "ერთი ბოთლი ლუდის შესახებ
კედელი, ერთი ბოთლი ლუდი.
მიიღეთ ერთი ქვემოთ, გაივლის ირგვლივ.
0 ბოთლი ლუდი კედელზე. "ბოლომდე, რადგან მე
მიიღეთ მდგომარეობა სწორი.
ეს მეტია 0.
მე არ მიიღოს ეს შეცდომა.
>> ასე რომ რაც უკეთესი, ვერსია ერთი ან ორი ვერსია?
ასე გავიგე bunch of murmurings ორი.
რატომ ორი?
რა არის ეს?
აუდიტორია: [INAUDIBLE].
დევიდ ჯ Malan: Oh, okay.
ასე რომ, ეს არ გამოვა ქვემოთ 0, მაგრამ გვახსოვდეს, რომ ერთი ვერსია,
ორიგინალური სწორი ვერსია არ წასვლა ქვემოთ 0 ან.
ასე რომ გვახსოვდეს, რომ ეს არის სწორი ვერსია.
მოდით მინიმუმ შეადაროთ ორი სწორ ვარიანტებს.
რა არგუმენტს ვერსია
ორი მყოფი, Mmm, უკეთესი?
ჰო?
აუდიტორია: იგი იყენებს ნაკლებად სივრცეში.
დევიდ ჯ Malan: Okay, ასე რომ იყენებს ნაკლებად სივრცეში, არა?
ვინაიდან ვერსია ერთ გამოიყენება 32 ბიტი for N, და შემდეგ სხვა
32 ბიტი მე.
ვერსია ორი მხოლოდ იყენებს 32 ბიტს ამისთვის N, ისე, რომ
როგორც ჩანს, პლუს.
სხვა აზრები?
ვინმეს მინდა მოგიწოდოთ სასარგებლოდ ერთი?
ჰო?
აუდიტორია: თქვენ უნდა გამოიყენოთ დამატებითი ხაზი კოდი N -.
>> დევიდ ჯ Malan: Okay, დარწმუნებული.
ასე რომ სამართლიანი.
ასე რომ, ეს უბრალოდ, სულ მცირე ჩემთვის -
მე ვგულისხმობ, ამ რეალურად გრძნობს პატარა messier, ის ფაქტი, რომ
მე ვერ სახის encapsulate ყველა ჩემი ლოგიკით ერთ
ლამაზი ხაზი, ამისთვის მარყუჟის, როგორც ამისთვის loop შეგიძლიათ.
აქ, მე სახის უნდა Tack ამ N -
დასასრულს მარყუჟის, რადგან
ეს ლოგიკურად საჭირო.
მაგრამ ეს სახის rubs ჩემთვის არასწორი გზა, მხოლოდ იმიტომ, რომ იგი
როგორც ჩანს ცალკე საწყისი ლოგიკა აქ, მიუხედავად იმისა,
ერთხელ, აუცილებელია.
სხვა აზრები?
ჰო?
აუდიტორია: [INAUDIBLE].
>> დევიდ ჯ Malan: ჰო.
მერე რა, რომ თქვენ მაგივრად, დასასრულს სიმღერა, სურდა
ამობეჭდოთ ისევ სახელით სიმღერა?
როგორც "წყალობით სათამაშოდ 99 ბოთლი ლუდი", ან რაღაც
სულელური ასე?
მაგრამ საქმე იმაშია,, თქვენ სურდა ხელმისაწვდომობის ორიგინალური ღირებულება.
ის ფაქტი, რომ თქვენ mutated ან იცვლება N ყოველ
iteration და ამიტომ არ გაანადგურეს პირვანდელი ღირებულება
იმას ნიშნავს, თქვენ უბრალოდ ვერ გავაკეთოთ, რომ დასასრულს.
ახლა, სავარაუდოდ, ჩვენ ნათლად არ სურს
რომ ამ პროგრამაში.
ასე რომ, ვინც ზრუნავს?
მაგრამ ეს ძალიან მოქმედებს წერტილი.
და იყოს პატიოსანი, იქ ნამდვილად არავინ
სწორად უნდა უპასუხოს აქ.
ისინი ორივე ერთნაირად სწორი.
მე შეიძლება დაარწმუნა არც გზა.
მინდა ვთქვა, რომ, ზოგადად, ეს კარგი პრინციპი თუ
სთხოვა მომხმარებლის გარკვეული ღირებულება და შენახული ცვლადი
მოსწონს N, უბრალოდ სახის პრინციპულად, ეს ალბათ კარგი
შენარჩუნება, რომ გარშემო.
და ნებისმიერი მონაცემების გსურთ mutate ისევ და ისევ, მხოლოდ
მისცეს თავის ასლი, რომ ცვლადი, მხოლოდ ისე, რომ თქვენ
ხელი მიუწვდება ორიგინალური.
თქვენ ხარჯავს 32 მეტი ბიტი, მაგრამ რეალობა ის არის, ამ
კომპიუტერი, ისევე როგორც, ორი გიგაბაიტი ოპერატიული მეხსიერება ამ დღეებში,
და ჩვენ quibbling ზე 32 ბიტი?
ნამდვილად არ ასეთი დიდი გარიგება.
და თუნდაც ამ მოწყობილობის აქ, ერთად ნახევარი GIG ან
Gigabyte of RAM, 32 ბიტი წინააღმდეგ 64 ბიტი,
არა ეს დიდი გარიგება.
რა თქმა უნდა დღეს, ეს იქნება გზა გადაატვირთული მიერ ზომა
პროგრამის თავად, რომელიც იქნება რამდენიმე ასეული
kilobytes, თუ არა რამდენიმე მბ, ამ დღეებში.
>> ამიტომ გონივრული შეშფოთება, არავის უფლება პასუხი.
მაგრამ მაინც ეს ის აზრები რომ უნდა დაიწყოს
გავლა თქვენი აზრით?
რადგან pset 0, მიუხედავად იმისა, რომ ჩვენ ნამდვილად მხოლოდ მოსალოდნელია
სისწორე, ან თუნდაც უარყოფდა სხვადასხვა შეცდომები, რომ
თქვენ შეიძლება არ შეექმნა, მივიწევთ, დიზაინი
იქნება კიდევ ერთი გასაღები ასპექტი, როგორც წერის კოდი
და ასევე ჩვენი შეფასებისას კოდი.
და ასე მინიმუმ მისცეს აზრის რამ მოსწონს ეს.
და მხოლოდ იმიტომ, რომ რაღაც სამუშაოები არ ნიშნავს კარგია,
არ ნიშნავს, რომ ის კარგად დაპროექტებული.
და ეს ერთი რამ სწავლების პრაქტიკის და
პრობლემა კომპლექტი დაგვეხმარება აჯავრებენ ნაწილი დროთა განმავლობაში.
>> ისე, რაც შეეხება, ვთქვათ, ეს ვერსია აქ?
ნება მომეცით რაღაც პატარა sexy აქ მომენტი.
პირველი ნება მომეცით დავაღწიოთ ამ.
და ახლა მოდით დაფიქსირება ამ გრამატიკული საკითხი.
ასე რომ, ეს ვერსია, მინდა დაფიქსირება გრამატიკა ასე რომ,
ვიდრე უბრალოდ, ვამბობთ ჩართული s, როგორიცაა "ბოთლი"
ან "ბოთლი" -
მე არ მინდა, რომ გაჭრა კუთხეში -
მინდა ასევე დინამიურად ამობეჭდოთ სიტყვა "ბოთლი"
ან "ბოთლი", რითაც გამოყენებით ამ% s placeholders დღეს.
ასე რომ მე უნდა პირობითად შეამოწმოთ რა არის ღირებულება მე.
და თუ ის 1, მინდა ვთქვა, "ბოთლი", და თუ ეს არაფერი
სხვაგან, მინდა ვთქვა, "ბოთლი". მოდით ცდილობენ ამის გაკეთებას.
ასე რომ, თუ მე == 1, მაშინ ნება მომეცით წავიდეთ წინ და აცხადებენ -
მჭირდება სიმებიანი, ნება მომეცით, გავაკეთოთ სიმებიანი S1, რადგან ეს
პირველი სტრიქონი მე აინტერესებს ახლავე.
მე ვაპირებ ვთქვა "ბოთლი". და შემდეგ, ვნახოთ, string
S2 - მე კი განმარტავენ, სადაც მე ვაპირებ წელს მომენტში -
"ბოთლი". ასე რომ გავიხსენოთ, რომ ეს სიმღერა, ჩვენ უნდა შევძლოთ
ბეჭდვა რამ, ორი სხვადასხვა სიტყვა პოტენციურად.
ასე რომ, თუ ჩვენ ვიხსენებთ აქ შეამჩნევთ, რომ როდესაც ჩვენ მისაღებად
ეს მაგალითი აქ, "ორი ბოთლი ლუდი კედელზე,
ორი ბოთლი ლუდი, მიიღოს ერთი ქვემოთ, გაივლის ირგვლივ ", მინდა
ამ მეოთხე ხაზი ახლა ამბობენ "ერთი ბოთლი ლუდის შესახებ
კედლის ". ამიტომ მე უნდა გადაწყვიტოს, რა მინდა ვთქვა" ბოთლი "ან
"ბოთლი"? ამიტომ მე ვაპირებ თვითნებურად ამბობენ, ყველა უფლება,
მე ვაპირებ ახლა განაცხადოს ცვლადში S1, string
ერთი, რომ აპირებს კიდევ plugged აქ და ასევე აქ,
რადგან ეს სიტყვები ყოველთვის იდენტურია, მხოლოდ იმიტომ, რომ
ბუნების სიმღერა.
მე ვაპირებ მოვუწოდო s2 რასაც სიტყვა მინდა
საბოლოოდ გამოჩნდება ქვემოთ აქ.
ახლა, სიტყვასიტყვით, 99 ჯერ აქედან 100, ეს იქნება
იგივე ორივე შემთხვევაში, რადგან 3 არის მრავლობითი, 2 არის
მრავლობითი, 4 პლურალურია.
მაგრამ ამ შემთხვევაში კუთხეში, სადაც მივიღებთ დან 2 და შემდეგ 1, ან
კიდევ 1 და შემდეგ 0, მჭირდება ამ ლოგიკით.
ასე რომ უნდა გარკვეული დრო გაატაროს ჩემი კოდი მიღების უფლება, რომ.
ასე რომ, თუ ამ, თუ == 1, მაშინ მითითებული S1 ტოლია "ბოთლი"
და s2 ტოლია "ბოთლი", რადგან ეს იქნება 1
ბოთლი, და ეს იქნება ამისთვის 0 ბოთლებში.
და ეს აქ, რას წარმოადგენს?
უბრალოდ უნდა იყოს წმინდა.
ეს არის მხოლოდ კომენტარი.
ასე რომ ის ფაქტი, რომ თქვენ შეგიძლიათ ერთხაზიანი კომენტარი იმას ნიშნავს, თქვენ
შეიძლება კომენტარი თქვენი კოდი მოსწონს, მაგრამ კიდევ ერთი საერთო
პარადიგმა, ძალიან, არის, რომ, თუ თქვენ გაქვთ სუპერ მოკლე ფრაზა, რომ
გსურთ დააყენა თავის და უბრალოდ მეტი იკითხება დააყენოს
ეს უფლება დასასრულს ხაზი კოდი, თქვენ შეგიძლიათ
აბსოლუტურად რაღაც მოსწონს ეს.
>> ახლა მე ვფიქრობ ამის გაკეთება? Else თუ არ არის ტოლი 1.
ამიტომ bang შეადგენს -
ძახილის წერტილი ცნობილია როგორც "bang".
ამიტომ bang = 1.
ასე რომ, თუ მე არ ტოლია 1, რა ნაცვლად გსურთ?
ისე, პირველი სიტყვა მინდა იყოს რა?
ამიტომ string 1 უნდა იყოს "ბოთლი" ამისთვის მრავლობითი ბოთლები,
და მაშინ ეს იქნება მრავლობითი "ბოთლი", ისევე, ახლა.
და ვნახავთ, თუ ეს რეალურად იღებს გვაძლევს
სად გვინდა წასვლა.
ახლა თუ გადახვევა ქვემოთ აქ, რომ მე ჩართვის
არა მარტო მე, არამედ S1.
მე ჩართვის მე და S1.
და შემდეგ ქვევით აქ, მე მინუს 1, რომელიც იგივეა, რაც
ადრე, მაგრამ S2.
სხვა სიტყვებით, მინდა ინგლისური სიტყვა შეცვალოს საფუძველზე
ამ ლოგიკით.
ახლა უკვე გარკვეული პრობლემები ამ კოდექსში.
რა ბრალია უკვე გარეთ კარიბჭე აქ?
ჰო?
აუდიტორია: [INAUDIBLE].
>> დევიდ ჯ Malan: ზუსტად.
ასე რომ მე უკვე დაარღვია გაკვეთილი ფარგლებს.
ამიტომ მე განაცხადა S1 და S2, მაგრამ მე ვაკეთებ ამას შიგნით
Curly braces, რაც იმას ნიშნავს, yeah, ამ კოდექსით იმუშავებს up
სანამ ხაზი 42, მაგრამ როგორც კი მოხვდა ხაზი 43, გამოიცანით რა არ
აღარ არსებობს?
ისე, მიხვდები რა აღარ ფარგლებს - არც S1 ან S2.
ამიტომ, ჩვენ უნდა დაფიქსირება ამ.
ნება მომეცით წაშლა დეკლარაციების.
მე დავტოვებთ ცვლადი სახელები და წაშლა ამ აქ
და წაშლა ამ აქ.
და რა ხაზები უნდა ნამდვილად განაცხადოს ეს ყველაფერი?
აუდიტორია: [INAUDIBLE].
დევიდ ჯ Malan: ჰო, ასე ალბათ
უფლება აქ, 33-ish.
ამიტომ სიმებიანი S1 და შემდეგ სიმებიანი S2.
და თურმე, შემიძლია ამის გაკეთება.
თუ თქვენ გამოცხადების ორი ცვლადი იგივე ტიპის,
შეგიძლიათ რეალურად მხოლოდ გამოიყენოთ მძიმით და გავაკეთოთ, რომ C. ყველა
უფლება, ამიტომ ახლა მე ორი ცვლადის -
S1 და S2.
მე მინიჭება მათ ღირებულებებს ამ
პირობები აქ, ან აქ.
და მაშინ მე გამოყენებით მათ ქვემოთ ქვემოთ.
რამდენად კარგად არის ეს ახლა იმუშავებს?
>> ისე, ეს მაინც ცოტა buggy, მაგრამ მოდით მინიმუმ ვხედავ
რამდენად შორს ჩვენ მიღებული.
ნება მომეცით, წავიდეთ წინ და მიიღოს beer3.
ეს beer3?
Yep, ეს არის beer3.
და ახლა ნება მომეცით წავიდეთ წინ და აწარმოებს beer3.
399 99.
ჩვენ შეგვიძლია ალბათ გამოტოვოთ მათი უმრავლესობა.
და ქვემოთ აქ, შევხედოთ, რომ.
"ერთი ბოთლი ლუდი კედელზე, ერთი ბოთლი ლუდი, მიიღოს
ერთი ქვევით, გაიაროს ეს გარშემო, 0 ბოთლი ლუდი კედელზე. "
მაგრამ მე ხატვის თქვენს ყურადღებას მხოლოდ ნახევარი გადაწყვეტა.
სახის ბრალია აქ.
ასე რომ, როგორც ჩანს, კუთხეში შემთხვევებში წარმოიქმნება როცა შეადგენს რა
ორი ღირებულებები?
აუდიტორია: 2, 1.
დევიდ ჯ Malan: 2 და 1.
ეს არ არის 1 და არა 1.
ეს მართლაც მხოლოდ ამ ბოლო ორი stanzas ამ სიმღერას.
რა შემიძლია ნაცვლად გსურთ?
ასე რომ, როგორც ჩანს, არ დაიჭირეს შემთხვევაში თუ არის == 1,
მაშინ პირველი სიტყვა არის "ბოთლი", მაგრამ მეორე სიტყვა
არის "ბოთლი". მაგრამ აქ, მინდა, რომ შეიცვალოს ეს უნდა იყოს == 2.
და თუ ეს საქმე, რა უნდათ
პირველი სიტყვა უნდა იყოს?
აუდიტორია: "ბოთლები".
დევიდ ჯ Malan: "ბოთლები", ასე რომ ორი ბოთლი.
და შემდეგ ეს სიტყვა აქ უნდა იყოს -
აუდიტორია: "ბოთლი".
დევიდ ჯ Malan: "ბოთლი", სინგულარული.
>> ყველა უფლება, მოდით დააშორებს, დაბრუნდეს აქ, ხელახლა აწარმოებს გააკეთოს,
ხელახალი პერსპექტივაში beer3, ტიპის 99 ერთხელ.
Okay, "სეგმენტაციის ბრალია (ბირთვი dumped)."
რა არ მე დავაშავეთ?
აუდიტორია: თქვენ არ ღირებულება [INAUDIBLE].
დევიდ ჯ Malan: Ah, კარგი წერტილი.
ყველა უფლება, ასე რომ არასწორი აქ?
ასე რომ სეგმენტაციის ბრალია, და ჩვენ რეალურად აპირებს ვხედავ
ამ საკმაოდ რამდენჯერმე მომავალში, შეგნებულად.
მაგრამ ახლა, რას ნიშნავს რეალურად?
სეგმენტაცია ბრალია თითქმის ყოველთვის ნიშნავს, რომ თქვენ გაქვთ
როგორღაც ცდილობდა წვდომისათვის მეხსიერება, RAM თქვენს კომპიუტერში,
რომ არა ხართ საკუთარი, რომ თქვენ რეალურად არ სთხოვა
ოპერაციული სისტემა.
ასე რომ, ამ შემთხვევაში, შეამჩნია რა მე ვაკეთებ, რაც
გაყალბდა ჩემი ლოგიკა.
მე არ ენიჭება S1 და S2 ღირებულება თუ უდრის 1.
მე ასევე კეთდება, რომ თუ შეადგენს 2.
მაგრამ მე არ გაკეთდეს ეს უსასრულო რიგი სხვა
შესაძლებლობები -
კერძოდ, 3 ან 4 ან dot, dot, dot, 99.
ასე რომ ერთი სარემონტო ამ შეეძლო მხოლოდ მოდით
აქვს სხვაგან მდგომარეობა.
და ნება მომეცით წავიდეს აქ და ვთქვათ S1 შეადგენს -
რა უნდა იყოს აქ?
აუდიტორია: [INAUDIBLE].
>> დევიდ ჯ Malan: "ბოთლები", რადგან საერთო შემთხვევაში,
უბრალოდ იგივე.
ამიტომ შეადგენს ციტირებით, unquote, "ბოთლი". ასე რომ მრავლობითი
ბოთლები, და შემდეგ აქ, ამისთვის მრავლობითი ბოთლებში.
Okay, ახლა ნება მომეცით დაბრუნდეს ჩემი ტერმინალის ფანჯარა,
recompile, ხელახლა გაუშვით.
99.
Whew.
და მოდით სწრაფი საღი აზრის ქვითარი.
ტექნიკურად ჩვენ ავღნიშნო მინდა წაიკითხონ ყველა ამ დარწმუნდეთ
ისინი ზუსტი, მაგრამ მოდით შევხედოთ
მაინც ცნობილი დამნაშავეები.
3 ბოთლი, 2 ბოთლი, 2 ბოთლი, 1
ბოთლი, 1 ბოთლი, 0 ბოთლებში.
ჩვენ, როგორც ჩანს, მაინც დაფიქსირდა ის არის.
მაგრამ დაჭერა აქ არის ის, რომ რა ღმერთი საშინელი ხმაური ეს
უბრალოდ გადაჭრის სულელური
ერთი ხასიათი გრამატიკული დეტალურად.
ასე რომ არსებობს სახის მიზეზის გამო, რომ მე გაჭრა ამ კუთხეში
ადრე, რადგან ის უბრალოდ სრულიად შემაშფოთებელი უნდა უნდა
წერენ ამ ბევრად კოდი.
მაგრამ აღმოჩნდება, რომ იქ ოდნავ უფრო ელეგანტური გზები
გამოხატავს ზუსტად იგივე რამ.
და ჩვენ შეგვიძლია გავაკეთოთ ეს შემდეგნაირად.
>> ნება მომეცით დატოვეთ ეკრანზე ერთი მომენტი და
შემოიღონ რაღაც ცნობილი როგორც ternary ოპერატორს.
ეს არის სახის ერთი ლაინერი ეს მხოლოდ იმას ნიშნავდა, რომ ჩვენი
ცხოვრობს პატარა sexier, როგორც დაჰპირდა.
და მე ვაპირებ ამის გაკეთება შემდეგნაირად.
მომეცი სიმებიანი მოუწოდა S1, და ნება მომეცით
მივანიჭოთ შემდეგი რედაქციით.
(I == 1)?
"ბოთლი", წინააღმდეგ შემთხვევაში "ბოთლი". სიმებიანი s2 იღებს (მე == 2)?
"ბოთლი", წინააღმდეგ შემთხვევაში "ბოთლი".
მერე რა მაშინ არის განსხვავება აქ?
ეს ორი ხაზი კოდი, მე ამტკიცებენ, შეიძლება
შეცვალეთ ეს მთელი სასადილო.
ასე რომ ეძახით სასადილო, მხოლოდ იმიტომ, რომ იგი სახის rubs me
არასწორი გზა, რომ ამდენი ხაზები კოდი.
არ არასწორია.
ეს არ არის ცუდი დიზაინი.
ისევე, ეს შესანიშნავად სწორი და შესანიშნავად ჯარიმა.
მაგრამ კოდირების იღებს რუტინული თუ თქვენ უნდა გამოხატოს თავის ასე
Damn კონკრეტულად ისევ და ისევ და ისევ და ისევ მარტივი
სცენარი მოსწონს ეს.
ამიტომ C აქვს გარკვეული კომბინაციები, მოსწონს ეს.
ასე რომ, ეს არსებითად ამბობს, განაცხადოს სიმებიანი მოუწოდა S1 და
მივანიჭოთ მას არც ამ მნიშვნელობის ან ამ მნიშვნელობის თუ არის == -
უკაცრავად, მინდა გითხრათ, ამ უფრო ნათლად.
განაცხადოს ცვლადი S1, მივანიჭოთ ის მნიშვნელობა, თუ ეს მართლაც ასეა.
წინააღმდეგ შემთხვევაში, დაავალოს ეს მნიშვნელობა.
ასე რომ, სხვა სიტყვებით, ეს არის ერთგვარი ერთი ხაზის გზა
ამბობდნენ, თუ სხვაგან მაგრამ ამით დავალება გასწვრივ გზა.
ასე რომ, თუ მე არის 1, მაშინ წავიდეთ წინ და დაარქვით "ბოთლი". და
მაშინ ეს სხვას, მას "ბოთლი". იმავდროულად, S2,
მეორე სიტყვა, რომელიც ჩვენ გვჭირდება, რომ განსაზღვროს, თუ უდრის 2, ჩვენ
მითითებული s2 რომ "ბოთლი". წინააღმდეგ შემთხვევაში, ვაყენებთ მას "ბოთლი". და რა
ეს იმას ნიშნავს, ახლა შემიძლია გავლა ამ და წაშლა ყველა
იმ ხაზების კოდი.
და როდესაც ვამბობ, რომ, გარკვეულწილად ridiculously, რომ ეს არის
sexier, ეს sexier წელს სახის სტილისტური გრძნობა.
იმისა, რომ ფუნქციურად კოდი რეალურად აპირებს
გააკეთოს ზუსტად იგივე რამ.
და მიუხედავად იმისა, რომ შეიძლება პატარა cryptic თავდაპირველად
ერთი შეხედვით, რადგან ჩვენ არ უნახავს ამ შენება ადრე, მინდა
ამტკიცებენ, რომ ის საბოლოოდ იქნება ასე უფრო მეტი
იკითხება და იმდენად ადვილი ჩვენ ადამიანები, რათა სახის
მესმის, რადგან ახლა თქვენ შეგიძლიათ უბრალოდ წაიკითხა
კოდი ყველა ერთ ხაზს.
ეს ჯერ კიდევ მსგავსი სულისკვეთებით უნდა თუ, სადაც ეს არის
მდგომარეობა და შემდეგ ეს რა შიგნით თუ და ამ
არის რა შიგნით სხვას.
მაგრამ ჩვენ შეგვიძლია გავაკეთოთ ეს უბრალოდ ბევრად უფრო ელეგანტურად.
>> და თუ ახლა დავუბრუნდეთ ჩემი ტერმინალი, რომელმაც წაიშალოს ყველა
იმ ხაზები და შეცვალა მათ მხოლოდ ამ ორ,
recompile, ხელახლა პერსპექტივაში ბოთლი ლუდის 99 შეამჩნევთ, რომ ჩემი
გრამატიკა არის, ფაქტობრივად, დღემდე სწორი.
ასე რომ კიდევ ერთხელ, რაღაც უნდა დაწყებულიყო.
2 ბოთლი ლუდი, 1 ბოთლი ლუდი.
გამოიყურება უფლება.
Yeah.
ასე რომ გვაქვს ბევრად უფრო ლაკონური გადაწყვეტა.
ასე რომ, ეს, ძალიან, როგორც თქვენ მიიღებთ უფრო კომფორტულად C, არ
ემთხვეოდეს პირველი pset ან თუნდაც მეორე, მაგრამ
გააცნობიეროს, რომ ეს აშენებს შეგიძლიათ საშუალებას მოგვცემს გავაკეთოთ რამ ოდესმე
უფრო ელეგანტურად.
ახლა მოდით ერთი სხვა რამ აქ.
ნება მომეცით წავიდეთ წინ და ქმნის return1.c.
ახლა დავიწყოთ გადაჭრას ერთი პრობლემა ისე, რომ
საშუალებას გვაძლევს დავწეროთ უფრო დახვეწილი კოდი.
>> ასე რომ აქ მარტივი პატარა პროგრამა, რომლის მიზანი ცხოვრებაში
არის ნამატი ღირებულებებს.
და ფაქტობრივად, ავიღოთ უკან გადადგმული ნაბიჯია.
ნება მომეცით ამის გაკეთება ხელით.
ნება მომეცით გავაკეთოთ მოიცავს და int ძირითადი (void).
და ნება მომეცით დაარქვით increment.c.
და რა გსურთ?
მე ვაპირებ წავიდეთ წინ და ვთქვათ რაღაც -
ჩვენ მოვუწოდებთ ნომრები იგივე -
int x.
ასე int x იღებს 2; printf x არის% d, ახალი ხაზი, x.
ამიტომ მე აკრეფით სწრაფად, მაგრამ სახის ნაცნობი პერსონალის არის.
მაშინ მე აპირებს x + +.
მაშინ მე ვაპირებ ბეჭდვა იმავე სასჯელს კვლავ.
და შემდეგ მე ვაპირებ დაბრუნებას 0 მხოლოდ დატოვა პროგრამა.
ყველა უფლება, ასე რომ ეს არის პროგრამა, რომელიც
increments ნომერი.
ეს პირველი აპირებს ინიციალიზაცია რაღაც 2, და შემდეგ ეს
აპირებს ნამატი იგი და დაბეჭდეთ ერთხელ.
>> მოდით აწარმოებს წუთობრივი, წარმოუდგენლად მარტივი პროგრამა.
მაგრამ ვარაუდობენ, რომ მინდა კუბი ღირებულება, ასე რომ
რაღაც გარკვეულწილად თვითნებური.
მე რეალურად გსურთ x იღებს კუბი იგი.
ასე რომ მე ვერ გამოიყენებს რასაც POW ფუნქცია, მაგრამ არ
ნამდვილად ვიცი, სად, რომ ჯერ კიდევ არ არის.
ამიტომ მე ვაპირებ ამის გაკეთებას მოძველებული გზა.
x ჯერ ამ უდრის x ჯერ x ჯერ x.
ამიტომ მე cubing ღირებულება, გამრავლებით ეს თავისთავად ერთხელ
და ისევ და ისევ, ისე, რომ არ მივიღებთ ძალა
3 ამ შემთხვევაში.
ახლა ციფრები უნდა ბეჭდვა უნდა იყოს, როგორც ჩვენ დავინახავთ
აქ - გაამწვანე წუთობრივი, ამიტომ რეალურად ნამდვილად არ იყოს
აღარ, მაგრამ ჩვენ დავტოვებთ სახელი მარტო -
2 და შემდეგ 8.
ახლა ჩვენ გვყავს დასაწყისი შესაძლებლობა დახვეწას
აქ, სადაც ამ cubing რამ საქართველოს გამრავლებით ნომერი
თავისთავად თავისთავად თავისთავად იგრძნობა ეს შეიძლება იყოს მხოლოდ
სასარგებლო ჰქონდეს როგორც ფუნქცია, ჰგავს ვინმე გადაწყვიტა
წლის წინ - იცით, როგორი სასარგებლო თუ რომელიმე ჩვენგანი ზის ქვემოთ
და წერს printf ისე, რომ დანარჩენ მსოფლიოსთან შეგიძლიათ მისი გამოყენება,
რატომ არ გვაქვს დასხდნენ და დაწეროთ ფუნქცია მოუწოდა კუბი
რომ აკეთებს ამას cubing ჩვენთვის, ამიტომ ჩვენ არ გვაქვს ხელით
განახორციელოს ცნება cubing ღირებულებების აქ?
>> ასე მარტივი მაგალითი, მაგრამ მოდით წავიდეთ წინ და გამოიყენოთ ეს არის როგორც
შესაძლებლობა დავწეროთ ჩვენი საკუთარი ფუნქცია.
ასე რომ ჯერჯერობით ჩვენ მხოლოდ გამოყენებული ძირითადი და ჩვენ გამოყენებული სხვა
სახალხო ფუნქციებს, მაგრამ ჩვენ არ წერია ჩვენი საკუთარი.
ასე რომ აქ ჩვენ მივდივართ.
მე ვაპირებ წავიდეთ წინ და დაწეროთ ფუნქცია მოუწოდა კუბი.
და მე ვაპირებ აქვს მიიღოს შეყვანის.
ამიტომ მისი შეყვანის იქნება მთელი რიცხვი.
და რა არის ეს გაკეთებას აპირებს?
ის აპირებს გამოაცხადოს int გამომავალი = შეყვანის ჯერ შეყვანის
ჯერ შეყვანის.
და მაშინ ის დაბრუნებას აპირებს, რომ გამომუშავება.
და მერე უნდა იყოს კონკრეტული ახლა.
ეს ფუნქცია დაბრუნებას აპირებს int.
ასე რომ აქ მაშინ ასე მინდა დაწეროთ ფუნქციები.
თქვენ პირველი გადაწყვიტოს რა სახელი თქვენი
ფუნქცია იქნება.
და საერთოდ, რაღაც განმარტებითი კარგია, ასე რომ მე
ეძახით კუბი.
მაშინ თქვენ უნდა მიუთითოთ ის დაბრუნებას აპირებს, რა
მისი გამომავალი იქნება.
და ჩვენ არ გვაქვს, რომ ბევრი პარამეტრით ამჟამად.
Int, char, ათწილადი, bool, სიმებიანი.
ახლა მე ვაპირებ გამყარებაში int, რადგან მინდა ეს
დაბრუნების რიცხვი.
მაშინ თქვენ უნდა მიუთითოთ მისი საშუალებებით, მათი არსებობის შემთხვევაში, რომლებიც.
და თუ კუბი იღებს არგუმენტი, იღებს რაღაც შორის
ფრჩხილებში, თქვენ უნდა მივცეთ, რომ არგუმენტად სახელი ისე, რომ
შეგიძლიათ ეძახით რაღაც როგორც თქვენ განხორციელების ან წერილობით
ამ ფუნქციის, და თქვენ უნდა მისცეს მას ტიპი, რომელიც ამ
შემთხვევაში იქნება int.
ასე მოკლედ, კუბი არის ფუნქცია, რომელიც იღებს მთელ რიცხვს
როგორც შეყვანის და ანაზღაურება რიცხვი როგორც გამომუშავება.
>> ასე რომ რას ვუყოთ, რომ შეყვანის?
კარგად, შეესაბამება 14, ვაცხადებ ცვლადში გამომუშავება, და მე
დაავალოს ეს ღირებულება, შეყვანის ჯერ შეყვანის ჯერ შეყვანის.
და მერე დაბრუნდნენ გამომუშავება.
ასე როგორ უნდა გამოვიყენო ეს მაშინ?
რა შევცვალო ეს ხაზგასმით გმირები on line
7 უნდა, როგორ ფიქრობთ?
აუდიტორია: [INAUDIBLE].
დევიდ ჯ Malan: ჰო, ასე Cube of x.
ასე რომ X არის ცვლადი, რაც იმას ნიშნავს, იგი აჩერებს გარკვეული მნიშვნელობა.
საბედნიეროდ, ეს ტიპის რიცხვი.
და რადგან x არის int, რაც იმას ნიშნავს, მე ვერ გაივლის მას კუბი.
და მიუხედავად იმისა, მე უმთავრესი ღირებულება x ღირებულების
საქართველოს Cube x, როგორც უკვე შემთხვევაში ჯერჯერობით ნებისმიერ დროს
თანაბარი ნიშანი და ხაზი კოდი, პერსონალის მარჯვენა
იღებს შესრულებული და შემდეგ იღებს ენიჭება
ღირებულება მარცხენა.
ასე რომ ბრძანებით ოპერაციების არის როგორც ჩვენ ვიმედოვნებთ.
ასე რომ ჯერ ეს სამუშაო?
ისე, ნება მომეცით დაცემას აქ.
ნება მომეცით გახსენით ჩემი ტერმინალის ფანჯარაში.
ნება მომეცით არ მიიღოს წუთობრივი, შეიყვანეთ.
"იმპლიციტური დეკლარაცია ფუნქცია" კუბი "არასწორია წელს
C99. "როგორც განზე, c99 ეხება ენა C, როგორიც იყო
განისაზღვრა 1999 წელს, რომელიც იყო update ზე მეტი ვერსია საწყისი
1989, რომელიც განახლების მეტი ორიგინალური.
ასე რომ ყველა უნდა ნიშნავდეს ეს.
>> ასე რომ რას ნიშნავს, რომ "დაფარული დეკლარაცია
ფუნქცია "კუბი" არასწორია? "ეს უფლება აქ.
ეს უფლება იქ ხაზი 12.
აუდიტორია: [INAUDIBLE].
დევიდ ჯ Malan: რა არის ეს?
აუდიტორია: ეს არ იყო მანამდე.
დევიდ ჯ Malan: ეს არ იყო მანამდე.
ასე რომ, ეს რამ.
C არის სახის სულელური, ან C compilers არიან სახის სულელური.
ისინი მართლაც მხოლოდ რა თქვენ ვუთხრა უნდა გააკეთოს.
და ისინი, კერძოდ, მხოლოდ წაიკითხა თქვენი კოდი ყველაზე ქვედა,
მარცხნიდან მარჯვნივ.
ასე რომ, თუ შემდგენელი, Clang, კითხულობს თქვენი კოდი, ხაზი 1: იგი
გათვლით თუ როგორ გააკეთოთ ეს.
ოჰ, აქ მოდის მთავარი.
Okay, ნება მომეცით წავიდეთ წინ და აცხადებენ ცვლადი x.
ნება მომეცით ბეჭდვა რაღაც.
Line 7, რა heck არის კუბი?
ეს არ გამოცხადდა stdio.h.
იგი არ მოდის ერთად C. არ ვიცი რა უნდა გააკეთოს.
და ასე Clang მხოლოდ bails და ტოვებს, რომ შეცდომა.
ასე რომ ჩვენ შეგვიძლია დაფიქსირება ამ რამდენიმე გზები.
ჩვენ შეგვიძლია ვასწავლოთ Clang რა კუბი არის მხოლოდ მოძრავი სადაც
დეკლარაცია არის.
ასე რომ გაჭრა და pasted ეს atop ძირითადი.
ახლა ვაცნობიერებთ, რომ მხოლოდ იმიტომ, რომ ძირითად აღარ არის პირველი, ეს
დღემდე შესრულებული იყოს.
მთავარი არის მთავარი.
ეს რა ფუნქცია სახელი.
არ აქვს მნიშვნელობა, სადაც ეს არის ფაილი.
მაგრამ მაინც არის Clang უნახავს კუბი ადრე მე გამოიყენოს იგი.
მოდით ვნახოთ, თუ Clang არის ბედნიერი არის.
ჩადება ნამატი, ეს ასე კომპილირდება ამ დროს.
>> ნება მომეცით აწარმოებს იყოს.
მართლაც, აშკარად ჩანს, რომ სამუშაო.
ახლა თქვენ შეგიძლიათ ამუშავება სცენარი საბოლოოდ აქ
ეს არ არის მიზანშეწონილი დააყენოს ყველა ფუნქცია
ზემოთ ყველა სხვა ფუნქცია.
თქვენ მიიღებთ დავრჩებოდით ამ უსასრულო ციკლი რეალურად,
აქ ამ ბიჭს სურს იყოს აქ, მაგრამ ამ
ბიჭი უნდა იყოს იქ.
ასე რომ ყოველთვის არ იმუშაოს.
ასე რომ საბედნიეროდ, C უფრო ელეგანტური გამოსავალი.
მე ვაპირებ დააყენა ამ თავში, სადაც იგი იყო, მხოლოდ იმიტომ, რომ მე
ურჩევნია, როგორც პრინციპული საკითხია, რომ ძირითადი ყოველთვის
ზედა, რადგან ეს მხოლოდ ლამაზი, რომ ნახოთ თუ რა ამ პროგრამის
არ იყოს.
და რა მე ვაპირებ ამის გაკეთებას აქ არის განაცხადოს, რასაც
პროტოტიპი.
მე ვაპირებ ხელახლა განაცხადოს ჩემი კუბი ფუნქციის მიერ სიტყვასიტყვით
გადაწერა და pasting.
სინამდვილეში, ეს ასე არ არის სიტყვასიტყვით.
ასე სიტყვასიტყვით გადაწერა და pasting ხაზი 15
up ზემოთ ხაზი 6.
არ აქვს მნიშვნელობა, რა ხაზის ამ მთავრდება შესახებ.
ეს ხდება, რომ იყოს on line 4.
მაგრამ ეს იმას უნდა იყოს ადრე ძირითადი.
მაგრამ შეამჩნია განსხვავება.
Line 4 სრულდება მძიმით, რაც იმას ნიშნავს, Hey,
Clang, მიიღოს ჩემი სიტყვა, რომ არსებობს ფუნქცია
მოუწოდა კუბი რომ იღებს int და დააბრუნებს int.
მაგრამ მე არ gonna გითხრათ რა არის ამჟამად.
უბრალოდ ვიცი, რომ მე გპირდებით გითხრათ საბოლოოდ.
მართლაც, ახლა okay, რომ ეს არის ქვემოთ ქვემოთ.
>> ასე რომ, ეს არის ზოგადად უკეთესი, რადგან მაშინ ზედა
თქვენი ფაილი, თქვენ შეგიძლიათ მისი rattle off, სწრაფი ცეცხლი, ერთი ხაზი
ყოველი, რა სახელები თქვენი ფუნქციები, რაც მათი
საშუალებებით არიან, როგორია მათი შედეგები არიან.
და იყოს უფრო მკაფიო, შეყვანის ზოგადად ნიშნავს არგუმენტი ან
პარამეტრი, სინონიმებია.
გამოყვანის დაბრუნებას ნიშნავს ღირებულებით, რას
მხრივ უკან ჩემთვის.
ასე რომ, ამ შემთხვევაში აქ, Cube გამოცხადდა ზედა, მაგრამ
განსაზღვრული, სხვაგვარად ცნობილია როგორც განხორციელდა, ბოლოში.
ახლა მოდით დავუბრუნდეთ აქ და ხელახლა აწარმოებს ამ.
ახლა ნება მომეცით წავიდეთ წინ და ხელახლა აწარმოებს გააკეთოს, ხელახლა აწარმოებს იყოს.
და ეს არის როგორც ჩანს, სამუშაო მხოლოდ ჯარიმა.
ახლა ჩვენ შეგვიძლია წავიდეთ წინ და ფაქტორი გარეთ რაღაც
ლუდი მაგალითად ამ მეოთხე ვერსია.
ნება მომეცით, გადახვევა ქვემოთ აქ.
და შენიშნავს, რომ I ტიპის აიღო ამ გაკვეთილში გული ახლა.
ის ფაქტი, რომ მე სიმღერა იგივე stanza ერთხელ და
ისევ და ისევ, იგივე გუნდი ხაზს სიმღერა, ვიგრძენი
like რატომ არ მე ფაქტორი რომ შევიდა ფუნქცია?
მართლაც, ეს უნდა იყოს ერთი მოტივაცია.
გარდა იმისა, რომ ვინმე მსოფლიოში დაგვჭირდება
გამოიყენოს კუბი ფუნქცია -
რომ კარგ საფუძველს აძლევს ფაქტორი რაღაც გარეთ და დაწეროთ თქვენი
საკუთარი ფუნქციის -
თუ არსებობს ბლოკი კოდი თქვენს პროგრამა, რომელიც მხოლოდ ხდის
კონცეპტუალური თვალსაზრისით, რომ თქვენ ტიპის მინდა ეს
სახელი - როგორც ამ შემთხვევაში, გუნდი -
მაშინ ანალოგიურად წერენ რომ როგორც ცალკეული ფუნქცია.
თქვენ არ დაწერა ყველაფერი მთავარი თუ უბრალოდ
გრძნობს სუფთა გამიჯვნას ის და მისთვის სახელი.
>> ასე რომ, ამ შემთხვევაში აქ, რომ მე კომენტარის atop
ამ ფუნქციის რომ მღერის შესახებ
მითითებული ნომრები ბოთლებში.
გაითვალისწინეთ, რომ მე არ უნდა დარეკონ ამ
რამ და ჩასათვლელი.
ფაქტობრივად, ეს დრო უბრალოდ მოუწოდა ჩემი შეყვანის ბ ამისთვის ბოთლი.
და შენიშნავს, აქ, ბათილად ვარაუდობს რა?
რომ გუნდი -
აუდიტორია: არ დააბრუნებს მას.
დევიდ ჯ Malan: არ დააბრუნებს მნიშვნელობას.
მართლაც, ფუნქციები არ გვაქვს დასაბრუნებელი ღირებულებებს.
მათ შეუძლიათ მხოლოდ რაღაც.
მათ შეუძლიათ, თუ რა ეწოდება გვერდითი მოვლენები, რომელიც ამ
საქმე ის არის, უბრალოდ მთელი bunch დაბეჭდვის ეკრანზე.
ასე რომ ეს კოდი აქ, მე უბრალოდ სიტყვასიტყვით მოიპარეს საწყისი
წინა მაგალითი.
ერთადერთი განსხვავება არის ის ნაცვლად გამოყენებით მე როგორც ჩემი
ცვლადი, მე ახლა გამოყენებით B როგორც ჩემი ცვლადი.
ასე მაქვს B ქვემოთ აქ, მაქვს B ქვემოთ აქ, მაქვს B
მინუს 1 down აქ.
მაგრამ კოდი არის ზუსტად იგივე.
მაგრამ მხოლოდ იმიტომ, რომ გაჩვენოთ ეხლა როგორ შეგვიძლია გამოვიყენოთ ეს, მინდა წასვლა
წინ და პრაქტიკულად შეცვლის ეს უნდა იყოს ამისთვის loop.
ამისთვის (int i = n; i> n; მე -).
>> ამიტომ მე მოპარული, რომ ჩვენი წინა მაგალითი.
მანამდე, ეს შეესაბამება 37 რომ მე არ დაიწყო
მღერის ამ შემაშფოთებელი სიმღერა.
მაგრამ ამის ნაცვლად, მე უბრალოდ აპირებს ახლა მოვუწოდებთ გუნდი მე.
შესრულებულია.
ახლა ყოველ iteration ამ მარყუჟის, მოვუწოდებ ამ სხვა
ფუნქცია, გუნდი, რომ მე მოხდა დაწერა.
იგი დაწერილი არ არის ვიღაცის წლის წინ.
მაგრამ გუნდი, იმავდროულად, იყენებს printf ბეჭდვა
აღნიშნული ოთხი ხაზები.
მაგრამ ის ფაქტი, რომ მე მოუწოდებდა გუნდი ისევ და ისევ
loop იმას ნიშნავს, რომ მე ვაპირებ კიდევ, ზუსტად იმ მიზნით,
ზუსტად იგივე სიმღერა მაქვს ჯერჯერობით.
ასე მოკლედ, ახლა თუ ვიხსენებთ ჩემს კოდი, მიუხედავად იმისა,
ფუნქციურად ეს ექვივალენტი შეამჩნევთ, რომ ეს
ვიწყებთ უფრო იკითხება.
მე ზუსტად არ ვიცი როგორ GetInt
ხორციელდება.
გულწრფელად ვამბობ, არ ვიცი როგორ გუნდისათვის ხორციელდება.
მაგრამ მნიშვნელობა არ აქვს ჩემთვის.
არ მაინტერესებს, რადგან ახლა მე შემიძლია სახის, როგორც ადამიანის, წაიკითხოთ
ამ ზემოდან უნდა ბოლოში.
და რადგან ფუნქციები დაასახელა მიხედვით, რაც მათ
გავაკეთოთ, ჩემი კოდი უფრო იკითხება.
და როგორც ჩვენი პროგრამების კიდევ უფრო უფრო რთული -
მიერ სემესტრის ბოლოს, თქვენ უნდა წერა ასობით ხაზები
კოდის ენაზე, როგორიცაა PHP და JavaScript და მოსწონს -
თქვენ იპოვით რომ ასე ბევრად უფრო ადვილია, ვიდრე ტრეკზე
რა თქვენ გაკეთდეს.
და როდის დაიწყება თანამშრომლობს მეგობრები ან
პარტნიორები ან კოლეგებს, თქვენ გექნებათ დაწერა ბევრად უფრო
მასიური პროგრამების მიერ დაწყებული განახორციელოს ამ ძირითადი
შენობა ბლოკები.
>> ამრიგად, რომ განაცხადა, რატომ არ მოვუწოდებთ ეს დღე?
და ვნახავთ თქვენ ოთხშაბათს.
[ტაში]