[Powered by Google Translate] DAVID Malan: ეს არის CS50, და ეს არის დაწყების კვირა 1.
რა გვეგონა ჩვენ გვინდა გავაკეთოთ დღეს არის მიიღოს ვიხსენებთ
რაღაც ბევრ თქვენგანს ალბათ დადიოდა წარსულში ზოგიერთი
ახლა არის და შეიძლება ცოტა ნაცნობი.
ეს რამ აქ, ამ თქმა უნდა არის -
აუდიტორია: მეცნიერების.
DAVID Malan: მეცნიერების ცენტრი.
ასე რომ, ეს არის რეალურად ერთი ყველაზე ადრეული კომპიუტერები
უკან 1940.
ეს იყო ერთერთი პირველი ელექტრომექანიკური კომპიუტერები
რომ შეეძლო განსაკუთრებით ხანგრძლივი,
თვითმმართველობის მდგრადი computations, და რაც ჩვენ რეალურად ვხედავთ
მეცნიერების ცენტრი არის მხოლოდ პატარა ნაჭერი ამ რამ.
რა გვეგონა ჩვენ გვინდა გავაკეთოთ მაშინ არის მიიღოს ვიხსენებთ ვიდეო
რომ გაკეთდა ცოტა ხნის წინ, ვნერგავთ ამ
რამ მსოფლიოში.
და დაინახავთ საწყისი მუსიკა და ხმა, რომ მართლაც იმ
ძალიან ბედნიერი ჯერ.
>> [ვიდეო აღწარმოების]
-ტრიუმფი მათემატიკური და მექანიკური უნარი არის ამ
დიდი ახალი ავტომატური კალკულატორი ჰარვარდის უნივერსიტეტი.
რთული პრობლემების მათემატიკაში, დააყენა მეშვეობით
მანქანა კოდირებული ფორმით ფირზე, მათ ზუსტად მოგვარდება
წუთი ფრაქცია საჭირო დროისა ადამიანის
გაანგარიშებით.
განკუთვნილია დააჩქარებს ყველა ფორმის მათემატიკური და სამეცნიერო
კვლევის, გიგანტური მექანიკური ტვინის იმუშავებს ერთიანი
შტატები საზღვაო სანამ ომი დასრულდა.
>> DAVID Malan: რაც თქვენ შეიძლება არ ვიცი ის არის, რომ ეს იყო
იგივე მოწყობილობა, რომელიც ვადის ჩვენ ყველა ახლა მიიღოს საკმაოდ ბევრი
თავისთავად ცხადად იყო coined, რომ ხარვეზის შესახებ.
ასე რომ ერთი ინჟინრები მუშაობენ ამ კომპიუტერზე
სიტყვასიტყვით ნაპოვნი პატარა moth ავტომატში, რამაც
ზოგიერთ არასწორი გაანგარიშებები.
და როგორც ამბავი მიდის, რომ moth იყო სატელეფონო ამ შესვლა
ჟურნალი აქ, უკან 9 სექტემბერს, 1940 წელს, რაც,
და ამით დაიბადა მსოფლიოს ტერმინი "ხარვეზის".
ასე რომ ამიერიდან მიგვაჩნია შეცდომები უნდა იყოს ნებისმიერი სახის შეცდომები
პროგრამები, თუ არა ადამიანის მიერ ან, ამ შემთხვევაში, მწერები.
>> ასე რომ რამდენიმე განცხადებები, როგორც ვაგრძელებთ.
ამიტომ CS50 აქვს ტრადიცია სთავაზობს lunches of ჯიშები შესახებ
საუკეთესო პარასკევს დროს სემესტრში, სადაც ჩვენ ვიღებთ 30 დან
40 სტუდენტებს ცეცხლი და ყინულის მოედანზე ამისთვის ჩვეულებრივი
chitchat, საუბარი კომპიუტერულ მეცნიერებათა
ლაპარაკი მომავალში.
ჩვენ ვიწვევთ კურსდამთავრებულები და მეგობრები მრეწველობის სტატისტიკა up
სტუდენტებს ასევე.
მართლაც მიმართ ბოლომდე მიღების რა საკმაოდ დიდ კლასის
უფრო ინტიმური, ერთხელ მაინც ხოლო
subsets სტუდენტების.
ასე რომ, თუ გსურთ შემოგვიერთდნენ ამ პარასკევი, 1:15 PM, წასვლა
CS50.net/lunch to RSVP.
და ჩვენ ყველაფერს გავაკეთებთ ამ recurringly, ასე რომ არ ინერვიულოთ, თუ თქვენ არ
შორის პირველი 30 ან იმდენად ამ კვირაში.
>> ამიტომ scribe აღნიშნავს.
სიტყვა რესურსები, ახლა დაიწყება მყოფი ხელმისაწვდომია
სტუდენტებს კლასი.
ისე, რომ თქვენი თავები არ უნდა იყოს ქვემოთ დროს ლექციები
scribbling ქვემოთ ყველაფერს ვამბობ და ა.შ., თუ ​​რას ვაკეთებთ
ნაცვლად არის უზრუნველყოფს აკადემიური პერსონალის
კანონიკური კომპლექტი შენიშვნები.
ასე რომ ჩვენ ერთი ჩვენი სწავლების პრაქტიკის, ენდრიუ Sellergren,
ვინც ზის ქვემოთ ყოველ კვირას, მიმოხილულია ვიდეოები და შემდეგ
წერს ქვევით, რაც ჩვენ მიგვაჩნია, რომ საკმაოდ
ავტორიტეტული კომპლექტი შენიშვნები.
და ანდრიას უყვარდა, ასევე, საქართველოს აყენებს snarky სქოლიოში წელს
ბოლოში.
ასე რომ თქვენ იმედია დატკბეს ამ როგორც მინიშნება წიგნი
გართობა, ასევე, მოდის Quiz დრო, როგორც შესაძლებლობა განიხილოს
რა მოხდა ინდივიდუალური ლექცია.
ასე რომ იმ უკავშირდება შესახებ ლექციები გვერდზე.
>> პრობლემა კომპლექტი 0, იმავდროულად, არის გარეთ.
და კუთხით რესურსი ხელმისაწვდომი -
walkthrough.
მილო ხელმძღვანელობდა პირველ პარასკევს.
იგი გადაიღეს, დაუსვან ონლაინ შაბათი.
და ასე გააცნობიეროს, თუ თქვენ ნამდვილად არ დარწმუნებული სად უნდა დაიწყოს,
ამ ან მომავალში P-კომპლექტი, ყოველთვის ჩართოთ პირველი და
walkthrough ან ვიდეო მათი.
Sectioning წარმოება; საათზე cs50.net/section არის სადაც თქვენ
უნდა წარმოადგინოს თქვენი არჩევანი, თუ არ
უკვე, რომელსაც დღეს.
რადგან სექციები დაიწყება მოდის კვირა, ორშაბათი,
და სამშაბათი.
ჩვენ ამას ვაკეთებთ სექციები იმ სამი დღის განმავლობაში, ყოველ კვირას
სემესტრის ყველაზე ნაწილი.
ჩვენ ასევე წარმოგიდგინოთ, კიდევ ერთხელ, სხვადასხვა კომპოზიციები.
ასე რომ თქვენ უნდა სთხოვა ამ sectioning ფორმით, თუ
არ მინახავს ეს უკვე, თუ თქვენ ერთი იმ ნაკლებად
კომფორტული, უფრო კომფორტული, ან სადღაც შორის.
და თუ თქვენ სახის on ღობე, ზოგადად სადღაც
შორის არის ის, რაც ყველაზე მეტად სტუდენტები დასრულდება მდე შემოწმების.
ოფისი საათის დაიწყოს ამაღამ.
>> ამიტომ Scratch საკმაოდ დაბალი გასაღები, მიუხედავად იმისა, რომ ეს ბუნებრივია
to გადაეყარონ სხვადასხვა შეცდომები, ან იყოს გაურკვეველი, თუ როგორ უნდა
განახორციელოს რაიმე.
ასე რომ მიხვდებიან, რომ დავიწყებთ საათებში ამ კვირაში.
ისინი ყველაფერს იყოს Annenberg ორშაბათს, სამშაბათს, ოთხშაბათს,
ხუთშაბათი, საწყისი 8:00 PM 11:00 PM განმავლობაში ტვინის შესვენების.
ზემო classmen შეუძლიათ მიიღონ, და თუ თქვენ ოდესმე უჭირთ მისაღებად
წელს კარით, რადგან ისინი გექნებათ swiping, უბრალოდ გაიგო თქვენი გზა
და ხსნიან თქვენ ერთად CS50.
როგორც წესი 20 დან 30 ჩვენგანს შესახებ პერსონალი იქნება მას დახმარებას
თქვენ ერთ ერთი.
>> ჩასვლისთანავე იდეა არის ამ: თქვენ მოუტანს თქვენი ლეპტოპი,
თქვენ თქვენი დამტენი, ჩვენ გვექნება დამატებითი ძალა cords,
განსაკუთრებით გასწვრივ სამხრეთ კედელზე Annenberg აქ
არსებობს უამრავი ელექტრო საშუალებებს.
და მთავარი შესვლის წერტილი საათებში Q & არის წასვლა
cs50.net/discuss და დატოვე
თქვენი შეკითხვა არსებობს.
და წარწერა იგი pset 0 ან 1 pset, რასაც კვირაში
შეიძლება მოხდეს, რომ იყოს.
და შემდეგ, რაც ჩვენ გავაკეთებთ არის აქვს მაგიდასთან სწავლების პრაქტიკის
და რა თქმა უნდა თანაშემწეები, ზოგადად 8 ან 10 ან იმდენად ჩვენგანი,
გადის, შენახვა სიფხიზლისაკენ თვალის ფორუმში, და
plucking off კითხვები მართლაც როგორც სწრაფად, როგორც შეგვიძლია,
მხედველობაში თქვენ დაკავშირებული შეტყობინება თუ არ ი იმ
თქუენგან, ონლაინ ცნობას, შესაბამისი.
და მაშინ, თუ არსებობს პრობლემები, როგორც იქ აუცილებლად
იქნება, ან უბრალოდ უფრო გრძნობა დაიწოს ერთ ერთი,
მუშაობა მეშვეობით პრობლემები ვინმეს.
>> ან უბრალოდ მოვიდეს ოფისში საათის ნამდვილად
სჭირდება, რომ განწყობა.
თქვენ არ მინდა გავლა ელექტრონული ფორმით, თქვენ
ნამდვილად გსურთ შეხვდება ვინმე.
ინფორმაცია, რომ ჩვენთვის, და რა მოხდება, როდესაც თქვენი
კითხვაზე უკვე დაინახა აპარატის წევრი და ჩვენ
განსაზღვროს, yup, ეს უნდა იყოს გაგზავნილი ერთი 20 ან
30 გუნდის შემადგენლობა აქ ადგილობრივად, ვნახავთ ზედა დაუტოვებიათ ამ
პატარა შეიყვანეთ რიგში ღილაკს იწყება flashing on cs50.net /
განიხილავენ.
და ეს არის გეუბნებოდით, რომ თქვენ ახლა უკვე მიიწვია, ასე
საუბარი, შესვლის რიგიდან.
და დაწკაპვით რომ ღილაკს, თქვენი სახელი ამის შემდეგ გამოჩნდება
iPad, რომ CS50 greeter, ერთი რა თქმა უნდა ხელმძღვანელები, ნების
იყოს ჩატარების ახლოს შესასვლელთან Annenberg, რომელიც მაშინ
ნახავთ, როგორც გამოსახული აქ, სტუდენტებს, რომლებმაც კითხვების
მარცხენა, პერსონალის წევრები, რომლებიც იმყოფებიან მარჯვენა.
და click of მარცხენა და მარჯვენა, ბრაუზერში იქნება
დაიწყება flashing როგორც კი, მაგალითად, პროფესორი McGonnagal
მზად არის, რომ ნახოთ თქვენ კონკრეტულ მაგიდაზე Annenberg.
>> ამიტომ ჩვენ გარკვეული ამ შარშან.
ჩვენ rebooted საათებში და
ხელახლა განხორციელებული დიდი პროგრამული უზრუნველყოფა.
ასე რომ მიხვდებიან, რომ ეს იქნება თბილი up ამ კვირაში.
არამედ გააცნობიეროს ძალიან, წლების განმავლობაში წარსულში, როგორც თქვენ ალბათ მსმენია
მეგობრებისგან, საოფისე საათი ჰქონდა მართლაც 50 დან
150 სტუდენტი ერთდროულად.
და ეს უბრალოდ არ შეიძლება ჩვენთვის გაუმკლავდეს, რომ
ეფექტურად, ერთი წლის ერთი, მთელი საღამოს.
და მერე რა რომ ჩვენ მართლაც აპირებს ცდილობენ ამის გაკეთებას წელს არის
ესარგებლა იმ ფაქტს, რომ ბევრი შეკითხვა
ხშირად დასმულ და ხშირ შემთხვევაში შეიძლება უკეთესი უპასუხა
asynchronously.
ასე რომ თქვენ შეგიძლიათ სახის ვფიქრობ მეშვეობით პერსონალის საპასუხოდ,
და ჩვენ შეიძლება ვიფიქროთ თქვენი კოდი, გარეშე ცხარე
წნევა აუცილებლად იბრძვის
მეშვეობით ეს თალიზში.
ამიტომ, ჩვენ ვარაუდით, უხეშად მესამე ან ნახევარი კითხვები
იქნება გავგზავნე პირადად, და ჩვენ შევეცდებით pluck off როგორც
რის შედეგადაც ნახევარი ან მეტი ელექტრონულად,
დროს საათებში.
და გავაგრძელებთ გამოიყენოს იმსჯელებს
მთელ კვირაში ისევე.
>> და ბოლოს, გააცნობიეროს, რომ ეს კურსი შეიძლება გაიაროს / ჩავარდება.
ასე რომ, თუ თქვენ წლის ღობე ან უბრალოდ ფიქრობთ, რომ თქვენ ნამდვილად
არ ვიცი, თუ ეს მსოფლიოში თქვენთვის, ან ეს მართლაც
საკმაოდ საგარეო თქვენ, გააცნობიეროს, რომ ეს არის შესანიშნავი გზა
მოპოვების გარკვეული ნდობის რომელთანაც დახევას შევიდა
კლასის, როგორიც მე გულწრფელად, წლის წინ.
და მაშინ, ხუთი კვირის სახის ფიგურა გარეთ
თავის, თუ გსურთ დარჩება მიღება / ვერ, გადახვიდეთ წერილი
კლასის, ან მოსწონს.
და, როგორც წესი, რა გაივლის / ვერ ამჯამად, მე ვფიქრობ, სტუდენტებისათვის არის
რომ, თუ თქვენც არ დაიშურებთ, რომ 10 საათის განმავლობაში, 20 საათი, რაც არ
შესაძლოა, გარკვეული პრობლემები, და თქვენ banging თქვენი უფროსი
წინააღმდეგ კედელზე,
და ნამდვილად ვერ აყვანას რაღაც ქვემოთ და თქვენ
აქვს უამრავი სხვა რამ, რაც უნდა გავაკეთოთ, პატიოსნად, რაც მე
ვფიქრობ გაივლის / ვერ არის, სჭირდება პირას გამორთვა
სიტუაციებში, როგორიცაა, რომ.
სად თქვენ გადაღებული რამ 90% გზა.
თქვენ იცით, ეს არ საკმაოდ სრულყოფილი.
მაგრამ თქვენ ბევრი გარეთ, მიუხედავად ამისა.
ასე მიიჩნევენ მიღება / ვერ როგორც გაწვდით, რომ
გონებრივი მოდელი, ალბათ.
>> ყველა უფლება, ასე რომ გასულ კვირას ჩვენ dove შევიდა Scratch, და ჩვენ
ისაუბრა პროგრამირების შესახებ საკმაოდ მაღალი დონის გრაფიკული.
და დღეს ჩვენ გადასვლას ენა
მოუწოდა C, ქვედა დონის პროგრამირების ენა თავზე
რომელიც მრავალი თანამედროვე ენებზე ახლა აგებული, მათ შორის რამდენიმე
საქართველოს პირობა ჩვენ უნდა გამოყენებით მიმართ ტერმინი ბოლოს.
და syntactically, რაც მათ გამოიყურებოდეს
არის ყველა საკმაოდ მსგავსი.
მოდით ახლა გადავიდეთ რათა ამ გარდამავალ აქ.
ასე რომ, ეს იყო პროგრამა გასულ კვირას რომ იყო მარტივი of
Hello world პროგრამები.
ეს უბრალოდ დაბეჭდილი რომ ეკრანზე Hello world, ერთად
პატარა სიტყვის ბუშტი გამოდის კატა.
ისე, თუ ჩვენ ახლავე თარგმნოს ამ სხვა
ენა, გააცნობიეროს, რომ იდეები დღეს და ოთხშაბათს
იდენტური, მაგრამ სინტაქსი იწყებს შეიცვლება.
ასე რომ, მაშინ როდესაც გასულ კვირას გვქონდა, როდესაც მწვანე დროშა დააწკაპებთ, ამბობენ
Hello world.
დღეს ჩვენ ვაპირებთ აქვს int, მთავარ, ბათილად, printf,
დაბრუნების, ზოგიერთი სხვა სინტაქსის იქ ისევე.
Curly braces, და ბრჭყალების და შეთავაზებები და whatnot.
მაგრამ გვესმის, რომ ძირითადი იდეა აქ არის ბეჭდვის,
და საბოლოოდ ის ფაქტი, რომ ძირითად არის იქნება
სინონიმი დაწყების პროგრამა.
მთავარი იქნება, სადაც მწვანე დროშა ჩათვლით რამ off.
>> ახლა მოდით აჯავრებენ გარდა ზოგიერთი შენობა ბლოკები აქ
სანამ ჩვენ ჩაყვინთვის შევიდა კონკრეტული მაგალითები.
ამიტომ, ჩვენ მოუწოდა ამ განაცხადი გასულ კვირას, რომლის დროსაც უბრალოდ
ინსტრუქცია.
გააკეთეთ - ამ შემთხვევაში, მიესალმები მსოფლიოში.
კარგად C, თუ დავაკვირდებით მხოლოდ, რომ ხაზი, ასე ჩვენ
იწყებს გამოხატავს კონკრეტულ თავსატეხი ცალი:
printf ("Hello World");.
და ახლა ჩვენ აჯავრებენ ამ გარდა სულ უფრო და უფრო მეტი დრო,
მაგრამ ვაცნობიერებთ, რომ არსებობს ნიმუში აქ.
ასე ერთი, ჩვენ გვაქვს ამ რამ მოუწოდა printf, რომელიც
არსებითად ანალოგიური სიტყვა Say.
სწორედ რასაც ის აპირებს.
Printf და F აქ ნიშნავს "დაფორმატებული".
ასე რომ, ეს მხოლოდ იმას ნიშნავს, თქვენ შეგიძლიათ ჩაწეროთ
სხვადასხვა ესთეტიკური მონაცემებით.
ამიტომ ციტირებით unquote არის დასაწყისში, რასაც ჩვენ ვაპირებთ
დაიწყოს მოუწოდებდა სიმებიანი.
სიტყვა, ფრაზა, წინადადება.
String in პროგრამირების ენა არის თანმიმდევრობა ნულოვანი
ან მეტი სიმბოლო.
ასე რომ H-E-L-L-O, მძიმით, და ა.შ. არის,
ციტირებით unquote, სიმებიანი.
და ახლა backslash N, პატარა syntactically უცნაური, მაგრამ ჩვენ
უკვე განსაზღვრულია, რომ გასულ კვირას, როგორც იმას ნიშნავს, თუ რა?
უბრალოდ ახალი ხაზი.
უბრალოდ გზა conveying კომპიუტერის გსურთ
ეკვივალენტს hitting შეიყვანეთ არსებობს, მაგრამ თქვენ არ
გვინდა რეალურად დააჭიროთ და ამიტომ სასადილო up ყველა
გაფორმებით, თქვენი ფაქტობრივი პროგრამა.
ახლა ფრჩხილებში დაურთოს ეს კონტექსტი, ღია PAREN და
მჭიდრო PAREN, და შიგნით რომ არის ჩვენი სიმებიანი.
იმიტომ რომ იმიტომ, დო, და სხვა პროგრამირების
ენებზე, რამ, როგორიცაა printf მიიღოს არგუმენტები, ან მიიღოს
პარამეტრების.
>> ასე რომ დავიწყოთ ფიქრი ახლა ამ purple Say ბლოკი როგორც
ფუნქცია, როგორც მეთოდი, როგორც პროცედურა.
შეგიძლიათ ნამდვილად ეძახით რაც გაგიხარდებათ ახლა, მაგრამ
ეს ერთგვარი მინიატურული პროგრამა, რომელიც მხოლოდ ერთი
რამ, ერთ ხაზზე, არანაკლებ.
ამიტომ printf ასევე რასაც ჩვენ ვაპირებთ დავიწყოთ მოუწოდებენ
ფუნქცია და ფუნქციები რაღაც - ამ შემთხვევაში
ბეჭდავს ფორმატირებული სიმებიანი რომ ეკრანზე -
მაგრამ ფუნქციებს იღებენ აგრეთვე არგუმენტები ან პარამეტრებს.
და არგუმენტები ან პარამეტრების, მადლობა, იგულისხმება
რომ მათი საქციელი შეიძლება გავლენა მოახდინა, რაც თქვენ კორიდორი
შიგნით ფრჩხილებში.
ასე რომ, ამ შემთხვევაში, printf საჭიროებებს უნდა უთხრა რა ბეჭდვა და ჩვენ
უბრალოდ კორიდორი, ორმაგ ბრჭყალებში აქ, სიმებიანი, რომ ჩვენ
ნამდვილად გინდათ ბეჭდვა.
და მძიმით წლის ბოლომდე ამ ხაზის მხოლოდ
ისტორიული nuisance რომლის დასასრულს საუკეთესო ხაზების კოდი,
თქვენ დააყენა მძიმით, რათა სუპერ ნათელი კომპიუტერი
რომ ეს ხაზი კოდი დამთავრდა აქ.
ახლა ეს არის კარგი, რადგან როგორც ჩვენ დავინახავთ, როგორც პროგრამების უფრო
კომპლექსი, მძიმით გახდის სუპერ წმინდა ჩვენთვის ადამიანები,
და ასევე კომპიუტერს, სადაც ხაზი კოდი დაწყება და დასასრული.
გააცნობიეროს, რომ რამდენიმე ენა არ გვაქვს
ამ იგივე დეტალები.
და ფაქტია, რომ JavaScript, თქვენ ყოველთვის არ გვჭირდება რაღაც
მოსწონს მძიმით.
მაგრამ უფრო, რომ მოვა.
>> ამიტომ მარყუჟების.
ჩვენ გვქონდა მსგავსი რამ, ძალიან ინტუიციურად, ცხადია, არ
რაღაც ისევ და ისევ და ისევ.
Like აყენებს on წინდები, ან ამბობდა Hello, ამ შემთხვევაში.
ისე, დღეიდან დო, შეიძლება გამოხატოს ამ Scratch
ბლოკირება როგორც ხოლო (ნამდვილი) printf ("Hello World").
ასე რომ შეამჩნია ჩვენ ვიწყებთ დაეყრდნონ სიტყვასიტყვით თავსატეხი
ცალი მხრიდან ადრე.
ჩვენ გვყავს იგივე purple ბლოკი, მაგრამ შიგნით ამ
bracketed სამუდამოდ ბლოკი და საუკეთესო გზა თარგმნოს, რომ
to C ასეთია.
იქ არ არის სამუდამოდ სიტყვით.
თქვენ არ შეგიძლიათ უბრალოდ აკრიფოთ F-o-r-e-V-e-რ C.
ასე რომ უახლოესი ანალოგი არის ხოლო.
>> ახლა, ხოლო (ნამდვილი) როგორც ჩანს ცოტა სულელური, რადგან არ ღირებულება
ჭეშმარიტი ოდესმე ცვლილება?
სავარაუდოდ არ.
ეს იგივეა, თითქოს ამბობდა, ხოლო ერთი, ხოლო, ხოლო ჭეშმარიტი.
ეს ყველაფერი იგივე, ჭეშმარიტი ყოველთვის შემთხვევაში.
ასე რომ, ეს მარყუჟი რეალურად inducing რა სახის loop?
უბრალოდ უსასრულო ციკლი, მარჯვნივ.
სამუდამოდ მარყუჟი ან როგორც ჩვენ მას გასულ კვირას,
მხოლოდ უსასრულო ციკლი.
ასე რომ ხანდახან რომ ცუდია.
ზოგჯერ რომ bug, ზოგჯერ ამიტომ თქვენ
დაწნული Beach ball ან Hourglass ან მოსწონს.
მაგრამ ამ შემთხვევაში, ჩვენ შეგნებულად, რადგან რაც არ უნდა
მიზეზი, სურდა ბეჭდვა იგივე ერთხელ
და ისევ და ისევ.
ან შემთხვევაში მოსწონს watch, გსურთ
რაღაც ისევ და ისევ და ისევ.
ასე უსასრულო მარყუჟების შესაძლოა აზრი.
სწორედ ასე დო შეიძლება თარგმნოს სამუდამოდ უნდა კოდი.
>> ახლა ამ ერთი პატარა უფრო კონკრეტული.
ჩვენ გავიმეოროთ 10 ჯერ შემდეგ განაცხადი.
ასე რომ სანამ (ნამდვილი) არ საკმაოდ იქ მუშაობენ, რადგან ჭეშმარიტი არის
ყოველთვის მართალია.
ასე რომ, თუ ჩვენ ნაცვლად შევხედოთ C ვერსია, ახლა სინტაქსის იღებს
ცოტა მეტი cryptic.
მაგრამ უნდა იყოს პატიოსანი ერთხელ თქვენ დაიწყება, რომ ეს, ეს ყველაფერი იღებს
საკმაოდ ნაცნობი სწრაფად.
ასე რომ, ეს არის ის, რაც ე.წ. ამისთვის loop.
ამისთვის loop აპირებს ვუთხრა კომპიუტერში რომ რამე
ისევ და ისევ და ისევ რადგან
ეს ყველაფერი არის ჭეშმარიტი.
ახლა რას ვგულისხმობთ, რომ?
ისე, არსებობს სამ ნაწილად, რათა ამისთვის მარყუჟი, და ჩვენ ვაპირებთ
დაუბრუნდეს ამ კონტექსტში ფაქტობრივი
მაგალითები მომენტში.
ასე რომ არ ინერვიულოთ, თუ ის არ საკმაოდ ჩაიძიროს ყველა ერთდროულად.
მაგრამ int i = 0 არის, ხანგრძლივი ამბავი მოკლე და განაცხადა, რომ მომეცი
ცვლადი რომ ტიპის რიცხვი, ასე რომ მომეცი ნომერი
მოუწოდა მე და ინიციალიზაცია მას 0.
სწორედ მომეცი მოსწონს ალგებრული ცვლადი x და
ინიციალიზაცია მას 0.
მაგრამ ამ შემთხვევაში ჩვენ მას მე.
შემდეგ შუა, ნათქვამია მე ნაკლებია 10.
რომ ვეუბნებოდი კომპიუტერი შემდეგი პერსონალი ცოტა ხნის
როგორც მე ნაკლებია 10.
და ცხადია, რომ ეს იწყება არანაკლებ 10 რადგან
იგი იწყება 0.
მაშინ ბოლოს, თქვენ შეგიძლიათ, ალბათ მიხვდები რა + + საშუალებით.
ეს ცოტა სინტაქსი, რომ მხოლოდ იმას ნიშნავს, ნამატი მე.
ასე რომ დაამატოთ 1 I, ისევ და ისევ და ისევ.
>> და ისე, თითქოს ჩვენ დავინახავთ ამ მარყუჟის, ამ სინტაქსი, არამედ ახორციელებს
ზუსტად იგივე, რაც, სიმართლე გითხრათ, წელს Scratch იყო ასე
ბევრად უფრო ადვილია, რათა გამოხატოს.
გაიმეორეთ 10, და თქვენ კეთდება.
In C, და უმეტეს პროგრამირების ენები, უნდა ვიყოთ
ცოტა მეტი სასწავლო კომპიუტერული და რეალურად
დააკონკრეტა მსგავსი რამ.
მაგრამ ჩვენ დავბრუნდებით ამ და სხვა სინტაქსი.
>> რა ცვლადები?
In Scratch გვქონდა რაღაც ამ ფორთოხალი ბლოკები,
სადაც მე შეიძლება განაცხადოს ცვლადი.
მოდით თვითნებურად ეძახით Counter.
მოდით ინიციალიზაცია მას 0, ხოლო შემდეგ
მოდით სამუდამოდ რაღაც.
ამ შემთხვევაში წელს Scratch მე ვამბობ, counter, ისე
cat აპირებს აქვს პატარა სიტყვის ბუშტი რომ საუბარი
ხმების რომ ამ ცვლადში.
და შემდეგ ჩვენ გვყავს ენის counter მიერ 1.
ასე რომ ეს ყველაფერი გახვეული შიგნით სამუდამოდ საკეტი.
ამიტომ, ჩვენ უკვე გვყავს შენობა ბლოკები C ერთად
რაც თარგმნოს ამ.
>> ერთი გზა ჩვენ შეგვიძლია გავაკეთოთ, რომ ეს.
მომეცი მთელი რიცხვი, ეძახით Counter.
ინიციალიზაცია მას 0
წელს პირველი ხაზი არსებობს.
მიუხედავად იმისა, (ნამდვილი), ასე რომ მე ქურდობაში ეს იდეა დან მხოლოდ მომენტში
წინ, წავიდეთ წინ და ნუ შემდეგ.
ამობეჭდვა counter და შემდეგ ნამატი counter,
ისევ და ისევ, და ისევ.
ან ერთხელ, + + უბრალოდ ნიშნავს დაამატოთ 1 რაიმე.
მაგრამ არის ახალი ნაჭერი სინტაქსი აქ.
რა jumping out როგორც არ შედის ჩვენი წინა მაგალითები?
დიახ, ეს% d.
ასე რომ თქვენ შეგიძლიათ იქნებ infer რა ამ ყველაფერს აკეთებს, გულწრფელად, დაფუძნებული
რა Scratch ბლოკი აკეთებს.
მაგრამ კვლავ C, ჩვენ უბრალოდ უნდა იყოს ცოტა მეტი კერძოდ
როდესაც საქმე გამოხატავს საკუთარ თავს.
>> ამიტომ printf ("% d \ n").
კარგად უმეტესობა, რომ ჩვენ შეგვიძლია გადაყარეთ როგორც ნაცნობი.
შეთავაზებები მხოლოდ იმას ნიშნავს, რომ ის ტექსტი, backslash N
მხოლოდ ახალი ხაზი.
ასე მხოლოდ ახალი რამ აქ არის% d.
და ეს ყველაფერი არის placeholder.
% D აპირებს აღინიშნოს ათობითი რიცხვი.
და% d საშუალებით კომპიუტერი, დაუსვან ათობითი რიცხვი აქ.
ისე, რა რაოდენობის გსურთ დააყენა იქ?
ისე, როგორც შეგიძლიათ, ალბათ infer, შემდეგ მძიმით ვამბობთ
Counter, რომ სახელწოდება ცვლადი, რომ ჩვენ დეკლარირებული ან
შექმნილი წყვილი ხაზები ადრე.
ასე რომ, ეს უბრალოდ C გზა ჩართვის ცვლადი შევიდა
სიმებიანი დინამიურად ვითარდება.
იმის გამო, რომ პირიქით, მე რომ ნაცვლად გაკეთდეს რაღაც
ამ, printf ("მთვლელი"), რას ამ
პროგრამის ნაცვლად გავაკეთოთ, სავარაუდოდ?
იგი ყველაფერს სიტყვასიტყვით ბეჭდვა "მთვლელი".
რომელი არ არის ეფექტი, რომ მინდა.
მე უნდა შეცვალოს ზოგიერთი რიცხვითი მნიშვნელობა.
ამიტომ, ჩვენ დავინახავთ, რომ ფუნქციები, მაშინ, ისევე როგორც printf, შეუძლია არ
მხოლოდ მარტოხელა არგუმენტები, როგორიცაა
"Hello World".
მათ შეუძლიათ მიიღონ ციტირებით unquote მძიმით, და შემდეგ ზოგიერთი ცვლადის
რომ მიიღებს plugged შევიდა, როგორც ვნახავთ, წინა სიმებიანი
მეშვეობით ამ% ნიშანი placeholders.
>> კარგად რა ლოგიკური გამონათქვამები?
ლოგიკური გამონათქვამები იყო ამ ღირებულებების, ჭეშმარიტი ან მცდარი.
დიახ ან არა.
1 ან 0.
ან გამოსართავად.
ასე რომ Scratch ისინი ასე გამოიყურება, და შეამჩნია, რომ
ქვედა ბლოკი აქ არის რეალურად ერთობლიობაში
ორი პატარა ბლოკები.
ასე, რომ სახის გამოათრიეს და ჩამოაგდო სამი თავსატეხი ცალი
ერთად, რათა, რომ აღარ თავსატეხი ცალი იქ ისე, რომ მე
შეეძლო გადმოეცა იმ აზრს, რომ მინდა x ნაკლები Y და
Y ნაკლები z.
და ასე, რომ შეიძლება თარგმნოს ეს ორი ცალკე ხაზები შემდეგნაირად.
დაბრუნება ერთი შეიძლება ძალიან trivially ითარგმნა ენაზე C,
მხოლოდ x <y.
იქნებ ზოგიერთ ფრჩხილებში კარგი ღონისძიება.
ხოლო შემდეგ C, თქვენ არ წერენ და აღინიშნოს
ერთობლიობაში რაღაც.
თქვენს ნაცვლად წერენ &&.
და როგორც ჩვენ საბოლოოდ ვხედავთ, ერთი ampersand ხდება
ვგულისხმობ რაიმე განსხვავებული.
ამიტომ && უბრალოდ ნიშნავს იდეა და.
>> ასე რომ კიდევ ერთხელ, მიუხედავად იმისა, რომ ამ იწყებს გამოიყურება საკმაოდ რთული,
ერთი მიზნებისათვის შემოღების Scratch, გარდა
უბრალოდ მქონე სახის fun on-ramp, სადაც შეგიძლიათ გააკეთოთ
რაღაც რომ ძალიან გრაფიკული და ანიმაციური და
shareable და მოსწონს, ასევე გადმომეცა იდეა, რომ
ყველა იდეები ჩვენ ვიწყებთ diving შევიდა დღეს და Onward
უკვე რომლებიც განხორციელებულია კი, რომ მარტივი
ინტერფეისი წლიდან დღეში ერთი.
რაც შეეხება ამ ერთ აქ?
>> ასე პირობები.
ამიტომ Scratch ბლოკის მარცხენა იქ გამოიყურება
ცოტა უფრო რთული.
მაგრამ ეს მხოლოდ ზოგიერთ გადმოიყვანა და
ჩაშვების ნაცნობი დარტყმები.
თუ x არის ნაკლები Y, ვთქვათ ასე.
Else თუ x მეტია y, ვთქვათ ასე.
სხვაგან, ჩვენ შეგვიძლია ვივარაუდოთ, ლოგიკურად ეს inferred რომ
ისინი უნდა იყოს თანაბარი.
ამიტომ ამბობენ, რომ ისინი თანასწორი.
ახლა C მარჯვენა, იმავე ზუსტი რამ.
და შენიშნავს, რომ curly braces ვაპირებთ იყოს
თვისება C და სხვა ენებზე, რომ ამის გაკეთება დალაგება
საქართველოს encapsulation.
ისევე როგორც თუ ბლოკი ამ ყვითელი რამ რომ სახის
grabbing purple ბლოკის შიგნით მას.
ანალოგიურად ეს braces -
ამ Curly braces -
ნიშნავდა conjure up იმავე იდეას მოიცავს ერთ ან მეტ
ხაზების კოდი რომლებიც indented შიგნით მათ.
ასე მარჯვენა მხარეს აქ, თუ x ნაკლები Y, printf
("X ნაკლებია, ვიდრე Y").
Else თუ x მეტია y, ამობეჭდოთ იგივე.
Else ბეჭდვა, რომ ისინი თანასწორი.
>> ასე მოკლედ, არსებობს საკმაოდ პირდაპირი რუკების ან თარგმანი
ენის ჩვენ ვნახეთ დღემდე, მათ შორის ზოგიერთი
უფრო დახვეწილი თვისებები.
ასე რომ თქვენ შეიძლება არ იყოს გამოყენებისას თქვენი პროექტი, ან შეიძლება არ
იყოს გამოყენებისას თქვენი პროექტის ამ კვირაში.
მაგრამ ჩვენ ეს ყველაფერი მოუწოდა კოლექტორები in C. In Scratch,
ისინი მოუწოდა სიები.
და ჩვენ ვხედავთ ამ ერთად Fruitcraft RPG გასულ კვირას.
პატარა ლურჯი ბიჭი, რომელიც ფეხით გარშემო, კრეფა up
ალუბალი და ფორთოხალი და მოსწონს.
კარგად Scratch, რომ განხორციელდა ამ ფორთოხლის
ბლოკირება რომელიც შეიცავს სიტყვას; ამ შემთხვევაში, ჩვენ სიტყვასიტყვით
დასძინა "ფორთოხალი", რათა
ცვლადში ინვენტარი.
ასე რომ, C, ამ სინტაქსის აპირებს მიიღოს ცოტა მეტი cryptic.
და ჩვენ დავბრუნდებით ამ მომავალ კვირას და უფრო მეტი
საინტერესო რამ სამყაროში კრიპტოგრაფიის იგი.
მაგრამ ბოლოში აქ, ამ ორ წყებას არსებითად
თარგმნა ენაზე იმას თუ რას ვაკეთებთ ერთ Scratch გადაკეტვას არსებობს.
მაგრამ უფრო, რომ მოვა.
>> ასე აყენებს ერთად, აქ არის პროგრამა C. მოდით
სწრაფად აჯავრებენ გარდა ზოგიერთი ცალი სინტაქსი აქ, არამედ
მაშინ მოდით რეალურად დაიწყოს წერა რამდენიმე კოდი, გაეცნოს
თქვენ ზოგიერთ ინსტრუმენტები ჩვენ უნდა გამოყენებით, და თუ ჩვენ
შეიძლება დაეყრდნონ ახლა ზოგიერთი ამ ძირითადი შენობა ბლოკების საწყისი
გასულ კვირას, ახლა syntactically in C. ამიტომ ზედა აქ, ამ
ალბათ ერთ ერთი ყველაზე მოსაწყენი პროგრამები შეგიძლიათ
წერენ უმეტეს ნებისმიერი პროგრამირების ენაზე.
მაგრამ სახის განსაკუთრებული მნიშვნელობა იმიტომ რომ
კანონიკური პროგრამა, რომელიც ნებისმიერი კომპიუტერული მეცნიერი წერს, როდესაც
სწავლების ვინმე პროგრამირების ენა -
Hello world პროგრამა.
>> ამრიგად, ძალიან ზემოთ, ჩვენ ვხედავთ ამ ცნება # include
შემდეგ, დახრილი ფრჩხილები, stdio.h.
ჩვენ ვაპირებთ დაბრუნებას, მაგრამ რეალურად რა, რომ
ნიშნავს, რომ არსებობს ფაილური ამ სამყაროში მოუწოდა სტანდარტული
I / O, stdio dot თ, და ეს მხოლოდ ტექსტური ფაილი,
ვიღაცამ დაწერა წლის წინ.
და შიგნით რომ ტექსტური ფაილი არიან მთელი bunch of
ფუნქციები, ან მეთოდები, ან პროცედურები, რომ ვინმე
წერს, რომ ჩვენ ვართ ბენეფიციარები რადგან ჩვენ
ახლა გამოყენება, რომ პირის კოდი.
ფუნქციების მან დაწერა.
ამ შემთხვევაში, printf არ არის რაღაც, რომ დავწერე, ეს
არ არის რაღაც, რომ CS50 დაწერა.
ეს რაღაც, რომ ვიღაცამ დაწერა წლის წინ და დასვა
ფაილი სახელად stdio.h და შემდეგ, როგორც განზე დააყენა
მეორე ნაწილი ფუნქციის სხვა ფაილი.
მაგრამ ჩვენ იქ.
>> ასე # include მხოლოდ ჩვენი გზა ამბობდნენ, წელს
C, მომეცი ხელმისაწვდომობის ფუნქციები რომ ვინმე წერდა.
და ამ შემთხვევაში მე ზრუნვა, რადგან მინდა printf.
ჩვენ მივიღებთ int ძირითადი (void).
ასე რომ, ეს არის ერთ ერთი ეს ყველაფერი, სიმართლე გითხრათ, რომ დღეს 0,
საკმაოდ ბევრი მე რომ სახის ზონის გარეთ, რადგან ეს მხოლოდ
არ საინტერესო
ინტელექტუალურად, ზოგიერთი სინტაქსს.
მაგრამ ახლა ვიცი, რომ ფუნქციები, სხვაგვარად ცნობილია როგორც
პროცედურები, ან მეთოდები, ზოგადად აწარმოოს გარკვეული მნიშვნელობა.
ისინი რაღაც.
ისინი ამუშავება პასუხი.
ისინი აწარმოებენ გამომუშავება.
ასე int შემდეგი მთავარ მხოლოდ ჩვენი სტენოგრამის გზას ვამბობ,
რომ ამ ფუნქციას, ამ პროცედურას, რომელიც საბოლოოდ აპირებს
გადმოგცეთ უკან ნომერი.
და რატომ არის რომ, ჩვენ დაბრუნდება.
მთავარი არის მხოლოდ რა მსოფლიოში სტანდარტი რა
ფუნქცია, რომ აპირებს მიიღოს შესრულებული C პროგრამის როდესაც
თქვენ გაუშვით.
ძალადაკარგულად მხოლოდ იმას ნიშნავს, ამ რამ, მთავარი, იღებს არ
არგუმენტები, ამ შემთხვევაში.
ამიტომ მე ყოფნის super სიცოცხლისუნარიანობა.
იქ არ არის სიმებისათვის იქ არ მძიმეები.
ძალადაკარგულად ნიშნავს არანაირი არგუმენტი მთავარ.
>> ახლა ბოლოს, საბედნიეროდ, ბოლო ორი ხაზი იცნობს.
Inside Curly braces გვაქვს printf
და ჩვენ გვაქვს დაბრუნების.
და დაბრუნების სახის სამწუხაროა, რომ ჩვენ უნდა
ვთქვათ არსებობს, რადგან ამ შემთხვევაში ეს არ აკეთებს ყველა რომ
დიდი ინტერესი გამოიწვია.
მაგრამ კომპიუტერულ პროგრამას, როდესაც ფუნქცია დააბრუნებს 0,
ეს ნიშნავს, რომ ყველა კარგად არის.
არაფერი არ მოხდა ისე.
ამის საპირისპიროდ, თუ ფუნქცია დააბრუნებს 1, ან ნეგატიური 1, ან
უარყოფითი 1.337, ან შემთხვევითი რიცხვები როგორც რომ, რომ
ზოგადად იმას ნიშნავს, რომ შეცდომა რეალურად მოხდა.
ასე რომ, თუ თქვენ თქვენი Mac ან PC, თუ თქვენ ოდესმე დავინახე
ზოგიერთი შემაშფოთებელი გაგზავნა, რადგან თქვენს კომპიუტერში ავარიულად ან
გაყინული, და იქ cryptic შეცდომა,
და შემდეგ რამდენიმე კოდი, ისევე როგორც სისტემის კოდი
1,2,3,4, ზოგიერთი ნომერი,
რომ ზოგადად არის ზედმეტი დეტალი ვუთხრა
ყველაზე მეტად ჩვენს ადამიანებში, მაგრამ ეს არის ის, რაც ზოგიერთი ფუნქცია ან რამდენიმე
პროგრამა ფაქტობრივად დაბრუნდა, არასამთავრობო zero ღირებულება.
და საკეთილდღეოდ არის ის, რომ 0 ნიშნავს ყველა ისევე, და
მაშინ არსებითად აქვს უსასრულო რაოდენობის რამ
შეიძლება არასწორი.
რის გამოც ისინი აირჩია 0 კარგი და არასამთავრობო ნულოვანი მნიშვნელობა
ცუდი, როგორც ჩვენ უნდა მალე ვხედავ.
>> მოდით წავიდეთ წინ და დაწეროთ ამ.
ასე რომ გავიხსენოთ, რომ მეორე დღეს მე ჩემი Mac უნდა გაიხსნას
ტერმინალი ფანჯარა, და მერე გახსნეს ტექსტი პროგრამა, ისევე როგორც
TextEdit, და დავიწყე წერა რამდენიმე კოდი.
კარგად რომ ჯარიმა.
მაგრამ თქვენი გამოცდილება იქნება სხვადასხვა on Mac, ან
on Solaris კომპიუტერი, Linux კომპიუტერზე, რასაც ოპერაციული
სისტემა თქვენ მოხდეს უნდა გამოყენება.
და ისე რა თქმა უნდა, ჩვენ ნაცვლად გამოიყენოს ეს რაღაც
მოუწოდა CS50 ელექტრო მოწყობილობების.
ამიტომ CS50 ელექტრო მოწყობილობების არის ჩამოსატვირთი ნაჭერი პროგრამული უზრუნველყოფა
რომელიც საშუალებას გაძლევთ აწარმოებს ოპერაციული სისტემა უწოდა Linux,
კონკრეტულად Fedora Linux, საკუთარ Mac ან PC.
გაქვთ და ამ მიერ ჩამოტვირთვის რაღაც მოუწოდა hypervisor.
ასე რომ ეს ყველაფერი იყოს დოკუმენტირებული პრობლემა კომპლექტი 1.
და თქვენ იხელმძღვანელებენ მიმართ, რაც თქვენ უნდა ჩამოტვირთოთ.
მაგრამ საბოლოო ჯამში, თუ არა აქვს Mac ან PC, არის თქვენ
download ზოგიერთი უფასო პროგრამული უზრუნველყოფის.
მაშინ ჩამოტვირთოთ CS50 ელექტრო და თქვენ გითხრათ, რომ
უფასო პროგრამული უზრუნველყოფის - hypervisor -
გასაშვებად CS50 ელექტრო in ფანჯარა თქვენს კომპიუტერში.
და რა ხდება ამ.
>> მე ახლა, შეამჩნევთ აქ, რა ჩანს desktop
გარემოს.
და ნება მომეცით რეალურად shrink ამ ერთჯერადი ფანჯარაში.
ასე რომ, ეს არის არის ჩემი Mac, მცირედი ფანჯარა აქ და შიგნით
ამ ფანჯარაში ხდება იყოს მთლიანად
სხვადასხვა ოპერაციული სისტემა.
მართლაც არსებობს ამ Start მენიუში ქვევით აქ, თქვენში
Windows, რომელსაც აქვს მთელი bunch of ქვე მენიუები, მათ შორის
ბმული CS50 მექანიკური, Dropbox, და მოსწონს.
და რა ამ გარემოში ახლა არის სტანდარტული გარემო
რომ ყველას შეუძლია გამოიყენოს, რათა არ აქვს მნიშვნელობა რა თქვენი
კომპიუტერი, რაც თქვენ დამონტაჟებული, რა ვერსია
of Mac OS ან Windows თქვენ გაშვებული, ჩვენ ყველა ახლა
იგივე გარემოში.
და ახლა ამ გარემოში ჩვენ შეგვიძლია დავიწყოთ წერა რამდენიმე კოდი.
>> ამიტომ მე ვაპირებ წავიდეთ წინ და გახსნას პროგრამა მოუწოდა gedit.
ეს არის შედარებით notepad.exe, ან
TextEdit on Mac.
და ეს მხოლოდ სუპერ მარტივი ტექსტი რედაქტირება პროგრამა
რომ ასე გამოიყურება ერთი შეხედვით.
ახლა ძალიან ზევით, მაქვს თეთრი პალიტრა, ბოლოში მე
ეს შავი ფანჯარა რომ ამბობს jharvard @ ელექტრო მოწყობილობების.
და ეს იმიტომ, რომ მომხმარებელს, რომ ჩვენ წინასწარ შექმნილი
ყველასათვის ეწოდება ჯონ ჰარვარდის.
მას აქვს ფოლდერი სადაც ყველა მისი ფაილი ვაპირებთ წასვლა, და
აქ, სადაც ჩვენ შეგვიძლია დავიწყოთ წერა რამდენიმე კოდი.
ნება მომეცით, წავიდეთ წინ აქ და მასშტაბის მხოლოდ ცოტა, და მე
აპირებს # მოიცავს , int ძირითადი (void), და
მაშინ მე აპირებს printf ("Hello World")
; დაბრუნებას 0.
ახლა ეს არის ყველა საკმაოდ შავი და თეთრი.
>> ნება მომეცით წავიდეთ წინ და ნუ ერთი რამ ასწავლოს gedit რა მე
რეალურად აკეთებს.
ნება მომეცით წასვლა შენახვა როგორც.
მე ვაპირებ აირჩიოს დროს მარცხენა მხარეს აქ jharvard.
ასე რომ კიდევ ერთხელ, თუნდაც თქვენ არასდროს არ გამოიყენება Linux ადრე, გულახდილად
ამ დღეებში, ყველა მათგანი devolving შევიდა არსებითად
იმავე ტიპის ინტერფეისი -
Mac OS, Windows, და Linux.
ასე რომ, მე აირჩია jharvard სახლში ფოლდერი აქ.
და მე ვაპირებ გადარჩენა ამ ფაილის როგორც hello.c.
ამრიგად, ძალიან ზემოთ, მე აკრეფილი hello.c; დასახელებისგან C
პროგრამა. გ გაფართოება
რა საერთო პრაქტიკა.
მე მოხვდა შენახვა.
და ახლა რა ლამაზი არის, რომ მე ეფექტურად ასწავლიან gedit,
რომ ეს არის C პროგრამა.
გაითვალისწინეთ, რომ ჩემი შავი და თეთრი ტექსტი არის ფერი კოდირებული ან
სინტაქსი ხაზი გაუსვა, რომელიც მხოლოდ ამახვილებს ჩემი ყურადღებას
სხვადასხვა სემანტიკური ნაწილების პროგრამა.
ზედა მარცხენა იქ, როგორც ჩემი პროგრამები კიდევ უფრო რთული, მე
გვექნება შემაჯამებელი ყველა რამ მე არ წერია.
ასე რომ ეს იყო.
ნება მომეცით ახლა დააშორებს და ქვევით ამ ტერმინალის ფანჯარაში.
>> ასე რომ, ეს ალბათ ახალი ბევრ ადამიანს.
თუ თქვენ არ გამოიყენება ბრძანების გარემოს, თქვენ არასოდეს
გამოიყენება DOS, ან თქვენ არ გამოიყენება Linux, ან თქვენ არასდროს გაიხსნა
თქვენი Mac OS ტერმინალის ფანჯარა, არსებობს უამრავი რამ, რაც
შეეძლო ერთად GUI, როგორიცაა მიუთითებს, და დაჭერით, და
გადმოიყვანა და ჩაშვების, და მოსწონს, მაგრამ ზოგადად -
რა თქმა უნდა მსოფლიოში კომპიუტერულ მეცნიერებათა -
გამოყენებით ბრძანების, სადაც თქვენ არ თქვენი მაუსის
ზოგადად, თქვენ მხოლოდ თქვენს კლავიატურაზე, ფაქტიურად ბევრი
უფრო ძლიერი ვიდრე ინტერფეისი, ერთხელ თქვენ მიიღებთ acclimated to
სხვადასხვა ბრძანებებს.
და თქვენ ერთგვარი თავისუფალი თავს სჭირდება აღვნიშნო და დააჭირეთ
ზე ყველაფერი.
ასე რომ gedit ჩვენ ერთგვარი აქვს საუკეთესო ორივე სამყაროს.
ჩვენ შეგვიძლია გადააადგილება ტექსტი, ვხედავთ მას
ლამაზი და ფერადი კოდირებული.
მაგრამ როდესაც საქმე დროის გასაშვებად ჩვენი პროგრამა, ჩვენ ზოგჯერ
ისარგებლეთ ამ პატარა ფანჯარა აქ.
>> ამიტომ მე ვაპირებ წავიდეთ წინ და ამის გაკეთება.
ქვედა შავი და თეთრი ფანჯარა, მე ვაპირებ წავიდეთ წინ
და დაწეროთ clang.
და clang არის სახელი შემდგენელი.
ეს პროგრამა, რომელიც აკონვერტებს ჩემი კოდის
შევიდა, ასე რომ, ობიექტის კოდი.
0S და 1s, რომ ჩვენ ვნახეთ მოკლედ გასულ კვირას.
შეგახსენებთ, გასულ კვირას, ჩვენ დაგვპირდნენ, რომ ჩვენ ვაპირებთ
აქედან რაღაც მსგავსი - ჩვენ საჭიროებს
მსგავსი რამ -
და ეს ნამდვილად არ რაღაც რომ ადამიანის აპირებს
გავაკეთოთ ხელით.
ასე რომ ნაცვლად ჩვენ ვაპირებთ გამოვიყენოთ პროგრამა, და რომ პროგრამა
ამ შემთხვევაში ეწოდება Clang.
და სახელი ჩემი პროგრამა hello.c.
რათა მოხდეს კომპილაციის hello.c საწყისი კოდის შევიდა
ობიექტის კოდი, ან 0S და 1s, უნდა საკმარისი უბრალოდ
ამ და დააჭიროთ.
>> Okay, არაფერი ჩანს არ მოხდა.
მაგრამ მე ვიცი ახლა, ან გასულ კვირას, რომ რა სახელით
პროგრამა, როცა დაწერილი C, არის სულელურად მოუწოდა a.out.
ყველაზე uninteresting სახელი თქვენ ვერ ამუშავება.
ეს არის პირველი წერილი ანბანი, აქედან არის, რა იყო
outputted, მაგრამ ასე იქნება ეს.
ეს არის ჩემი პროგრამა, და ახლა dot ხაზი, როგორც ვნახავთ, არის
რეალურად მხოლოდ ერთგვარი უსაფრთხოების თვისება, რადგან
a.out არის პროგრამა დავწერე.
ეს არ მოდის და ჩემი კომპიუტერიდან, ის არის
არ Program Files.
ეს არ Mac OS-ის პროგრამები საქაღალდეში.
მე უნდა იყოს სუპერ გამოკვეთილ კომპიუტერული და აცხადებენ,
ამ პროგრამის a.out, არის მიმდინარე საქაღალდეში,
მიმდინარე დირექტორია.
და ისე წარმოადგინოს ეს გარემო მოსწონს
არის dot წარმოადგენს რომელ ფოლდერსაც თქვენ გაკეთებული სისტემაში
და ა.შ.. / მხოლოდ ნიშნავს აწარმოებს a.out
მიმდინარე საქაღალდეში.
მე აწარმოებს ამ შეიყვანეთ და voila, ჩემი პირველი პროგრამა.
>> ახლა ნება მომეცით მიიღოს უკან გადადგმული ნაბიჯია.
ეს ფანჯარა არის პატარა პატარა, და მიხვდებიან, რომ ბოლოში
დაუტოვებიათ მოწყობილობის აქ არის კიდევ ერთი ხატი.
ერთი არის Chrome, რომელიც უნდა იყოს საკმაოდ ნაცნობი, უბრალოდ ვებგვერდი
ბრაუზერის შიგნით ელექტრო მოწყობილობების.
და ეს შავი და თეთრი ხატია მხოლოდ
უფრო დიდი ტერმინალი ფანჯარა.
ასე რომ, თუ იგი იღებს პატარა შემაშფოთებელი დასალაგებლად აქვთ მხოლოდ
ამ პატარა პატარა ნაჭერი ფანჯარა რომელიც უნდა შეარჩიონ
ერთად პროგრამები, შეგვიძლია ნაცვლად ამის გაკეთება.
და ახლა დავიწყებ აკრეფის რამდენიმე მალე
უნდა იყოს ნაცნობი ბრძანებები.
LS.
ამიტომ ls არის შემქმნელი ჩამონათვალი.
ასე რომ Mac OS ან Windows, თქვენ ამას ჩვეულებრივ ორჯერ დააწკაპუნეთ
საქაღალდე და შემდეგ, voila, ხედავთ ყველა სხვადასხვა ფაილები
და დასტების.
In ბრძანების გარემო, სადაც შეგიძლიათ მხოლოდ აკრიფოთ
ბრძანებების ან ტექსტი, ls არის ეკვივალენტი.
ასე რომ ეჩვენებინა რა ამ დირექტორიაში.
>> ახლა არის bunch პერსონალის აქ რომ ორივე პატარა
ნაცნობი და პატარა უცნობ.
მაგრამ ცნობა, ისევე, როგორც Windows და Mac OS, jharvard
აქვს დესკტოპის ფოლდერი.
ასე რომ ნებისმიერი ხატები, რომლებიც მაგიდაზე მოხდება
უნდა იყოს, რომ საქაღალდეში.
არსებობს ჩამოტვირთვების ფოლდერი, პერსონალი რომ
Chrome შეიძლება დააყენოს იქ.
Dropbox.
ასე რომ ელექტრო მოწყობილობების გააჩნია ჩაშენებული მხარდაჭერა Dropbox
ასე რომ მეტი სემესტრის, შეგიძლიათ სინქრონიზაციის თქვენი Dropbox
ანგარიშის ისე, რომ ყველა თქვენი პროგრამების გამყარებული.
ისინი ხელმისაწვდომია თქვენს კომპიუტერში სხვა.
თუ რამე ოდესმე მიდის არასწორი ერთად ელექტრო მოწყობილობების, თქვენ შეგიძლიათ
ძალიან მარტივად აღდგენა Dropbox.
ასე რომ ფოლდერი არის იქ რომ.
არსებობს ორი ფაილი რომ მე მივიღე - hello.c
და a.out.
და შემდეგ უფლება არსებობს რამდენიმე სხვა ფოლდერები რომ ჩვენ
მისაღებად მიმართ ბოლომდე სემესტრის ერთად ვებგვერდი
პროგრამირების.
ასე რომ, როდესაც გავაკეთო. /, A.out, მიუთითოთ, რომ ვამბობ, წავიდეთ
დირექტორიაში მე, მიმდინარე დირექტორიაში და გაუშვით
პროგრამის მოუწოდა a.out უფლება არსებობს.
>> ყველა უფლება ისე, რომ ლამაზი და კარგია, მაგრამ ეს არ არის ყველა, რომ
მყარი დაწერა პროგრამა მოუწოდა დაეხმარონ a.out.
ასე რომ ჩვენ შეგვიძლია რეალურად ამის გაკეთება ცოტა განსხვავებულად.
ასე რომ ნაცვლად მხოლოდ გაშვებული clang, hello.c, მოდით დაამატოთ
რასაც ბრძანების არგუმენტი.
ასე რომ ბრძანების არგუმენტი, ან შეცვლა, ამ შემთხვევაში, მხოლოდ
კიდევ ერთი სიტყვა ან ფრაზა, რომ თქვენ ტიპის სწრაფი შემდეგ
პროგრამის გსურთ აწარმოებს.
ასე რომ, ამ შემთხვევაში, clang არის პროგრამა მინდა აწარმოებს,-o
საშუალებების გამომავალი ფაილი რომ აღარ მოუწოდა a.out.
გამოყვანის ფაილი სახელად hello, და ამისათვის მიერ შედგენა
ბოლო სიტყვა ხაზი, hello.c.
ასე მოკლედ, ეს არის ძალიან მარგინალური გაუმჯობესების, რომლის დროსაც
ნაცვლად, რომელმაც ამ stupidly დაასახელა ფაილი a.out,
შემიძლია ახლა clang-o hello, მაშინ hello.c, და
შემდეგ დააჭიროთ.
არაფერი ჩანს მოხდეს, მაგრამ კიდევ ერთხელ ჰგავს - 0, როდესაც
არაფერი ჩანს რომ მოხდეს, რომ არაფერს ნიშნავს არასწორი მოხდა -
ამიტომ მოდით ls ახლა, შეიტანეთ, და მართლაც მე ახლა
აქვს მიესალმები პროგრამა.
ასე რომ, თუ მე აკრიფოთ მიესალმები ახლა, ბრძანება ვერ იქნა ნაპოვნი.
OK,. /.
ასე რომ სწორედ.
ასე რომ, რადგან ეს პროგრამა დავწერე, და ეს არ მოდის ერთად
კომპიუტერი,. / Hello, მიუთითოთ, ნიშნავს
მე კოალიციაში hello.
>> ასე რომ ის არსებობს.
ეხლა ჩვენ ყველაფერს საბოლოოდ კიდევ უფრო და უფრო command line
არგუმენტები, რომ საშუალებას მოგვცემს უფრო მეტი, მაგრამ მხოლოდ იმ მიზნით
ვისაც ეს შეიძლება იყოს წლის ქუდი, მინდა რეალურად წასვლას
დირექტორია აქ და მხოლოდ მოგცემთ teaser, თუ როგორ სხვაგან ჩვენ
შეიძლება წავიდეს შესახებ ახორციელებს Hello world.
ნება მომეცით წასვლას აქ, და მე ვაპირებ გახსნა.
ასე რომ, რეალურად, მე ვაპირებ აგიხსნათ რა ვაკეთებ, ისე
ეს არის სასარგებლო.
ნება მიბოძეთ უკან მდე.
>> ასე რომ მე ამით დიდი ხნის განმავლობაში.
ასე რომ შეამჩნია დასრულდა უფლება არსებობს რამდენიმე
დირექტორიები, რომლებიც უცნაური სახელწოდებით source1m და source1w.
ეს არის უბრალოდ სულელური კონვენციის ვიყენებთ.
წყარო მხოლოდ იმას ნიშნავს, კოდის, 1 ნიშნავს ეს კვირაში ერთი, და
მ ნიშნავს ეს ორშაბათს, და w ნიშნავს ეს კვირა.
ასე რომ არაფერი cryptic არსებობს.
უბრალოდ სტენოგრამის ნოტაცია.
ეს ლურჯი რამ ფოლდერები, სხვაგვარად ცნობილია როგორც
დირექტორიების.
მინდა წასვლას რომ ფოლდერი არის და ნორმალური კომპიუტერი
შემეძლო მხოლოდ ორჯერ დააწკაპუნეთ საქაღალდეში ხატი და
იქ ყველა ჩემს კომპიუტერში.
მაგრამ ბრძანების გარემო, მე ვერ გავაკეთებ საკმაოდ
რომ, ასე ნაცვლად, უნდა შეიცვალოს დირექტორიები ხელით.
ასე რომ, თუ I ტიპის CD და შემდეგ source1m, შეიყვანეთ შეამჩნევთ, რომ
ჩემი დროული, რამ თეთრი დროს მარცხენა, უბრალოდ შეიცვალა.
და ა.შ. რა თქმა უნდა, როდესაც ეს უბრალოდ განაცხადა ფრჩხილებში და მერე
პატარა squiggle, tilde სიმბოლო, რომ მხოლოდ იმას ნიშნავდა, მე ვიყავი
იოანე ჰარვარდის სახლის დირექტორია, მისი ჩემი დოკუმენტები,
მისი პირადი საქმეები.
მაგრამ ახლა ფრჩხილებში წერია ~ / source1m.
ეს მხოლოდ იმას ნიშნავს, მე საქაღალდეში მოუწოდა source1m
რომ იოანე ჰარვარდის სახლის დირექტორია.
ასე რომ, თუ მე ახლა მინდა ჩამოთვლა ფაილი ფოლდერის, ადვილად
კითხვას, აკრიფოთ მხოლოდ ls.
და ახლა მე ვხედავ ყველა ფაილი, რომელიც მე წინასწარ შექმნილი დღევანდელი
ლექცია, რაც, ან ყველაზე მეტად რაც, მოხდება
უნდა დასრულდეს. გ.
>> ნება მომეცით, წავიდეთ წინ არის და აწარმოებს gedit პროგრამის მოუწოდა
holloway.c, რომელიც დაწერილი ზოგიერთი შემთხვევითი ჰაკერი
ინტერნეტში, რომელიც გამოიყურება პატარა მოსწონს ეს.
და ჩვენ არ ვაპირებთ გავლა ამ ერთი ნებისმიერ
დეტალურად, არამედ იმ უფრო კომფორტული, კერძოდ, თუ
გსურთ მიიღოს ამოიცნობთ, თუ რა ამ პროგრამის აკეთებს აქ.
დანარჩენი დავრწმუნდი, თუ თქვენ ნაკლებად ან უფრო კომფორტული,
ჩვენ კი არ მიიღოთ ამ სახის რამ ბოლოსთვის
ამ სემესტრში.
ეს არის რა მაგალითია obfuscated C კონკურსში, რომელიც
საშუალებები წერენ საუკეთესო cryptic ეძებს პროგრამა თქვენ შესაძლოა
შეიძლება რომ outdo სხვა ჭკვიანი ადამიანები, რომლებიც ასეთივე
ცდილობს დაწეროს ნივთები და გამოიჩენენ, რომ მათ შეუძლიათ დაწერონ
მეტი cryptic რამ, ვიდრე თქვენ.
ასე რომ, ეს არ არის მაგალითი კარგად დაწერილი პროგრამის
პერსპექტივა სტილი, ეს არის მაგალითი იმისა, რომ პროგრამა
გაიმარჯვებს კონკურსში, ხალხისთვის ცდილობს
იყოს ბუნდოვანი და აბსტრაქტული.
>> ასე რომ, თუ ჩვენ აწარმოებს ამ რამ, ნება მომეცით წასვლას ჩემი ტერმინალის ფანჯარა,
ასე ვთქვათ.
ასე რომ, ეს შავი და თეთრი გარემოს ეწოდება
ტერმინალის ფანჯარაში ზოგადად.
ნება მომეცით წავიდეთ წინ და კომპილირება.
მე არ ვაპირებ გამოიყენოს clang, რადგან ამ პროგრამის
პატარა cryptic და მას სჭირდება სხვადასხვა
შემდგენელი, ერთი მოუწოდა gcc.
მაგრამ ეს იმას იგივე.
იგი იღებს კოდის გააპროტესტებენ კოდი.
და ახლა თუ აწარმოებს a.out, რომ პროგრამის
უბრალოდ დაინახა აკეთებს ამას.
ასე რომ თანამემამულე, რომ წელიწადში მოიგო, რომ კონკურსში.
Anyhow, ჩვენ არ ვაპირებთ ამ მიმართულებით, თავისთავად.
>> მოდით რეალურად ცდილობენ ახლა აჯავრებენ გარდა რა შეგვიძლია გავაკეთოთ
ამ საბაზისო შენობის ბლოკები, რათა უფრო და უფრო
საინტერესო პროგრამები.
ამიტომ ჩვენ წერილობითი პროგრამა, ჩვენ აწარმოებს პროგრამა.
ახლა ჩვენ შეგვიძლია რეალურად გაამარტივებს და აღარ წერენ
სიტყვა clang ბრძანებათა ზოლზე.
თურმე, როგორც ჩვენი პროგრამების უფრო cryptic, ჩვენ შევძლებთ, ან
უფრო რთული არამედ, ჩვენ შეგვიძლია რეალურად აწარმოებს ამ ბრძანებას.
ნება მომეცით, დავუბრუნდე ჩემს სახლში დირექტორია, ასე ვთქვათ, ნება მომეცით
ამოიღონ - Rm არის remove ბრძანება - I'm going ამოიღონ
ფაილი სახელად a.out და hello.
და ახლა ცნობა, ბრძანების გარემო, ჰგავს, რომელიც
GUI, თქვენ აიძულა. მე ვერ დააჭირეთ ღილაკს თუმცა, მე
უნდა აკრიფოთ Y ამისთვის კი, Y ამისთვის კი.
და ახლა თუ აკრიფოთ ls კვლავ შეამჩნევთ, რომ იმ მწვანე
პროგრამები - a.out და მიესალმები -
არ გაქრება.
ვუფრთხილდეთ Rm.
მას შეუძლია გააკეთოს ცუდი რამეები, ისევე, როგორც თქვენ შეგიძლიათ მიერ გადმოიყვანა
რამ თქვენი ურნის.
>> ახლა მოდით წავიდეთ წინ - და მე ვერ გავაკეთებ ამ - clang-o
hello, მიესალმები -
მე უკვე შეწუხებული აკრეფით, რომ ბრძანება.
მიუხედავად იმისა, რომ მე აკრეფილი ეს პატარა სწრაფად.
ასე რომ ჩვენ შეგვიძლია გავაკეთოთ ნაცვლად მიიღოს hello.
ასე რომ არ არის შემდგენელი.
უბრალოდ მეგობრული პროგრამა, რომელიც მოდის Linux, ამ
შემთხვევაში - ოპერაციული სისტემა -
რომ automates პროცესში შედგენა პროგრამები.
ასე რომ ნაცვლად დამახსოვრების clang-o ფაილის სახელი და
მაშინ ა.შ., განსაკუთრებით ერთხელ იმ ხაზების მისაღებად აღარ და
აღარ შემიძლია უბრალოდ წერენ მიიღოს.
და ეს არის აპირებს Spit out მთელი bunch პერსონალის, რომ
ჩვენ საბოლოოდ ვხედავთ ამ სემესტრში.
მაგრამ შეამჩნევს არის თუ ტიპის ls, მიესალმები დაბრუნდა ჩემი დირექტორია.
მართლაც შემიძლია აწარმოებს იგი. / Hello.
ასე რომ მხოლოდ automates პროცესში გაშვებული, რა იყო,
ამ შემთხვევაში, გაცილებით ადრე, უფრო რთული ბრძანება.
ამიტომ, ჩვენ ვაპირებთ დავიწყოთ გამოყენებით მარკა, მხოლოდ იმიტომ, რომ ეს ბევრი
მეტი მომხმარებლის მეგობრული.
>> მაგრამ ახლა მოდით უფრო საინტერესო პროგრამა
ვიდრე უბრალოდ მიესალმები.
ასე რომ, პროგრამების ჩვენ წერილობითი დღემდე იქ მთავარ.
ეს მხოლოდ ნაგულისხმევი რაც ჩათვლით ყველაფერი off.
თუმცა, არსებობს სხვა ფუნქციები არსებობს ასევე, და
stdio.h არის, რაც ჩვენ ვნახეთ ზედა ჩვენი
ფაილი წინაშე, და არის ის, რაც ცნობილია, როგორც სტანდარტულ ბიბლიოთეკაში.
შიგნით სტანდარტული ბიბლიოთეკა მთელი bunch of ფუნქციები
რომ ვინმე წერს, და ჩვენ შეგვიძლია დავიწყოთ გამოყენებით ამ
ფუნქციების დაწერა მეტი
საინტერესო პროგრამები საკუთარ თავს.
>> ნება მომეცით, დავუბრუნდე ელექტრო მოწყობილობების.
მე ვაპირებ დახურვა ტერმინალის ფანჯარაში.
მე ვაპირებ დახუროს რამ დაწერა ადრე, და უბრალოდ
შევიდა hello.c, და შეამჩნია, ახლა შემიძლია შემდეგ.
Hello world არ არის ყველა, რომ საინტერესო, მინდა
personalize ეს პროგრამა თვითონ.
ასე რომ ნაცვლად ამბობდა მსოფლიოში, მე ვაპირებ
წავიდეთ წინ და ვთქვათ -
მე ვერ აკრიფოთ დავით - მაგრამ ეს ნამდვილად არის ერთგვარი
ფუნდამენტურად იგივე.
მაგრამ მოდით ვცდილობთ out ამ placeholder იდეა.
შეგახსენებთ, რომ C, საკმაოდ წელს printf, ჩვენ გვქონდა ამ
placeholders, და არსებობს მხოლოდ% d.
ასე% d იყო, სწრაფი sanity ქვითარი.
Okay, ათობითი რიცხვი, რომ არის ის.
ათობითი ციფრები, ეს იყო.
ასე% C, როგორც ჩვენ ვაწყდებით, იქნება ხასიათი.
განათავსეთ ხასიათი აქ, წერილში მეშვეობით z,
ან პუნქტუაციის სიმბოლო.
ერთჯერადი ხასიათი,% f, რა სხვა ენებზე?
ასე რომ მცურავი წერტილი ღირებულება.
რეალური რაოდენობა.
ასე რომ არ ათობითი რიცხვი - ეს არის რეალურად ნამდვილი ნომერი
ათობითი წერტილი, და ზოგიერთი ხმების ციფრები მარცხნივ
და მარჯვნივ.
% S, სტრიქონი.
რომ ერთ ჩვენ ვაპირებთ ვხედავ ხშირად.
სიმებიანი, კიდევ ერთხელ, მხოლოდ ერთი სიტყვით, ფრაზა, თანმიმდევრობა
ინდივიდუალური სიმბოლო.
და ბოლოს, lld?
ასე რომ, ეს უფრო კუთხეში შემთხვევაში.
ხანგრძლივი ათობითი.
ასე რომ, თუ გსურთ არა მხოლოდ ნომერი, რომელიც ამ დიდ, თქვენ
მინდა უფრო დიდი რაოდენობის, თქვენ აპირებს უნდა მიუთითოს, რათა
კომპიუტერი რომ კონკრეტული ზომა.
>> მოდით tweak ამ ცოტა.
და არა მხოლოდ მძიმე კოდი დავით, ნება მომეცით ოდნავ
დინამიურად ამბობენ% s.
ასე დააყენა% s აქ, რაც placeholder for სიმებიანი.
მაშინ ნება მომეცით გავაკეთოთ მძიმით, და შემდეგ "დავითი" აქ.
ახლა ეს არ არის ყველა, რომ ინტელექტუალურად საინტერესო,
რადგან ყველა მე ვაკეთებ ახლა ნამდვილად შექმნა სამუშაოები
კომპიუტერი.
იმის ნაცვლად, რომ გითხრათ კომპიუტერი ამ ერთდროულად, მე ახლა
ამბობდა ამის გაკეთება და ჩადეთ სიმებიანი აქ საბოლოოდ, მძიმე,
აქ არის ის, რომ სიმებიანი.
ასე რომ, ეს არ არის უკეთესი გაუმჯობესებას, მაგრამ არანაკლებ
ნაბიჯი უფრო საინტერესო პროგრამა.
რადგან ახლა, მინდა წავიდეთ წინ და ამ ფანჯრის პატარა
დიდია, ნება მომეცით წავიდეთ წინ და აწარმოებს მიიღოს hello.
და ახლა,. / A.out არ მუშაობს, რატომ?
ყველა უფლება, ახლა კი მოუწოდა hello.
ასე რომ კიდევ ერთხელ გააკეთოს, და ასევე clang ერთად-o, ეწოდა
პროგრამა უნდა იყოს რაღაც უფრო საინტერესო.
და voila: ახლა კი ამბობს მიესალმები დავით.
>> ყველა უფლება, ისევ სულელური პროგრამა.
ახლა მოდით რეალურად დაბრუნდეს აქ და დანერგვა ცნება
საქართველოს ცვლადი.
არ იქნება ლამაზი, თუ შეიძლება განაცხადოს ცვლადი
რომელთა ტიპის სიმებიანი?
და ცვალებადი ღირებულების რეალურად მოდის მომხმარებლის
მას ან თავად.
ასე თვითნებურად, მე ვაპირებ მოვუწოდო ჩემი variable s, რომელიც
უბრალოდ საერთო კონვენციის როდესაც თქვენ ერთი ცვლადში
სიმებიანი.
მე აპირებს თანაბარი ნიშანი, ხოლო შემდეგ მე ვაპირებ მოვუწოდო
ფუნქციის მოუწოდა GetString.
ამიტომ GetString არ არის რაღაც, რომ მოდის ჩაშენებული C. ეს
ფუნქცია რომ CS50 პერსონალის წერდა, ნამდვილად მხოლოდ
ამ პირველი რამდენიმე კვირის, გამარტივება პროცესში
მიღების მომხმარებლის შეყვანის და იძენს მომხმარებლის შეყვანის სახით
საქართველოს სიმები, ან ნომრები, და ასეთი.
ამიტომ GetString ჰგავს printf, მაგრამ აშკარად, ვიდრე
ბეჭდვა ეს აპირებს რა მისი სახელი ამბობს, მიიღოს სიმებიანი.
მაგრამ გამოიყენოს GetString, ჩვენ ვაპირებთ უნდა გააკეთოთ ცვლილება
აქ, სცილდება ამ.
ასე რომ ინტუიციურად, ამ პროგრამის, იმედია, აპირებს როგორღაც
მიიღოს სიმებიანი საწყისი მომხმარებელი, და მაშინ რა არის ის აპირებს
რომ სიმებიანი, მოუწოდა s?
უბრალოდ აპირებს ბეჭდვა ეს, არა?
ჯერ კიდევ არ არის მასტიმულირებელი პროგრამა, რადგან ყველა ეს ხდება
გააკეთოთ plug ამ ღირებულების შევიდა, სადაც% s
ამბობს, რომ უნდა წავიდეს.
>> მოდით მინიმუმ ვხედავთ ამ მოქმედებაში.
ნება მომეცით შენახვა და დააშორებს.
ახლა ჩემი ტერმინალის ფანჯარაში ქვემოთ აქ, პატარა ნაჭერი ერთი,
ნება მომეცით კიდევ ერთხელ გავაკეთოთ მიიღოს hello.
Okay, და AH, Damn, მე მივიღე მთელი bunch of შეცდომები.
ნება მომეცით გადახვევა მდე, და ჩვენ ვხედავთ ჩვენი პირველი -
მოდით რეალურად ამის გაკეთება წელს უფრო დიდი ფანჯარაში, ასე რომ თქვენ
ხედავთ, როგორ ცუდად მე ბრალია -
ასე რომ hello.
Okay, რომ კატასტროფა, არა?
მე დაწერილი სამი ხაზი კოდი და
ეს მომცა 12 შეცდომები.
მაშ რატომ არის ეს?
ასე რომ საბედნიეროდ, oftentimes როდესაც ხედავთ ბევრი, ბევრი შეცდომები
spitting გარეთ ერთდროულად, ეს მართლაც მხოლოდ იმიტომ, რომ თქვენ
დაბნეული კომპიუტერი აქ.
და ეს რჩება დაბნეული ახლა იგი იღებს ქვემოთ აქ.
ამიტომ მხოლოდ იწყება tripping და stumbling, და
spitting მეტი საშინელი პერსონალის ვიდრე რეალურად ვრცელდება.
ასე რომ ზოგადად, ყოველთვის იწყება ზედა ერთი.
>> ასე რომ ძალიან დაბრუნება საუკეთესო მაგალითად წითელი,
შეცდომა არის ამ.
გამოყენება გამოუცხადებელ იდენტიფიკატორი სიმებიანი, არც მე
ნიშნავს სტანდარტს?
მე არ.
ამას ვგულისხმობდი სიმებიანი, მაგრამ ეს იმიტომ, რომ, ძალიან, სიტყვა string
რომ მე შენარჩუნება გამოყენებით სიტყვიერი რეალურად
არ არსებობს C ან.
ეს რაღაც ჩვენ ვიყენებთ მხოლოდ პირველი ორი კვირის
აქ, მაგრამ ის არსებობს ფაილი სახელად cs50.h.
ასე რომ, ახლა, ვიცით, რომ არსებობს ამ სხვა ბიბლიოთეკაში, რომ
პერსონალის წერდა, ამიტომ დაწერილი მეტი ხნის წინ, ვიდრე
stdio.h.
მაგრამ შიგნით cs50.h არის განმარტება, სინონიმი
ჯიშები, რომელიც ქმნის ამ სიტყვის სიმებიანი.
>> ახლა ნება მომეცით დაბრუნდეს ჩემი ტერმინალის ფანჯარაში.
მე ვაპირებ გარკვევას ამ მთელი სასადილო მიერ Ctrl-L. ჩვენ ყველაფერს მხოლოდ
wipe ყველაფერი სუფთა, და მე ვაპირებ წავიდეთ წინ და მიიღოს
მიესალმები ერთხელ, შეიყვანეთ.
ასე რომ, თუ რა მოხდა ახლა?
ახლა ყველა იმ შეცდომების წავიდა.
მერე რა არ მე ნამდვილად კეთდება?
მე უბრალოდ ისწავლება კომპიუტერის რომ სიმებიანი არსებობს, და ეს
ამ ფაილის მოუწოდა cs50.h.
ასე რომ შეწყვიტოს პრეტენზიებს, რადგან ახლა თქვენ იცით სად შეიძლება ვიპოვოთ
რომ ფუნქცია განცხადებას ასე ვთქვათ.
სადაც ის არსებობს მსოფლიოში.
>> ახლა მე ვაპირებ წავიდეთ წინ და აწარმოებს hello.
მე, როგორც ჩანს, აქვს უსასრულო მარყუჟის, არაფერი ხდება.
ასე რომ მე უნდა აკრიფოთ რაღაც აქ, მარჯვნივ.
პირველი ხაზი კოდი ჩემი პროგრამა GetString.
ამიტომ სიტყვასიტყვით მელოდება მიიღოს სიმებიანი.
ასე რომ ამ მხრივ კი, ეს უსასრულო ციკლი.
როგორც ჩანს წელს GetString არის რა საქციელი, რომ ჩვენ
წერდა - თანამშრომლები -
რომ ამბობს დაველოდოთ და დაველოდოთ და დაველოდოთ და დაველოდოთ და დაველოდოთ,
სანამ მომხმარებლის გაძლევთ სიმებიანი აკრეფით რაღაც სისტემაში
ნება მომეცით, წავიდეთ წინ და ტიპის D--V - I-დ, შეიყვანეთ.
და იქ არის, მიესალმები დავით.
>> ახლა ამჯამად ამ თითქოს ეს მხოლოდ აქტი?
ნება მომეცით წავიდეთ წინ და აკრიფოთ ტომი.
შეიყვანეთ, okay, როგორც ჩანს, სამუშაო.
სამუშაოები რობ, სამუშაოები Zamyla, მუშაობს - okay.
ამიტომ იმუშავებს, სავარაუდოდ.
ასე რომ უნდა ამობეჭდოთ რაც ჩვენ რეალურად მისცეს მას,
და ჩვენ შეგვიძლია ვიყოთ ცოტა რთული აქ.
ვნახოთ თუ რაღაც მსგავსი hello.
შეიძლება მეტი აქ, ვნახოთ, ასლი, პასტა.
მე არ ვაპირებ, რომ სწრაფად ჩასვით რომ ბევრჯერ აქ.
Paste, okay, Shift + Ctrl + V. ასე რა
მოხდეს რომ ცუდი აქ?
>> Okay, ასე, segfaults.
ასე რომ ზოგიერთი თქვენგანი წინასწარი ფონზე ეცოდინებათ, რომ
ზოგადად, რაც კომპიუტერები უამრავი საშუალებებით, როდესაც ისინი
ალბათ არ გულისხმობს მიიღოს ხანგრძლივი სახელები მოსწონს - ცუდი
რამ ხდება.
მართლაც, სამყაროში ვებგვერდი, ძალიან, ეს ხდება საკმაოდ მწირი,
რის, როდესაც თქვენ დიზაინის ნახვა, როდესაც თქვენ
პროექტირება Facebook, თქვენ უნდა გააკეთოთ თვითნებური გადაწყვეტილებები up
წინა, როგორიცაა სანამდე გაგრძელდება ვინმეს
Facebook ნიკი იყოს?
ან რამდენ ხანს იქნება ვინმეს სახელი იყოს?
რამდენ ხანს იქნება ვინმეს ტელეფონის ნომერი იყოს და ასე შემდეგ.
და თუ პროგრამისტები მიიღოს ცუდი ვარაუდები, პროგრამები შესვენება
რადგან თქვენ ცდილობენ მათთვის უფრო გამომუშავება, მეტი შეყვანის
უფრო მეტიც, ვიდრე მათ აქვთ მეხსიერებაში.
ან RAM გამოყოფილი, და ასე რომ, თუ ახლა მე 'Enter,
რომ პროგრამა რეალურად მუშაობდა, რადგან ჩვენ იმყოფებოდნენ ბიბლიოთეკა
და ჩვენ, ფაქტობრივად, მოსალოდნელია ამ კონკრეტულ შემთხვევაში.
მაგრამ უდავოდ ამ სემესტრში, თქვენ უნდა დაწეროს მინიმუმ ერთი
პროგრამა, რომელიც აცხადებენ, რომ ეს სიტყვები.
დამახსოვრება ამ კვირის ახლა, შესაძლოა, ორი დღის ამიერიდან.
სეგმენტაციის ბრალია ცუდი რამ.
ეს იქნება მიმართეთ თქვენს აკეთებს, რომ რაღაც კომპიუტერულ
არ გავუსწრო.
და ამ შემთხვევაში, თქვენ, პროგრამისტი, არ გავუსწრო.
ჰგავს რა ამ pile of წინდები, იყო სხვადასხვა
კუთხეში შემთხვევაში ჩვენ შეეძლო შეექმნა.
ანალოგიურად პროგრამების თუ არ გავუსწრო რამდენი ხანი
ვინმეს სახელი იქნება.
ან რა თუ მაქვს მუქარის მომხმარებელი, და მისი სახელი არის
რეალურად საკმაოდ ცოტაა, მაგრამ ისინი უბრალოდ ვცდილობთ
to mess with me?
რა იქნება ქცევის ჩემი პროგრამა?
ისე, ამ შემთხვევაში, რაიმე შედეგს რეალურად მისაწოდებლად.
>> ასე რომ მოდით ეს.
In 90 წუთი, ეს საშინელი ხანგრძლივი დროის
გავაკეთოთ კომპიუტერულ მეცნიერებათა.
რატომ არ მივიღებთ შევიდა ჩვევა აღების ხუთი წუთი
შესვენება აქ, და როდესაც ჩვენ დავბრუნდებით, ჩვენ ჩაყვინთვის შევიდა ზოგიერთი
უფრო რთული და მყარი პროგრამებს?
ხუთი წუთის განმავლობაში.
>> ყველა უფლება.
ასე რომ ერთი სწრაფი კომენტარი.
მე მითხრეს, რომ მიუხედავად იმისა, რომ ეს იყო ეკრანზე, სანამ, თუ რა
გამოვიდა ჩემი პირით იყო cs50.net/rsvp.
ეს არის სწორი. cs50.net/lunch.
ახლა შეგიძლიათ RSVPing ამ დროს / ლანჩი.
მაგრამ მოდით ეს არის.
ასე რომ, ეს იყო სუპერ სწრაფი, სუპერ ახალი, უამრავი FOLKS.
ძველი ქუდი ზოგიერთი FOLKS.
მოდით გადახვევა მხოლოდ მომენტში და ვნახავთ, როგორ მივიღეთ, რათა
ამ Hello world გამომავალი მხოლოდ მომენტში წინ.
>> ამიტომ პირველი, ამ CS50 ელექტრო მოწყობილობების.
ერთხელ, ნაჭერი პროგრამული უზრუნველყოფა, პრობლემის მითითებული 1 აპირებს ვუთხრა
თუ როგორ უნდა გადმოწეროთ, სადაც მისი ჩამოტვირთვა, რა უნდა მიჰყვეთ
და სხვ.
და მერე კიდევ თქვენ დაიცვას იმ ინსტრუქციების, თქვენ გექნებათ
მაქსიმალურად თქვენი ფანჯარა, და თქვენი Mac ან PC გამოიყურება
პატარა რაღაც მსგავსი.
შავი ფონზე, მთავარი ფოლდერი ზედა, სადაც ყველა
თქვენი ფაილების წასვლა, ნაგვის შეიძლება ზედა მარცხენა,
მენიუ ბოლოში.
ასე რომ კიდევ ერთხელ, საკმაოდ მსგავსი სულისკვეთებით, რათა Mac OS ან Windows,
მიუხედავად იმისა, რომ ეს მოხდება იქნება Linux.
ასე რომ რა მივიღეთ შემდეგი გავაკეთოთ?
კარგად დავიწყეთ წერა პროგრამები.
და გავიხსენოთ გასულ კვირას, რომ ყველა ეს ხდება დაწერა
პროგრამა არის მარტივი ტექსტური რედაქტორი,
მოსწონს ჩასაწერი ან TextEdit.
გულწრფელად ვამბობ, თქვენ შეგიძლიათ კიდევ გამოიყენოთ Microsoft Word.
მაგრამ ცუდი საბოლოოდ მოხდეს, რადგან ისინი ძალიან
მძიმე გადასცა გადაწყვეტა პროგრამის წერა, პლუს ეს გამოგიგზავნით
შეინახეთ ის არასწორი ფაილის ფორმატი.
მაგრამ ეს მხოლოდ ტექსტური რედაქტორი, სიტყვა პროცესორი, რომელიც ყველა რომ
საჭირო დაწერა პროგრამა.
>> ასე რომ, CS50 ელექტრო მოწყობილობების, ჩვენ შეგვიძლია გავაკეთოთ ეს ერთი მარტივი გზა.
ჩვენ შეგვიძლია უბრალოდ დააწკაპუნეთ ამ ხატულაზე ქვედა მარცხენა.
ისევ და ისევ, პრობლემა მითითებული იქნება 1 გირჩევთ ამ და voila -
თქვენ ამ შავი და თეთრი ინტერფეისი, სადაც შეგვიძლია დავიწყოთ
წერა კოდი.
მოდით ახლა გადავიდეთ წერილობით სუპერ მარტივი პროგრამა ერთხელ.
მე ვაპირებ წასვლა მდე ფაილი, შენახვა, და მე ვაპირებ მოვუწოდო
ამ, ასე ვთქვათ, hello2.c.
და მე უბრალოდ ვეუბნებოდი ეს დაწკაპვით jharvard, დაუსვან მას
მისი მთავარი დირექტორია, მე ნამდვილად არ აღელვებს
სადაც ეს ერთი მიდის.
და შემდეგ შენახვა.
და ახლა შეიძლება დაიწყოს წერა ჩემი პროგრამა.
და მახსოვს საწყისი ადრე რომ უნდა დაწეროს int
ძირითადი (void).
მიუახლოვდით ზედა მარცხენა.
და მაშინ მინდა ვთქვა printf, ორი.
და ახლა სტრიქონების გადატანით, მჭიდრო ციტირებით ახლოს
ფრჩხილებში, მძიმით.
და მერე ქვევით აქ ჩემი ტერმინალის ფანჯარაში რომ
ჩართული gedit, უბრალოდ მოხერხებულობის.
და მე ვაპირებ წავიდეთ წინ და დაწეროთ მიიღოს hello, მაგრამ არა
მიესალმები მარტო, hello2.
>> ასე რომ ჩემი ფაილის მოუწოდა hello2.c. ჩემი ფაილის ამიტომ
უნდა მოეთხოვოს hello2, ამ შემთხვევაში.
Dammit, რა გავაკეთო არასწორი?
ყველა უფლება, ამიტომ მე ნათლად გამოტოვებული ხაზი, თუ გავიხსენებთ რა
წინა პროგრამების გამოიყურებოდეს.
მაგრამ ვნახოთ, შევძლებთ თუ არა აჯავრებენ ამ გარდა.
სამწუხაროდ, ადამიანები, რომლებიც წერენ პროგრამებს, რომელთანაც
ჩვენ წერენ პროგრამებს არ გაამარტივებს რამ ყველა რომ კარგად.
ამიტომ, ჩვენ უნდა სახის skim მეტი რა არ მიიღოს საკმაოდ
იგრძნოს აქ და ვნახოთ, შევძლებთ თუ გაერკვნენ, რა არასწორი.
ძალიან პირველი ხაზი იქ ამბობს მინიშნებით გამოცხადების C
ბიბლიოთეკის ფუნქცია printf ერთად ტიპის int.
OK, მივხვდი, ნაწილი რომ.
მაგრამ, როგორც ჩანს უნდა alluding იმ ფაქტს, რომ მე გამოიყენება printf
არასწორი, რატომღაც.
და რა გაგებით არის ეს არასწორია?
მე უბრალოდ არ ასწავლიან კომპიუტერს რომ წელს ფაილი
მოუწოდა stdio.h.
ახლა მხოლოდ უნდა მხოლოდ გვემახსოვრება რომ printf არის
წელს stdio.h, და მართლაც, იქ იყოს სხვა
ფუნქციებს, რომ იგივე ფაილი, რომელიც ჩვენ შეეგუება.
>> ახლა ნება მომეცით წავიდეთ წინ და მოხვდა Ctrl-L უბრალოდ მიანიშნა, რომ
დაშორებით, გამეორება მიიღოს hello2 და voila.
და ეს ბრძანება ერთხელ, უფრო რთული, ვიდრე ჩვენ განუმარტოს
დღევანდელი მიზნებისათვის.
მაგრამ ამანაც აწარმოებს clang და clang იღებს კოდის და
SpitS გარეთ 0S და 1s.
და იმ 0S და 1s ამ შემთხვევაში უწოდებენ რა?
Okay, ობიექტი კოდი.
და ფაილი რომ ისინი წელს ეწოდება, ასე რომ,
hello2, ამ შემთხვევაში.
რადგან ჩემი ტექსტური ფაილი იყო hello2.c, შეიყვანეთ.
და ახლა არ მიიღოს ორი ძახილის წერტილი, ძახილის
წერტილი, ძახილის წერტილი.
ყველა უფლება, ასე რომ, ჩვენ გვაქვს ახლა უნარი მიიღოს სიმები,
როგორც ჩანს.
ისე, რა ვიღებთ წევრებს?
>> კარგად CS50 ბიბლიოთეკა, არსებობს სხვა ფუნქციებს,
ვაპირებთ გაამარტივებს ჩვენი ცხოვრება ამ პირველი რამდენიმე დღის განმავლობაში.
GetChar, GetDouble, GetFloat, GetInt,
GetLongLong, GetString.
კარგად, მოდით pluck off იოლი ამ პირველი.
GetString სიტყვასიტყვით არ რომ.
უბრალოდ ზის იქ, ელოდება მომხმარებელს აკრიფოთ რაღაცას,
და როგორც კი აკრიფოთ რაღაცას და დააჭიროთ, ეს
აკეთებს რაღაც, რომ ღირებულება.
მოდით დავუბრუნდეთ, რომ მაგალითად, რომ ნახოთ ზუსტად რა
GetString აკეთებდა.
ნება მომეცით წავიდეთ წინ და ქმნის წელს gedit, hello.c, და გავიხსენოთ
რომ უფლება, სანამ შესვენების ეს სადაც ჩვენ შეჩერდით.
>> მოდით ახლა აჯავრებენ ამ დაშლის პატარა უფრო დეტალურად.
ასე რომ on line 6, არსებობს ორი რამ
ხდება მომენტში.
თანაბარი ნიშანი არის ჰყოფს პირველ ნახევარში და მეორე ნახევარში.
ა.შ. მარცხენა მხარეს თანაბარი ნიშანი, ჩვენ
ამბობდა string s.
და მაშინ, ერისკაცად წარმოგვიდგება მისი თვალსაზრისით, რა არის string s
აკეთებს, როგორ ფიქრობთ?
ეს შექმნის რა?
ამიტომ შექმნა string მოუწოდა s.
ახლა რა, რომ ნამდვილად ნიშნავს?
ისე, ეს დაჯავშნა ფართი სიმებიანი მოუწოდა s.
ეს არ არის საკმაოდ უფლება.
რა არის ეს აკეთებს?
კარგად კომპიუტერები, როგორც მოგეხსენებათ, აქვს მყარი დისკები, რომ სადაც
თქვენი ფაილი ინახება.
კომპიუტერები აქვს RAM, და რომ სადაც პროგრამების ჩატვირთვის
ხოლო ისინი გაშვებული.
ასე რომ, როდესაც თქვენ ორჯერ დააწკაპუნეთ ხატი და Microsoft Word ხსნის
up, Microsoft Word გაშვებულია, ასე ვთქვათ, წელს RAM, რომელიც
ელექტრონული ნაწილი თქვენს კომპიუტერში.
არ ფიზიკური, მექანიკური ნაწილი რომ დაწნული, სადაც
მონაცემები ზოგადად ინახება ხანგრძლივი ვადით.
ამიტომ string s არის საკმაოდ ბევრი ეუბნება კომპიუტერი მომეცი
საკმარისი RAM, რათა შეწყობოდა სიმებიანი.
ახლა რომ ცოტა oversimplification, რადგან
რამდენად დიდი არის სიმებიანი იქნება?
კარგად ჩვენ რეალურად ჯერ არ ვიცით, ისე კვირის მოსვლა
ჩვენ რეალურად უკან დახევის ფენას, რომელიც სიმებიანი და
ჩვენ გეტყვით რა ის მართლა.
სიმებიანი, ამ დროისთვის, მხოლოდ ლამაზი გამარტივებას ჩვენი სამყარო.
მაგრამ string s აცხადებს სიმებიანი მოუწოდა s, ახლა.
აცხადებს სიმებიანი.
იგი იტოვებს ზოგიერთი სივრცეში RAM for სიმებიანი მომხმარებელს
შესახებ შეიტანოთ.
>> ახლა მოდით წავიკითხოთ in უფლება თანაბარი ნიშანი.
ასე რომ ამბობს GetString ().
და პატარა საღი აზრის შეამოწმოს.
ის ფაქტი, რომ არაფერი შიგნით ფრჩხილებში
გულისხმობს რა GetString?
იგი იღებს არანაირი არგუმენტი.
ანუ, ვერ ახდენს გავლენას მისი ქცევა არანაირად.
ყოველთვის, როცა მისი გამოყენება, ეს იქნება კიდევ სიმებიანი და ამით ყველაფერი მთავრდება.
პირიქით, printf, იმედია მისი ქცევა არ
შეცვალოს ყოველ ჯერზე.
წინააღმდეგ შემთხვევაში, ეს საკმაოდ უსარგებლო ბეჭდვის ფუნქცია თუ
ეს იმას იგივე.
თუ ეს ყოველთვის ბეჭდავს დავით ან რამე
თვითნებური ყველა დროის.
ამიტომ printf აზრი ჰქონდეს არგუმენტი.
GetString ნამდვილად არ სჭირდება არგუმენტი, რადგან მინდოდა
მიიღოს სიმებიანი საწყისი მომხმარებელი და ეს მომხმარებელს, რომელიც ხდება
მიაწოდოს დინამიზმის აკრეფით სხვადასხვა წერილებს
ყოველ დროს კლავიატურაზე.
>> რას GetString ნუ საბოლოოდ?
იფიქრეთ, როგორც ეს პატარა შავი ყუთი.
და ეს შავი ყუთი იღებს არ შეყვანა, მაგრამ როდესაც თქვენ bang on
ეს, ის SpitS გარეთ სიმებიანი რომ მომხმარებელს უკვე აკრეფილი შემოსული
და ის ფაქტი, რომ არსებობს თანაბარი ნიშანი არსებობს ნიშნავს მიიღოს
რა არის Spit out მარჯვენა და ჩაწეროთ იგი შიგნით
რა მარცხენა.
ასე რომ თანაბარი ნიშანი აქ, ფაქტობრივად, არ ნიშნავს,
თანასწორობა, არამედ ტექნიკურად ნიშნავს დავალება.
Take ღირებულება მარჯვენა, და მისი
ცვლადი მარცხენა.
ასე რომ ყველა რომ ხდება იქ.
>> ახლა ხაზის 7, ჩვენ მოუწოდებდა printf.
ამიტომ printf იმედია დღითიდღე პატარა მოსაწყენი მიერ არის.
ამიტომ ბეჭდვა ფორმატირებული სიმებიანი.
რა სიმებიანი?
ამობეჭდვა, "H-E-L-L-O,% s
\ N ".
ყველა უფლება, ასე რომ რას მინდა დანამატი for% s?
სიტყვასიტყვით, რაც ინახება s.
ასე რომ, ამ შემთხვევაში, ცოტა საღი აზრის შემოწმება, რამდენი არგუმენტები აკეთებს
printf მიიღოს?
Okay, მე გავიგე ერთი.
გავიგე ერთი ერთხელ.
ორი, მე გავიგე ორი.
და როგორ დაახლოებით სამი?
Okay, სამი?
შესანიშნავი.
სამი სავარაუდო პასუხი, მხოლოდ ერთი მათგანი არის სწორი.
ასე რომ არგუმენტები კვლავ გავლენას ახდენს ქცევის ფუნქცია.
წარსულში, printf არც მხოლოდ ერთი არგუმენტი.
"Hello World" იყო ერთი არგუმენტი.
თუმცა, ახლა, შეამჩნევთ, სადაც ეს მძიმით არის.
ეს მძიმით არის გარეთ ციტირებით / unquote, რაც იმას ნიშნავს,
hey printf, აქ მოდის მეორე არგუმენტი.
>> ამიტომ მძიმეები უმეტეს პროგრამირების ენები
ცალკე მრავალჯერადი არგუმენტები.
ასე რომ პასუხი აქ ნამდვილად არ არის ერთი, რადგან
არსებობს ამ მძიმით.
ასე მინიმალურად, printf აშკარად აღების ორი
არგუმენტები ამ დროს.
მაგრამ შესაძლებლობა შეასრულა კითხვა აქ არის რა
ამ მძიმით?
ამჯამად ამ გულისხმობს, რომ იქ რეალურად სამ არგუმენტს?
ეს, ამ, და ეს.
ასე რომ არა, იმიტომ, რომ მძიმით არის შიგნით შეთავაზებები, რომელიც
ნიშნავს ეს მართლაც მხოლოდ ესთეტიკურ ინგლისური.
მას არაფერი აქვს საერთო რაოდენობის
არგუმენტები ამ პროგრამაში.
ასე რომ, ეს არის მძიმით გარეთ ორმაგი შეთავაზებები.
ხოლო შემდეგ დაბრუნდნენ 0.
ახლა მოდით უბრალოდ სახის მიიღოს ამ ერთი რწმენა ამისთვის
დღეს, და მხოლოდ ის ვიცი, რომ როდესაც ფუნქციების კეთდება შესრულებაში
ხაზების კოდი, ისინი უნდა ზოგადად დააბრუნებს მნიშვნელობას.
ამ შემთხვევაში, მხოლოდ იმიტომ, რომ ძირითად უნდა დაბრუნდეს int,
ეს მხოლოდ გზა ენა C მუშაობს.
>> ასე რომ, ვინაიდან არაფერი არ მოხდა ისე, იგრძნობა ამ პროგრამის
ჯარიმა, უბრალოდ მძიმე კოდირებული სანაცვლოდ 0.
მაგრამ განსხვავებით, და მე ვაპირებ წერენ ეს ფსევდო კოდი
ახლა, ჰგავს ჯოზეფ გააკეთა, როდესაც ჩვენ გავაკეთეთ წინდების
მაგალითად გასულ კვირას.
თუ რამე არ მოხდა ისე, - ეს არ არის ფაქტობრივი კოდი - წავიდა
არასწორი, მაშინ დაბრუნდებიან, ვთქვათ, 1.
Else დაბრუნებას 0.
ასე რომ, ეს არის სადაც ჩვენ ვაპირებთ ამ.
ეს არ არის ფაქტობრივი C კოდი, უბრალოდ pseudocode.
მაგრამ ეს როგორ შეიძლება დაბრუნდეს
სხვადასხვა შესაძლო მნიშვნელობებია.
მაგრამ ახლა მე უბრალოდ აპირებს წავიდეთ წინ და უკან დაბრუნებას 0.
ყველა უფლება, რაიმე კითხვა ამგვარად შორს სინტაქსი, ფუნქციონირება,
ან მოგწონთ?
ჰო, წელს უკან.
>> აუდიტორია: [INAUDIBLE]
DAVID Malan: იქნებ ცოტა louder?
რატომ ამ პროგრამის დაბრუნების 0, და?
აუდიტორია: [INAUDIBLE]
DAVID Malan: Oh, ეს იმიტომ, რომ მე მივიღე ზარმაცი, უკაცრავად.
არარის კარგი აკადემიური საპასუხოდ, დაუბრუნოს 0.
მე შემიძლია სახის სამაშველო ამ, განაცხადა ტექნიკურად C, თუ მთავარი
არ მკაფიოდ დაბრუნების ღირებულება, 0 დაუბრუნდება
ავტომატურად თქვენთვის.
რაც მართალია, მე არა მხოლოდ დაფარვა.
მაგრამ, მე უნდა ყოფილიყო იგი ამ გზით.
არარის საინტერესო takeaway ვიდრე რომ გარდა ჩემი შეცდომა იყო.
ჰო?
>> აუდიტორია: ჩვეულებრივ, როდესაც თქვენ აკრიფოთ ბათილად, რაც იმას ნიშნავს, რომ თქვენ
არ დაბრუნებას რაღაც.
DAVID Malan: სწორი.
თუ ნაცვლად, თქვენს მიერ მითითებული ადრე სახელით ფუნქცია, ამისთვის
მაგალითად აქ, ბათილად, მაშინ ფუნქცია
არ დააბრუნებს არაფერი.
და ამიტომ მინდა უბრალოდ, ვამბობთ, დაბრუნების ან არაფერი საერთოდ,
და რომ იყოს თანმიმდევრული.
და ჩვენ დავბრუნდებით იმ.
და მხოლოდ FYI, ერთი იჭერს ერთად სწავლის
პროგრამების სამყაროში, რომელსაც აქვს ასობით წიგნი და
ასობით საიტებზე out არსებობს თქვენ უცვლელად
ვხედავთ სხვადასხვა სინტაქსი სხვადასხვა წიგნები
სხვადასხვა ადამიანებს.
გააცნობიეროს ჩვენ გავაკეთებთ სექციები და ლექციები უნდა იყოს
თანმიმდევრული.
მაგრამ ზოგჯერ ნახავთ კონფლიქტის სინტაქსი.
ასე რომ როდესაც ეჭვი, ჰკითხეთ.
და ზოგადად, ჩვენ ვიზრუნებთ in ლექციები და სექციები
თითქმის ყოველთვის წარადგინოს იგი სწორი გზა.
და მე ვიტყვი, თითქმის ყოველთვის, რადგან მაგალითია.
გაქვთ სხვა კითხვები?
>> აუდიტორია: არა% s არსებობს გარეთ ელექტრო?
DAVID Malan: არა% s არსებობს გარეთ ელექტრო?
დიახ.
ასე% s არ უკავშირდება C. იმისა, რომ ჩვენ იყენებთ მას
ელექტრო ფუნდამენტურად არაფერი აქვს ერთად
თვისებები ენა ჩვენ გამოყენებით.
მართლაც, გასულ კვირას, როდესაც ჩვენ გამოყენებული ჩემი Mac, მე დავწერე
C კოდექსის ჩემი Mac.
შემეძლო არ გამოიყენება% s ჩემი Mac, და თქვენ შეიძლება გამოიყენოთ ეს
თქვენი Windows კომპიუტერში თუ თქვენ დააყენეთ შემდგენელი, მოსწონს
Visual Studio საწყისი Microsoft.
ასე% s.
ყველაფერი ვაკეთებთ შიგნით ფანჯრის დღეს უნდა
საერთო C. და ფუნდამენტურად არაფერ შუაშია
ოპერაციული სისტემის საკითხს.
პირიქით, შავი და თეთრი ტერმინალის ფანჯარაში - როდესაც
მე აკრეფის რამ, როგორიცაა ls და RM, და CD -
რომ აქვს კავშირი არა ოპერაციული სისტემა და
ნავიგაცია გარშემო.
Yeah.
აუდიტორია: ვგულისხმობდი ბიბლიოთეკა, CS50 ბიბლიოთეკაში.
DAVID Malan: Okay, ასე რომ, თუ თქვენ ნიშნავს, სიტყვით ტექსტი, რომ
მხოლოდ არსებობს CS50 ბიბლიოთეკა, სწორი.
რომ არ არსებობს C თავად, და მართლაც რამდენიმე
კვირის ჩვენ გადაყარეთ CS50 ბიბლიოთეკა და დაიწყოს
აკეთებს რამ ნულიდან თავს, ასე ვთქვათ.
გაქვთ სხვა კითხვები?
Yeah.
>> აუდიტორია: [INAUDIBLE]
DAVID Malan: კარგი კითხვაა.
არიან ბრძანებები ასოთი?
და ნება მომეცით მიიღოს განსხვავება აქ.
ამიტომ ბრძანებები ზოგადად რამ ჩვენ წერენ ზე
ბოლოში ფანჯარა, წელს ტერმინალის ფანჯარაში.
არაფერი აქ იქნება განცხადებებს ან C კოდი.
მაგრამ ორივე შემთხვევაში, პასუხი არის იგივე, დიახ.
ორივე გარემოში, C კოდი ზედა და
ოპერაციული სისტემის ბრძანება ხაზს
ბოლოში, არის ასოთი.
ასე რომ თქვენ უნდა capitalize GetString ერთად დედაქალაქში G,
კაპიტალური ს თქვენ უნდა დაწეროს printf ყველა ამას.
თქვენ უნდა აკრიფოთ ls ყველა ამას.
ასე რომ, თითქმის ყველა სიტუაციაში ამ სემესტრში, საქმეს, რომელიც
ფაქტობრივად, ამ საკითხზე.
დიახ.
>> აუდიტორია: [INAUDIBLE]
DAVID Malan: Ah, ასე okay, რა, თუ გვქონდა ფაილი
მოუწოდა hello.d.
გამოდის, D არის პროგრამირების ენა.
და ასე, რიგ შემთხვევებში, შეიძლება რეალურად დაწეროს პროგრამა
რომ ფაილი და არ ის შედგენილი, რომ მოდის.
ჩვენ შეგვიძლია, და ფაქტობრივად, მოკლე პასუხი არის, არ ვიცი.
ამიტომ, ჩვენ ვაპირებთ ამის გაკეთებას.
ნება მომეცით წავიდეთ წინ და შევქმნათ ახალი ფაილი.
და Spin აქ, პატიოსნად ზოგადად, არის როდესაც რაიმე ეჭვი
ამ სემესტრში, და თქვენ გაქვთ თქვენი მოწყობილობის ან კომპიუტერული
გახსნა, წავიდეთ წინ და ძიებასა.
ამიტომ მე ვაპირებ შენახვა ფაილი სახელად hello.d.
შენახვა.
და მე ვაპირებ აწარმოებს მიიღოს მიესალმები შეიყვანეთ.
იგი თითქოს infer რომ გ იყო უფრო მეტი ალბათობით
ვიდრე დ, ამ შემთხვევაში.
სხვა კითხვები.
Yeah.
>> აუდიტორია: [INAUDIBLE]
DAVID Malan: Okay, ამბობენ, რომ კიდევ ერთხელ.
აუდიტორია: [INAUDIBLE]
DAVID Malan: რა წასვლა შესახებ დიაგნოზი, რომ ან
troubleshooting რომ?
ასე რომ, სავარაუდოდ, რადგან ისინი სხვადასხვა ენებზე,
სავარაუდოდ თქვენ დაიჭერს სრულად
სხვადასხვა პროგრამა outputted.
თქვენ დაიჭერს სრულიად განსხვავებული შეცდომის შეტყობინებები.
და ასევე უბრალოდ თვალსაზრისით დიზაინი, ეს იქნებოდა სავარაუდოდ იქნება
ცუდი დიზაინი გადაწყვეტილება უნდა წერილობით ორ სხვადასხვა
ენებზე თითქმის იდენტურად დაასახელა ფაილი წელს
ზუსტად იგივე დირექტორიაში, გამოყენებით
ავტომატური ინსტრუმენტი, როგორიცაა მიიღოს.
ასე, რომ შეიძლება ასევე დააყენებს უკან და ამბობენ 15 წლის აკეთებს ეს
არასდროს რომ შეცდომა იყო.
შეიძლება მოხდეს.
მაგრამ უბრალოდ სხვადასხვა, ვფიქრობ,
ლოგისტიკური თავდაცვითი ადგილი.
Plus შეცდომის შეტყობინებები, რომ მოჰყვეს, რომელიც
საბოლოოდ გამოვლენა რა საკითხი.
მაგრამ შესაძლებელი კუთხეში შემთხვევაში.
>> ყველა უფლება, მოდით შემოიღონ მხოლოდ რამდენიმე სხვა
მახასიათებლები აქ არის, ასე რომ ჩვენ შეგვიძლია დავიწყოთ მშენებლობაზე უფრო
და უფრო რთული პროგრამა.
ასე რომ, პირველ რიგში, მათემატიკის.
ამიტომ მათემატიკის მაგალითები მხოლოდ სახის ადვილი პირველ კვირას.
ეს არ არის იმის თქმა, რომ ყველა პროგრამირების დაახლოებით
მათემატიკის.
რა თქმა უნდა, გაგება სხვადასხვა თვისებები
მათემატიკის, ალგებრა, კერძოდ, არის
საკმაოდ შესაბამისი აქ.
უმაღლეს დონეზე CS კლასების, წრფივი ალგებრა,
Calculus, და მოსწონს.
მაგრამ რეალიზება უმეტესობა, რაც ჩვენ გავაკეთებთ ამ სემესტრის ამცირებს არ
to მათემატიკის, და, რა თქმა უნდა, არ არითმეტიკა, თავისთავად, მაგრამ ნამდვილად
უბრალოდ ლოგიკა და აზროვნების ფრთხილად.
და ამიტომ ეს ურთიერთკავშირი, რომ კომპიუტერული მეცნიერების დიდი ხანია ჰქონდა,
განსაკუთრებით საშუალო სკოლა დონეზე, ერთად მათემატიკის, არის
ცოტა დამაბნეველი.
რადგან ყველაზე პროგრამებს, ჩვენ წერენ, მართლაც, არის
სახის მაღალ დონეზე და ფოკუსირება პრობლემის გადაჭრის რომ,
დარწმუნებული, შესაძლოა გამოვიყენოთ გარდა ამისა, გამოკლება, და სხვადასხვა
მათემატიკური ფორმულები ან მოსწონს,
მაგრამ დღის ბოლოს, ის შესახებ ფიქრი და არა
უბრალოდ განხორციელების ხომ შეიძლება ეს გააკეთა, როგორიცაა საერთაშორისო გამჭვირვალობა
კალკულატორი in საშუალო სკოლა.
>> ამრიგად, რომ განაცხადა, მოდით ახლა რაღაც ამ
მათემატიკური ოპერატორები, რომ არსებობენ, რათა შევძლოთ მოგზაურობა
მეტი ზოგიერთი ფუძემდებლური ასპექტები პროგრამირება, ან
ამ შემთხვევაში C. ასე რომ, როგორც CS50 ბიბლიოთეკა ვარაუდით,
და დღეს ჩვენ მხოლოდ გამოყენებით GetString - და მომენტი
ალბათ ერთი სხვა ფუნქცია -
მაგრამ არსებობს სხვადასხვა მონაცემები ტიპების კომპიუტერი.
დასასრულს დღეს, კომპიუტერები მხოლოდ ვიცი 0S და 1s.
მაგრამ გავიხსენოთ, რომ გასულ კვირას ჩვენ ვისაუბრეთ ორობითი სისტემა
წელს წარმოადგენს ნომრები, როგორიცაა ნომერი 0, და 1 და 2,
ყველა გზა ზე მდე 8, როგორც Nate-ის ვიდეო.
და მაშინ ჩვენ შეგვიძლია ითვლიან ბევრად უფრო მაღალია, როგორც ჩვენ
გააკეთა სცენაზე აქ.
მაგრამ თუ გსურთ წარმოადგენენ არა მხოლოდ ციფრები მაგრამ წერილებს,
ჩვენ, ადამიანები, უნდა ამუშავება ზოგიერთი თვითნებური
კონვენციები, რომლის დროსაც თუ დღის ბოლოს ყველა ჩემი კომპიუტერი
არ არის უნარი გამოხატოს 0S და 1s, ისევე ჩვენ უმჯობესია
დაიწყოს მასტანდარტიზირებელი ნიმუში 0S და 1s რომ წარმოადგენენ
სხვადასხვა რამ.
ნიმუში 0S და 1s, რომელიც წარმოადგენს წერილში.
ნიმუში 0S და 1s რომ წარმოადგენენ წერილში z.
ნიმუში 0S და 1s რომ წარმოადგენენ ფერი ცისფერი, ან
წითელი, ან მოსწონს.
ჩვენ უნდა გამოვიყენოთ ყველა ამ 0S და 1s გამოხატოს ვდებთ წელს
სხვადასხვა კონტექსტში, სხვადასხვა გზით, რომლებიც არ არიან
აუცილებლად numeric.
>> ამიტომ თვალსაზრისით წარმომადგენლობა, C აქვს სხვადასხვა მონაცემთა ტიპები,
და ჩვენ ვნახეთ ერთი ასეთი ჯერჯერობით.
ჩვენ ვნახეთ int, და გაფრთხილების რა არ ეკრანზე
ახლავე არის სიმებიანი.
სიმებიანი არ, ფაქტობრივად, არსებობს C. ისევ, ეს
გამარტივებას ჩვენ წარდგენის პირველად
რამდენიმე კვირის.
Char არის ინდივიდუალური ხასიათი.
Float არის რეალური ნომერი, ერთად ათობითი წერტილი და ციფრები უნდა
მარცხენა და მარჯვნივ.
ორმაგი არის ის, რაც, მათ, ვისაც დაბრუნება ადრე ფონზე?
ამიტომ ორმაგი ორჯერ რაღაც.
დასძენს ორჯერ იმდენი სიზუსტით.
ასე რომ რას ნიშნავს ეს?
ასე რომ თითოეულ ამ შემთხვევაში, მსოფლიოს მსგავსი სტანდარტიზებული
რამდენი ბიტი გამოიყენება წარმოადგენენ
თითოეული ეს ყველაფერი.
ასე რომ, თუ თქვენ ადევნებდნენ Nate ს ASCII ვიდეო უკვე ნაწილი
საქართველოს pset 0, თუ გვიან ამ კვირაში თქვენ, თქვენ ალბათ იცით
რომ ASCII -
ხასიათი წარმომადგენლობების -
გამოყენება რამდენი ბიტი?
და თქვენ ალბათ კი მახსოვს ჩვენი დემო გასულ კვირას, თუ როგორ
ბევრი სცენაზე.
ასე 7 ან 8, როგორც წესი.
ასე რომ ზოგადად 8, და იქ რაღაც იწოდებოდა გაგრძელდეს
ASCII, რომელიც იყენებს ყველა 8 ბიტი, ნაცვლად 7.
მაგრამ ზოგადად, ჩვენ ვსაუბრობთ იმ უფლებამოსილების 2, ასე რომ, ამ შემთხვევაში, 8.
ასე რომ char in პროგრამირების ენა ჩვეულებრივ 8 ბიტი.
ასე int ზოგადად 32 ბიტი.
Float ზოგადად 32 ბიტი.
ორმაგი ზოგადად 64 ბიტი.
და რას ნიშნავს ეს?
ეს იმას ნიშნავს, თქვენ შეგიძლიათ წარმოადგენს უფრო დიდი ციფრები, ან იმ შემთხვევაში,
რეალური ციფრები, შეგიძლიათ კიდევ ბევრი გვაქვს ნომრები შემდეგ
ათობითი ადგილი.
გაცილებით მეტი სიზუსტით, ამ შემთხვევაში.
არის ხანგრძლივი ხანგრძლივი, სამწუხაროდ დაასახელა.
ასე რომ არსებობს int რომელიც 32 ბიტი.
არსებობს ხანგრძლივი რომელიც, nope, 32 ბიტი.
და ხანგრძლივი ხანგრძლივი რომელიც 64 ბიტი.
თუმცა ზოგიერთი ეს ის კონტექსტში მგრძნობიარე, ეს დამოკიდებულია
როგორი კომპიუტერი გაქვთ.
ასე რომ ზოგადად, ჩვენ აკონკრეტებენ, საშინაო დავალების ან ინტელექტუალური, როდესაც
ეს ფაქტიურად საკითხები.
მაგრამ საქმე ის არის, არსებობს ყველა ამ სხვადასხვა
წარმომადგენლობების აქ.
>> მოდით რეალურად ჩაყვინთვის შევიდა პროგრამა.
იმის ნაცვლად, რომ დაეწერა ეს ერთი ნულიდან, მინდა წავიდეთ წინ
და ქმნის დღევანდელი კოდის - რაც არის
ონლაინ - თუ გსურთ Tinker გარშემო შემოსული, ან დაბრუნების შესახებ
ოთხშაბათს ელექტრო თქვენს კომპიუტერში, ინსტრუქციები
ამისთვის რაც ბმული on კურსი ვებგვერდი.
აქ სუპერ მარტივი პროგრამა.
მაგრამ მივიღე პატარა რაღაც ახალი ზედა, რომ
არ გვქონდა ადრე.
მთელი უამრავი ლურჯი ხაზები ტექსტი.
ასე რომ ეს ლურჯი ხაზები წარმოადგენენ კომენტარები.
ასე რომ საკმაოდ სასარგებლოა პროგრამის შეძლონ წერა
რამდენიმე კომენტარი საკუთარ თავს, ან კოლეგებს, ან მეგობრები, ან
სწავლების პრაქტიკის, რომ სახის აღწერს რა ხდება
ამ ფაილის, მაგრამ არაფერი აქვთ ერთად C კოდი თავისთავად.
არაფერ შუაშია პროგრამის ფუნქციურად, უბრალოდ
ესთეტიკას.
ასე რომ გზა ხაზვის დო არის თქვენ ზოგადად დაიწყოს თქვენი
კომენტარების / * და თქვენ დასრულდება თქვენი კომენტარი
* /.
და თუ თქვენ ნამდვილად anal და მოსწონს მიაპყროს სახის სურათები,
მაშინ მინდა დააყენა მთელი ბევრი ვარსკვლავი, ნეტავ გააკეთებს
პატარა ყუთი მოსწონს ეს.
მაგრამ არცერთი რომ საკითხები.
ერთადერთი, რაც მნიშვნელოვანია არის ძალიან პირველი
და ძალიან ბოლო.
ეს არის რასაც მრავალ ხაზის კომენტარი.
და ეს მხოლოდ ადამიანის კონვენციის ხშირად ვარსკვლავი და ყუთი
რამ ასე, თუ თქვენ გაქვთ ბევრი თავისუფალი დრო.
>> ამიტომ მას შემდეგ, რაც თქვენ დაწერილი რამდენიმე კომენტარი, ზოგადად, მოდის
ფაქტობრივი guts პროგრამის.
აი ჩვენი ნაცნობი # მოიცავს .
და უბრალოდ სწრაფი, ეს აუცილებელია თუ არა საჭირო?
აუდიტორია: აუცილებელია.
DAVID Malan: ასე რომ რეალურად საჭირო არ არის.
რატომ, თუმცა, არის ეს საჭირო არ?
ასე რომ არ არსებობს printf.
მართლაც.
ყველა ვაკეთებთ ამ პროგრამაში არის მათემატიკა.
ასე, რომ შეიძლება რეალურად წაშლა რომ.
ასე, რომ თქვენ ყოველთვის არ უნდა შეიცავდეს რაიმე ზე
ზევით პროგრამა.
>> მოდით გაამარტივებს ამ bit.
და ახლა შეამჩნია რა ეს პროგრამა აკეთებს.
ბევრი საინტერესო.
int x = 1.
ისე, რა არის ეს აკეთებს?
ისე, ვფიქრობ, თავში გონებრივი მოდელი ადრე.
მარცხენა მხარეს ამ გამოხატვის აკეთებს იმას?
შექმნა ფართი რიცხვი.
ასე რომ რა ზომის?
ასევე, ჩვენ არ უნდა გაიგოს, რომ 32 ბიტი.
მანამდე, string იყო ტექნიკურად 32 ბიტი, მაგრამ უფრო
on რომ მომავალში.
მაგრამ int არის 32 ბიტი.
ასე რომ, ეს გამოხატვის მარცხენა აქ, int x უბრალოდ ამბობს hey
ოპერაციული სისტემა, მომეცი 32 ​​ბიტი ოპერატიული -
სხვაგვარად ცნობილია როგორც 4 bytes of RAM -
ასე რომ შემიძლია დააყენა მთელი ამ სივრცეში.
რა რიცხვი არ გვინდა დააყენა?
ისე, უბრალოდ ნომერი 1.
int y იღებს 2, აკეთებს ზუსტად იგივე რამ, მიუხედავად იმისა,
ნომერი მეტია, თვალსაზრისით მასშტაბები.
პუნქტების თავისთავად ჯერ კიდევ მხოლოდ 32 ბიტი.
უბრალოდ ნიმუში ბიტი განსხვავებულია, რათა
წარმოადგენენ 1 წინააღმდეგ 2.
int z ახლა ამბობს მომეცი კიდევ 32 ბიტი, ეძახით z, და ამით
summation საქართველოს 1 და 2 იქ.
ასე რომ ახლა z სავარაუდოდ შენახვის ღირებულება 3,
და შემდეგ დაბრუნდნენ 0.
>> ახლა ამ პროგრამის ამჯამად მას არაფერი საინტერესო?
ასე რომ რეალურად არაფერს აკეთებს საინტერესო, ნებისმიერ
გრძნობა, რადგან, თუ რატომ? იგი აკეთებს რაღაც მათემატიკის.
მაგრამ არ ბრუნდებოდა პასუხი, უფლება.
ეს დაბრუნების 0.
ეს არ დაბეჭდვის პასუხი.
ასე რომ ამ პროგრამის ძირეულად უსარგებლო, როგორც ეს
დგას ახლა.
იგი აკეთებს რაღაც მუშაობა.
იგი აპირებს გარკვეული რაოდენობის წამში, ან microseconds, რათა
აწარმოებს, მაგრამ რეალურად არ აკეთებს არაფერს
სასარგებლოა ადამიანის.
>> მოდით რეალურად ახლა გახსნა math2, სადაც ახლა მე რეალურად
დაბეჭდვის შედეგი.
ასე რომ, ეს ძალიან შეიძლება inferred ჩვენი წინა მაგალითები.
თუკი მინდა დაკავდით მარტივი მათემატიკა, int x = 1, Y
= 2. Z არის 1 plus 2 არის.
რა არის ეს აპირებს ამობეჭდოთ აშკარად?
მხოლოდ 3.
ამიტომ სწრაფი საღი აზრის შეამოწმოს.
ნება მომეცით გადაინაცვლოს ამ დირექტორიაში.
ასე CD source1m.
ნება მომეცით წავიდეთ წინ და ტიპის მიიღოს math2.
არარის შეცდომის შეტყობინებები გამოვიდა, ნება მომეცით, აწარმოებს -
არ a.out--ნება მომეცით აწარმოებს math2. შეიყვანეთ.
მართლაც, ეს ამობეჭდილი 3.
კარგად მოდით შევხედოთ ვარიანტი ამ.
In math3.c, ჩვენ ახლა ამ მაგალითს აქ.
>> ასე რომ, ეს ერთი სახის საინტერესო.
ასე რომ ამ ერთი აქ, პასუხი აპირებს მიიღოს 1 დაყოფილი 10,
და შენიშნავს, მე გამოაცხადა როგორც float.
რატომ მინდა, რომ იყოს float?
ისე, ეს ფრაქცია.
ეს იქნება რეალური რაოდენობა.
ასე რომ, ეს იქნება 0.1, იმედია - 10%, ამ შემთხვევაში.
და რა მერე გვინდა ამობეჭდოთ?
ისე, ეს პასუხი.
კარგად, მოდით აჯავრებენ ამ გარდა პირველი.
ა.შ. მარცხენა მხარეს, განაცხადოს
ათწილადი, ეძახით უპასუხოს.
მარჯვენა მხარეს, ნუ 1 დაყოფილი 10 და დააყენა, რომ
უპასუხოს შიგნით ცვლადი.
ახლა, ამ ხაზის გამოიყურება ცოტა მეტი cryptic.
მაგრამ შეამჩნია რამდენიმე ნაცნობი თვისებები. % ნიშნავს აქ მოდის
placeholder.
ვ ნიშნავს აქ მცურავი წერტილი ღირებულება, უბრალოდ რეალური
ნომერი, რაღაც ერთად ათობითი წერტილი.
0.2 საშუალებით რა?
ვინმეს ვიცით ადრე გამოცდილება?
ორი ათობითი ადგილებში.
ამიტომ ჩვენ არ უნახავს ამ ადრე, მაგრამ ეს მხოლოდ გზა
განხორციელებისას ცოტა მეტი კონტროლი printf და
გამონათქვამი არ მაძლევს 30 ქულა შემდეგ ათობითი წერტილი,
ნაცვლად მომეცი მხოლოდ 2.
>> და მაშინ მოდით წავიდეთ წინ და აწარმოებს ამ.
ასე რომ მათემატიკის 3 და ახლა ნება მომეცით აწარმოებს მათემატიკის 3, შეიყვანეთ.
და ეს არ არის სწორი.
ჩვენ, როგორც ჩანს, არ შეექმნა ჩვენი პირველი ნამდვილი bug.
კარგად, იქნებ მე უბრალოდ არ ეძებს მჭიდრო საკმარისი.
ნება მომეცით ახვიდეთ აქ, და ნება მიბოძეთ 20 ათობითი
წერტილი ადგილებში.
და ნება მომეცით შეადგინონ ამ გააკეთეთ math3, აწარმოებს.
Pretty დარწმუნებული 1 დაყოფილი 10 არ არის 0.
ასე რომ, რა ხდება?
კარგად okay, ამიტომ რეალურად ეს არ უნდა გავაკეთოთ ეს.
სწორედ კარგი აზრის.
ეს მართლაც მხოლოდ დამთხვევა
რომ ვაკეთებთ ამ.
მაგრამ იმის დასამტკიცებლად, რომ ეს არ არის ის, მე
დაბრუნების რაღაც შემთხვევითი.
ნუ გააკეთებთ ამას სახლში, რადგან უბრალოდ არასწორია.
მაგრამ მიიღოს math3, ნება მომეცით გაუშვით.
ასე რომ არაფერი აქვს, რასაც მე დაბრუნებას, მხოლოდ უნდა გააკეთოს
რა მე ბეჭდვა.
მაგრამ გავიგე მისი დანგრევა აქ.
რა?
აუდიტორია: ამიტომ, ჩვენ უნდა დაწეროთ ნომრები
გაყოფის, როგორც -
>> DAVID Malan: Okay კარგი.
ამიტომ, ჩვენ უნდა დაწეროთ ნომრები მონაწილე
სამმართველოს აქ როგორც მცურავი პუნქტიანი აფასებს საკუთარ თავს.
ასე რომ პრობლემა აქ არ არის, როგორც ადრე: C, როგორც ბევრი
ენებზე, აქვს სხვადასხვა ტიპის მონაცემები.
და იმ მონაცემთა ტიპები, მაგალითად, ეს აქ.
და მონაცემთა ტიპები კითხვა აქ, როცა ტიპი 1 და მერე
ტიპის 10, ალბათ, რა ტიპის მონაცემები?
ასე რომ ალბათ int, არა?
ეს ნამდვილად არ float რადგან იქ არ არის ათობითი
წერტილი ან რამე მაგდაგვარს.
ასე რომ, რეალურად, მაქვს int დაყოფილი int.
>> ასე რომ საინტერესო რამ შესახებ მათემატიკის და კომპიუტერულ არის, რომ
თუ თქვენ აკეთებთ სამმართველოს გამოყენებით რიცხვებით -
1 დაყოფილი 10, დიახ არის 0.1.
თუმცა, როდესაც თქვენ გამყოფი რიცხვი მიერ მთელი რიცხვი,
პასუხი უნდა იყოს ასევე მთელი რიცხვი მხოლოდ იმიტომ, ახლა.
და რაც გულისხმობს შემდეგ?
ისე, თუ პასუხი 1 დაყოფილი 10 უდრის 0.1, რა
კომპიუტერის გაკეთებას აპირებს, რომელიც არ ვიცი როგორ
წარმოადგენენ 0.1, რადგან ისინი მცურავი წერტილი ღირებულება, არ
მთელი რიცხვი, ის აპირებს Chop off ყველაფერი შემდეგ
ათობითი წერტილი და უბრალოდ გაჩვენებთ 0 დასაწყისში.
და ის ფაქტი, რომ ის ბეჭდვას, როგორც მცურავი წერტილი
ღირებულება, უბრალოდ ესთეტიკური რამ.
ეს იმიტომ, რომ მე აიძულა კომპიუტერიდან ბეჭდვა ეს
მცურავი წერტილი ღირებულება.
მართლაც მე გამოაცხადა როგორც float, მაგრამ მათემატიკის არის
ხდება აქ.
>> ნება მომეცით, რეალურად დაფიქსირება ამ ერთ საკმაოდ მარტივი გზა.
რატომ არ მე უბრალოდ 10.0 და 1.0, თუმცა
ტექნიკურად მე ვერ მიიღოს away მასთან უბრალოდ აკეთებს ერთი იმ.
ახლა ნება მომეცით წავიდეთ წინ და მიიღოს math3.
ნება მომეცით წავიდეთ წინ და ახლა აწარმოებს math3, შეიყვანეთ.
და ახლა, OH ბიჭი.
ახლა ჩვენ გვაქვს ახალი პრობლემა საერთოდ.
ასე უკეთესი, უფლება; ჩვენ უფრო ახლოს 0.1, მაგრამ რაც ნათლად არის
არასწორი აქ?
თუ ჩვენ ცრუობს თქვენ წლების განმავლობაში, არა?
1 დაყოფილი 10 ფაქტიურად არ საკმაოდ 0.1, ისე რა
მართლაც ხდება?
კარგად შეგიძლიათ სახის მიზეზი ამ ლოგიკურად.
თუ კომპიუტერში მხოლოდ სასრულ თანხის RAM დაიწყოს
, და მართლაც კომპიუტერი მხოლოდ იყენებს 32 ბიტს ამისთვის
მცურავი წერტილი ღირებულება, იგი დგას, რომ მიზეზი, რომ
სასრულ რაოდენობის ბიტი, 32 ამ შემთხვევაში, დიახ, შეგიძლიათ
წარმოადგენს ბევრი პერსონალი.
ეს ფაქტიურად არის ოთხი მილიარდი სხვადასხვა ღირებულებების შეიძლება იყოს
წარმოდგენილი 32 ბიტი, 2 დან 32, მაგრამ მაინც სასრული.
ასე რომ პრობლემა ის არის, არსებობს უსასრულო რაოდენობის ნამდვილი
ციფრები, უფლება.
თუ მაძლევს რეალური ნომერი, მე ყოველთვის იპოვით თქვენთვის ერთი
ოდნავ უფრო, ოდნავ ნაკლები, მხოლოდ tweaking
ციფრები, რომლებიც შემდეგ ათობითი წერტილი.
ასე რომ, თუ თქვენ არ უსასრულო რაოდენობის ბიტი, თქვენ
ვერ შესაძლოა წარმოადგენდეს უსასრულო
პუნქტების რეალური ციფრები.
>> ასე რომ არსებობს ამ თანდაყოლილი ორაზროვნება კომპიუტერები და
ამ იღებს იმყოფებოდა ყველა დროის თუნდაც უმარტივესი of
პროგრამების მოსწონს ეს.
არამედ რამდენიმე ძალიან რეალური სამყაროს პრობლემაც.
ფაქტობრივად, მოდით მიიღოს მომენტში უბრალოდ შეხედეთ
რაღაც რომ მოხდა სინამდვილეში რეალობად.
ჩვენ უყუროთ მხოლოდ პირველი რამდენიმე წუთის, შემდეგ კი
ჩვენ პოსტი ლინკები ხაზზე.
მაგრამ ეს არის აღთქმა, რომ მხოლოდ ის, რაც შეიძლება არასწორი, საკმაოდ
პატიოსნად, ძალიან ტრაგიკული გზა, როდესაც ეს ყველაფერი არ
დასაფასებელია ან უბრალოდ ჩვენ ადამიანებს უშვებენ შეცდომებს, როდესაც საქმე
ამ სახის განხორციელების დეტალებს თანამედროვე კომპიუტერი.
>> [VIDEO Playing]
-ჩვენ ახლა დაბრუნდით საინჟინრო უბედურებების თანამედროვე Marvels.
კომპიუტერები.
ჩვენ ყველა მოდის მიიღოს ხშირად frustrating პრობლემები
რომ წავიდეთ მათთან.
Bugs, ვირუსებს, და პროგრამული უზრუნველყოფის glitches მცირე ფასების
გადაიხადოთ მოხერხებულობისთვის.
მაგრამ მაღალი ტექნიკური და მაღალი სიჩქარით სამხედრო და სივრცეში
პროგრამის განცხადებები, პატარა პრობლემა შეიძლება იყოს
Magnified შევიდა უბედურება.
4 ივნისს, 1996, მეცნიერები მზად დაიწყოს უპილოტო
Ariane 5 რაკეტა.
ეს იყო დატვირთული სამეცნიერო თანამგზავრების განკუთვნილია
დაამყაროს ზუსტად როგორ დედამიწის მაგნიტური ველი
ურთიერთქმედებს მზის ქარები.
სარაკეტო აშენდა ევროპის კოსმოსური სააგენტო და
გააუქმა off მისი დაწესებულებაში სანაპიროზე საფრანგეთის გაიანა.
>> -დაახლოებით შესახებ 37 წამში შევიდა ფრენის, მათ პირველი
შენიშნა რაღაც ხდებოდა არასწორი, რომ რეაქტიული საქშენები იყო
swiveling ისე, რომ ისინი მართლაც არ უნდა.
დაახლოებით 40 წამში შევიდა ფრენის, ნათლად ავტომობილის
იყო პრობლემები, და ეს მაშინ, როდესაც ისინი გადაწყვეტილება
გაანადგუროს იგი.
სპექტრი უსაფრთხოების მოხელის უზარმაზარ guts დაპრესილი
ღილაკს, ააფეთქეს სარაკეტო სანამ გახდებოდა
Hazard საჯარო უსაფრთხოებას.
>> -ეს იყო maiden voyage of Ariane 5, და მისი
განადგურების მოხდა გამო ხარვეზის ჩართული
სარაკეტო ის პროგრამული.
>> -პრობლემა Ariane იყო, რომ ნომერი, რომელიც
მოითხოვს 64 ბიტი გამოთქვას და მათ სურდათ გადაიყვანოთ იგი
დან 16 bit ნომერი.
ისინი ფიქრობდნენ, რომ ხმების არასდროს ყოფილა
იქნება ძალიან დიდი,
რომ ყველაზე მეტად იმ ციფრები წელს 64 bit ნომერი იყო 0S.
ისინი არასწორია.
>> -უუნარობა ერთ პროგრამული უზრუნველყოფის პროგრამა მიიღოს
სახის ნომერი მიერ გამომუშავებული სხვა იყო ფესვი
უკმარისობა.
პროგრამული უზრუნველყოფის დამუშავება გახდა ძალიან ძვირადღირებული ნაწილი
ახალი ტექნოლოგია.
Ariane 4 სარაკეტო იყო ძალიან წარმატებული.
იმდენად, რამდენადაც პროგრამული შექმნილი იგი ასევე გამოიყენებოდა
წელს Ariane 5.
>> -ძირითადი პრობლემა იყო ის, რომ Ariane 5 იყო სწრაფად,
დააჩქარა სწრაფად.
და პროგრამული უზრუნველყოფის არ ჰქონდა აღრიცხვა რომ.
>> -განადგურების სარაკეტო იყო უზარმაზარი ფინანსური
უბედურება, ყველა გამო წუთი პროგრამული შეცდომა.
მაგრამ ეს არ იყო პირველად მონაცემები კონვერტაციის პრობლემები ჰქონდა
ხშირია თანამედროვე სარაკეტო ტექნიკა.
>> DAVID Malan: ჩვენ დავტოვებთ მას რომ.
მაგრამ ეს პატივისცემის თუ რამდენად გამოიყენება ზოგიერთი
ამ ყველაზე დაბალი დონე დეტალები, რომ ჩვენ დავიწყეთ
შეისწავლონ დღეს არიან.
ისე კი, როგორც თქვენ გაქვთ პატარა სცილდება ალბათ ზოგიერთი
სინტაქსი და arcaneness აქ, გააცნობიერონ, რომ მეტი
ტერმინი ჩვენ იყოს მიმართული მხოლოდ როგორ გამოიყენება ეს არის
მსოფლიოს მიღმა CS.
ჩვენ ვხედავთ თქვენ ოთხშაბათს.